Metal example code cleanup

Add Metal guide
Initial Metal example
2026-09-17 22:32:50 +00:00 · 2016-12-19 13:50:57 +01:00 · 2016-12-19 13:49:57 +01:00 · 2016-12-19 13:49:57 +01:00 · 2016-12-19 13:13:46 +01:00 · 2016-12-18 15:49:17 +01:00
119 changed files with 30308 additions and 2939 deletions
@@ -140,7 +140,7 @@ include the __GLFW release version__ (e.g. `3.1.2`), otherwise include the
 __GLFW commit ID__ (e.g.  `3795d78b14ef06008889cc422a1fb8d642597751`) from Git.

 Please also include the __GLFW version string__ (`3.2.0 X11 EGL clock_gettime
-/dev/js XI Xf86vm`), as described
+/dev/js`), as described
 [here](http://www.glfw.org/docs/latest/intro.html#intro_version_string), the
 __GPU model and driver version__ (e.g. `GeForce GTX660 with 352.79`), and the
 __output of `glfwinfo`__ (with switches matching any hints you set in your
@@ -55,6 +55,7 @@ examples/*.exe
 examples/boing
 examples/gears
 examples/heightmap
+examples/offscreen
 examples/particles
 examples/splitview
 examples/simple
@@ -78,7 +79,6 @@ tests/tearing
 tests/threads
 tests/timeout
 tests/title
-tests/version
 tests/vulkan
 tests/windows

@@ -2,17 +2,36 @@
 #
 # This will define:
 #
-#   MIR_LIBRARIES   - Link these to use Wayland
-#   MIR_INCLUDE_DIR - Include directory for Wayland
-#
-# Copyright (c) 2014 Brandon Schaefer <brandon.schaefer@canonical.com>
+#   MIR_FOUND       - System has Mir
+#   MIR_LIBRARIES   - Link these to use Mir
+#   MIR_INCLUDE_DIR - Include directory for Mir
+#   MIR_DEFINITIONS - Compiler switches required for using Mir

 if (NOT WIN32)

  find_package (PkgConfig)
  pkg_check_modules (PKG_MIR QUIET mirclient)
+  set(MIR_DEFINITIONS ${PKG_MIR_CFLAGS_OTHER})
+
+  find_path(MIR_INCLUDE_DIR
+      NAMES xkbcommon/xkbcommon.h
+      HINTS ${PC_XKBCOMMON_INCLUDE_DIR} ${PC_XKBCOMMON_INCLUDE_DIRS}
+  )
+
+  find_library(MIR_LIBRARY
+      NAMES mirclient
+      HINTS ${PKG_MIR_LIBRARIES} ${MIR_LIBRARY_DIRS}
+  )

  set (MIR_INCLUDE_DIR ${PKG_MIR_INCLUDE_DIRS})
-  set (MIR_LIBRARIES   ${PKG_MIR_LIBRARIES})
+  set (MIR_LIBRARIES   ${MIR_LIBRARY})
+
+  include (FindPackageHandleStandardArgs)
+  find_package_handle_standard_args (MIR DEFAULT_MSG
+      MIR_LIBRARIES
+      MIR_INCLUDE_DIR
+  )
+
+  mark_as_advanced (MIR_LIBRARIES MIR_INCLUDE_DIR)

 endif ()
@@ -0,0 +1,18 @@
+# Try to find OSMesa on a Unix system
+#
+# This will define:
+#
+#   OSMESA_LIBRARIES   - Link these to use OSMesa
+#   OSMESA_INCLUDE_DIR - Include directory for OSMesa
+#
+# Copyright (c) 2014 Brandon Schaefer <brandon.schaefer@canonical.com>
+
+if (NOT WIN32)
+
+  find_package (PkgConfig)
+  pkg_check_modules (PKG_OSMESA QUIET osmesa)
+
+  set (OSMESA_INCLUDE_DIR ${PKG_OSMESA_INCLUDE_DIRS})
+  set (OSMESA_LIBRARIES   ${PKG_OSMESA_LIBRARIES})
+
+endif ()
@@ -20,6 +20,13 @@ if (WIN32)
            "$ENV{VULKAN_SDK}/Bin32"
            "$ENV{VK_SDK_PATH}/Bin32")
    endif()
+elseif (APPLE)
+    find_library(VULKAN_LIBRARY MoltenVK)
+    if (VULKAN_LIBRARY)
+        set(VULKAN_STATIC_LIBRARY ${VULKAN_LIBRARY})
+        find_path(VULKAN_INCLUDE_DIR NAMES vulkan/vulkan.h HINTS
+            "${VULKAN_LIBRARY}/Headers")
+    endif()
 else()
    find_path(VULKAN_INCLUDE_DIR NAMES vulkan/vulkan.h HINTS
        "$ENV{VULKAN_SDK}/include")
@@ -28,6 +28,10 @@ option(GLFW_INSTALL "Generate installation target" ON)
 option(GLFW_VULKAN_STATIC "Use the Vulkan loader statically linked into application" OFF)
 option(GLFW_DOCUMENT_INTERNALS "Include internals in documentation" OFF)

+if (UNIX)
+    option(GLFW_USE_OSMESA "Use OSMesa for offscreen context creation" OFF)
+endif()
+
 if (WIN32)
    option(GLFW_USE_HYBRID_HPG "Force use of high-performance GPU on hybrid systems" OFF)
 endif()
@@ -35,7 +39,6 @@ endif()
 if (APPLE)
    option(GLFW_USE_CHDIR "Make glfwInit chdir to Contents/Resources" ON)
    option(GLFW_USE_MENUBAR "Populate the menu bar on first window creation" ON)
-    option(GLFW_USE_RETINA "Use the full resolution of Retina displays" ON)
 endif()

 if (UNIX AND NOT APPLE)
@@ -76,6 +79,17 @@ endif()
 # Set compiler specific flags
 #--------------------------------------------------------------------
 if (MSVC)
+    if (MSVC90)
+        # Workaround for VS 2008 not shipping with the DirectX 9 SDK
+        include(CheckIncludeFile)
+        check_include_file(dinput.h DINPUT_H_FOUND)
+        if (NOT DINPUT_H_FOUND)
+            message(FATAL_ERROR "DirectX 9 SDK not found")
+        endif()
+        # Workaround for VS 2008 not shipping with stdint.h
+        list(APPEND glfw_INCLUDE_DIRS "${GLFW_SOURCE_DIR}/deps/vs2008")
+    endif()
+
    if (NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
        foreach (flag CMAKE_C_FLAGS
                      CMAKE_C_FLAGS_DEBUG
@@ -129,26 +143,36 @@ if (MINGW)
    endif()
 endif()

+if (APPLE)
+    # Dependencies required by the MoltenVK static library
+    set(GLFW_VULKAN_DEPS
+        "-lc++"
+        "-framework Cocoa"
+        "-framework Metal"
+        "-framework QuartzCore")
+endif()
+
 #--------------------------------------------------------------------
 # Detect and select backend APIs
 #--------------------------------------------------------------------
-if (WIN32)
+if (GLFW_USE_WAYLAND)
+    set(_GLFW_WAYLAND 1)
+    message(STATUS "Using Wayland for window creation")
+elseif (GLFW_USE_MIR)
+    set(_GLFW_MIR 1)
+    message(STATUS "Using Mir for window creation")
+elseif (GLFW_USE_OSMESA)
+    set(_GLFW_OSMESA 1)
+    message(STATUS "Using OSMesa for headless context creation")
+elseif (WIN32)
    set(_GLFW_WIN32 1)
    message(STATUS "Using Win32 for window creation")
 elseif (APPLE)
    set(_GLFW_COCOA 1)
    message(STATUS "Using Cocoa for window creation")
 elseif (UNIX)
-    if (GLFW_USE_WAYLAND)
-        set(_GLFW_WAYLAND 1)
-        message(STATUS "Using Wayland for window creation")
-    elseif (GLFW_USE_MIR)
-        set(_GLFW_MIR 1)
-        message(STATUS "Using Mir for window creation")
-    else()
-        set(_GLFW_X11 1)
-        message(STATUS "Using X11 for window creation")
-    endif()
+    set(_GLFW_X11 1)
+    message(STATUS "Using X11 for window creation")
 else()
    message(FATAL_ERROR "No supported platform was detected")
 endif()
@@ -158,7 +182,10 @@ endif()
 #--------------------------------------------------------------------
 if (GLFW_VULKAN_STATIC)
    if (VULKAN_FOUND AND VULKAN_STATIC_LIBRARY)
-        list(APPEND glfw_LIBRARIES ${VULKAN_STATIC_LIBRARY})
+        list(APPEND glfw_LIBRARIES ${VULKAN_STATIC_LIBRARY} ${GLFW_VULKAN_DEPS})
+        if (BUILD_SHARED_LIBS)
+            message(WARNING "Linking Vulkan loader static library into GLFW")
+        endif()
    else()
        if (BUILD_SHARED_LIBS OR GLFW_BUILD_EXAMPLES OR GLFW_BUILD_TESTS)
            message(FATAL_ERROR "Vulkan loader static library not found")
@@ -235,21 +262,6 @@ if (_GLFW_X11)
    list(APPEND glfw_LIBRARIES "${X11_Xinerama_LIB}")
    list(APPEND glfw_PKG_DEPS "xinerama")

-    # Check for Xf86VidMode (fallback gamma control)
-    if (X11_xf86vmode_FOUND)
-        list(APPEND glfw_INCLUDE_DIRS "${X11_xf86vmode_INCLUDE_PATH}")
-        list(APPEND glfw_PKG_DEPS "xxf86vm")
-
-        if (X11_Xxf86vm_LIB)
-            list(APPEND glfw_LIBRARIES "${X11_Xxf86vm_LIB}")
-        else()
-            # Backwards compatibility (see CMake bug 0006976)
-            list(APPEND glfw_LIBRARIES Xxf86vm)
-        endif()
-
-        set(_GLFW_HAS_XF86VM TRUE)
-    endif()
-
    # Check for Xkb (X keyboard extension)
    if (NOT X11_Xkb_FOUND)
        message(FATAL_ERROR "The X keyboard extension headers were not found")
@@ -306,6 +318,14 @@ if (_GLFW_MIR)
    list(APPEND glfw_LIBRARIES "${XKBCOMMON_LIBRARY}")
 endif()

+#--------------------------------------------------------------------
+# Use OSMesa for offscreen context creation
+#--------------------------------------------------------------------
+if (_GLFW_OSMESA)
+    find_package(OSMesa REQUIRED)
+    list(APPEND glfw_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
+endif()
+
 #--------------------------------------------------------------------
 # Use Cocoa for window creation and NSOpenGL for context creation
 #--------------------------------------------------------------------
@@ -319,23 +339,11 @@ if (_GLFW_COCOA)
        set(_GLFW_USE_CHDIR 1)
    endif()

-    if (GLFW_USE_RETINA)
-        set(_GLFW_USE_RETINA 1)
-    endif()
-
-    # Set up library and include paths
-    find_library(COCOA_FRAMEWORK Cocoa)
-    find_library(IOKIT_FRAMEWORK IOKit)
-    find_library(CORE_FOUNDATION_FRAMEWORK CoreFoundation)
-    find_library(CORE_VIDEO_FRAMEWORK CoreVideo)
-    mark_as_advanced(COCOA_FRAMEWORK
-                     IOKIT_FRAMEWORK
-                     CORE_FOUNDATION_FRAMEWORK
-                     CORE_VIDEO_FRAMEWORK)
-    list(APPEND glfw_LIBRARIES "${COCOA_FRAMEWORK}"
-                               "${IOKIT_FRAMEWORK}"
-                               "${CORE_FOUNDATION_FRAMEWORK}"
-                               "${CORE_VIDEO_FRAMEWORK}")
+    list(APPEND glfw_LIBRARIES
+        "-framework Cocoa"
+        "-framework IOKit"
+        "-framework CoreFoundation"
+        "-framework CoreVideo")

    set(glfw_PKG_DEPS "")
    set(glfw_PKG_LIBS "-framework Cocoa -framework IOKit -framework CoreFoundation -framework CoreVideo")
@@ -1,5 +1,5 @@
 Copyright (c) 2002-2006 Marcus Geelnard
-Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>

 This software is provided 'as-is', without any express or implied
 warranty. In no event will the authors be held liable for any damages
@@ -11,7 +11,7 @@ application development.  It provides a simple, platform-independent API for
 creating windows, contexts and surfaces, reading input, handling events, etc.

 GLFW is licensed under the [zlib/libpng
-license](https://opensource.org/licenses/Zlib).
+license](http://www.glfw.org/license.html).

 The latest stable release is version 3.2.1.

@@ -19,6 +19,8 @@ See the [downloads](http://www.glfw.org/download.html) page for details and
 files, or fetch the `latest` branch, which always points to the latest stable
 release.  Each release starting with 3.0 also has a corresponding [annotated
 tag](https://github.com/glfw/glfw/releases) with source and binary archives.
+The [version history](http://www.glfw.org/changelog.html) lists all user-visible
+changes for every release.

 This is a development branch for version 3.3, which is _not yet described_.

@@ -36,7 +38,7 @@ does not need the headers for any context creation API (WGL, GLX, EGL, NSGL) or
 rendering API (OpenGL, OpenGL ES, Vulkan) to enable support for them.

 GLFW supports compilation on Windows with Visual C++ 2010 and later, MinGW and
-MinGW-w64, on OS X with Clang and on Linux and other Unix-like systems with GCC
+MinGW-w64, on macOS with Clang and on Linux and other Unix-like systems with GCC
 and Clang.  It will likely compile in other environments as well, but this is
 not regularly tested.

@@ -80,6 +82,8 @@ located in the `deps/` directory.
   [glad](https://github.com/Dav1dde/glad) for examples using modern OpenGL
 - [linmath.h](https://github.com/datenwolf/linmath.h) for linear algebra in
   examples
+ - [Nuklear](https://github.com/vurtun/nuklear) for test and example UI
+ - [stb\_image\_write](https://github.com/nothings/stb) for writing images to disk
 - [Vulkan headers](https://www.khronos.org/registry/vulkan/) for Vulkan tests

 The Vulkan example additionally requires the Vulkan SDK to be installed, or it
@@ -99,7 +103,32 @@ information on what to include when reporting a bug.

 ## Changelog

- [X11] Bugfix: The last interaction event time was not tracked
+- Added `glfwGetKeyScancode` function that allows retrieving platform dependent
+  scancodes for keys (#830)
+- Added `glfwSetWindowMaximizeCallback` and `GLFWwindowmaximizefun` for
+  receiving window maximization events (#778)
+- Added `glfwSetWindowAttrib` function for changing window attributes (#537)
+- Added headless [OSMesa](http://mesa3d.org/osmesa.html) backend (#281,#850)
+- Added definition of `GLAPIENTRY` to public header
+- Added macOS specific `GLFW_COCOA_RETINA_FRAMEBUFFER` window hint
+- Removed `GLFW_USE_RETINA` compile-time option
+- Bugfix: Calling `glfwMaximizeWindow` on a full screen window was not ignored
+- Bugfix: `GLFW_INCLUDE_VULKAN` could not be combined with the corresponding
+          OpenGL and OpenGL ES header macros
+- Bugfix: `glfwGetInstanceProcAddress` returned `NULL` for
+          `vkGetInstanceProcAddr` when `_GLFW_VULKAN_STATIC` was enabled
+- [Win32] Bugfix: Undecorated windows could not be iconified by the user (#861)
+- [Win32] Bugfix: Deadzone logic could underflow with some controllers (#910)
+- [X11] Replaced `_GLFW_HAS_XF86VM` compile-time option with dynamic loading
+- [Cocoa] Added support for Vulkan window surface creation via MoltenVK (#870)
+- [Cocoa] Bugfix: Disabling window aspect ratio would assert (#852)
+- [Cocoa] Bugfix: Window creation failed to set first responder (#876,#883)
+- [Cocoa] Bugfix: Removed use of deprecated `CGDisplayIOServicePort` function
+                  (#165,#192,#508,#511)
+- [Cocoa] Bugfix: Disabled use of deprecated `CGDisplayModeCopyPixelEncoding`
+                  function on macOS 10.12+
+- [Cocoa] Bugfix: Running in AppSandbox would emit warnings (#816,#882)
+- [EGL] Added support for `EGL_KHR_get_all_proc_addresses` (#871)


 ## Contact
@@ -134,11 +163,13 @@ skills.
 - Niklas Bergström
 - Doug Binks
 - blanco
+ - Kyle Brenneman
 - Martin Capitanio
 - Chi-kwan Chan
 - Lambert Clara
 - Andrew Corrigan
 - Noel Cower
+ - Jason Daly
 - Jarrod Davis
 - Olivier Delannoy
 - Paul R. Deppe
@@ -150,6 +181,7 @@ skills.
 - Siavash Eliasi
 - Michael Fogleman
 - Gerald Franz
+ - Mário Freitas
 - GeO4d
 - Marcus Geelnard
 - Eloi Marín Gratacós
@@ -220,6 +252,7 @@ skills.
 - Patrick Snape
 - Julian Squires
 - Johannes Stein
+ - Michael Stocker
 - Justin Stoecker
 - Elviss Strazdins
 - Nathan Sweet
@@ -228,7 +261,9 @@ skills.
 - Arthur Tombs
 - Ioannis Tsakpinis
 - Samuli Tuomola
+ - Matthew Turner
 - urraka
+ - Elias Vanderstuyft
 - Jari Vetoniemi
 - Ricardo Vieira
 - Nicholas Vitovitch
@@ -1,3 +1,25 @@
+/*
+
+    OpenGL loader generated by glad 0.1.12a0 on Fri Sep 23 13:36:15 2016.
+
+    Language/Generator: C/C++
+    Specification: gl
+    APIs: gl=3.2
+    Profile: compatibility
+    Extensions:
+        GL_ARB_multisample,
+        GL_ARB_robustness,
+        GL_KHR_debug
+    Loader: False
+    Local files: False
+    Omit khrplatform: False
+
+    Commandline:
+        --profile="compatibility" --api="gl=3.2" --generator="c" --spec="gl" --no-loader --extensions="GL_ARB_multisample,GL_ARB_robustness,GL_KHR_debug"
+    Online:
+        http://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&api=gl%3D3.2&extensions=GL_ARB_multisample&extensions=GL_ARB_robustness&extensions=GL_KHR_debug
+*/
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -5,14 +27,59 @@

 struct gladGLversionStruct GLVersion;

+#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
+#define _GLAD_IS_SOME_NEW_VERSION 1
+#endif
+
+static int max_loaded_major;
+static int max_loaded_minor;
+
+static const char *exts = NULL;
+static int num_exts_i = 0;
+static const char **exts_i = NULL;
+
+static int get_exts(void) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
+#endif
+        exts = (const char *)glGetString(GL_EXTENSIONS);
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    } else {
+        int index;
+
+        num_exts_i = 0;
+        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i);
+        if (num_exts_i > 0) {
+            exts_i = (const char **)realloc((void *)exts_i, num_exts_i * sizeof *exts_i);
+        }
+
+        if (exts_i == NULL) {
+            return 0;
+        }
+
+        for(index = 0; index < num_exts_i; index++) {
+            exts_i[index] = (const char*)glGetStringi(GL_EXTENSIONS, index);
+        }
+    }
+#endif
+    return 1;
+}
+
+static void free_exts(void) {
+    if (exts_i != NULL) {
+        free((char **)exts_i);
+        exts_i = NULL;
+    }
+}
+
 static int has_ext(const char *ext) {
-#if defined(GL_VERSION_3_0) || defined(GL_ES_VERSION_3_0)
-    if(GLVersion.major < 3 || glGetStringi == NULL) {
+#ifdef _GLAD_IS_SOME_NEW_VERSION
+    if(max_loaded_major < 3) {
 #endif
        const char *extensions;
        const char *loc;
        const char *terminator;
-        extensions = (const char*) glGetString(GL_EXTENSIONS);
+        extensions = exts;
        if(extensions == NULL || ext == NULL) {
            return 0;
        }
@@ -30,13 +97,14 @@ static int has_ext(const char *ext) {
            }
            extensions = terminator;
        }
-#if defined(GL_VERSION_3_0) || defined(GL_ES_VERSION_3_0)
+#ifdef _GLAD_IS_SOME_NEW_VERSION
    } else {
-        GLint num_exts, index;
+        int index;

-        glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts);
-        for(index = 0; index < num_exts; index++) {
-            if(strcmp((const char*) glGetStringi(GL_EXTENSIONS, index), ext) == 0) {
+        for(index = 0; index < num_exts_i; index++) {
+            const char *e = exts_i[index];
+
+            if(strcmp(e, ext) == 0) {
                return 1;
            }
        }
@@ -316,7 +384,7 @@ PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
 PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
 PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
 PFNGLDELETESYNCPROC glad_glDeleteSync;
-PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
+PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
 PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
 PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
 PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
@@ -363,7 +431,7 @@ PFNGLVIEWPORTPROC glad_glViewport;
 PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
 PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
 PFNGLINDEXDVPROC glad_glIndexdv;
-PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
+PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
 PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
 PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
 PFNGLCLEARDEPTHPROC glad_glClearDepth;
@@ -722,9 +790,9 @@ PFNGLCOLORPOINTERPROC glad_glColorPointer;
 PFNGLFRONTFACEPROC glad_glFrontFace;
 PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
 PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
+int GLAD_GL_KHR_debug;
 int GLAD_GL_ARB_robustness;
 int GLAD_GL_ARB_multisample;
-int GLAD_GL_EXT_separate_specular_color;
 PFNGLSAMPLECOVERAGEARBPROC glad_glSampleCoverageARB;
 PFNGLGETGRAPHICSRESETSTATUSARBPROC glad_glGetGraphicsResetStatusARB;
 PFNGLGETNTEXIMAGEARBPROC glad_glGetnTexImageARB;
@@ -746,6 +814,27 @@ PFNGLGETNCONVOLUTIONFILTERARBPROC glad_glGetnConvolutionFilterARB;
 PFNGLGETNSEPARABLEFILTERARBPROC glad_glGetnSeparableFilterARB;
 PFNGLGETNHISTOGRAMARBPROC glad_glGetnHistogramARB;
 PFNGLGETNMINMAXARBPROC glad_glGetnMinmaxARB;
+PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl;
+PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert;
+PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback;
+PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog;
+PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup;
+PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup;
+PFNGLOBJECTLABELPROC glad_glObjectLabel;
+PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel;
+PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel;
+PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel;
+PFNGLDEBUGMESSAGECONTROLKHRPROC glad_glDebugMessageControlKHR;
+PFNGLDEBUGMESSAGEINSERTKHRPROC glad_glDebugMessageInsertKHR;
+PFNGLDEBUGMESSAGECALLBACKKHRPROC glad_glDebugMessageCallbackKHR;
+PFNGLGETDEBUGMESSAGELOGKHRPROC glad_glGetDebugMessageLogKHR;
+PFNGLPUSHDEBUGGROUPKHRPROC glad_glPushDebugGroupKHR;
+PFNGLPOPDEBUGGROUPKHRPROC glad_glPopDebugGroupKHR;
+PFNGLOBJECTLABELKHRPROC glad_glObjectLabelKHR;
+PFNGLGETOBJECTLABELKHRPROC glad_glGetObjectLabelKHR;
+PFNGLOBJECTPTRLABELKHRPROC glad_glObjectPtrLabelKHR;
+PFNGLGETOBJECTPTRLABELKHRPROC glad_glGetObjectPtrLabelKHR;
+PFNGLGETPOINTERVKHRPROC glad_glGetPointervKHR;
 static void load_GL_VERSION_1_0(GLADloadproc load) {
 	if(!GLAD_GL_VERSION_1_0) return;
 	glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace");
@@ -1475,10 +1564,38 @@ static void load_GL_ARB_robustness(GLADloadproc load) {
 	glad_glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC)load("glGetnHistogramARB");
 	glad_glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC)load("glGetnMinmaxARB");
 }
-static void find_extensionsGL(void) {
-	GLAD_GL_EXT_separate_specular_color = has_ext("GL_EXT_separate_specular_color");
+static void load_GL_KHR_debug(GLADloadproc load) {
+	if(!GLAD_GL_KHR_debug) return;
+	glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)load("glDebugMessageControl");
+	glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)load("glDebugMessageInsert");
+	glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)load("glDebugMessageCallback");
+	glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)load("glGetDebugMessageLog");
+	glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)load("glPushDebugGroup");
+	glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)load("glPopDebugGroup");
+	glad_glObjectLabel = (PFNGLOBJECTLABELPROC)load("glObjectLabel");
+	glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)load("glGetObjectLabel");
+	glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)load("glObjectPtrLabel");
+	glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)load("glGetObjectPtrLabel");
+	glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv");
+	glad_glDebugMessageControlKHR = (PFNGLDEBUGMESSAGECONTROLKHRPROC)load("glDebugMessageControlKHR");
+	glad_glDebugMessageInsertKHR = (PFNGLDEBUGMESSAGEINSERTKHRPROC)load("glDebugMessageInsertKHR");
+	glad_glDebugMessageCallbackKHR = (PFNGLDEBUGMESSAGECALLBACKKHRPROC)load("glDebugMessageCallbackKHR");
+	glad_glGetDebugMessageLogKHR = (PFNGLGETDEBUGMESSAGELOGKHRPROC)load("glGetDebugMessageLogKHR");
+	glad_glPushDebugGroupKHR = (PFNGLPUSHDEBUGGROUPKHRPROC)load("glPushDebugGroupKHR");
+	glad_glPopDebugGroupKHR = (PFNGLPOPDEBUGGROUPKHRPROC)load("glPopDebugGroupKHR");
+	glad_glObjectLabelKHR = (PFNGLOBJECTLABELKHRPROC)load("glObjectLabelKHR");
+	glad_glGetObjectLabelKHR = (PFNGLGETOBJECTLABELKHRPROC)load("glGetObjectLabelKHR");
+	glad_glObjectPtrLabelKHR = (PFNGLOBJECTPTRLABELKHRPROC)load("glObjectPtrLabelKHR");
+	glad_glGetObjectPtrLabelKHR = (PFNGLGETOBJECTPTRLABELKHRPROC)load("glGetObjectPtrLabelKHR");
+	glad_glGetPointervKHR = (PFNGLGETPOINTERVKHRPROC)load("glGetPointervKHR");
+}
+static int find_extensionsGL(void) {
+	if (!get_exts()) return 0;
 	GLAD_GL_ARB_multisample = has_ext("GL_ARB_multisample");
 	GLAD_GL_ARB_robustness = has_ext("GL_ARB_robustness");
+	GLAD_GL_KHR_debug = has_ext("GL_KHR_debug");
+	free_exts();
+	return 1;
 }

 static void find_coreGL(void) {
@@ -1516,6 +1633,7 @@ static void find_coreGL(void) {
 #endif

    GLVersion.major = major; GLVersion.minor = minor;
+    max_loaded_major = major; max_loaded_minor = minor;
 	GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
 	GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
 	GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
@@ -1527,6 +1645,10 @@ static void find_coreGL(void) {
 	GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
 	GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
 	GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
+	if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 2)) {
+		max_loaded_major = 3;
+		max_loaded_minor = 2;
+	}
 }

 int gladLoadGLLoader(GLADloadproc load) {
@@ -1547,9 +1669,10 @@ int gladLoadGLLoader(GLADloadproc load) {
 	load_GL_VERSION_3_1(load);
 	load_GL_VERSION_3_2(load);

-	find_extensionsGL();
+	if (!find_extensionsGL()) return 0;
 	load_GL_ARB_multisample(load);
 	load_GL_ARB_robustness(load);
+	load_GL_KHR_debug(load);
 	return GLVersion.major != 0 || GLVersion.minor != 0;
 }

@@ -0,0 +1,350 @@
+/*
+ * Nuklear - v1.17 - public domain
+ * no warrenty implied; use at your own risk.
+ * authored from 2015-2016 by Micha Mettke
+ */
+/*
+ * ==============================================================
+ *
+ *                              API
+ *
+ * ===============================================================
+ */
+#ifndef NK_GLFW_GL2_H_
+#define NK_GLFW_GL2_H_
+
+#include <GLFW/glfw3.h>
+
+enum nk_glfw_init_state{
+    NK_GLFW3_DEFAULT = 0,
+    NK_GLFW3_INSTALL_CALLBACKS
+};
+NK_API struct nk_context*   nk_glfw3_init(GLFWwindow *win, enum nk_glfw_init_state);
+NK_API void                 nk_glfw3_font_stash_begin(struct nk_font_atlas **atlas);
+NK_API void                 nk_glfw3_font_stash_end(void);
+
+NK_API void                 nk_glfw3_new_frame(void);
+NK_API void                 nk_glfw3_render(enum nk_anti_aliasing , int max_vertex_buffer, int max_element_buffer);
+NK_API void                 nk_glfw3_shutdown(void);
+
+NK_API void                 nk_glfw3_char_callback(GLFWwindow *win, unsigned int codepoint);
+NK_API void                 nk_gflw3_scroll_callback(GLFWwindow *win, double xoff, double yoff);
+
+#endif
+
+/*
+ * ==============================================================
+ *
+ *                          IMPLEMENTATION
+ *
+ * ===============================================================
+ */
+#ifdef NK_GLFW_GL2_IMPLEMENTATION
+
+#ifndef NK_GLFW_TEXT_MAX
+#define NK_GLFW_TEXT_MAX 256
+#endif
+
+struct nk_glfw_device {
+    struct nk_buffer cmds;
+    struct nk_draw_null_texture null;
+    GLuint font_tex;
+};
+
+struct nk_glfw_vertex {
+    float position[2];
+    float uv[2];
+    nk_byte col[4];
+};
+
+static struct nk_glfw {
+    GLFWwindow *win;
+    int width, height;
+    int display_width, display_height;
+    struct nk_glfw_device ogl;
+    struct nk_context ctx;
+    struct nk_font_atlas atlas;
+    struct nk_vec2 fb_scale;
+    unsigned int text[NK_GLFW_TEXT_MAX];
+    int text_len;
+    float scroll;
+} glfw;
+
+NK_INTERN void
+nk_glfw3_device_upload_atlas(const void *image, int width, int height)
+{
+    struct nk_glfw_device *dev = &glfw.ogl;
+    glGenTextures(1, &dev->font_tex);
+    glBindTexture(GL_TEXTURE_2D, dev->font_tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLsizei)width, (GLsizei)height, 0,
+                GL_RGBA, GL_UNSIGNED_BYTE, image);
+}
+
+NK_API void
+nk_glfw3_render(enum nk_anti_aliasing AA, int max_vertex_buffer, int max_element_buffer)
+{
+    /* setup global state */
+    struct nk_glfw_device *dev = &glfw.ogl;
+    glPushAttrib(GL_ENABLE_BIT|GL_COLOR_BUFFER_BIT|GL_TRANSFORM_BIT);
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_SCISSOR_TEST);
+    glEnable(GL_BLEND);
+    glEnable(GL_TEXTURE_2D);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    /* setup viewport/project */
+    glViewport(0,0,(GLsizei)glfw.display_width,(GLsizei)glfw.display_height);
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    glOrtho(0.0f, glfw.width, glfw.height, 0.0f, -1.0f, 1.0f);
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    {
+        GLsizei vs = sizeof(struct nk_glfw_vertex);
+        size_t vp = offsetof(struct nk_glfw_vertex, position);
+        size_t vt = offsetof(struct nk_glfw_vertex, uv);
+        size_t vc = offsetof(struct nk_glfw_vertex, col);
+
+        /* convert from command queue into draw list and draw to screen */
+        const struct nk_draw_command *cmd;
+        const nk_draw_index *offset = NULL;
+        struct nk_buffer vbuf, ebuf;
+
+        /* fill convert configuration */
+        struct nk_convert_config config;
+        static const struct nk_draw_vertex_layout_element vertex_layout[] = {
+            {NK_VERTEX_POSITION, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, position)},
+            {NK_VERTEX_TEXCOORD, NK_FORMAT_FLOAT, NK_OFFSETOF(struct nk_glfw_vertex, uv)},
+            {NK_VERTEX_COLOR, NK_FORMAT_R8G8B8A8, NK_OFFSETOF(struct nk_glfw_vertex, col)},
+            {NK_VERTEX_LAYOUT_END}
+        };
+        NK_MEMSET(&config, 0, sizeof(config));
+        config.vertex_layout = vertex_layout;
+        config.vertex_size = sizeof(struct nk_glfw_vertex);
+        config.vertex_alignment = NK_ALIGNOF(struct nk_glfw_vertex);
+        config.null = dev->null;
+        config.circle_segment_count = 22;
+        config.curve_segment_count = 22;
+        config.arc_segment_count = 22;
+        config.global_alpha = 1.0f;
+        config.shape_AA = AA;
+        config.line_AA = AA;
+
+        /* convert shapes into vertexes */
+        nk_buffer_init_default(&vbuf);
+        nk_buffer_init_default(&ebuf);
+        nk_convert(&glfw.ctx, &dev->cmds, &vbuf, &ebuf, &config);
+
+        /* setup vertex buffer pointer */
+        {const void *vertices = nk_buffer_memory_const(&vbuf);
+        glVertexPointer(2, GL_FLOAT, vs, (const void*)((const nk_byte*)vertices + vp));
+        glTexCoordPointer(2, GL_FLOAT, vs, (const void*)((const nk_byte*)vertices + vt));
+        glColorPointer(4, GL_UNSIGNED_BYTE, vs, (const void*)((const nk_byte*)vertices + vc));}
+
+        /* iterate over and execute each draw command */
+        offset = (const nk_draw_index*)nk_buffer_memory_const(&ebuf);
+        nk_draw_foreach(cmd, &glfw.ctx, &dev->cmds)
+        {
+            if (!cmd->elem_count) continue;
+            glBindTexture(GL_TEXTURE_2D, (GLuint)cmd->texture.id);
+            glScissor(
+                (GLint)(cmd->clip_rect.x * glfw.fb_scale.x),
+                (GLint)((glfw.height - (GLint)(cmd->clip_rect.y + cmd->clip_rect.h)) * glfw.fb_scale.y),
+                (GLint)(cmd->clip_rect.w * glfw.fb_scale.x),
+                (GLint)(cmd->clip_rect.h * glfw.fb_scale.y));
+            glDrawElements(GL_TRIANGLES, (GLsizei)cmd->elem_count, GL_UNSIGNED_SHORT, offset);
+            offset += cmd->elem_count;
+        }
+        nk_clear(&glfw.ctx);
+        nk_buffer_free(&vbuf);
+        nk_buffer_free(&ebuf);
+    }
+
+    /* default OpenGL state */
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glDisableClientState(GL_COLOR_ARRAY);
+
+    glDisable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_SCISSOR_TEST);
+    glDisable(GL_BLEND);
+    glDisable(GL_TEXTURE_2D);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glPopAttrib();
+}
+
+NK_API void
+nk_glfw3_char_callback(GLFWwindow *win, unsigned int codepoint)
+{
+    (void)win;
+    if (glfw.text_len < NK_GLFW_TEXT_MAX)
+        glfw.text[glfw.text_len++] = codepoint;
+}
+
+NK_API void
+nk_gflw3_scroll_callback(GLFWwindow *win, double xoff, double yoff)
+{
+    (void)win; (void)xoff;
+    glfw.scroll += (float)yoff;
+}
+
+NK_INTERN void
+nk_glfw3_clipbard_paste(nk_handle usr, struct nk_text_edit *edit)
+{
+    const char *text = glfwGetClipboardString(glfw.win);
+    if (text) nk_textedit_paste(edit, text, nk_strlen(text));
+    (void)usr;
+}
+
+NK_INTERN void
+nk_glfw3_clipbard_copy(nk_handle usr, const char *text, int len)
+{
+    char *str = 0;
+    (void)usr;
+    if (!len) return;
+    str = (char*)malloc((size_t)len+1);
+    if (!str) return;
+    NK_MEMCPY(str, text, (size_t)len);
+    str[len] = '\0';
+    glfwSetClipboardString(glfw.win, str);
+    free(str);
+}
+
+NK_API struct nk_context*
+nk_glfw3_init(GLFWwindow *win, enum nk_glfw_init_state init_state)
+{
+    glfw.win = win;
+    if (init_state == NK_GLFW3_INSTALL_CALLBACKS) {
+        glfwSetScrollCallback(win, nk_gflw3_scroll_callback);
+        glfwSetCharCallback(win, nk_glfw3_char_callback);
+    }
+
+    nk_init_default(&glfw.ctx, 0);
+    glfw.ctx.clip.copy = nk_glfw3_clipbard_copy;
+    glfw.ctx.clip.paste = nk_glfw3_clipbard_paste;
+    glfw.ctx.clip.userdata = nk_handle_ptr(0);
+    nk_buffer_init_default(&glfw.ogl.cmds);
+    return &glfw.ctx;
+}
+
+NK_API void
+nk_glfw3_font_stash_begin(struct nk_font_atlas **atlas)
+{
+    nk_font_atlas_init_default(&glfw.atlas);
+    nk_font_atlas_begin(&glfw.atlas);
+    *atlas = &glfw.atlas;
+}
+
+NK_API void
+nk_glfw3_font_stash_end(void)
+{
+    const void *image; int w, h;
+    image = nk_font_atlas_bake(&glfw.atlas, &w, &h, NK_FONT_ATLAS_RGBA32);
+    nk_glfw3_device_upload_atlas(image, w, h);
+    nk_font_atlas_end(&glfw.atlas, nk_handle_id((int)glfw.ogl.font_tex), &glfw.ogl.null);
+    if (glfw.atlas.default_font)
+        nk_style_set_font(&glfw.ctx, &glfw.atlas.default_font->handle);
+}
+
+NK_API void
+nk_glfw3_new_frame(void)
+{
+    int i;
+    double x, y;
+    struct nk_context *ctx = &glfw.ctx;
+    struct GLFWwindow *win = glfw.win;
+
+    glfwGetWindowSize(win, &glfw.width, &glfw.height);
+    glfwGetFramebufferSize(win, &glfw.display_width, &glfw.display_height);
+    glfw.fb_scale.x = (float)glfw.display_width/(float)glfw.width;
+    glfw.fb_scale.y = (float)glfw.display_height/(float)glfw.height;
+
+    nk_input_begin(ctx);
+    for (i = 0; i < glfw.text_len; ++i)
+        nk_input_unicode(ctx, glfw.text[i]);
+
+    /* optional grabbing behavior */
+    if (ctx->input.mouse.grab)
+        glfwSetInputMode(glfw.win, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
+    else if (ctx->input.mouse.ungrab)
+        glfwSetInputMode(glfw.win, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+
+    nk_input_key(ctx, NK_KEY_DEL, glfwGetKey(win, GLFW_KEY_DELETE) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_ENTER, glfwGetKey(win, GLFW_KEY_ENTER) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_TAB, glfwGetKey(win, GLFW_KEY_TAB) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_BACKSPACE, glfwGetKey(win, GLFW_KEY_BACKSPACE) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_UP, glfwGetKey(win, GLFW_KEY_UP) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_DOWN, glfwGetKey(win, GLFW_KEY_DOWN) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_TEXT_START, glfwGetKey(win, GLFW_KEY_HOME) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_TEXT_END, glfwGetKey(win, GLFW_KEY_END) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_START, glfwGetKey(win, GLFW_KEY_HOME) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_END, glfwGetKey(win, GLFW_KEY_END) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_DOWN, glfwGetKey(win, GLFW_KEY_PAGE_DOWN) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SCROLL_UP, glfwGetKey(win, GLFW_KEY_PAGE_UP) == GLFW_PRESS);
+    nk_input_key(ctx, NK_KEY_SHIFT, glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS||
+                                    glfwGetKey(win, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS);
+
+    if (glfwGetKey(win, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS ||
+        glfwGetKey(win, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS) {
+        nk_input_key(ctx, NK_KEY_COPY, glfwGetKey(win, GLFW_KEY_C) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_PASTE, glfwGetKey(win, GLFW_KEY_P) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_CUT, glfwGetKey(win, GLFW_KEY_X) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_UNDO, glfwGetKey(win, GLFW_KEY_Z) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_REDO, glfwGetKey(win, GLFW_KEY_R) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, glfwGetKey(win, GLFW_KEY_LEFT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, glfwGetKey(win, GLFW_KEY_RIGHT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_LINE_START, glfwGetKey(win, GLFW_KEY_B) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_TEXT_LINE_END, glfwGetKey(win, GLFW_KEY_E) == GLFW_PRESS);
+    } else {
+        nk_input_key(ctx, NK_KEY_LEFT, glfwGetKey(win, GLFW_KEY_LEFT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_RIGHT, glfwGetKey(win, GLFW_KEY_RIGHT) == GLFW_PRESS);
+        nk_input_key(ctx, NK_KEY_COPY, 0);
+        nk_input_key(ctx, NK_KEY_PASTE, 0);
+        nk_input_key(ctx, NK_KEY_CUT, 0);
+        nk_input_key(ctx, NK_KEY_SHIFT, 0);
+    }
+
+    glfwGetCursorPos(win, &x, &y);
+    nk_input_motion(ctx, (int)x, (int)y);
+    if (ctx->input.mouse.grabbed) {
+        glfwSetCursorPos(glfw.win, ctx->input.mouse.prev.x, ctx->input.mouse.prev.y);
+        ctx->input.mouse.pos.x = ctx->input.mouse.prev.x;
+        ctx->input.mouse.pos.y = ctx->input.mouse.prev.y;
+    }
+
+    nk_input_button(ctx, NK_BUTTON_LEFT, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS);
+    nk_input_button(ctx, NK_BUTTON_MIDDLE, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_MIDDLE) == GLFW_PRESS);
+    nk_input_button(ctx, NK_BUTTON_RIGHT, (int)x, (int)y, glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_RIGHT) == GLFW_PRESS);
+    nk_input_scroll(ctx, glfw.scroll);
+    nk_input_end(&glfw.ctx);
+    glfw.text_len = 0;
+    glfw.scroll = 0;
+}
+
+NK_API
+void nk_glfw3_shutdown(void)
+{
+    struct nk_glfw_device *dev = &glfw.ogl;
+    nk_font_atlas_clear(&glfw.atlas);
+    nk_free(&glfw.ctx);
+    glDeleteTextures(1, &dev->font_tex);
+    nk_buffer_free(&dev->cmds);
+    NK_MEMSET(&glfw, 0, sizeof(glfw));
+}
+
+#endif
@@ -21,7 +21,7 @@ freely, subject to the following restrictions:
    distribution.
 */

-/* 2013-01-06 Camilla Berglund <elmindreda@glfw.org>
+/* 2013-01-06 Camilla Löwy <elmindreda@glfw.org>
 *
 * Added casts from time_t to DWORD to avoid warnings on VC++.
 * Fixed time retrieval on POSIX systems.
@@ -123,7 +123,9 @@ typedef int _tthread_clockid_t;
 /* Emulate clock_gettime */
 int _tthread_clock_gettime(clockid_t clk_id, struct timespec *ts);
 #define clock_gettime _tthread_clock_gettime
-#define CLOCK_REALTIME 0
+#ifndef CLOCK_REALTIME
+  #define CLOCK_REALTIME 0
+#endif
 #endif


@@ -0,0 +1,247 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006-2008 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+// 
+//   3. The name of the author may be used to endorse or promote products
+//      derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+#  include <wchar.h>
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]
@@ -51,13 +51,13 @@ extern "C"
    #define VKAPI_ATTR
    #define VKAPI_CALL __stdcall
    #define VKAPI_PTR  VKAPI_CALL
-#elif defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
-    // Android does not support Vulkan in native code using the "armeabi" ABI.
-    #error "Vulkan requires the 'armeabi-v7a' or 'armeabi-v7a-hard' ABI on 32-bit ARM CPUs"
-#elif defined(__ANDROID__) && defined(__ARM_ARCH_7A__)
-    // On Android/ARMv7a, Vulkan functions use the armeabi-v7a-hard calling
-    // convention, even if the application's native code is compiled with the
-    // armeabi-v7a calling convention.
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
+    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && __ARM_32BIT_STATE
+    // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
+    // calling convention, i.e. float parameters are passed in registers. This
+    // is true even if the rest of the application passes floats on the stack,
+    // as it does by default when compiling for the armeabi-v7a NDK ABI.
    #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))
    #define VKAPI_CALL
    #define VKAPI_PTR  VKAPI_ATTR
@@ -43,7 +43,7 @@ extern "C" {
 #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
 #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
 // Version of this file
-#define VK_HEADER_VERSION 11
+#define VK_HEADER_VERSION 26


 #define VK_NULL_HANDLE 0
@@ -53,11 +53,13 @@ extern "C" {
 #define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;


-#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
 #else
        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
 #endif
+#endif
        


@@ -135,6 +137,7 @@ typedef enum VkResult {
    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
    VK_ERROR_TOO_MANY_OBJECTS = -10,
    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+    VK_ERROR_FRAGMENTED_POOL = -12,
    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
    VK_SUBOPTIMAL_KHR = 1000001003,
@@ -142,9 +145,9 @@ typedef enum VkResult {
    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
    VK_ERROR_INVALID_SHADER_NV = -1000012000,
-    VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
+    VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
    VK_RESULT_END_RANGE = VK_INCOMPLETE,
-    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1),
+    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 } VkResult;

@@ -210,6 +213,18 @@ typedef enum VkStructureType {
    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
+    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
    VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
    VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
@@ -422,6 +437,14 @@ typedef enum VkFormat {
    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
+    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
+    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
+    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
+    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
+    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
+    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
+    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
    VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
    VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
@@ -2343,7 +2366,7 @@ typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkIm
 typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
 typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
+typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
 typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
 typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
 typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
@@ -3028,7 +3051,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
    VkBuffer                                    dstBuffer,
    VkDeviceSize                                dstOffset,
    VkDeviceSize                                dataSize,
-    const uint32_t*                             pData);
+    const void*                                 pData);

 VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
    VkCommandBuffer                             commandBuffer,
@@ -3168,13 +3191,14 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)

 #define VK_KHR_SURFACE_SPEC_VERSION       25
 #define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
+#define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR


 typedef enum VkColorSpaceKHR {
-    VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
-    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
-    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
-    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
+    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
+    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
 } VkColorSpaceKHR;

@@ -3710,7 +3734,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
 #define VK_EXT_debug_report 1
 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)

-#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  2
+#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  3
 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
 #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT

@@ -3828,6 +3852,270 @@ VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
 #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"


+#define VK_AMD_rasterization_order 1
+#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
+#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
+
+
+typedef enum VkRasterizationOrderAMD {
+    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
+    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
+    VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
+    VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
+    VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
+    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkRasterizationOrderAMD;
+
+typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkRasterizationOrderAMD    rasterizationOrder;
+} VkPipelineRasterizationStateRasterizationOrderAMD;
+
+
+
+#define VK_AMD_shader_trinary_minmax 1
+#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
+#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
+
+
+#define VK_AMD_shader_explicit_vertex_parameter 1
+#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
+#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
+
+
+#define VK_EXT_debug_marker 1
+#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  3
+#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
+
+typedef struct VkDebugMarkerObjectNameInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDebugReportObjectTypeEXT    objectType;
+    uint64_t                      object;
+    const char*                   pObjectName;
+} VkDebugMarkerObjectNameInfoEXT;
+
+typedef struct VkDebugMarkerObjectTagInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDebugReportObjectTypeEXT    objectType;
+    uint64_t                      object;
+    uint64_t                      tagName;
+    size_t                        tagSize;
+    const void*                   pTag;
+} VkDebugMarkerObjectTagInfoEXT;
+
+typedef struct VkDebugMarkerMarkerInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pMarkerName;
+    float              color[4];
+} VkDebugMarkerMarkerInfoEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
+    VkDevice                                    device,
+    VkDebugMarkerObjectTagInfoEXT*              pTagInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
+    VkDevice                                    device,
+    VkDebugMarkerObjectNameInfoEXT*             pNameInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkDebugMarkerMarkerInfoEXT*                 pMarkerInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
+    VkCommandBuffer                             commandBuffer,
+    VkDebugMarkerMarkerInfoEXT*                 pMarkerInfo);
+#endif
+
+#define VK_AMD_gcn_shader 1
+#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
+#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
+
+
+#define VK_NV_dedicated_allocation 1
+#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
+#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
+
+typedef struct VkDedicatedAllocationImageCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dedicatedAllocation;
+} VkDedicatedAllocationImageCreateInfoNV;
+
+typedef struct VkDedicatedAllocationBufferCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dedicatedAllocation;
+} VkDedicatedAllocationBufferCreateInfoNV;
+
+typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkBuffer           buffer;
+} VkDedicatedAllocationMemoryAllocateInfoNV;
+
+
+
+#define VK_AMD_draw_indirect_count 1
+#define VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
+#define VK_AMD_EXTENSION_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
+
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+#endif
+
+#define VK_IMG_format_pvrtc 1
+#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
+#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
+
+
+#define VK_NV_external_memory_capabilities 1
+#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
+
+
+typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkExternalMemoryHandleTypeFlagBitsNV;
+typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
+
+typedef enum VkExternalMemoryFeatureFlagBitsNV {
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
+    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkExternalMemoryFeatureFlagBitsNV;
+typedef VkFlags VkExternalMemoryFeatureFlagsNV;
+
+typedef struct VkExternalImageFormatPropertiesNV {
+    VkImageFormatProperties              imageFormatProperties;
+    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
+    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
+    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
+} VkExternalImageFormatPropertiesNV;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkImageTiling                               tiling,
+    VkImageUsageFlags                           usage,
+    VkImageCreateFlags                          flags,
+    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
+    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
+#endif
+
+#define VK_NV_external_memory 1
+#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
+
+typedef struct VkExternalMemoryImageCreateInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
+} VkExternalMemoryImageCreateInfoNV;
+
+typedef struct VkExportMemoryAllocateInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
+} VkExportMemoryAllocateInfoNV;
+
+
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#define VK_NV_external_memory_win32 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleType;
+    HANDLE                               handle;
+} VkImportMemoryWin32HandleInfoNV;
+
+typedef struct VkExportMemoryWin32HandleInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+} VkExportMemoryWin32HandleInfoNV;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkExternalMemoryHandleTypeFlagsNV           handleType,
+    HANDLE*                                     pHandle);
+#endif
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#define VK_NV_win32_keyed_mutex 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeoutMilliseconds;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoNV;
+
+
+#endif /* VK_USE_PLATFORM_WIN32_KHR */
+
 #ifdef __cplusplus
 }
 #endif
@@ -14,6 +14,7 @@ set(glfw_DOCS_SOURCES
    "${GLFW_SOURCE_DIR}/docs/window.dox"
    "${GLFW_SOURCE_DIR}/docs/input.dox"
    "${GLFW_SOURCE_DIR}/docs/vulkan.dox"
+    "${GLFW_SOURCE_DIR}/docs/metal.dox"
    "${GLFW_SOURCE_DIR}/docs/compat.dox")

 if (GLFW_DOCUMENT_INTERNALS)
@@ -202,8 +202,9 @@ ALIASES                = "thread_safety=@par Thread safety\n" \
                         "errors=@par Errors\n" \
                         "glfw3=@par\n__GLFW 3:__" \
                         "x11=__X11:__" \
+                         "wayland=__Wayland:__" \
                         "win32=__Windows:__" \
-                         "osx=__OS X:__"
+                         "macos=__macOS:__"

 # This tag can be used to specify a number of word-keyword mappings (TCL only).
 # A mapping has the form "name=value". For example adding
@@ -467,14 +468,14 @@ INLINE_INFO            = YES
 # alphabetically by member name. If set to NO the members will appear in
 # declaration order.

-SORT_MEMBER_DOCS       = YES
+SORT_MEMBER_DOCS       = NO

 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
 # brief documentation of file, namespace and class members alphabetically
 # by member name. If set to NO (the default) the members will appear in
 # declaration order.

-SORT_BRIEF_DOCS        = NO
+SORT_BRIEF_DOCS        = YES

 # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
 # will sort the (brief and detailed) documentation of class members so that
@@ -1576,6 +1577,7 @@ PREDEFINED             = GLFWAPI=                   \
                         GLFW_EXPOSE_NATIVE_COCOA   \
                         GLFW_EXPOSE_NATIVE_NSGL    \
                         GLFW_EXPOSE_NATIVE_EGL     \
+                         GLFW_EXPOSE_NATIVE_OSMESA  \
                         VK_VERSION_1_0

 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
@@ -49,7 +49,7 @@ In other words:

 If you are using an OpenGL extension loading library such as
 [glad](https://github.com/Dav1dde/glad), the extension loader header should
-either be included _before_ the GLFW one, or the `GLFW_INCLUDE_NONE` macro
+either be included _before_ the GLFW one, or the @ref GLFW_INCLUDE_NONE macro
 (described below) should be defined.


@@ -58,46 +58,56 @@ either be included _before_ the GLFW one, or the `GLFW_INCLUDE_NONE` macro
 These macros may be defined before the inclusion of the GLFW header and affect
 its behavior.

-`GLFW_DLL` is required on Windows when using the GLFW DLL, to tell the compiler
-that the GLFW functions are defined in a DLL.
+@anchor GLFW_DLL
+__GLFW_DLL__ is required on Windows when using the GLFW DLL, to tell the
+compiler that the GLFW functions are defined in a DLL.

 The following macros control which OpenGL or OpenGL ES API header is included.
 Only one of these may be defined at a time.

-`GLFW_INCLUDE_GLCOREARB` makes the GLFW header include the modern
-`GL/glcorearb.h` header (`OpenGL/gl3.h` on OS X) instead of the regular OpenGL
+@anchor GLFW_INCLUDE_GLCOREARB
+__GLFW_INCLUDE_GLCOREARB__ makes the GLFW header include the modern
+`GL/glcorearb.h` header (`OpenGL/gl3.h` on macOS) instead of the regular OpenGL
 header.

-`GLFW_INCLUDE_ES1` makes the GLFW header include the OpenGL ES 1.x `GLES/gl.h`
+@anchor GLFW_INCLUDE_ES1
+__GLFW_INCLUDE_ES1__ makes the GLFW header include the OpenGL ES 1.x `GLES/gl.h`
 header instead of the regular OpenGL header.

-`GLFW_INCLUDE_ES2` makes the GLFW header include the OpenGL ES 2.0 `GLES2/gl2.h`
-header instead of the regular OpenGL header.
+@anchor GLFW_INCLUDE_ES2
+__GLFW_INCLUDE_ES2__ makes the GLFW header include the OpenGL ES 2.0
+`GLES2/gl2.h` header instead of the regular OpenGL header.

-`GLFW_INCLUDE_ES3` makes the GLFW header include the OpenGL ES 3.0 `GLES3/gl3.h`
-header instead of the regular OpenGL header.
+@anchor GLFW_INCLUDE_ES3
+__GLFW_INCLUDE_ES3__ makes the GLFW header include the OpenGL ES 3.0
+`GLES3/gl3.h` header instead of the regular OpenGL header.

-`GLFW_INCLUDE_ES31` makes the GLFW header include the OpenGL ES 3.1 `GLES3/gl31.h`
-header instead of the regular OpenGL header.
+@anchor GLFW_INCLUDE_ES31
+__GLFW_INCLUDE_ES31__ makes the GLFW header include the OpenGL ES 3.1
+`GLES3/gl31.h` header instead of the regular OpenGL header.

-`GLFW_INCLUDE_VULKAN` makes the GLFW header include the Vulkan `vulkan/vulkan.h`
-header instead of the regular OpenGL header.
-
-`GLFW_INCLUDE_NONE` makes the GLFW header not include any OpenGL or OpenGL ES API
-header.  This is useful in combination with an extension loading library.
+@anchor GLFW_INCLUDE_NONE
+__GLFW_INCLUDE_NONE__ makes the GLFW header not include any OpenGL or OpenGL ES
+API header.  This is useful in combination with an extension loading library.

 If none of the above inclusion macros are defined, the standard OpenGL `GL/gl.h`
-header (`OpenGL/gl.h` on OS X) is included.
+header (`OpenGL/gl.h` on macOS) is included.

 The following macros control the inclusion of additional API headers.  Any
 number of these may be defined simultaneously, and/or together with one of the
 above macros.

-`GLFW_INCLUDE_GLEXT` makes the GLFW header include the appropriate extension
+@anchor GLFW_INCLUDE_VULKAN
+__GLFW_INCLUDE_VULKAN__ makes the GLFW header include the Vulkan
+`vulkan/vulkan.h` header in addition to any selected OpenGL or OpenGL ES header.
+
+@anchor GLFW_INCLUDE_GLEXT
+__GLFW_INCLUDE_GLEXT__ makes the GLFW header include the appropriate extension
 header for the OpenGL or OpenGL ES header selected above after and in addition
 to that header.

-`GLFW_INCLUDE_GLU` makes the header include the GLU header in addition to the
+@anchor GLFW_INCLUDE_GLU
+__GLFW_INCLUDE_GLU__ makes the header include the GLU header in addition to the
 header selected above.  This should only be used with the standard OpenGL header
 and only for compatibility with legacy code.  GLU has been deprecated and should
 not be used in new code.
@@ -119,7 +129,7 @@ a shared library / dynamic library / DLL then it takes care of these links.
 However, if you are using GLFW as a static library then your executable will
 need to link against these libraries.

-On Windows and OS X, the list of system libraries is static and can be
+On Windows and macOS, the list of system libraries is static and can be
 hard-coded into your build environment.  See the section for your development
 environment below.  On Linux and other Unix-like operating systems, the list
 varies but can be retrieved in various ways as described below.
@@ -141,9 +151,9 @@ set of default libraries along with other dependencies like `user32` and
 `kernel32`.  If you are using GLU, you must also link with `glu32`.

 The link library for the GLFW DLL is named `glfw3dll`.  When compiling an
-application that uses the DLL version of GLFW, you need to define the `GLFW_DLL`
-macro _before_ any inclusion of the GLFW header.  This can be done either with
-a compiler switch or by defining it in your source code.
+application that uses the DLL version of GLFW, you need to define the @ref
+GLFW_DLL macro _before_ any inclusion of the GLFW header.  This can be done
+either with a compiler switch or by defining it in your source code.

 An application using the GLFW DLL does not need to link against any of its
 dependencies, but you still have to link against `opengl32` if your application
@@ -178,8 +188,8 @@ add_subdirectory(path/to/glfw)

 Once GLFW has been added to the project, link against it with the `glfw` target.
 This adds all link-time dependencies of GLFW as it is currently configured,
-the include directory for the GLFW header and, when applicable, the
-[GLFW_DLL](@ref build_macros) macro.
+the include directory for the GLFW header and, when applicable, the @ref
+GLFW_DLL macro.

@code{.cmake}
 target_link_libraries(myapp glfw)
@@ -289,7 +299,7 @@ env PKG_CONFIG_PATH=path/to/glfw/src cc `pkg-config --cflags glfw3` -o myprog my
@endcode

 The dependencies do not include OpenGL or GLU, as GLFW loads any OpenGL, OpenGL
-ES or Vulkan libraries it needs at runtime and does not use GLU.  On OS X, GLU
+ES or Vulkan libraries it needs at runtime and does not use GLU.  On macOS, GLU
 is built into the OpenGL framework, so if you need GLU you don't need to do
 anything extra.  If you need GLU and are using Linux or BSD, you should add the
 `glu` pkg-config package.
@@ -309,7 +319,7 @@ cc `pkg-config --cflags glfw3 glu` -o myprog myprog.c `pkg-config --static --lib
@endcode


-@subsection build_link_xcode With Xcode on OS X
+@subsection build_link_xcode With Xcode on macOS

 If you are using the dynamic library version of GLFW, simply add it to the
 project dependencies.
@@ -319,10 +329,10 @@ OpenGL, IOKit and CoreVideo frameworks to the project as dependencies.  They can
 all be found in `/System/Library/Frameworks`.


-@subsection build_link_osx With command-line on OS X
+@subsection build_link_osx With command-line on macOS

 It is recommended that you use [pkg-config](@ref build_link_pkgconfig) when
-building from the command line on OS X.  That way you will get any new
+building from the command line on macOS.  That way you will get any new
 dependencies added automatically.  If you still wish to build manually, you need
 to add the required frameworks and libraries to your command-line yourself using
 the `-l` and `-framework` switches.
@@ -342,6 +352,6 @@ against it from the command-line.
 The OpenGL framework contains both the OpenGL and GLU APIs, so there is nothing
 special to do when using GLU.  Also note that even though your machine may have
 `libGL`-style OpenGL libraries, they are for use with the X Window System and
-will _not_ work with the OS X native version of GLFW.
+will _not_ work with the macOS native version of GLFW.

 */
@@ -160,7 +160,7 @@ extensions to provide support for sRGB framebuffers.  Where both of these
 extension are unavailable, the `GLFW_SRGB_CAPABLE` hint will have no effect.


-@section compat_osx OpenGL 3.2 and later on OS X
+@section compat_osx OpenGL 3.2 and later on macOS

 Support for OpenGL 3.2 and above was introduced with OS X 10.7 and even then
 only forward-compatible, core profile contexts are supported.  Support for
@@ -185,10 +185,11 @@ a non-default value will cause @ref glfwCreateWindow to fail and the

@section compat_vulkan Vulkan loader and API

-GLFW uses the standard system-wide Vulkan loader to access the Vulkan API.
-This should be installed by graphics drivers and Vulkan SDKs.  If this is not
-available, @ref glfwVulkanSupported will return `GLFW_FALSE` and all other
-Vulkan-related functions will fail with an @ref GLFW_API_UNAVAILABLE error.
+By default, GLFW uses the standard system-wide Vulkan loader to access the
+Vulkan API on all platforms except macOS.  This is installed by both graphics
+drivers and Vulkan SDKs.  If the loader is not found, @ref glfwVulkanSupported
+will return `GLFW_FALSE` and all other Vulkan-related functions will fail with
+an @ref GLFW_API_UNAVAILABLE error.


@section compat_wsi Vulkan WSI extensions
@@ -201,6 +202,11 @@ surfaces on Microsoft Windows.  If any of these extensions are not available,
@ref glfwGetRequiredInstanceExtensions will return an empty list and window
 surface creation will fail.

+GLFW uses the `VK_KHR_surface` and `VK_MVK_macos_surface` extensions to create
+surfaces on macOS.  If any of these extensions are not available, @ref
+glfwGetRequiredInstanceExtensions will return an empty list and window surface
+creation will fail.
+
 GLFW uses the `VK_KHR_surface` and either the `VK_KHR_xlib_surface` or
 `VK_KHR_xcb_surface` extensions to create surfaces on X11.  If `VK_KHR_surface`
 or both `VK_KHR_xlib_surface` and `VK_KHR_xcb_surface` are not available, @ref
@@ -217,8 +223,4 @@ surfaces on Mir.  If any of these extensions are not available, @ref
 glfwGetRequiredInstanceExtensions will return an empty list and window surface
 creation will fail.

-GLFW does not support any extensions for window surface creation on OS X,
-meaning@ref glfwGetRequiredInstanceExtensions will return an empty list and
-window surface creation will fail.
-
 */
@@ -14,7 +14,8 @@ GLFW uses [CMake](http://www.cmake.org/) to generate project files or makefiles
 for a particular development environment.  If you are on a Unix-like system such
 as Linux or FreeBSD or have a package system like Fink, MacPorts, Cygwin or
 Homebrew, you can simply install its CMake package.  If not, you can download
-installers for Windows and OS X from the [CMake website](http://www.cmake.org/).
+installers for Windows and macOS from the
+[CMake website](http://www.cmake.org/).

@note CMake only generates project files or makefiles.  It does not compile the
 actual GLFW library.  To compile GLFW, first generate these files for your
@@ -76,11 +77,11 @@ the CMake wiki.
 Once you have this set up, move on to @ref compile_generate.


-@subsubsection compile_deps_xcode Dependencies for Xcode on OS X
+@subsubsection compile_deps_xcode Dependencies for Xcode on macOS

 Xcode comes with all necessary tools except for CMake.  The required headers
-and libraries are included in the core OS X frameworks.  Xcode can be downloaded
-from the Mac App Store or from the ADC Member Center.
+and libraries are included in the core macOS frameworks.  Xcode can be
+downloaded from the Mac App Store or from the ADC Member Center.

 Once you have Xcode installed, move on to @ref compile_generate.

@@ -96,6 +97,17 @@ Once you have installed the necessary packages, move on to @ref
 compile_generate.


+@subsection compile_deps_osmesa Dependencies for Linux and OSMesa
+
+To compile GLFW for OSMesa, you need to install the OSMesa library and header
+packages.  For example, on Ubuntu and other distributions based on Debian
+GNU/Linux, you need to install the `libosmesa6-dev` package.  The OSMesa library
+is required at runtime for context creation and is loaded on demand.
+
+Once you have installed the necessary packages, move on to @ref
+compile_generate.
+
+
@subsection compile_generate Generating build files with CMake

 Once you have all necessary dependencies it is time to generate the project
@@ -181,45 +193,52 @@ cmake -DBUILD_SHARED_LIBS=ON .

@subsubsection compile_options_shared Shared CMake options

-`BUILD_SHARED_LIBS` determines whether GLFW is built as a static
+@anchor BUILD_SHARED_LIBS
+__BUILD_SHARED_LIBS__ determines whether GLFW is built as a static
 library or as a DLL / shared library / dynamic library.

-`LIB_SUFFIX` affects where the GLFW shared /dynamic library is installed.  If it
-is empty, it is installed to `${CMAKE_INSTALL_PREFIX}/lib`.  If it is set to
+@anchor LIB_SUFFIX
+__LIB_SUFFIX__ affects where the GLFW shared /dynamic library is installed.  If
+it is empty, it is installed to `${CMAKE_INSTALL_PREFIX}/lib`.  If it is set to
 `64`, it is installed to `${CMAKE_INSTALL_PREFIX}/lib64`.

-`GLFW_BUILD_EXAMPLES` determines whether the GLFW examples are built
+@anchor GLFW_BUILD_EXAMPLES
+__GLFW_BUILD_EXAMPLES__ determines whether the GLFW examples are built
 along with the library.

-`GLFW_BUILD_TESTS` determines whether the GLFW test programs are
+@anchor GLFW_BUILD_TESTS
+__GLFW_BUILD_TESTS__ determines whether the GLFW test programs are
 built along with the library.

-`GLFW_BUILD_DOCS` determines whether the GLFW documentation is built along with
-the library.
+@anchor GLFW_BUILD_DOCS
+__GLFW_BUILD_DOCS__ determines whether the GLFW documentation is built along
+with the library.

-`GLFW_VULKAN_STATIC` determines whether to use the Vulkan loader linked
+@anchor GLFW_VULKAN_STATIC
+__GLFW_VULKAN_STATIC__ determines whether to use the Vulkan loader linked
 statically into the application.


-@subsubsection compile_options_osx OS X specific CMake options
+@subsubsection compile_options_osx macOS specific CMake options

-`GLFW_USE_CHDIR` determines whether `glfwInit` changes the current
+@anchor GLFW_USE_CHDIR
+__GLFW_USE_CHDIR__ determines whether @ref glfwInit changes the current
 directory of bundled applications to the `Contents/Resources` directory.

-`GLFW_USE_MENUBAR` determines whether the first call to
-`glfwCreateWindow` sets up a minimal menu bar.
-
-`GLFW_USE_RETINA` determines whether windows will use the full resolution of
-Retina displays.
+@anchor GLFW_USE_MENUBAR
+__GLFW_USE_MENUBAR__ determines whether the first call to @ref glfwCreateWindow
+sets up a minimal menu bar.


@subsubsection compile_options_win32 Windows specific CMake options

-`USE_MSVC_RUNTIME_LIBRARY_DLL` determines whether to use the DLL version or the
+@anchor USE_MSVC_RUNTIME_LIBRARY_DLL
+__USE_MSVC_RUNTIME_LIBRARY_DLL__ determines whether to use the DLL version or the
 static library version of the Visual C++ runtime library.  If set to `ON`, the
 DLL version of the Visual C++ library is used.

-`GLFW_USE_HYBRID_HPG` determines whether to export the `NvOptimusEnablement` and
+@anchor GLFW_USE_HYBRID_HPG
+__GLFW_USE_HYBRID_HPG__ determines whether to export the `NvOptimusEnablement` and
 `AmdPowerXpressRequestHighPerformance` symbols, which force the use of the
 high-performance GPU on Nvidia Optimus and AMD PowerXpress systems.  These symbols
 need to be exported by the EXE to be detected by the driver, so the override
@@ -236,46 +255,39 @@ features.

 When building with CMake, the `glfw_config.h` configuration header is generated
 based on the current platform and CMake options.  The GLFW CMake environment
-defines `_GLFW_USE_CONFIG_H`, which causes this header to be included by
+defines @b GLFW_USE_CONFIG_H, which causes this header to be included by
 `internal.h`.  Without this macro, GLFW will expect the necessary configuration
 macros to be defined on the command-line.

 The window creation API is used to create windows, handle input, monitors, gamma
 ramps and clipboard.  The options are:

- - `_GLFW_COCOA` to use the Cocoa frameworks
- - `_GLFW_WIN32` to use the Win32 API
- - `_GLFW_X11` to use the X Window System
- - `_GLFW_WAYLAND` to use the Wayland API (experimental and incomplete)
- - `_GLFW_MIR` to use the Mir API (experimental and incomplete)
+ - @b _GLFW_COCOA to use the Cocoa frameworks
+ - @b _GLFW_WIN32 to use the Win32 API
+ - @b _GLFW_X11 to use the X Window System
+ - @b _GLFW_WAYLAND to use the Wayland API (experimental and incomplete)
+ - @b _GLFW_MIR to use the Mir API (experimental and incomplete)
+ - @b _GLFW_OSMESA to use the OSMesa API (headless and non-interactive)

 If you are building GLFW as a shared library / dynamic library / DLL then you
-must also define `_GLFW_BUILD_DLL`.  Otherwise, you must not define it.
+must also define @b _GLFW_BUILD_DLL.  Otherwise, you must not define it.

 If you are linking the Vulkan loader statically into your application then you
-must also define `_GLFW_VULKAN_STATIC`.  Otherwise, GLFW will attempt to use the
+must also define @b _GLFW_VULKAN_STATIC.  Otherwise, GLFW will attempt to use the
 external version.

 For the EGL context creation API, the following options are available:

- - `_GLFW_USE_EGLPLATFORM_H` to use `EGL/eglplatform.h` for native handle
+ - @b _GLFW_USE_EGLPLATFORM_H to use `EGL/eglplatform.h` for native handle
   definitions (fallback)

-If you are using the X11 window creation API, support for the following X11
-extensions can be enabled:
-
- - `_GLFW_HAS_XF86VM` to use Xxf86vm as a fallback when RandR gamma is broken
- (recommended)
-
 If you are using the Cocoa window creation API, the following options are
 available:

- - `_GLFW_USE_CHDIR` to `chdir` to the `Resources` subdirectory of the
+ - @b _GLFW_USE_CHDIR to `chdir` to the `Resources` subdirectory of the
   application bundle during @ref glfwInit (recommended)
- - `_GLFW_USE_MENUBAR` to create and populate the menu bar when the first window
+ - @b _GLFW_USE_MENUBAR to create and populate the menu bar when the first window
   is created (recommended)
- - `_GLFW_USE_RETINA` to have windows use the full resolution of Retina displays
-   (recommended)

@note None of the @ref build_macros may be defined during the compilation of
 GLFW.  If you define any of these in your build files, make sure they are not
@@ -30,8 +30,8 @@ the `glfwinfo` test program.

@note Vulkan does not have a context and the Vulkan instance is created via the
 Vulkan API itself.  If you will be using Vulkan to render to a window, disable
-context creation by setting the [GLFW_CLIENT_API](@ref window_hints_ctx) hint to
-`GLFW_NO_API`.  For more information, see the @ref vulkan_guide.
+context creation by setting the [GLFW_CLIENT_API](@ref GLFW_CLIENT_API_hint)
+hint to `GLFW_NO_API`.  For more information, see the @ref vulkan_guide.


@subsection context_hints Context creation hints
@@ -68,7 +68,7 @@ GLFW comes with a simple object sharing test program called `sharing`.

 GLFW doesn't support creating contexts without an associated window.  However,
 contexts with hidden windows can be created with the
-[GLFW_VISIBLE](@ref window_hints_wnd) window hint.
+[GLFW_VISIBLE](@ref GLFW_VISIBLE_hint) window hint.

@code
 glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
@@ -84,7 +84,7 @@ objects are recommended for rendering with such contexts.
 You should still [process events](@ref events) as long as you have at least one
 window, even if none of them are visible.

-__OS X:__ The first time a window is created the menu bar is populated with
+@macos The first time a window is created the menu bar is populated with
 common commands like Hide, Quit and About.  This is not desirable for example
 when writing a command-line only application.  The menu bar setup can be
 disabled with a [compile-time option](@ref compile_options_osx).
@@ -93,8 +93,8 @@ disabled with a [compile-time option](@ref compile_options_osx).
@subsection context_less Windows without contexts

 You can disable context creation by setting the
-[GLFW_CLIENT_API](@ref window_hints_ctx) hint to `GLFW_NO_API`.  Windows without
-contexts must not be passed to @ref glfwMakeContextCurrent or @ref
+[GLFW_CLIENT_API](@ref GLFW_CLIENT_API_hint) hint to `GLFW_NO_API`.  Windows
+without contexts must not be passed to @ref glfwMakeContextCurrent or @ref
 glfwSwapBuffers.


@@ -266,8 +266,8 @@ supports.  These have names like `PFNGLGETDEBUGMESSAGELOGARBPROC` (for
 `glGetDebugMessageLogARB`), i.e. the name is made uppercase and `PFN` (pointer
 to function) and `PROC` (procedure) are added to the ends.

-To include the extension header, define [GLFW_INCLUDE_GLEXT](@ref build_macros)
-before including the GLFW header.
+To include the extension header, define @ref GLFW_INCLUDE_GLEXT before including
+the GLFW header.

@code
 #define GLFW_INCLUDE_GLEXT
@@ -15,10 +15,9 @@ for the other areas of GLFW.
 - @ref monitor_guide

 GLFW provides many kinds of input.  While some can only be polled, like time, or
-only received via callbacks, like scrolling, there are those that provide both
-callbacks and polling.  Where a callback is provided, that is the recommended
-way to receive that kind of input.  The more you can use callbacks the less time
-your users' machines will need to spend polling.
+only received via callbacks, like scrolling, many provide both callbacks and
+polling.  Callbacks are more work to use than polling but is less CPU intensive
+and guarantees that you do not miss state changes.

 All input callbacks receive a window handle.  By using the
 [window user pointer](@ref window_userptr), you can access non-global structures
@@ -32,14 +31,14 @@ information.

@section events Event processing

-GLFW needs to communicate regularly with the window system both in order to
-receive events and to show that the application hasn't locked up.  Event
-processing must be done regularly while you have any windows and is normally
-done each frame after [buffer swapping](@ref buffer_swap).  Even when you have
-no windows, event polling needs to be done in order to receive monitor
-connection events.
+GLFW needs to poll the window system for events both to provide input to the
+application and to prove to the window system that the application hasn't locked
+up.  Event processing is normally done each frame after
+[buffer swapping](@ref buffer_swap).  Even when you have no windows, event
+polling needs to be done in order to receive monitor and joystick connection
+events.

-There are two functions for processing pending events.  @ref glfwPollEvents,
+There are three functions for processing pending events.  @ref glfwPollEvents,
 processes only those events that have already been received and then returns
 immediately.

@@ -47,7 +46,7 @@ immediately.
 glfwPollEvents();
@endcode

-This is the best choice when rendering continually, like most games do.
+This is the best choice when rendering continuously, like most games do.

 If you only need to update the contents of the window when you receive new
 input, @ref glfwWaitEvents is a better choice.
@@ -61,8 +60,8 @@ processes all received events.  This saves a great deal of CPU cycles and is
 useful for, for example, editing tools.  There must be at least one GLFW window
 for this function to sleep.

-If you want to wait for events but have UI elements that need periodic updates,
-call @ref glfwWaitEventsTimeout.
+If you want to wait for events but have UI elements or other tasks that need
+periodic updates, @ref glfwWaitEventsTimeout lets you specify a timeout.

@code
 glfwWaitEventsTimeout(0.7);
@@ -80,10 +79,17 @@ glfwPostEmptyEvent.
 glfwPostEmptyEvent();
@endcode

-Do not assume that callbacks will _only_ be called through either of the above
-functions.  While it is necessary to process events in the event queue, some
-window systems will send some events directly to the application, which in turn
-causes callbacks to be called outside of regular event processing.
+Do not assume that callbacks will _only_ be called in response to the above
+functions.  While it is necessary to process events in one or more of the ways
+above, 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.
+
+For example, on Windows the system function that @ref glfwSetWindowSize is
+implemented with will send window size events directly to the event callback
+that every window has and that GLFW implements for its windows.  If you have set
+a [window size callback](@ref window_size) GLFW will call it in turn with the
+new size before everything returns back out of the @ref glfwSetWindowSize call.


@section input_keyboard Keyboard input
@@ -125,9 +131,16 @@ _E-mail_ and _Play_ keys.
 The scancode is unique for every key, regardless of whether it has a key token.
 Scancodes are platform-specific but consistent over time, so keys will have
 different scancodes depending on the platform but they are safe to save to disk.
+You can query the scancode for any [named key](@ref keys) on the current
+platform with @ref glfwGetKeyScancode.

-Key states for [named keys](@ref keys) are also saved in per-window state arrays
-that can be polled with @ref glfwGetKey.
+@code
+const int scancode = glfwGetKeyScancode(GLFW_KEY_X);
+set_key_mapping(scancode, swap_weapons);
+@endcode
+
+The last reported state for every [named key](@ref keys) is also saved in
+per-window state arrays that can be polled with @ref glfwGetKey.

@code
 int state = glfwGetKey(window, GLFW_KEY_E);
@@ -138,7 +151,7 @@ if (state == GLFW_PRESS)
 The returned state is one of `GLFW_PRESS` or `GLFW_RELEASE`.

 This function only returns cached key event state.  It does not poll the
-system for the current state of the key.
+system for the current physical state of the key.

 Whenever you poll state, you risk missing the state change you are looking for.
 If a pressed key is released again before you poll its state, you will have
@@ -504,6 +517,9 @@ Joystick state is updated as needed when a joystick function is called and does
 not require a window to be created or @ref glfwPollEvents or @ref glfwWaitEvents
 to be called.

+To see all the properties of all connected joysticks in real-time, run the
+`joysticks` test program.
+

@subsection joystick_axis Joystick axis states

@@ -561,7 +577,7 @@ The callback function receives the ID of the joystick that has been connected
 and disconnected and the event that occurred.

@code
-void joystick_callback(int joy, int event)
+void joystick_callback(int jid, int event)
 {
    if (event == GLFW_CONNECTED)
    {
@@ -111,6 +111,6 @@ which is generated from the `glfw_config.h.in` file by CMake.
 Configuration macros the same style as tokens in the public interface, except
 with a leading underscore.

-Examples: `_GLFW_HAS_XF86VM` 
+Examples: `_GLFW_USE_HYBRID_HPG` 

 */
@@ -34,6 +34,8 @@ use the new API.
 There is a section on @ref guarantees_limitations for pointer lifetimes,
 reentrancy, thread safety, event order and backward and forward compatibility.

+The @ref metal shows how to use Metal with GLFW on OS X.
+
 The [FAQ](http://www.glfw.org/faq.html) answers many common questions about the
 design, implementation and use of GLFW.

@@ -0,0 +1,7 @@
+/*!
+
+@page metal Metal guide
+ 
+@tableofcontents
+
+*/
@@ -213,4 +213,12 @@ glfwSetGammaRamp with the resulting ramp.
 glfwSetGamma(monitor, 1.0);
@endcode

+To experiment with gamma correction via the @ref glfwSetGamma function, run the
+`gamma` test program.
+
+@note The software controlled gamma ramp is applied _in addition_ to the
+hardware gamma correction, which today is usually an approximation of sRGB
+gamma.  This means that setting a perfectly linear ramp, or gamma 1.0, will
+produce the default (usually sRGB-like) behavior.
+
 */
@@ -434,7 +434,7 @@ GLFW 3 does not by default include the GLU header and GLU itself has been
 deprecated by [Khronos](https://en.wikipedia.org/wiki/Khronos_Group).  __New
 projects should not use GLU__, but if you need it for legacy code that
 has been moved to GLFW 3, you can request that the GLFW header includes it by
-defining `GLFW_INCLUDE_GLU` before the inclusion of the GLFW header.
+defining @ref GLFW_INCLUDE_GLU before the inclusion of the GLFW header.

@par Old syntax
@code
@@ -4,6 +4,38 @@

@section news_33 New features in 3.3

+@subsection news_33_maximize Window maximization callback
+
+GLFW now supports window maximization notifications with @ref
+glfwSetWindowMaximizeCallback.
+
+
+@subsection news_33_keyscancode Platform-specific key scancode query
+
+GLFW now supports querying the platform dependent scancode of any key with
+@ref glfwGetKeyScancode.
+
+
+@subsection news_33_setwindowattrib Support for updating window attributes
+
+GLFW now supports changing the [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
+[GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib),
+[GLFW_FLOATING](@ref GLFW_FLOATING_attrib) and
+[GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib) attributes for existing
+windows with @ref glfwSetWindowAttrib.
+
+
+@subsection news_33_moltenvk Support for Vulkan on macOS via MoltenVK
+
+GLFW now supports the `VK_MVK_macos_surface` window surface creation extension
+provided by [MoltenVK](https://moltengl.com/moltenvk/).
+
+
+@subsection news_33_osmesa OSMesa backend for headless software rendering
+
+GLFW now supports headless context creation and software rendering via OSMesa,
+intended for automated testing.  This backend does not provide input.
+

@section news_32 New features in 3.2

@@ -14,7 +46,7 @@ GLFW now supports basic integration with Vulkan with @ref glfwVulkanSupported,
@ref glfwGetRequiredInstanceExtensions, @ref glfwGetInstanceProcAddress, @ref
 glfwGetPhysicalDevicePresentationSupport and @ref glfwCreateWindowSurface.
 Vulkan header inclusion can be selected with
-[GLFW_INCLUDE_VULKAN](@ref build_macros).
+@ref GLFW_INCLUDE_VULKAN.


@subsection news_32_setwindowmonitor Window mode switching
@@ -27,7 +59,7 @@ the monitor and desired resolution and refresh rate of full screen windows with
@subsection news_32_maximize Window maxmimization support

 GLFW now supports window maximization with @ref glfwMaximizeWindow and the
-[GLFW_MAXIMIZED](@ref window_attribs_wnd) window hint and attribute.
+@ref GLFW_MAXIMIZED window hint and attribute.


@subsection news_32_focus Window input focus control
@@ -72,21 +104,21 @@ with @ref glfwSetJoystickCallback.

@subsection news_32_noapi Context-less windows

-GLFW now supports creating windows without a OpenGL or OpenGL ES context with
-[GLFW_NO_API](@ref window_hints_ctx).
+GLFW now supports creating windows without a OpenGL or OpenGL ES context by
+setting the [GLFW_CLIENT_API](@ref GLFW_CLIENT_API_hint) hint to `GLFW_NO_API`.


@subsection news_32_contextapi Run-time context creation API selection

-GLFW now supports selecting the context creation API at run-time with the
-[GLFW_CONTEXT_CREATION_API](@ref window_hints_ctx) window hint value.
+GLFW now supports selecting and querying the context creation API at run-time
+with the @ref GLFW_CONTEXT_CREATION_API hint and attribute.


@subsection news_32_noerror Error-free context creation

-GLFW now supports creating OpenGL and OpenGL ES contexts that do not emit errors
-with the [GLFW_CONTEXT_NO_ERROR](@ref window_hints_ctx) window hint, provided
-the machine supports the `GL_KHR_no_error` extension.
+GLFW now supports creating and querying OpenGL and OpenGL ES contexts that do
+not emit errors with the @ref GLFW_CONTEXT_NO_ERROR hint, provided the machine
+supports the `GL_KHR_no_error` extension.


@subsection news_32_cmake CMake config-file package support
@@ -140,21 +172,21 @@ client area of a window, with @ref glfwGetWindowFrameSize.
@subsection news_31_autoiconify Simultaneous multi-monitor rendering

 GLFW now supports disabling auto-iconification of full screen windows with
-the [GLFW_AUTO_ICONIFY](@ref window_hints_wnd) window hint.  This is intended
-for people building multi-monitor installations, where you need windows to stay
-in full screen despite losing input focus.
+the [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_hint) window hint.  This is
+intended for people building multi-monitor installations, where you need windows
+to stay in full screen despite losing input focus.


@subsection news_31_floating Floating windows

 GLFW now supports floating windows, also called topmost or always on top, for
-easier debugging with the [GLFW_FLOATING](@ref window_hints_wnd) window hint.
+easier debugging with the @ref GLFW_FLOATING window hint and attribute.


@subsection news_31_focused Initially unfocused windows

 GLFW now supports preventing a windowed mode window from gaining input focus on
-creation, with the [GLFW_FOCUSED](@ref window_hints_wnd) window hint.
+creation, with the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) window hint.


@subsection news_31_direct Direct access for window attributes and cursor position
@@ -175,24 +207,24 @@ being input, for example if the Control key is held down.

@subsection news_31_single Single buffered framebuffers

-GLFW now supports the creation of single buffered windows, with the
-[GLFW_DOUBLEBUFFER](@ref window_hints_fb) window hint.
+GLFW now supports the creation of single buffered windows, with the @ref
+GLFW_DOUBLEBUFFER hint.


@subsection news_31_glext Macro for including extension header

 GLFW now includes the extension header appropriate for the chosen OpenGL or
-OpenGL ES header when [GLFW_INCLUDE_GLEXT](@ref build_macros) is defined.  GLFW
-does not provide these headers.  They must be provided by your development
-environment or your OpenGL or OpenGL ES SDK.
+OpenGL ES header when @ref GLFW_INCLUDE_GLEXT is defined.  GLFW does not provide
+these headers.  They must be provided by your development environment or your
+OpenGL or OpenGL ES SDK.


@subsection news_31_release Context release behaviors

-GLFW now supports controlling whether the pipeline is flushed when a context is
-made non-current, with the
-[GLFW_CONTEXT_RELEASE_BEHAVIOR](@ref window_hints_ctx) window hint, provided the
-machine supports the `GL_KHR_context_flush_control` extension.
+GLFW now supports controlling and querying whether the pipeline is flushed when
+a context is made non-current, with the @ref GLFW_CONTEXT_RELEASE_BEHAVIOR hint
+and attribute, provided the machine supports the `GL_KHR_context_flush_control`
+extension.


@subsection news_31_wayland (Experimental) Wayland support
@@ -267,11 +299,11 @@ glfwSetGamma, which generates a ramp from a gamma value and then sets it.
@subsection news_30_gles OpenGL ES support

 GLFW now supports the creation of OpenGL ES contexts, by setting the
-`GLFW_CLIENT_API` window hint to `GLFW_OPENGL_ES_API`, where creation of such
-contexts are supported.  Note that GLFW _does not implement_ OpenGL ES, so your
-driver must provide support in a way usable by GLFW.  Modern Nvidia and Intel
-drivers support creation of OpenGL ES context using the GLX and WGL APIs, while
-AMD provides an EGL implementation instead.
+[GLFW_CLIENT_API](@ref GLFW_CLIENT_API_hint) hint to `GLFW_OPENGL_ES_API`, where
+creation of such contexts are supported.  Note that GLFW _does not implement_
+OpenGL ES, so your driver must provide support in a way usable by GLFW.  Modern
+Nvidia and Intel drivers support creation of OpenGL ES context using the GLX and
+WGL APIs, while AMD provides an EGL implementation instead.


@subsection news_30_egl (Experimental) EGL support
@@ -282,11 +314,12 @@ through CMake options.

@subsection news_30_hidpi High-DPI support

-GLFW now supports high-DPI monitors on both Windows and OS X, giving windows full
-resolution framebuffers where other UI elements are scaled up.  To achieve this,
-@ref glfwGetFramebufferSize and @ref glfwSetFramebufferSizeCallback have been
-added.  These work with pixels, while the rest of the GLFW API works with screen
-coordinates.  This is important as OpenGL uses pixels, not screen coordinates.
+GLFW now supports high-DPI monitors on both Windows and macOS, giving windows
+full resolution framebuffers where other UI elements are scaled up.  To achieve
+this, @ref glfwGetFramebufferSize and @ref glfwSetFramebufferSizeCallback have
+been added.  These work with pixels, while the rest of the GLFW API works with
+screen coordinates.  This is important as OpenGL uses pixels, not screen
+coordinates.


@subsection news_30_error Error callback
@@ -341,16 +374,17 @@ to @ref glfwCreateWindow.
@subsection news_30_hidden Hidden windows

 Windows can now be hidden with @ref glfwHideWindow, shown using @ref
-glfwShowWindow and created initially hidden with the `GLFW_VISIBLE` window hint.
-This allows for off-screen rendering in a way compatible with most drivers, as
-well as moving a window to a specific position before showing it.
+glfwShowWindow and created initially hidden with the @ref GLFW_VISIBLE window
+hint and attribute.  This allows for off-screen rendering in a way compatible
+with most drivers, as well as moving a window to a specific position before
+showing it.


@subsection news_30_undecorated Undecorated windows

 Windowed mode windows can now be created without decorations, e.g. things like
-a frame, a title bar, with the `GLFW_DECORATED` window hint.  This allows for
-the creation of things like splash screens.
+a frame, a title bar, with the @ref GLFW_DECORATED window hint and attribute.
+This allows for the creation of things like splash screens.


@subsection news_30_keymods Modifier key bit masks
@@ -340,7 +340,7 @@ The program above can be found in the
 [source package](http://www.glfw.org/download.html) as `examples/simple.c`
 and is compiled along with all other examples when you build GLFW.  If you
 built GLFW from the source package then already have this as `simple.exe` on
-Windows, `simple` on Linux or `simple.app` on OS X.
+Windows, `simple` on Linux or `simple.app` on macOS.

 This tutorial used only a few of the many functions GLFW provides.  There are
 guides for each of the areas covered by GLFW.  Each guide will introduce all the
@@ -11,8 +11,10 @@ with Vulkan concepts like loaders, devices, queues and surfaces and leaves it to
 the Vulkan documentation to explain the details of Vulkan functions.

 To develop for Vulkan you should install an SDK for your platform, for example
-the [LunarG Vulkan SDK](https://vulkan.lunarg.com/).  Apart from the headers and
-libraries, it also provides the validation layers necessary for development.
+the [LunarG Vulkan SDK](https://vulkan.lunarg.com/) for Windows and Linux or
+[MoltenVK](https://moltengl.com/moltenvk/) for macOS.  Apart from headers and
+link libraries, they should also provide the validation layers necessary for
+development.

 The GLFW library does not need the Vulkan SDK to enable support for Vulkan.
 However, any Vulkan-specific test and example programs are built only if the
@@ -28,10 +30,29 @@ are also guides for the other areas of the GLFW API.
 - @ref input_guide


+@section vulkan_loader Linking against the Vulkan loader
+
+By default, GLFW will look for the Vulkan loader on demand at runtime via its
+standard name (`vulkan-1.dll` on Windows, `libvulkan.so.1` on Linux and other
+Unix-like systems).  This means that GLFW does not need to be linked against the
+loader.  However, it also means that if you are using the static library form of
+the Vulkan loader GLFW will either fail to find it or (worse) use the wrong one.
+
+The @ref GLFW_VULKAN_STATIC CMake option makes GLFW link directly against the
+static form.  Not linking against the Vulkan loader will then be a compile-time
+error.
+
+@macos MoltenVK only provides the static library form of the Vulkan loader, but
+GLFW is able to find it without @ref GLFW_VULKAN_STATIC as long as it is linked
+into any of the binaries already loaded into the process.  As it is a static
+library, you must also link against its dependencies: the `Cocoa`, `Metal` and
+`QuartzCore` frameworks and the `libc++` library.
+
+
@section vulkan_include Including the Vulkan and GLFW header files

-To include the Vulkan header, define [GLFW_INCLUDE_VULKAN](@ref build_macros)
-before including the GLFW header.
+To include the Vulkan header, define @ref GLFW_INCLUDE_VULKAN before including
+the GLFW header.

@code
 #define GLFW_INCLUDE_VULKAN
@@ -181,7 +202,7 @@ an existing Vulkan surface.

 Unless you will be using OpenGL or OpenGL ES with the same window as Vulkan,
 there is no need to create a context.  You can disable context creation with the
-[GLFW_CLIENT_API](@ref window_hints_ctx) hint.
+[GLFW_CLIENT_API](@ref GLFW_CLIENT_API_hint) hint.

@code
 glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
@@ -71,10 +71,10 @@ Video mode field        | Corresponds to
 ----------------------- | ------------------------
 GLFWvidmode.width       | `width` parameter
 GLFWvidmode.height      | `height` parameter
-GLFWvidmode.redBits     | `GLFW_RED_BITS` hint
-GLFWvidmode.greenBits   | `GLFW_GREEN_BITS` hint
-GLFWvidmode.blueBits    | `GLFW_BLUE_BITS` hint
-GLFWvidmode.refreshRate | `GLFW_REFRESH_RATE` hint
+GLFWvidmode.redBits     | @ref GLFW_RED_BITS hint
+GLFWvidmode.greenBits   | @ref GLFW_GREEN_BITS hint
+GLFWvidmode.blueBits    | @ref GLFW_BLUE_BITS hint
+GLFWvidmode.refreshRate | @ref GLFW_REFRESH_RATE hint

 Once you have a full screen window, you can change its resolution, refresh rate
 and monitor with @ref glfwSetWindowMonitor.  If you just need change its
@@ -85,9 +85,9 @@ unaffected.

 By default, the original video mode of the monitor will be restored and the
 window iconified if it loses input focus, to allow the user to switch back to
-the desktop.  This behavior can be disabled with the `GLFW_AUTO_ICONIFY` window
-hint, for example if you wish to simultaneously cover multiple windows with full
-screen windows.
+the desktop.  This behavior can be disabled with the
+[GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_hint) window hint, for example if you
+wish to simultaneously cover multiple windows with full screen windows.


@subsubsection window_windowed_full_screen "Windowed full screen" windows
@@ -146,6 +146,11 @@ context.  These hints are set to their default values each time the library is
 initialized with @ref glfwInit, can be set individually with @ref glfwWindowHint
 and reset all at once to their defaults with @ref glfwDefaultWindowHints.

+Some hints are platform specific.  These are always valid to set on any
+platform but they will only affect their specific platform.  Other platforms
+will simply ignore them.  Setting these hints requires no platform specific
+headers or calls.
+
 Note that hints need to be set _before_ the creation of the window and context
 you wish to have the specified attributes.

@@ -158,107 +163,134 @@ that are not hard constraints are matched as closely as possible, but the
 resulting context and framebuffer may differ from what these hints requested.

 The following hints are always hard constraints:
- `GLFW_STEREO`
- `GLFW_DOUBLEBUFFER`
- `GLFW_CLIENT_API`
- `GLFW_CONTEXT_CREATION_API`
+- @ref GLFW_STEREO
+- @ref GLFW_DOUBLEBUFFER
+- [GLFW_CLIENT_API](@ref GLFW_CLIENT_API_hint)
+- [GLFW_CONTEXT_CREATION_API](@ref GLFW_CONTEXT_CREATION_API_hint)

 The following additional hints are hard constraints when requesting an OpenGL
 context, but are ignored when requesting an OpenGL ES context:
- `GLFW_OPENGL_FORWARD_COMPAT`
- `GLFW_OPENGL_PROFILE`
+- [GLFW_OPENGL_FORWARD_COMPAT](@ref GLFW_OPENGL_FORWARD_COMPAT_hint)
+- [GLFW_OPENGL_PROFILE](@ref GLFW_OPENGL_PROFILE_hint)


@subsubsection window_hints_wnd Window related hints

-`GLFW_RESIZABLE` specifies whether the windowed mode window will be resizable
+@anchor GLFW_RESIZABLE_hint
+__GLFW_RESIZABLE__ specifies whether the windowed mode window will be resizable
 _by the user_.  The window will still be resizable using the @ref
-glfwSetWindowSize function.  This hint is ignored for full screen windows.
+glfwSetWindowSize function.  This hint is ignored for full screen and
+undecorated windows.

-`GLFW_VISIBLE` specifies whether the windowed mode window will be initially
+@anchor GLFW_VISIBLE_hint
+__GLFW_VISIBLE__ specifies whether the windowed mode window will be initially
 visible.  This hint is ignored for full screen windows.

-`GLFW_DECORATED` specifies whether the windowed mode window will have window
-decorations such as a border, a close widget, etc.  An undecorated window may
-still allow the user to generate close events on some platforms.  This hint is
-ignored for full screen windows.
+@anchor GLFW_DECORATED_hint
+__GLFW_DECORATED__ specifies whether the windowed mode window will have window
+decorations such as a border, a close widget, etc.  An undecorated window will
+not be resizable by the user but will still allow the user to generate close
+events on some platforms.  This hint is ignored for full screen windows.

-`GLFW_FOCUSED` specifies whether the windowed mode window will be given input
+@anchor GLFW_FOCUSED_hint
+__GLFW_FOCUSED__ specifies whether the windowed mode window will be given input
 focus when created.  This hint is ignored for full screen and initially hidden
 windows.

-`GLFW_AUTO_ICONIFY` specifies whether the full screen window will
+@anchor GLFW_AUTO_ICONIFY_hint
+__GLFW_AUTO_ICONIFY__ specifies whether the full screen window will
 automatically iconify and restore the previous video mode on input focus loss.
 This hint is ignored for windowed mode windows.

-`GLFW_FLOATING` specifies whether the windowed mode window will be floating
+@anchor GLFW_FLOATING_hint
+__GLFW_FLOATING__ specifies whether the windowed mode window will be floating
 above other regular windows, also called topmost or always-on-top.  This is
 intended primarily for debugging purposes and cannot be used to implement proper
 full screen windows.  This hint is ignored for full screen windows.

-`GLFW_MAXIMIZED` specifies whether the windowed mode window will be maximized
+@anchor GLFW_MAXIMIZED_hint
+__GLFW_MAXIMIZED__ specifies whether the windowed mode window will be maximized
 when created.  This hint is ignored for full screen windows.


@subsubsection window_hints_fb Framebuffer related hints

-`GLFW_RED_BITS`, `GLFW_GREEN_BITS`, `GLFW_BLUE_BITS`, `GLFW_ALPHA_BITS`,
-`GLFW_DEPTH_BITS` and `GLFW_STENCIL_BITS` specify the desired bit depths of the
-various components of the default framebuffer.  `GLFW_DONT_CARE` means the
-application has no preference.
+@anchor GLFW_RED_BITS
+@anchor GLFW_GREEN_BITS
+@anchor GLFW_BLUE_BITS
+@anchor GLFW_ALPHA_BITS
+@anchor GLFW_DEPTH_BITS
+@anchor GLFW_STENCIL_BITS
+__GLFW_RED_BITS__, __GLFW_GREEN_BITS__, __GLFW_BLUE_BITS__, __GLFW_ALPHA_BITS__,
+__GLFW_DEPTH_BITS__ and __GLFW_STENCIL_BITS__ specify the desired bit depths of
+the various components of the default framebuffer.  A value of `GLFW_DONT_CARE`
+means the application has no preference.

-`GLFW_ACCUM_RED_BITS`, `GLFW_ACCUM_GREEN_BITS`, `GLFW_ACCUM_BLUE_BITS` and
-`GLFW_ACCUM_ALPHA_BITS` specify the desired bit depths of the various components
-of the accumulation buffer.  `GLFW_DONT_CARE` means the application has no
-preference.
+@anchor GLFW_ACCUM_RED_BITS
+@anchor GLFW_ACCUM_GREEN_BITS
+@anchor GLFW_ACCUM_BLUE_BITS
+@anchor GLFW_ACCUM_ALPHA_BITS
+__GLFW_ACCUM_RED_BITS__, __GLFW_ACCUM_GREEN_BITS__, __GLFW_ACCUM_BLUE_BITS__ and
+__GLFW_ACCUM_ALPHA_BITS__ specify the desired bit depths of the various
+components of the accumulation buffer.  A value of `GLFW_DONT_CARE` means the
+application has no preference.

@par
 Accumulation buffers are a legacy OpenGL feature and should not be used in new
 code.

-`GLFW_AUX_BUFFERS` specifies the desired number of auxiliary buffers.
-`GLFW_DONT_CARE` means the application has no preference.
+@anchor GLFW_AUX_BUFFERS
+__GLFW_AUX_BUFFERS__ specifies the desired number of auxiliary buffers.  A value
+of `GLFW_DONT_CARE` means the application has no preference.

@par
 Auxiliary buffers are a legacy OpenGL feature and should not be used in new
 code.

-`GLFW_STEREO` specifies whether to use stereoscopic rendering.  This is a hard
-constraint.
+@anchor GLFW_STEREO
+__GLFW_STEREO__ specifies whether to use OpenGL stereoscopic rendering.  This is
+a hard constraint.

-`GLFW_SAMPLES` specifies the desired number of samples to use for multisampling.
-Zero disables multisampling.  `GLFW_DONT_CARE` means the application has no
-preference.
+@anchor GLFW_SAMPLES
+__GLFW_SAMPLES__ specifies the desired number of samples to use for
+multisampling.  Zero disables multisampling.  A value of `GLFW_DONT_CARE` means
+the application has no preference.

-`GLFW_SRGB_CAPABLE` specifies whether the framebuffer should be sRGB capable.
+@anchor GLFW_SRGB_CAPABLE
+__GLFW_SRGB_CAPABLE__ specifies whether the framebuffer should be sRGB capable.
 If supported, a created OpenGL context will support the `GL_FRAMEBUFFER_SRGB`
 enable, also called `GL_FRAMEBUFFER_SRGB_EXT`) for controlling sRGB rendering
 and a created OpenGL ES context will always have sRGB rendering enabled.

-`GLFW_DOUBLEBUFFER` specifies whether the framebuffer should be double buffered.
-You nearly always want to use double buffering.  This is a hard constraint.
+@anchor GLFW_DOUBLEBUFFER
+__GLFW_DOUBLEBUFFER__ specifies whether the framebuffer should be double
+buffered.  You nearly always want to use double buffering.  This is a hard
+constraint.


@subsubsection window_hints_mtr Monitor related hints

-`GLFW_REFRESH_RATE` specifies the desired refresh rate for full screen windows.
-If set to `GLFW_DONT_CARE`, the highest available refresh rate will be used.
-This hint is ignored for windowed mode windows.
+@anchor GLFW_REFRESH_RATE
+__GLFW_REFRESH_RATE__ specifies the desired refresh rate for full screen
+windows.  A value of `GLFW_DONT_CARE` means the highest available refresh rate
+will be used.  This hint is ignored for windowed mode windows.


@subsubsection window_hints_ctx Context related hints

-`GLFW_CLIENT_API` specifies which client API to create the context for.
+@anchor GLFW_CLIENT_API_hint
+__GLFW_CLIENT_API__ specifies which client API to create the context for.
 Possible values are `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` and `GLFW_NO_API`.
 This is a hard constraint.

-`GLFW_CONTEXT_CREATION_API` specifies which context creation API to use to
+@anchor GLFW_CONTEXT_CREATION_API_hint
+__GLFW_CONTEXT_CREATION_API__ specifies which context creation API to use to
 create the context.  Possible values are `GLFW_NATIVE_CONTEXT_API` and
 `GLFW_EGL_CONTEXT_API`.  This is a hard constraint.  If no client API is
 requested, this hint is ignored.

@par
-__OS X:__ The EGL API is not available on this platform and requests to use it
+@macos The EGL API is not available on this platform and requests to use it
 will fail.

@par
@@ -274,16 +306,18 @@ the selected API.
 in a single process will cause the application to segfault.  Stick to one API or
 the other on Linux for now.

-`GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` specify the client
-API version that the created context must be compatible with.  The exact
+@anchor GLFW_CONTEXT_VERSION_MAJOR_hint
+@anchor GLFW_CONTEXT_VERSION_MINOR_hint
+__GLFW_CONTEXT_VERSION_MAJOR__ and __GLFW_CONTEXT_VERSION_MINOR__ specify the
+client API version that the created context must be compatible with.  The exact
 behavior of these hints depend on the requested client API.

@par
-__OpenGL:__ `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` are
-not hard constraints, but creation will fail if the OpenGL version of the
-created context is less than the one requested.  It is therefore perfectly safe
-to use the default of version 1.0 for legacy code and you will still get
-backwards-compatible contexts of version 3.0 and above when available.
+__OpenGL:__ These hints are not hard constraints, but creation will fail if the
+OpenGL version of the created context is less than the one requested.  It is
+therefore perfectly safe to use the default of version 1.0 for legacy code and
+you will still get backwards-compatible contexts of version 3.0 and above when
+available.

@par
 While there is no way to ask the driver for a context of the highest supported
@@ -291,14 +325,21 @@ version, GLFW will attempt to provide this when you ask for a version 1.0
 context, which is the default for these hints.

@par
-__OpenGL ES:__ `GLFW_CONTEXT_VERSION_MAJOR` and `GLFW_CONTEXT_VERSION_MINOR` are
-not hard constraints, but creation will fail if the OpenGL ES version of the
-created context is less than the one requested.  Additionally, OpenGL ES 1.x
-cannot be returned if 2.0 or later was requested, and vice versa.  This is
-because OpenGL ES 3.x is backward compatible with 2.0, but OpenGL ES 2.0 is not
-backward compatible with 1.x.
+__OpenGL ES:__ These hints are not hard constraints, but creation will fail if
+the OpenGL ES version of the created context is less than the one requested.
+Additionally, OpenGL ES 1.x cannot be returned if 2.0 or later was requested,
+and vice versa.  This is because OpenGL ES 3.x is backward compatible with 2.0,
+but OpenGL ES 2.0 is not backward compatible with 1.x.

-`GLFW_OPENGL_FORWARD_COMPAT` specifies whether the OpenGL context should be
+@note @macos The OS only supports forward-compatible core profile contexts for
+OpenGL versions 3.2 and later.  Before creating an OpenGL context of version
+3.2 or later you must set the
+[GLFW_OPENGL_FORWARD_COMPAT](@ref GLFW_OPENGL_FORWARD_COMPAT_hint) and
+[GLFW_OPENGL_PROFILE](@ref GLFW_OPENGL_PROFILE_hint) hints accordingly.  OpenGL
+3.0 and 3.1 contexts are not supported at all on macOS.
+
+@anchor GLFW_OPENGL_FORWARD_COMPAT_hint
+__GLFW_OPENGL_FORWARD_COMPAT__ specifies whether the OpenGL context should be
 forward-compatible, i.e. one where all functionality deprecated in the requested
 version of OpenGL is removed.  This must only be used if the requested OpenGL
 version is 3.0 or above.  If OpenGL ES is requested, this hint is ignored.
@@ -307,27 +348,31 @@ version is 3.0 or above.  If OpenGL ES is requested, this hint is ignored.
 Forward-compatibility is described in detail in the
 [OpenGL Reference Manual](https://www.opengl.org/registry/).

-`GLFW_OPENGL_DEBUG_CONTEXT` specifies whether to create a debug OpenGL context,
-which may have additional error and performance issue reporting functionality.
-If OpenGL ES is requested, this hint is ignored.
+@anchor GLFW_OPENGL_DEBUG_CONTEXT_hint
+__GLFW_OPENGL_DEBUG_CONTEXT__ specifies whether to create a debug OpenGL
+context, which may have additional error and performance issue reporting
+functionality.  If OpenGL ES is requested, this hint is ignored.

-`GLFW_OPENGL_PROFILE` specifies which OpenGL profile to create the context for.
-Possible values are one of `GLFW_OPENGL_CORE_PROFILE` or
+@anchor GLFW_OPENGL_PROFILE_hint
+__GLFW_OPENGL_PROFILE__ specifies which OpenGL profile to create the context
+for.  Possible values are one of `GLFW_OPENGL_CORE_PROFILE` or
 `GLFW_OPENGL_COMPAT_PROFILE`, or `GLFW_OPENGL_ANY_PROFILE` to not request
 a specific profile.  If requesting an OpenGL version below 3.2,
-`GLFW_OPENGL_ANY_PROFILE` must be used.  If OpenGL ES is requested,
-this hint is ignored.
+`GLFW_OPENGL_ANY_PROFILE` must be used.  If OpenGL ES is requested, this hint
+is ignored.

@par
 OpenGL profiles are described in detail in the
 [OpenGL Reference Manual](https://www.opengl.org/registry/).

-`GLFW_CONTEXT_ROBUSTNESS` specifies the robustness strategy to be used by the
+@anchor GLFW_CONTEXT_ROBUSTNESS_hint
+__GLFW_CONTEXT_ROBUSTNESS__ specifies the robustness strategy to be used by the
 context.  This can be one of `GLFW_NO_RESET_NOTIFICATION` or
 `GLFW_LOSE_CONTEXT_ON_RESET`, or `GLFW_NO_ROBUSTNESS` to not request
 a robustness strategy.

-`GLFW_CONTEXT_RELEASE_BEHAVIOR` specifies the release behavior to be
+@anchor GLFW_CONTEXT_RELEASE_BEHAVIOR_hint
+__GLFW_CONTEXT_RELEASE_BEHAVIOR__ specifies the release behavior to be
 used by the context.  Possible values are one of `GLFW_ANY_RELEASE_BEHAVIOR`,
 `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`.  If the
 behavior is `GLFW_ANY_RELEASE_BEHAVIOR`, the default behavior of the context
@@ -341,7 +386,8 @@ Context release behaviors are described in detail by the
 [GL_KHR_context_flush_control](https://www.opengl.org/registry/specs/KHR/context_flush_control.txt)
 extension.

-`GLFW_CONTEXT_NO_ERROR` specifies whether errors should be generated by the
+@anchor GLFW_CONTEXT_NO_ERROR_hint
+__GLFW_CONTEXT_NO_ERROR__ specifies whether errors should be generated by the
 context.  If enabled, situations that would have generated errors instead cause
 undefined behavior.

@@ -359,42 +405,50 @@ fail on early drivers where this flag is supported without those extensions
 being listed.


+@subsubsection window_hints_osx macOS specific hints
+
+@anchor GLFW_COCOA_RETINA_FRAMEBUFFER_hint
+__GLFW_COCOA_RETINA_FRAMEBUFFER__ specifies whether to use full resolution
+framebuffers on Retina displays.  This is ignored on other platforms.
+
+
@subsubsection window_hints_values Supported and default values

-Window hint                     | Default value               | Supported values
------------------------------- | --------------------------- | ----------------
-`GLFW_RESIZABLE`                | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_VISIBLE`                  | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_DECORATED`                | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_FOCUSED`                  | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_AUTO_ICONIFY`             | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_FLOATING`                 | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_MAXIMIZED`                | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_RED_BITS`                 | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_GREEN_BITS`               | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_BLUE_BITS`                | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_ALPHA_BITS`               | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_DEPTH_BITS`               | 24                          | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_STENCIL_BITS`             | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_ACCUM_RED_BITS`           | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_ACCUM_GREEN_BITS`         | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_ACCUM_BLUE_BITS`          | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_ACCUM_ALPHA_BITS`         | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_AUX_BUFFERS`              | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_SAMPLES`                  | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_REFRESH_RATE`             | `GLFW_DONT_CARE`            | 0 to `INT_MAX` or `GLFW_DONT_CARE`
-`GLFW_STEREO`                   | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_SRGB_CAPABLE`             | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_DOUBLEBUFFER`             | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_CLIENT_API`               | `GLFW_OPENGL_API`           | `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`
-`GLFW_CONTEXT_CREATION_API`     | `GLFW_NATIVE_CONTEXT_API`   | `GLFW_NATIVE_CONTEXT_API` or `GLFW_EGL_CONTEXT_API`
-`GLFW_CONTEXT_VERSION_MAJOR`    | 1                           | Any valid major version number of the chosen client API
-`GLFW_CONTEXT_VERSION_MINOR`    | 0                           | Any valid minor version number of the chosen client API
-`GLFW_CONTEXT_ROBUSTNESS`       | `GLFW_NO_ROBUSTNESS`        | `GLFW_NO_ROBUSTNESS`, `GLFW_NO_RESET_NOTIFICATION` or `GLFW_LOSE_CONTEXT_ON_RESET`
-`GLFW_CONTEXT_RELEASE_BEHAVIOR` | `GLFW_ANY_RELEASE_BEHAVIOR` | `GLFW_ANY_RELEASE_BEHAVIOR`, `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`
-`GLFW_OPENGL_FORWARD_COMPAT`    | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_OPENGL_DEBUG_CONTEXT`     | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
-`GLFW_OPENGL_PROFILE`           | `GLFW_OPENGL_ANY_PROFILE`   | `GLFW_OPENGL_ANY_PROFILE`, `GLFW_OPENGL_COMPAT_PROFILE` or `GLFW_OPENGL_CORE_PROFILE`
+Window hint                   | Default value               | Supported values
+----------------------------- | --------------------------- | ----------------
+GLFW_RESIZABLE                | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_VISIBLE                  | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_DECORATED                | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_FOCUSED                  | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_AUTO_ICONIFY             | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_FLOATING                 | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_MAXIMIZED                | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_RED_BITS                 | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_GREEN_BITS               | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_BLUE_BITS                | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_ALPHA_BITS               | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_DEPTH_BITS               | 24                          | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_STENCIL_BITS             | 8                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_ACCUM_RED_BITS           | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_ACCUM_GREEN_BITS         | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_ACCUM_BLUE_BITS          | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_ACCUM_ALPHA_BITS         | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_AUX_BUFFERS              | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_SAMPLES                  | 0                           | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_REFRESH_RATE             | `GLFW_DONT_CARE`            | 0 to `INT_MAX` or `GLFW_DONT_CARE`
+GLFW_STEREO                   | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_SRGB_CAPABLE             | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_DOUBLEBUFFER             | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_CLIENT_API               | `GLFW_OPENGL_API`           | `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`
+GLFW_CONTEXT_CREATION_API     | `GLFW_NATIVE_CONTEXT_API`   | `GLFW_NATIVE_CONTEXT_API` or `GLFW_EGL_CONTEXT_API`
+GLFW_CONTEXT_VERSION_MAJOR    | 1                           | Any valid major version number of the chosen client API
+GLFW_CONTEXT_VERSION_MINOR    | 0                           | Any valid minor version number of the chosen client API
+GLFW_CONTEXT_ROBUSTNESS       | `GLFW_NO_ROBUSTNESS`        | `GLFW_NO_ROBUSTNESS`, `GLFW_NO_RESET_NOTIFICATION` or `GLFW_LOSE_CONTEXT_ON_RESET`
+GLFW_CONTEXT_RELEASE_BEHAVIOR | `GLFW_ANY_RELEASE_BEHAVIOR` | `GLFW_ANY_RELEASE_BEHAVIOR`, `GLFW_RELEASE_BEHAVIOR_FLUSH` or `GLFW_RELEASE_BEHAVIOR_NONE`
+GLFW_OPENGL_FORWARD_COMPAT    | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_OPENGL_DEBUG_CONTEXT     | `GLFW_FALSE`                | `GLFW_TRUE` or `GLFW_FALSE`
+GLFW_OPENGL_PROFILE           | `GLFW_OPENGL_ANY_PROFILE`   | `GLFW_OPENGL_ANY_PROFILE`, `GLFW_OPENGL_COMPAT_PROFILE` or `GLFW_OPENGL_CORE_PROFILE`
+GLFW_COCOA_RETINA_FRAMEBUFFER | `GLFW_TRUE`                 | `GLFW_TRUE` or `GLFW_FALSE`


@section window_events Window event processing
@@ -730,7 +784,8 @@ glfwIconifyWindow(window);
 When a full screen window is iconified, the original video mode of its monitor
 is restored until the user or application restores the window.

-Iconified windows can be restored with @ref glfwRestoreWindow.
+Iconified windows can be restored with @ref glfwRestoreWindow.  This function
+also restores windows from maximization.

@code
 glfwRestoreWindow(window);
@@ -769,6 +824,62 @@ int iconified = glfwGetWindowAttrib(window, GLFW_ICONIFIED);
@endcode


+@subsection window_maximize Window maximization
+
+Windows can be maximized (i.e. zoomed) with @ref glfwMaximizeWindow.
+
+@code
+glfwMaximizeWindow(window);
+@endcode
+
+Full screen windows cannot be maximized and passing a full screen window to this
+function does nothing.
+
+Maximized windows can be restored with @ref glfwRestoreWindow.  This function
+also restores windows from iconification.
+
+@code
+glfwRestoreWindow(window);
+@endcode
+
+If you wish to be notified when a window is maximized or restored, whether by
+the user, system or your own code, set a maximize callback.
+
+@code
+glfwSetWindowMaximizeCallback(window, window_maximize_callback);
+@endcode
+
+The callback function receives changes in the maximization state of the window.
+
+@code
+void window_maximize_callback(GLFWwindow* window, int maximized)
+{
+    if (maximized)
+    {
+        // The window was maximized
+    }
+    else
+    {
+        // The window was restored
+    }
+}
+@endcode
+
+You can also get the current maximization state with @ref glfwGetWindowAttrib.
+
+@code
+int maximized = glfwGetWindowAttrib(window, GLFW_MAXIMIZED);
+@endcode
+
+By default, newly created windows are not maximized.  You can change this
+behavior by setting the [GLFW_MAXIMIZED](@ref GLFW_MAXIMIZED_hint) window hint
+before creating the window.
+
+@code
+glfwWindowHint(GLFW_MAXIMIZED, GLFW_TRUE);
+@endcode
+
+
@subsection window_hide Window visibility

 Windowed mode windows can be hidden with @ref glfwHideWindow.
@@ -787,11 +898,6 @@ Hidden windows can be shown with @ref glfwShowWindow.
 glfwShowWindow(window);
@endcode

-Windowed mode windows can be created initially hidden with the `GLFW_VISIBLE`
-[window hint](@ref window_hints_wnd).  Windows created hidden are completely
-invisible to the user until shown.  This can be useful if you need to set up
-your window further before showing it, for example moving it to a specific
-location.

 You can also get the current visibility state with @ref glfwGetWindowAttrib.

@@ -799,6 +905,18 @@ You can also get the current visibility state with @ref glfwGetWindowAttrib.
 int visible = glfwGetWindowAttrib(window, GLFW_VISIBLE);
@endcode

+By default, newly created windows are visible.  You can change this behavior by
+setting the [GLFW_VISIBLE](@ref GLFW_VISIBLE_hint) window hint before creating
+the window.
+
+@code
+glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
+@endcode
+
+Windows created hidden are completely invisible to the user until shown.  This
+can be useful if you need to set up your window further before showing it, for
+example moving it to a specific location.
+

@subsection window_focus Window input focus

@@ -838,6 +956,14 @@ You can also get the current input focus state with @ref glfwGetWindowAttrib.
 int focused = glfwGetWindowAttrib(window, GLFW_FOCUSED);
@endcode

+By default, newly created windows are given input focus.  You can change this
+behavior by setting the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) window hint
+before creating the window.
+
+@code
+glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
+@endcode
+

@subsection window_refresh Window damage and refresh

@@ -867,10 +993,10 @@ the window or framebuffer is resized.
@subsection window_attribs Window attributes

 Windows have a number of attributes that can be returned using @ref
-glfwGetWindowAttrib.  Some reflect state that may change during the lifetime of
-the window, while others reflect the corresponding hints and are fixed at the
-time of creation.  Some are related to the actual window and others to its
-context.
+glfwGetWindowAttrib.  Some reflect state that may change as a result of user
+interaction, (e.g. whether it has input focus), while others reflect inherent
+properties of the window (e.g. what kind of border it has).  Some are related to
+the window and others to its OpenGL or OpenGL ES context.

@code
 if (glfwGetWindowAttrib(window, GLFW_FOCUSED))
@@ -879,65 +1005,99 @@ if (glfwGetWindowAttrib(window, GLFW_FOCUSED))
 }
@endcode

+The [GLFW_DECORATED](@ref GLFW_DECORATED_attrib),
+[GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib),
+[GLFW_FLOATING](@ref GLFW_FLOATING_attrib) and
+[GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib) window attributes can be
+changed with @ref glfwSetWindowAttrib.
+
+@code
+glfwSetWindowAttrib(window, GLFW_RESIZABLE, GLFW_FALSE);
+@endcode
+
+

@subsubsection window_attribs_wnd Window related attributes

-`GLFW_FOCUSED` indicates whether the specified window has input focus.  Initial
-input focus is controlled by the [window hint](@ref window_hints_wnd) with the
-same name.   
+@anchor GLFW_FOCUSED_attrib
+__GLFW_FOCUSED__ indicates whether the specified window has input focus.  See
+@ref window_focus for details.

-`GLFW_ICONIFIED` indicates whether the specified window is iconified, whether by
-the user or with @ref glfwIconifyWindow.
+@anchor GLFW_ICONIFIED_attrib
+__GLFW_ICONIFIED__ indicates whether the specified window is iconified.
+See @ref window_iconify for details.

-`GLFW_MAXIMIZED` indicates whether the specified window is maximized, whether by
-the user or with @ref glfwMaximizeWindow.
+@anchor GLFW_MAXIMIZED_attrib
+__GLFW_MAXIMIZED__ indicates whether the specified window is maximized.  See
+@ref window_maximize for details.

-`GLFW_VISIBLE` indicates whether the specified window is visible.  Window
-visibility can be controlled with @ref glfwShowWindow and @ref glfwHideWindow
-and initial visibility is controlled by the [window hint](@ref window_hints_wnd)
-with the same name.  
+@anchor GLFW_VISIBLE_attrib
+__GLFW_VISIBLE__ indicates whether the specified window is visible.  See @ref
+window_hide for details.

-`GLFW_RESIZABLE` indicates whether the specified window is resizable _by the
-user_.  This is set on creation with the [window hint](@ref window_hints_wnd)
-  with the same name.
+@anchor GLFW_RESIZABLE_attrib
+__GLFW_RESIZABLE__ indicates whether the specified window is resizable _by the
+user_.  This can be set before creation with the
+[GLFW_RESIZABLE](@ref GLFW_RESIZABLE_hint) window hint or after with @ref
+glfwSetWindowAttrib.

-`GLFW_DECORATED` indicates whether the specified window has decorations such as
-a border, a close widget, etc.  This is set on creation with the
-[window hint](@ref window_hints_wnd) with the same name. 
+@anchor GLFW_DECORATED_attrib
+__GLFW_DECORATED__ indicates whether the specified window has decorations such
+as a border, a close widget, etc.  This can be set before creation with the
+[GLFW_DECORATED](@ref GLFW_DECORATED_hint) window hint or after with @ref
+glfwSetWindowAttrib.

-`GLFW_FLOATING` indicates whether the specified window is floating, also called
-topmost or always-on-top.  This is controlled by the
-[window hint](@ref window_hints_wnd) with the same name. 
+@anchor GLFW_AUTO_ICONIFY_attrib
+__GLFW_AUTO_ICONIFY__ indicates whether the specified full screen window is
+iconified on focus loss, a close widget, etc.  This can be set before creation
+with the [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_hint) window hint or after
+with @ref glfwSetWindowAttrib.
+
+@anchor GLFW_FLOATING_attrib
+__GLFW_FLOATING__ indicates whether the specified window is floating, also
+called topmost or always-on-top.  This can be set before creation with the
+[GLFW_FLOATING](@ref GLFW_FLOATING_hint) window hint or after with @ref
+glfwSetWindowAttrib.


@subsubsection window_attribs_ctx Context related attributes

-`GLFW_CLIENT_API` indicates the client API provided by the window's context;
+@anchor GLFW_CLIENT_API_attrib
+__GLFW_CLIENT_API__ indicates the client API provided by the window's context;
 either `GLFW_OPENGL_API`, `GLFW_OPENGL_ES_API` or `GLFW_NO_API`.

-`GLFW_CONTEXT_CREATION_API` indicates the context creation API used to create
+@anchor GLFW_CONTEXT_CREATION_API_attrib
+__GLFW_CONTEXT_CREATION_API__ indicates the context creation API used to create
 the window's context; either `GLFW_NATIVE_CONTEXT_API` or
 `GLFW_EGL_CONTEXT_API`.

-`GLFW_CONTEXT_VERSION_MAJOR`, `GLFW_CONTEXT_VERSION_MINOR` and
-`GLFW_CONTEXT_REVISION` indicate the client API version of the window's context.
+@anchor GLFW_CONTEXT_VERSION_MAJOR_attrib
+@anchor GLFW_CONTEXT_VERSION_MINOR_attrib
+@anchor GLFW_CONTEXT_REVISION_attrib
+__GLFW_CONTEXT_VERSION_MAJOR__, __GLFW_CONTEXT_VERSION_MINOR__ and
+__GLFW_CONTEXT_REVISION__ indicate the client API version of the window's
+context.

-`GLFW_OPENGL_FORWARD_COMPAT` is `GLFW_TRUE` if the window's context is an OpenGL
-forward-compatible one, or `GLFW_FALSE` otherwise.
+@anchor GLFW_OPENGL_FORWARD_COMPAT_attrib
+__GLFW_OPENGL_FORWARD_COMPAT__ is `GLFW_TRUE` if the window's context is an
+OpenGL forward-compatible one, or `GLFW_FALSE` otherwise.

-`GLFW_OPENGL_DEBUG_CONTEXT` is `GLFW_TRUE` if the window's context is an OpenGL
-debug context, or `GLFW_FALSE` otherwise.
+@anchor GLFW_OPENGL_DEBUG_CONTEXT_attrib
+__GLFW_OPENGL_DEBUG_CONTEXT__ is `GLFW_TRUE` if the window's context is an
+OpenGL debug context, or `GLFW_FALSE` otherwise.

-`GLFW_OPENGL_PROFILE` indicates the OpenGL profile used by the context.  This is
-`GLFW_OPENGL_CORE_PROFILE` or `GLFW_OPENGL_COMPAT_PROFILE` if the context uses
-a known profile, or `GLFW_OPENGL_ANY_PROFILE` if the OpenGL profile is unknown
-or the context is an OpenGL ES context.  Note that the returned profile may not
-match the profile bits of the context flags, as GLFW will try other means of
-detecting the profile when no bits are set.
+@anchor GLFW_OPENGL_PROFILE_attrib
+__GLFW_OPENGL_PROFILE__ indicates the OpenGL profile used by the context.  This
+is `GLFW_OPENGL_CORE_PROFILE` or `GLFW_OPENGL_COMPAT_PROFILE` if the context
+uses a known profile, or `GLFW_OPENGL_ANY_PROFILE` if the OpenGL profile is
+unknown or the context is an OpenGL ES context.  Note that the returned profile
+may not match the profile bits of the context flags, as GLFW will try other
+means of detecting the profile when no bits are set.

-`GLFW_CONTEXT_ROBUSTNESS` indicates the robustness strategy used by the context.
-This is `GLFW_LOSE_CONTEXT_ON_RESET` or `GLFW_NO_RESET_NOTIFICATION` if the
-window's context supports robustness, or `GLFW_NO_ROBUSTNESS` otherwise.
+@anchor GLFW_CONTEXT_ROBUSTNESS_attrib
+__GLFW_CONTEXT_ROBUSTNESS__ indicates the robustness strategy used by the
+context.  This is `GLFW_LOSE_CONTEXT_ON_RESET` or `GLFW_NO_RESET_NOTIFICATION`
+if the window's context supports robustness, or `GLFW_NO_ROBUSTNESS` otherwise.


@subsubsection window_attribs_fb Framebuffer related attributes
@@ -1,7 +1,7 @@

 link_libraries(glfw)

-include_directories(${glfw_INCLUDE_DIRS})
+include_directories(${glfw_INCLUDE_DIRS} "${GLFW_SOURCE_DIR}/deps")

 if (BUILD_SHARED_LIBS)
    link_libraries("${MATH_LIBRARY}")
@@ -11,14 +11,16 @@ if (MSVC)
    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()

-include_directories("${GLFW_SOURCE_DIR}/deps")
+if (GLFW_USE_OSMESA)
+    add_definitions(-DUSE_NATIVE_OSMESA)
+endif()

 if (WIN32)
    set(ICON glfw.rc)
 elseif (APPLE)
    set(ICON glfw.icns)
    set_source_files_properties(glfw.icns PROPERTIES
-        MAXOSX_PACKAGE_LOCATION "Resources")
+        MACOSX_PACKAGE_LOCATION "Resources")
 endif()

 set(GLAD "${GLFW_SOURCE_DIR}/deps/glad/glad.h"
@@ -31,6 +33,7 @@ set(TINYCTHREAD "${GLFW_SOURCE_DIR}/deps/tinycthread.h"
 add_executable(boing WIN32 MACOSX_BUNDLE boing.c ${ICON} ${GLAD})
 add_executable(gears WIN32 MACOSX_BUNDLE gears.c ${ICON} ${GLAD})
 add_executable(heightmap WIN32 MACOSX_BUNDLE heightmap.c ${ICON} ${GLAD})
+add_executable(offscreen offscreen.c ${ICON} ${GLAD})
 add_executable(particles WIN32 MACOSX_BUNDLE particles.c ${ICON} ${TINYCTHREAD} ${GETOPT} ${GLAD})
 add_executable(simple WIN32 MACOSX_BUNDLE simple.c ${ICON} ${GLAD})
 add_executable(splitview WIN32 MACOSX_BUNDLE splitview.c ${ICON} ${GLAD})
@@ -38,9 +41,18 @@ add_executable(wave WIN32 MACOSX_BUNDLE wave.c ${ICON} ${GLAD})

 target_link_libraries(particles "${CMAKE_THREAD_LIBS_INIT}" "${RT_LIBRARY}")

-set(WINDOWS_BINARIES boing gears heightmap particles simple splitview wave)
+if (APPLE)
+    add_executable(metal MACOSX_BUNDLE metal.m ${ICON})
+    target_compile_options(metal PUBLIC "-fobjc-arc")
+    target_link_libraries(metal "-framework Metal" "-framework QuartzCore")
+    set_target_properties(metal PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Metal")
+endif()

-set_target_properties(${WINDOWS_BINARIES} PROPERTIES FOLDER "GLFW3/Examples")
+set(WINDOWS_BINARIES boing gears heightmap particles simple splitview wave)
+set(CONSOLE_BINARIES offscreen)
+
+set_target_properties(${WINDOWS_BINARIES} ${CONSOLE_BINARIES} PROPERTIES
+                      FOLDER "GLFW3/Examples")

 if (MSVC)
    # Tell MSVC to use main instead of WinMain for Windows subsystem executables
@@ -52,6 +64,7 @@ if (APPLE)
    set_target_properties(boing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Boing")
    set_target_properties(gears PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Gears")
    set_target_properties(heightmap PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Heightmap")
+    set_target_properties(metal PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Metal")
    set_target_properties(particles PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Particles")
    set_target_properties(simple PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Simple")
    set_target_properties(splitview PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "SplitView")
@@ -15,7 +15,7 @@
 *   - Slightly modified camera that should work better for stereo viewing
 *
 *
- * Camilla Berglund:
+ * Camilla Löwy:
 *   - Removed FPS counter (this is not a benchmark)
 *   - Added a few comments
 *   - Enabled vsync
@@ -0,0 +1,162 @@
+//========================================================================
+// Simple GLFW+Metal example
+// Copyright (c) Camilla Berglund <elmindreda@elmindreda.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//! [code]
+
+#define GLFW_INCLUDE_NONE
+#import <GLFW/glfw3.h>
+#define GLFW_EXPOSE_NATIVE_COCOA
+#import <GLFW/glfw3native.h>
+
+#import <Metal/Metal.h>
+#import <QuartzCore/QuartzCore.h>
+#import <simd/simd.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void error_callback(int error, const char* description)
+{
+    fputs(description, stderr);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+}
+
+int main(void)
+{
+	id<MTLDevice> device = MTLCreateSystemDefaultDevice();
+	if (!device)
+		exit(EXIT_FAILURE);
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+    GLFWwindow* window = glfwCreateWindow(640, 480, "Metal Example", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    NSWindow* nswin = glfwGetCocoaWindow(window);
+    CAMetalLayer* layer = [CAMetalLayer layer];
+    layer.device = device;
+    layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+    nswin.contentView.layer = layer;
+    nswin.contentView.wantsLayer = YES;
+
+    MTLCompileOptions* compileOptions = [MTLCompileOptions new];
+    compileOptions.languageVersion = MTLLanguageVersion1_1;
+    NSError* compileError;
+    id<MTLLibrary> lib = [device newLibraryWithSource:
+       @"#include <metal_stdlib>\n"
+        "using namespace metal;\n"
+        "vertex float4 v_simple(\n"
+        "    constant float4* in  [[buffer(0)]],\n"
+        "    uint             vid [[vertex_id]])\n"
+        "{\n"
+        "    return in[vid];\n"
+        "}\n"
+        "fragment float4 f_simple(\n"
+        "    float4 in [[stage_in]])\n"
+        "{\n"
+        "    return float4(1, 0, 0, 1);\n"
+        "}\n"
+       options:compileOptions error:&compileError];
+    if (!lib)
+    {
+        NSLog(@"can't create library: %@", compileError);
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    id<MTLFunction> vs = [lib newFunctionWithName:@"v_simple"];
+    assert(vs);
+    id<MTLFunction> fs = [lib newFunctionWithName:@"f_simple"];
+    assert(fs);
+
+    id<MTLCommandQueue> cq = [device newCommandQueue];
+    assert(cq);
+
+    MTLRenderPipelineDescriptor* rpd = [MTLRenderPipelineDescriptor new];
+    rpd.vertexFunction = vs;
+    rpd.fragmentFunction = fs;
+    rpd.colorAttachments[0].pixelFormat = layer.pixelFormat;
+    id<MTLRenderPipelineState> rps = [device newRenderPipelineStateWithDescriptor:rpd error:NULL];
+    assert(rps);
+
+    glfwSetKeyCallback(window, key_callback);
+
+    while (!glfwWindowShouldClose(window))
+    {
+        float ratio;
+        int width, height;
+
+        glfwGetFramebufferSize(window, &width, &height);
+        ratio = width / (float) height;
+
+        layer.drawableSize = CGSizeMake(width, height);
+        id<CAMetalDrawable> drawable = [layer nextDrawable];
+        assert(drawable);
+
+        id<MTLCommandBuffer> cb = [cq commandBuffer];
+
+        MTLRenderPassDescriptor* rpd = [MTLRenderPassDescriptor new];
+        MTLRenderPassColorAttachmentDescriptor* cd = rpd.colorAttachments[0];
+        cd.texture = drawable.texture;
+        cd.loadAction = MTLLoadActionClear;
+        cd.clearColor = MTLClearColorMake(1.0, 1.0, 1.0, 1.0);
+        cd.storeAction = MTLStoreActionStore;
+        id<MTLRenderCommandEncoder> rce = [cb renderCommandEncoderWithDescriptor:rpd];
+
+        [rce setRenderPipelineState:rps];
+        [rce setVertexBytes:(vector_float4[]){
+            { 0, 0, 0, 1 },
+            { -1, 1, 0, 1 },
+            { 1, 1, 0, 1 },
+        } length:3 * sizeof(vector_float4) atIndex:0];
+        [rce drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3];
+
+        [rce endEncoding];
+        [cb presentDrawable:drawable];
+        [cb commit];
+
+        glfwPollEvents();
+    }
+
+    glfwDestroyWindow(window);
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+
+//! [code]
@@ -0,0 +1,173 @@
+//========================================================================
+// Offscreen rendering example
+// Copyright (c) Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#if USE_NATIVE_OSMESA
+ #define GLFW_EXPOSE_NATIVE_OSMESA
+ #include <GLFW/glfw3native.h>
+#endif
+
+#include "linmath.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include <stb_image_write.h>
+
+static const struct
+{
+    float x, y;
+    float r, g, b;
+} vertices[3] =
+{
+    { -0.6f, -0.4f, 1.f, 0.f, 0.f },
+    {  0.6f, -0.4f, 0.f, 1.f, 0.f },
+    {   0.f,  0.6f, 0.f, 0.f, 1.f }
+};
+
+static const char* vertex_shader_text =
+"#version 110\n"
+"uniform mat4 MVP;\n"
+"attribute vec3 vCol;\n"
+"attribute vec2 vPos;\n"
+"varying vec3 color;\n"
+"void main()\n"
+"{\n"
+"    gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
+"    color = vCol;\n"
+"}\n";
+
+static const char* fragment_shader_text =
+"#version 110\n"
+"varying vec3 color;\n"
+"void main()\n"
+"{\n"
+"    gl_FragColor = vec4(color, 1.0);\n"
+"}\n";
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+    GLuint vertex_buffer, vertex_shader, fragment_shader, program;
+    GLint mvp_location, vpos_location, vcol_location;
+    float ratio;
+    int width, height;
+    mat4x4 mvp;
+    char* buffer;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
+
+    window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
+
+    // NOTE: OpenGL error checks have been omitted for brevity
+
+    glGenBuffers(1, &vertex_buffer);
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
+    glCompileShader(vertex_shader);
+
+    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
+    glCompileShader(fragment_shader);
+
+    program = glCreateProgram();
+    glAttachShader(program, vertex_shader);
+    glAttachShader(program, fragment_shader);
+    glLinkProgram(program);
+
+    mvp_location = glGetUniformLocation(program, "MVP");
+    vpos_location = glGetAttribLocation(program, "vPos");
+    vcol_location = glGetAttribLocation(program, "vCol");
+
+    glEnableVertexAttribArray(vpos_location);
+    glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
+                          sizeof(vertices[0]), (void*) 0);
+    glEnableVertexAttribArray(vcol_location);
+    glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE,
+                          sizeof(vertices[0]), (void*) (sizeof(float) * 2));
+
+    glfwGetFramebufferSize(window, &width, &height);
+    ratio = width / (float) height;
+
+    glViewport(0, 0, width, height);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    mat4x4_ortho(mvp, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
+
+    glUseProgram(program);
+    glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+
+#if USE_NATIVE_OSMESA
+    glfwGetOSMesaColorBuffer(window, &width, &height, NULL, (void**) &buffer);
+#else
+    buffer = calloc(4, width * height);
+    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
+#endif
+
+    // Write image Y-flipped because OpenGL
+    stbi_write_png("offscreen.png",
+                   width, height, 4,
+                   buffer + (width * 4 * (height - 1)),
+                   -width * 4);
+
+#if USE_NATIVE_OSMESA
+    // Here is where there's nothing
+#else
+    free(buffer);
+#endif
+
+    glfwDestroyWindow(window);
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+
@@ -1,7 +1,7 @@
 //========================================================================
 // A simple particle engine with threaded physics
 // Copyright (c) Marcus Geelnard
-// Copyright (c) Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -457,7 +457,9 @@ static void draw_particles(GLFWwindow* window, double t, float dt)
    {
        struct timespec ts;
        clock_gettime(CLOCK_REALTIME, &ts);
-        ts.tv_nsec += 100000000;
+        ts.tv_nsec += 100 * 1000 * 1000;
+        ts.tv_sec += ts.tv_nsec / (1000 * 1000 * 1000);
+        ts.tv_nsec %= 1000 * 1000 * 1000;
        cnd_timedwait(&thread_sync.p_done, &thread_sync.particles_lock, &ts);
    }

@@ -908,7 +910,9 @@ static int physics_thread_main(void* arg)
        {
            struct timespec ts;
            clock_gettime(CLOCK_REALTIME, &ts);
-            ts.tv_nsec += 100000000;
+            ts.tv_nsec += 100 * 1000 * 1000;
+            ts.tv_sec += ts.tv_nsec / (1000 * 1000 * 1000);
+            ts.tv_nsec %= 1000 * 1000 * 1000;
            cnd_timedwait(&thread_sync.d_done, &thread_sync.particles_lock, &ts);
        }

@@ -1,6 +1,6 @@
 //========================================================================
 // Simple GLFW example
-// Copyright (c) Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -44,6 +44,7 @@ static const struct
 };

 static const char* vertex_shader_text =
+"#version 110\n"
 "uniform mat4 MVP;\n"
 "attribute vec3 vCol;\n"
 "attribute vec2 vPos;\n"
@@ -55,6 +56,7 @@ static const char* vertex_shader_text =
 "}\n";

 static const char* fragment_shader_text =
+"#version 110\n"
 "varying vec3 color;\n"
 "void main()\n"
 "{\n"
@@ -124,10 +126,10 @@ int main(void)

    glEnableVertexAttribArray(vpos_location);
    glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
-                          sizeof(float) * 5, (void*) 0);
+                          sizeof(vertices[0]), (void*) 0);
    glEnableVertexAttribArray(vcol_location);
    glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE,
-                          sizeof(float) * 5, (void*) (sizeof(float) * 2));
+                          sizeof(vertices[0]), (void*) (sizeof(float) * 2));

    while (!glfwWindowShouldClose(window))
    {
@@ -5,7 +5,7 @@
 * Modified for GLFW by Sylvain Hellegouarch - sh@programmationworld.com
 * Modified for variable frame rate by Marcus Geelnard
 * 2003-Jan-31: Minor cleanups and speedups / MG
- * 2010-10-24: Formatting and cleanup - Camilla Berglund
+ * 2010-10-24: Formatting and cleanup - Camilla Löwy
 *****************************************************************************/

 #if defined(_MSC_VER)
@@ -3,7 +3,7 @@
 * A library for OpenGL, window and input
 *------------------------------------------------------------------------
 * Copyright (c) 2002-2006 Marcus Geelnard
- * Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+ * Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
@@ -50,7 +50,7 @@ extern "C" {
 *  doing and how to fix problems caused by using them.  If you don't, you
 *  shouldn't be using them.**
 *
- *  Before the inclusion of @ref glfw3native.h, you may define exactly one
+ *  Before the inclusion of @ref glfw3native.h, you may define zero or more
 *  window system API macro and zero or more context creation API macros.
 *
 *  The chosen backends must match those the library was compiled for.  Failure
@@ -68,6 +68,7 @@ extern "C" {
 *  * `GLFW_EXPOSE_NATIVE_NSGL`
 *  * `GLFW_EXPOSE_NATIVE_GLX`
 *  * `GLFW_EXPOSE_NATIVE_EGL`
+ *  * `GLFW_EXPOSE_NATIVE_OSMESA`
 *
 *  These macros select which of the native access functions that are declared
 *  and which platform-specific headers to include.  It is then up your (by
@@ -114,6 +115,9 @@ extern "C" {
 #if defined(GLFW_EXPOSE_NATIVE_EGL)
 #include <EGL/egl.h>
 #endif
+#if defined(GLFW_EXPOSE_NATIVE_OSMESA)
+ #include <GL/osmesa.h>
+#endif


 /*************************************************************************
@@ -448,6 +452,64 @@ GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
 GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
 #endif

+#if defined(GLFW_EXPOSE_NATIVE_OSMESA)
+/*! @brief Retrieves the color buffer associated with the specified window.
+ *
+ *  @param[in] window The window whose color buffer to retrieve.
+ *  @param[out] width Where to store the width of the color buffer, or `NULL`.
+ *  @param[out] height Where to store the height of the color buffer, or `NULL`.
+ *  @param[out] format Where to store the OSMesa pixel format of the color
+ *  buffer, or `NULL`.
+ *  @param[out] buffer Where to store the address of the color buffer, or
+ *  `NULL`.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.                
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* window, int* width, int* height, int* format, void** buffer);
+
+/*! @brief Retrieves the depth buffer associated with the specified window.
+ *
+ *  @param[in] window The window whose depth buffer to retrieve.
+ *  @param[out] width Where to store the width of the depth buffer, or `NULL`.
+ *  @param[out] height Where to store the height of the depth buffer, or `NULL`.
+ *  @param[out] bytesPerValue Where to store the number of bytes per depth
+ *  buffer element, or `NULL`.
+ *  @param[out] buffer Where to store the address of the depth buffer, or
+ *  `NULL`.
+ *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
+ *  [error](@ref error_handling) occurred.                
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* window, int* width, int* height, int* bytesPerValue, void** buffer);
+
+/*! @brief Returns the `OSMesaContext` of the specified window.
+ *
+ *  @return The `OSMesaContext` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.3.
+ *
+ *  @ingroup native
+ */
+GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* window);
+#endif
+
 #ifdef __cplusplus
 }
 #endif
@@ -45,6 +45,12 @@ elseif (_GLFW_MIR)
    set(glfw_SOURCES ${common_SOURCES} mir_init.c mir_monitor.c mir_window.c
                     linux_joystick.c posix_time.c posix_tls.c xkb_unicode.c
                     egl_context.c)
+elseif (_GLFW_OSMESA)
+    set(glfw_HEADERS ${common_HEADERS} osmesa_platform.h
+                     posix_time.h posix_tls.h osmesa_context.h)
+    set(glfw_SOURCES ${common_SOURCES} osmesa_init.c osmesa_monitor.c
+                     osmesa_window.c posix_time.c posix_tls.c
+                     osmesa_context.c)
 endif()

 if (APPLE)
@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -74,129 +74,129 @@ static void createKeyTables(void)
 {
    int scancode;

-    memset(_glfw.ns.publicKeys, -1, sizeof(_glfw.ns.publicKeys));
-    memset(_glfw.ns.nativeKeys, -1, sizeof(_glfw.ns.nativeKeys));
+    memset(_glfw.ns.keycodes, -1, sizeof(_glfw.ns.keycodes));
+    memset(_glfw.ns.scancodes, -1, sizeof(_glfw.ns.scancodes));

-    _glfw.ns.publicKeys[0x1D] = GLFW_KEY_0;
-    _glfw.ns.publicKeys[0x12] = GLFW_KEY_1;
-    _glfw.ns.publicKeys[0x13] = GLFW_KEY_2;
-    _glfw.ns.publicKeys[0x14] = GLFW_KEY_3;
-    _glfw.ns.publicKeys[0x15] = GLFW_KEY_4;
-    _glfw.ns.publicKeys[0x17] = GLFW_KEY_5;
-    _glfw.ns.publicKeys[0x16] = GLFW_KEY_6;
-    _glfw.ns.publicKeys[0x1A] = GLFW_KEY_7;
-    _glfw.ns.publicKeys[0x1C] = GLFW_KEY_8;
-    _glfw.ns.publicKeys[0x19] = GLFW_KEY_9;
-    _glfw.ns.publicKeys[0x00] = GLFW_KEY_A;
-    _glfw.ns.publicKeys[0x0B] = GLFW_KEY_B;
-    _glfw.ns.publicKeys[0x08] = GLFW_KEY_C;
-    _glfw.ns.publicKeys[0x02] = GLFW_KEY_D;
-    _glfw.ns.publicKeys[0x0E] = GLFW_KEY_E;
-    _glfw.ns.publicKeys[0x03] = GLFW_KEY_F;
-    _glfw.ns.publicKeys[0x05] = GLFW_KEY_G;
-    _glfw.ns.publicKeys[0x04] = GLFW_KEY_H;
-    _glfw.ns.publicKeys[0x22] = GLFW_KEY_I;
-    _glfw.ns.publicKeys[0x26] = GLFW_KEY_J;
-    _glfw.ns.publicKeys[0x28] = GLFW_KEY_K;
-    _glfw.ns.publicKeys[0x25] = GLFW_KEY_L;
-    _glfw.ns.publicKeys[0x2E] = GLFW_KEY_M;
-    _glfw.ns.publicKeys[0x2D] = GLFW_KEY_N;
-    _glfw.ns.publicKeys[0x1F] = GLFW_KEY_O;
-    _glfw.ns.publicKeys[0x23] = GLFW_KEY_P;
-    _glfw.ns.publicKeys[0x0C] = GLFW_KEY_Q;
-    _glfw.ns.publicKeys[0x0F] = GLFW_KEY_R;
-    _glfw.ns.publicKeys[0x01] = GLFW_KEY_S;
-    _glfw.ns.publicKeys[0x11] = GLFW_KEY_T;
-    _glfw.ns.publicKeys[0x20] = GLFW_KEY_U;
-    _glfw.ns.publicKeys[0x09] = GLFW_KEY_V;
-    _glfw.ns.publicKeys[0x0D] = GLFW_KEY_W;
-    _glfw.ns.publicKeys[0x07] = GLFW_KEY_X;
-    _glfw.ns.publicKeys[0x10] = GLFW_KEY_Y;
-    _glfw.ns.publicKeys[0x06] = GLFW_KEY_Z;
+    _glfw.ns.keycodes[0x1D] = GLFW_KEY_0;
+    _glfw.ns.keycodes[0x12] = GLFW_KEY_1;
+    _glfw.ns.keycodes[0x13] = GLFW_KEY_2;
+    _glfw.ns.keycodes[0x14] = GLFW_KEY_3;
+    _glfw.ns.keycodes[0x15] = GLFW_KEY_4;
+    _glfw.ns.keycodes[0x17] = GLFW_KEY_5;
+    _glfw.ns.keycodes[0x16] = GLFW_KEY_6;
+    _glfw.ns.keycodes[0x1A] = GLFW_KEY_7;
+    _glfw.ns.keycodes[0x1C] = GLFW_KEY_8;
+    _glfw.ns.keycodes[0x19] = GLFW_KEY_9;
+    _glfw.ns.keycodes[0x00] = GLFW_KEY_A;
+    _glfw.ns.keycodes[0x0B] = GLFW_KEY_B;
+    _glfw.ns.keycodes[0x08] = GLFW_KEY_C;
+    _glfw.ns.keycodes[0x02] = GLFW_KEY_D;
+    _glfw.ns.keycodes[0x0E] = GLFW_KEY_E;
+    _glfw.ns.keycodes[0x03] = GLFW_KEY_F;
+    _glfw.ns.keycodes[0x05] = GLFW_KEY_G;
+    _glfw.ns.keycodes[0x04] = GLFW_KEY_H;
+    _glfw.ns.keycodes[0x22] = GLFW_KEY_I;
+    _glfw.ns.keycodes[0x26] = GLFW_KEY_J;
+    _glfw.ns.keycodes[0x28] = GLFW_KEY_K;
+    _glfw.ns.keycodes[0x25] = GLFW_KEY_L;
+    _glfw.ns.keycodes[0x2E] = GLFW_KEY_M;
+    _glfw.ns.keycodes[0x2D] = GLFW_KEY_N;
+    _glfw.ns.keycodes[0x1F] = GLFW_KEY_O;
+    _glfw.ns.keycodes[0x23] = GLFW_KEY_P;
+    _glfw.ns.keycodes[0x0C] = GLFW_KEY_Q;
+    _glfw.ns.keycodes[0x0F] = GLFW_KEY_R;
+    _glfw.ns.keycodes[0x01] = GLFW_KEY_S;
+    _glfw.ns.keycodes[0x11] = GLFW_KEY_T;
+    _glfw.ns.keycodes[0x20] = GLFW_KEY_U;
+    _glfw.ns.keycodes[0x09] = GLFW_KEY_V;
+    _glfw.ns.keycodes[0x0D] = GLFW_KEY_W;
+    _glfw.ns.keycodes[0x07] = GLFW_KEY_X;
+    _glfw.ns.keycodes[0x10] = GLFW_KEY_Y;
+    _glfw.ns.keycodes[0x06] = GLFW_KEY_Z;

-    _glfw.ns.publicKeys[0x27] = GLFW_KEY_APOSTROPHE;
-    _glfw.ns.publicKeys[0x2A] = GLFW_KEY_BACKSLASH;
-    _glfw.ns.publicKeys[0x2B] = GLFW_KEY_COMMA;
-    _glfw.ns.publicKeys[0x18] = GLFW_KEY_EQUAL;
-    _glfw.ns.publicKeys[0x32] = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.ns.publicKeys[0x21] = GLFW_KEY_LEFT_BRACKET;
-    _glfw.ns.publicKeys[0x1B] = GLFW_KEY_MINUS;
-    _glfw.ns.publicKeys[0x2F] = GLFW_KEY_PERIOD;
-    _glfw.ns.publicKeys[0x1E] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.ns.publicKeys[0x29] = GLFW_KEY_SEMICOLON;
-    _glfw.ns.publicKeys[0x2C] = GLFW_KEY_SLASH;
-    _glfw.ns.publicKeys[0x0A] = GLFW_KEY_WORLD_1;
+    _glfw.ns.keycodes[0x27] = GLFW_KEY_APOSTROPHE;
+    _glfw.ns.keycodes[0x2A] = GLFW_KEY_BACKSLASH;
+    _glfw.ns.keycodes[0x2B] = GLFW_KEY_COMMA;
+    _glfw.ns.keycodes[0x18] = GLFW_KEY_EQUAL;
+    _glfw.ns.keycodes[0x32] = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.ns.keycodes[0x21] = GLFW_KEY_LEFT_BRACKET;
+    _glfw.ns.keycodes[0x1B] = GLFW_KEY_MINUS;
+    _glfw.ns.keycodes[0x2F] = GLFW_KEY_PERIOD;
+    _glfw.ns.keycodes[0x1E] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.ns.keycodes[0x29] = GLFW_KEY_SEMICOLON;
+    _glfw.ns.keycodes[0x2C] = GLFW_KEY_SLASH;
+    _glfw.ns.keycodes[0x0A] = GLFW_KEY_WORLD_1;

-    _glfw.ns.publicKeys[0x33] = GLFW_KEY_BACKSPACE;
-    _glfw.ns.publicKeys[0x39] = GLFW_KEY_CAPS_LOCK;
-    _glfw.ns.publicKeys[0x75] = GLFW_KEY_DELETE;
-    _glfw.ns.publicKeys[0x7D] = GLFW_KEY_DOWN;
-    _glfw.ns.publicKeys[0x77] = GLFW_KEY_END;
-    _glfw.ns.publicKeys[0x24] = GLFW_KEY_ENTER;
-    _glfw.ns.publicKeys[0x35] = GLFW_KEY_ESCAPE;
-    _glfw.ns.publicKeys[0x7A] = GLFW_KEY_F1;
-    _glfw.ns.publicKeys[0x78] = GLFW_KEY_F2;
-    _glfw.ns.publicKeys[0x63] = GLFW_KEY_F3;
-    _glfw.ns.publicKeys[0x76] = GLFW_KEY_F4;
-    _glfw.ns.publicKeys[0x60] = GLFW_KEY_F5;
-    _glfw.ns.publicKeys[0x61] = GLFW_KEY_F6;
-    _glfw.ns.publicKeys[0x62] = GLFW_KEY_F7;
-    _glfw.ns.publicKeys[0x64] = GLFW_KEY_F8;
-    _glfw.ns.publicKeys[0x65] = GLFW_KEY_F9;
-    _glfw.ns.publicKeys[0x6D] = GLFW_KEY_F10;
-    _glfw.ns.publicKeys[0x67] = GLFW_KEY_F11;
-    _glfw.ns.publicKeys[0x6F] = GLFW_KEY_F12;
-    _glfw.ns.publicKeys[0x69] = GLFW_KEY_F13;
-    _glfw.ns.publicKeys[0x6B] = GLFW_KEY_F14;
-    _glfw.ns.publicKeys[0x71] = GLFW_KEY_F15;
-    _glfw.ns.publicKeys[0x6A] = GLFW_KEY_F16;
-    _glfw.ns.publicKeys[0x40] = GLFW_KEY_F17;
-    _glfw.ns.publicKeys[0x4F] = GLFW_KEY_F18;
-    _glfw.ns.publicKeys[0x50] = GLFW_KEY_F19;
-    _glfw.ns.publicKeys[0x5A] = GLFW_KEY_F20;
-    _glfw.ns.publicKeys[0x73] = GLFW_KEY_HOME;
-    _glfw.ns.publicKeys[0x72] = GLFW_KEY_INSERT;
-    _glfw.ns.publicKeys[0x7B] = GLFW_KEY_LEFT;
-    _glfw.ns.publicKeys[0x3A] = GLFW_KEY_LEFT_ALT;
-    _glfw.ns.publicKeys[0x3B] = GLFW_KEY_LEFT_CONTROL;
-    _glfw.ns.publicKeys[0x38] = GLFW_KEY_LEFT_SHIFT;
-    _glfw.ns.publicKeys[0x37] = GLFW_KEY_LEFT_SUPER;
-    _glfw.ns.publicKeys[0x6E] = GLFW_KEY_MENU;
-    _glfw.ns.publicKeys[0x47] = GLFW_KEY_NUM_LOCK;
-    _glfw.ns.publicKeys[0x79] = GLFW_KEY_PAGE_DOWN;
-    _glfw.ns.publicKeys[0x74] = GLFW_KEY_PAGE_UP;
-    _glfw.ns.publicKeys[0x7C] = GLFW_KEY_RIGHT;
-    _glfw.ns.publicKeys[0x3D] = GLFW_KEY_RIGHT_ALT;
-    _glfw.ns.publicKeys[0x3E] = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.ns.publicKeys[0x3C] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.ns.publicKeys[0x36] = GLFW_KEY_RIGHT_SUPER;
-    _glfw.ns.publicKeys[0x31] = GLFW_KEY_SPACE;
-    _glfw.ns.publicKeys[0x30] = GLFW_KEY_TAB;
-    _glfw.ns.publicKeys[0x7E] = GLFW_KEY_UP;
+    _glfw.ns.keycodes[0x33] = GLFW_KEY_BACKSPACE;
+    _glfw.ns.keycodes[0x39] = GLFW_KEY_CAPS_LOCK;
+    _glfw.ns.keycodes[0x75] = GLFW_KEY_DELETE;
+    _glfw.ns.keycodes[0x7D] = GLFW_KEY_DOWN;
+    _glfw.ns.keycodes[0x77] = GLFW_KEY_END;
+    _glfw.ns.keycodes[0x24] = GLFW_KEY_ENTER;
+    _glfw.ns.keycodes[0x35] = GLFW_KEY_ESCAPE;
+    _glfw.ns.keycodes[0x7A] = GLFW_KEY_F1;
+    _glfw.ns.keycodes[0x78] = GLFW_KEY_F2;
+    _glfw.ns.keycodes[0x63] = GLFW_KEY_F3;
+    _glfw.ns.keycodes[0x76] = GLFW_KEY_F4;
+    _glfw.ns.keycodes[0x60] = GLFW_KEY_F5;
+    _glfw.ns.keycodes[0x61] = GLFW_KEY_F6;
+    _glfw.ns.keycodes[0x62] = GLFW_KEY_F7;
+    _glfw.ns.keycodes[0x64] = GLFW_KEY_F8;
+    _glfw.ns.keycodes[0x65] = GLFW_KEY_F9;
+    _glfw.ns.keycodes[0x6D] = GLFW_KEY_F10;
+    _glfw.ns.keycodes[0x67] = GLFW_KEY_F11;
+    _glfw.ns.keycodes[0x6F] = GLFW_KEY_F12;
+    _glfw.ns.keycodes[0x69] = GLFW_KEY_F13;
+    _glfw.ns.keycodes[0x6B] = GLFW_KEY_F14;
+    _glfw.ns.keycodes[0x71] = GLFW_KEY_F15;
+    _glfw.ns.keycodes[0x6A] = GLFW_KEY_F16;
+    _glfw.ns.keycodes[0x40] = GLFW_KEY_F17;
+    _glfw.ns.keycodes[0x4F] = GLFW_KEY_F18;
+    _glfw.ns.keycodes[0x50] = GLFW_KEY_F19;
+    _glfw.ns.keycodes[0x5A] = GLFW_KEY_F20;
+    _glfw.ns.keycodes[0x73] = GLFW_KEY_HOME;
+    _glfw.ns.keycodes[0x72] = GLFW_KEY_INSERT;
+    _glfw.ns.keycodes[0x7B] = GLFW_KEY_LEFT;
+    _glfw.ns.keycodes[0x3A] = GLFW_KEY_LEFT_ALT;
+    _glfw.ns.keycodes[0x3B] = GLFW_KEY_LEFT_CONTROL;
+    _glfw.ns.keycodes[0x38] = GLFW_KEY_LEFT_SHIFT;
+    _glfw.ns.keycodes[0x37] = GLFW_KEY_LEFT_SUPER;
+    _glfw.ns.keycodes[0x6E] = GLFW_KEY_MENU;
+    _glfw.ns.keycodes[0x47] = GLFW_KEY_NUM_LOCK;
+    _glfw.ns.keycodes[0x79] = GLFW_KEY_PAGE_DOWN;
+    _glfw.ns.keycodes[0x74] = GLFW_KEY_PAGE_UP;
+    _glfw.ns.keycodes[0x7C] = GLFW_KEY_RIGHT;
+    _glfw.ns.keycodes[0x3D] = GLFW_KEY_RIGHT_ALT;
+    _glfw.ns.keycodes[0x3E] = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.ns.keycodes[0x3C] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.ns.keycodes[0x36] = GLFW_KEY_RIGHT_SUPER;
+    _glfw.ns.keycodes[0x31] = GLFW_KEY_SPACE;
+    _glfw.ns.keycodes[0x30] = GLFW_KEY_TAB;
+    _glfw.ns.keycodes[0x7E] = GLFW_KEY_UP;

-    _glfw.ns.publicKeys[0x52] = GLFW_KEY_KP_0;
-    _glfw.ns.publicKeys[0x53] = GLFW_KEY_KP_1;
-    _glfw.ns.publicKeys[0x54] = GLFW_KEY_KP_2;
-    _glfw.ns.publicKeys[0x55] = GLFW_KEY_KP_3;
-    _glfw.ns.publicKeys[0x56] = GLFW_KEY_KP_4;
-    _glfw.ns.publicKeys[0x57] = GLFW_KEY_KP_5;
-    _glfw.ns.publicKeys[0x58] = GLFW_KEY_KP_6;
-    _glfw.ns.publicKeys[0x59] = GLFW_KEY_KP_7;
-    _glfw.ns.publicKeys[0x5B] = GLFW_KEY_KP_8;
-    _glfw.ns.publicKeys[0x5C] = GLFW_KEY_KP_9;
-    _glfw.ns.publicKeys[0x45] = GLFW_KEY_KP_ADD;
-    _glfw.ns.publicKeys[0x41] = GLFW_KEY_KP_DECIMAL;
-    _glfw.ns.publicKeys[0x4B] = GLFW_KEY_KP_DIVIDE;
-    _glfw.ns.publicKeys[0x4C] = GLFW_KEY_KP_ENTER;
-    _glfw.ns.publicKeys[0x51] = GLFW_KEY_KP_EQUAL;
-    _glfw.ns.publicKeys[0x43] = GLFW_KEY_KP_MULTIPLY;
-    _glfw.ns.publicKeys[0x4E] = GLFW_KEY_KP_SUBTRACT;
+    _glfw.ns.keycodes[0x52] = GLFW_KEY_KP_0;
+    _glfw.ns.keycodes[0x53] = GLFW_KEY_KP_1;
+    _glfw.ns.keycodes[0x54] = GLFW_KEY_KP_2;
+    _glfw.ns.keycodes[0x55] = GLFW_KEY_KP_3;
+    _glfw.ns.keycodes[0x56] = GLFW_KEY_KP_4;
+    _glfw.ns.keycodes[0x57] = GLFW_KEY_KP_5;
+    _glfw.ns.keycodes[0x58] = GLFW_KEY_KP_6;
+    _glfw.ns.keycodes[0x59] = GLFW_KEY_KP_7;
+    _glfw.ns.keycodes[0x5B] = GLFW_KEY_KP_8;
+    _glfw.ns.keycodes[0x5C] = GLFW_KEY_KP_9;
+    _glfw.ns.keycodes[0x45] = GLFW_KEY_KP_ADD;
+    _glfw.ns.keycodes[0x41] = GLFW_KEY_KP_DECIMAL;
+    _glfw.ns.keycodes[0x4B] = GLFW_KEY_KP_DIVIDE;
+    _glfw.ns.keycodes[0x4C] = GLFW_KEY_KP_ENTER;
+    _glfw.ns.keycodes[0x51] = GLFW_KEY_KP_EQUAL;
+    _glfw.ns.keycodes[0x43] = GLFW_KEY_KP_MULTIPLY;
+    _glfw.ns.keycodes[0x4E] = GLFW_KEY_KP_SUBTRACT;

    for (scancode = 0;  scancode < 256;  scancode++)
    {
        // Store the reverse translation for faster key name lookup
-        if (_glfw.ns.publicKeys[scancode] >= 0)
-            _glfw.ns.nativeKeys[_glfw.ns.publicKeys[scancode]] = scancode;
+        if (_glfw.ns.keycodes[scancode] >= 0)
+            _glfw.ns.scancodes[_glfw.ns.keycodes[scancode]] = scancode;
    }
 }

@@ -247,9 +247,6 @@ static GLFWbool initializeTIS(void)
    CFStringRef* kPropertyUnicodeKeyLayoutData =
        CFBundleGetDataPointerForName(_glfw.ns.tis.bundle,
                                      CFSTR("kTISPropertyUnicodeKeyLayoutData"));
-    CFStringRef* kNotifySelectedKeyboardInputSourceChanged =
-        CFBundleGetDataPointerForName(_glfw.ns.tis.bundle,
-                                      CFSTR("kTISNotifySelectedKeyboardInputSourceChanged"));
    _glfw.ns.tis.CopyCurrentKeyboardLayoutInputSource =
        CFBundleGetFunctionPointerForName(_glfw.ns.tis.bundle,
                                          CFSTR("TISCopyCurrentKeyboardLayoutInputSource"));
@@ -261,7 +258,6 @@ static GLFWbool initializeTIS(void)
                                          CFSTR("LMGetKbdType"));

    if (!kPropertyUnicodeKeyLayoutData ||
-        !kNotifySelectedKeyboardInputSourceChanged ||
        !TISCopyCurrentKeyboardLayoutInputSource ||
        !TISGetInputSourceProperty ||
        !LMGetKbdType)
@@ -273,8 +269,6 @@ static GLFWbool initializeTIS(void)

    _glfw.ns.tis.kPropertyUnicodeKeyLayoutData =
        *kPropertyUnicodeKeyLayoutData;
-    _glfw.ns.tis.kNotifySelectedKeyboardInputSourceChanged =
-        *kNotifySelectedKeyboardInputSourceChanged;

    return updateUnicodeDataNS();
 }
@@ -301,10 +295,10 @@ int _glfwPlatformInit(void)
    _glfw.ns.autoreleasePool = [[NSAutoreleasePool alloc] init];

    _glfw.ns.listener = [[GLFWLayoutListener alloc] init];
-    [[NSDistributedNotificationCenter defaultCenter]
+    [[NSNotificationCenter defaultCenter]
        addObserver:_glfw.ns.listener
           selector:@selector(selectedKeyboardInputSourceChanged:)
-               name:(__bridge NSString*)kTISNotifySelectedKeyboardInputSourceChanged
+               name:NSTextInputContextKeyboardSelectionDidChangeNotification
             object:nil];

 #if defined(_GLFW_USE_CHDIR)
@@ -355,11 +349,11 @@ void _glfwPlatformTerminate(void)

    if (_glfw.ns.listener)
    {
-        [[NSDistributedNotificationCenter defaultCenter]
+        [[NSNotificationCenter defaultCenter]
            removeObserver:_glfw.ns.listener
-                      name:(__bridge NSString*)kTISNotifySelectedKeyboardInputSourceChanged
+                      name:NSTextInputContextKeyboardSelectionDidChangeNotification
                    object:nil];
-        [[NSDistributedNotificationCenter defaultCenter]
+        [[NSNotificationCenter defaultCenter]
            removeObserver:_glfw.ns.listener];
        [_glfw.ns.listener release];
        _glfw.ns.listener = nil;
@@ -387,9 +381,6 @@ const char* _glfwPlatformGetVersionString(void)
 #if defined(_GLFW_USE_MENUBAR)
        " menubar"
 #endif
-#if defined(_GLFW_USE_RETINA)
-        " retina"
-#endif
 #if defined(_GLFW_BUILD_DLL)
        " dynamic"
 #endif
@@ -1,7 +1,7 @@
 //========================================================================
 // GLFW 3.3 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -1,7 +1,7 @@
 //========================================================================
 // GLFW 3.3 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
 //
 // This software is provided 'as-is', without any express or implied
@@ -272,24 +272,24 @@ static void matchCallback(void* context,
                          IOHIDDeviceRef deviceRef)
 {
    _GLFWjoystickNS* js;
-    int joy;
+    int jid;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (_glfw.ns_js[joy].present && _glfw.ns_js[joy].deviceRef == deviceRef)
+        if (_glfw.ns_js[jid].present && _glfw.ns_js[jid].deviceRef == deviceRef)
            return;
    }

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (!_glfw.ns_js[joy].present)
+        if (!_glfw.ns_js[jid].present)
            break;
    }

-    if (joy > GLFW_JOYSTICK_LAST)
+    if (jid > GLFW_JOYSTICK_LAST)
        return;

-    js = _glfw.ns_js + joy;
+    js = _glfw.ns_js + jid;
    js->present = GLFW_TRUE;
    js->deviceRef = deviceRef;

@@ -324,7 +324,7 @@ static void matchCallback(void* context,
    js->buttons = calloc(CFArrayGetCount(js->buttonElements) +
                         CFArrayGetCount(js->hatElements) * 4, 1);

-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
+    _glfwInputJoystickChange(jid, GLFW_CONNECTED);
 }

 // Callback for user-initiated joystick removal
@@ -334,13 +334,13 @@ static void removeCallback(void* context,
                           void* sender,
                           IOHIDDeviceRef deviceRef)
 {
-    int joy;
+    int jid;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (_glfw.ns_js[joy].deviceRef == deviceRef)
+        if (_glfw.ns_js[jid].deviceRef == deviceRef)
        {
-            removeJoystick(_glfw.ns_js + joy);
+            removeJoystick(_glfw.ns_js + jid);
            break;
        }
    }
@@ -456,11 +456,11 @@ void _glfwInitJoysticksNS(void)
 //
 void _glfwTerminateJoysticksNS(void)
 {
-    int joy;
+    int jid;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        _GLFWjoystickNS* js = _glfw.ns_js + joy;
+        _GLFWjoystickNS* js = _glfw.ns_js + jid;
        removeJoystick(js);
    }

@@ -473,15 +473,15 @@ void _glfwTerminateJoysticksNS(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////

-int _glfwPlatformJoystickPresent(int joy)
+int _glfwPlatformJoystickPresent(int jid)
 {
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
+    _GLFWjoystickNS* js = _glfw.ns_js + jid;
    return js->present;
 }

-const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+const float* _glfwPlatformGetJoystickAxes(int jid, int* count)
 {
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
+    _GLFWjoystickNS* js = _glfw.ns_js + jid;
    if (!pollJoystickAxisEvents(js))
        return NULL;

@@ -489,9 +489,9 @@ const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
    return js->axes;
 }

-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+const unsigned char* _glfwPlatformGetJoystickButtons(int jid, int* count)
 {
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
+    _GLFWjoystickNS* js = _glfw.ns_js + jid;
    if (!pollJoystickButtonEvents(js))
        return NULL;

@@ -500,9 +500,9 @@ const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
    return js->buttons;
 }

-const char* _glfwPlatformGetJoystickName(int joy)
+const char* _glfwPlatformGetJoystickName(int jid)
 {
-    _GLFWjoystickNS* js = _glfw.ns_js + joy;
+    _GLFWjoystickNS* js = _glfw.ns_js + jid;
    if (!js->present)
        return NULL;

@@ -1,8 +1,8 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -36,39 +36,82 @@
 #include <ApplicationServices/ApplicationServices.h>


-// Get the name of the specified display
+// Get the name of the specified display, or NULL
 //
 static char* getDisplayName(CGDirectDisplayID displayID)
 {
-    char* name;
-    CFDictionaryRef info, names;
-    CFStringRef value;
-    CFIndex size;
+    io_iterator_t it;
+    io_service_t service;
+    CFDictionaryRef info;

-    // NOTE: This uses a deprecated function because Apple has
-    //       (as of January 2015) not provided any alternative
-    info = IODisplayCreateInfoDictionary(CGDisplayIOServicePort(displayID),
-                                         kIODisplayOnlyPreferredName);
-    names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
+    if (IOServiceGetMatchingServices(kIOMasterPortDefault,
+                                     IOServiceMatching("IODisplayConnect"),
+                                     &it) != 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to get display service port iterator");
+        return 0;
+    }
+
+    while ((service = IOIteratorNext(it)) != 0)
+    {
+        info = IODisplayCreateInfoDictionary(service, kIODisplayOnlyPreferredName);
+
+        CFNumberRef vendorIDRef =
+            CFDictionaryGetValue(info, CFSTR(kDisplayVendorID));
+        CFNumberRef productIDRef =
+            CFDictionaryGetValue(info, CFSTR(kDisplayProductID));
+        if (!vendorIDRef || !productIDRef)
+        {
+            CFRelease(info);
+            continue;
+        }
+
+        unsigned int vendorID, productID;
+        CFNumberGetValue(vendorIDRef, kCFNumberIntType, &vendorID);
+        CFNumberGetValue(productIDRef, kCFNumberIntType, &productID);
+
+        if (CGDisplayVendorNumber(displayID) == vendorID &&
+            CGDisplayModelNumber(displayID) == productID)
+        {
+            // Info dictionary is used and freed below
+            break;
+        }
+
+        CFRelease(info);
+    }
+
+    IOObjectRelease(it);
+
+    if (!service)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to find service port for display");
+        return NULL;
+    }
+
+    CFDictionaryRef names =
+        CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
+
+    CFStringRef nameRef;

    if (!names || !CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
-                                                 (const void**) &value))
+                                                 (const void**) &nameRef))
    {
        // This may happen if a desktop Mac is running headless
        _glfwInputError(GLFW_PLATFORM_ERROR,
                        "Cocoa: Failed to retrieve display name");
-
        CFRelease(info);
-        return strdup("Unknown");
+        return NULL;
    }

-    size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
-                                             kCFStringEncodingUTF8);
-    name = calloc(size + 1, 1);
-    CFStringGetCString(value, name, size, kCFStringEncodingUTF8);
+    const CFIndex size =
+        CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef),
+                                          kCFStringEncodingUTF8);
+    char* name = calloc(size + 1, 1);
+    CFStringGetCString(nameRef, name, size, kCFStringEncodingUTF8);

    CFRelease(info);
-
    return name;
 }

@@ -77,15 +120,15 @@ static char* getDisplayName(CGDirectDisplayID displayID)
 static GLFWbool modeIsGood(CGDisplayModeRef mode)
 {
    uint32_t flags = CGDisplayModeGetIOFlags(mode);
+
    if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
        return GLFW_FALSE;
-
    if (flags & kDisplayModeInterlacedFlag)
        return GLFW_FALSE;
-
    if (flags & kDisplayModeStretchedFlag)
        return GLFW_FALSE;

+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101200
    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
        CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
@@ -95,6 +138,7 @@ static GLFWbool modeIsGood(CGDisplayModeRef mode)
    }

    CFRelease(format);
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
    return GLFW_TRUE;
 }

@@ -115,8 +159,8 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
            result.refreshRate = (int) (time.timeScale / (double) time.timeValue);
    }

+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101200
    CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
-
    if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
    {
        result.redBits = 5;
@@ -124,13 +168,16 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
        result.blueBits = 5;
    }
    else
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
    {
        result.redBits = 8;
        result.greenBits = 8;
        result.blueBits = 8;
    }

+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101200
    CFRelease(format);
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
    return result;
 }

@@ -264,6 +311,8 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)

        const CGSize size = CGDisplayScreenSize(displays[i]);
        char* name = getDisplayName(displays[i]);
+        if (!name)
+            name = strdup("Unknown");

        monitor = _glfwAllocMonitor(name, size.width, size.height);
        monitor->ns.displayID  = displays[i];
@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -39,6 +39,18 @@
 typedef void* id;
 #endif

+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+
+typedef struct VkMacOSSurfaceCreateInfoMVK
+{
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+typedef VkResult (APIENTRY *PFN_vkCreateMacOSSurfaceMVK)(VkInstance,const VkMacOSSurfaceCreateInfoMVK*,const VkAllocationCallbacks*,VkSurfaceKHR*);
+
 #include "posix_tls.h"
 #include "cocoa_joystick.h"
 #include "nsgl_context.h"
@@ -58,7 +70,6 @@ typedef void* id;

 // HIToolbox.framework pointer typedefs
 #define kTISPropertyUnicodeKeyLayoutData _glfw.ns.tis.kPropertyUnicodeKeyLayoutData
-#define kTISNotifySelectedKeyboardInputSourceChanged _glfw.ns.tis.kNotifySelectedKeyboardInputSourceChanged
 typedef TISInputSourceRef (*PFN_TISCopyCurrentKeyboardLayoutInputSource)(void);
 #define TISCopyCurrentKeyboardLayoutInputSource _glfw.ns.tis.CopyCurrentKeyboardLayoutInputSource
 typedef void* (*PFN_TISGetInputSourceProperty)(TISInputSourceRef,CFStringRef);
@@ -74,6 +85,9 @@ typedef struct _GLFWwindowNS
    id              object;
    id              delegate;
    id              view;
+    id              layer;
+
+    GLFWbool        maximized;

    // The total sum of the distances the cursor has been warped
    // since the last cursor motion event was processed
@@ -96,8 +110,8 @@ typedef struct _GLFWlibraryNS
    id                  listener;

    char                keyName[64];
-    short int           publicKeys[256];
-    short int           nativeKeys[GLFW_KEY_LAST + 1];
+    short int           keycodes[256];
+    short int           scancodes[GLFW_KEY_LAST + 1];
    char*               clipboardString;
    // Where to place the cursor when re-enabled
    double              restoreCursorPosX, restoreCursorPosY;
@@ -110,7 +124,6 @@ typedef struct _GLFWlibraryNS
        PFN_TISGetInputSourceProperty GetInputSourceProperty;
        PFN_LMGetKbdType GetKbdType;
        CFStringRef     kPropertyUnicodeKeyLayoutData;
-        CFStringRef     kNotifySelectedKeyboardInputSourceChanged;
    } tis;

 } _GLFWlibraryNS;
@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -32,6 +32,23 @@
 // Needed for _NSGetProgname
 #include <crt_externs.h>

+// HACK: The 10.12 SDK adds new symbols and immediately deprecates the old ones
+#if MAC_OS_X_VERSION_MAX_ALLOWED < 101200
+ #define NSWindowStyleMaskBorderless NSBorderlessWindowMask
+ #define NSWindowStyleMaskClosable NSClosableWindowMask
+ #define NSWindowStyleMaskMiniaturizable NSMiniaturizableWindowMask
+ #define NSWindowStyleMaskResizable NSResizableWindowMask
+ #define NSWindowStyleMaskTitled NSTitledWindowMask
+ #define NSEventModifierFlagCommand NSCommandKeyMask
+ #define NSEventModifierFlagControl NSControlKeyMask
+ #define NSEventModifierFlagOption NSAlternateKeyMask
+ #define NSEventModifierFlagShift NSShiftKeyMask
+ #define NSEventModifierFlagDeviceIndependentFlagsMask NSDeviceIndependentModifierFlagsMask
+ #define NSEventMaskAny NSAnyEventMask
+ #define NSEventTypeApplicationDefined NSApplicationDefined
+ #define NSEventTypeKeyUp NSKeyUp
+#endif
+

 // Returns the specified standard cursor
 //
@@ -63,14 +80,15 @@ static NSUInteger getStyleMask(_GLFWwindow* window)
    NSUInteger styleMask = 0;

    if (window->monitor || !window->decorated)
-        styleMask |= NSBorderlessWindowMask;
+        styleMask |= NSWindowStyleMaskBorderless;
    else
    {
-        styleMask |= NSTitledWindowMask | NSClosableWindowMask |
-                     NSMiniaturizableWindowMask;
+        styleMask |= NSWindowStyleMaskTitled |
+                     NSWindowStyleMaskClosable |
+                     NSWindowStyleMaskMiniaturizable;

        if (window->resizable)
-            styleMask |= NSResizableWindowMask;
+            styleMask |= NSWindowStyleMaskResizable;
    }

    return styleMask;
@@ -144,32 +162,32 @@ static void releaseMonitor(_GLFWwindow* window)
    _glfwRestoreVideoModeNS(window->monitor);
 }

-// Translates OS X key modifiers into GLFW ones
+// Translates macOS key modifiers into GLFW ones
 //
 static int translateFlags(NSUInteger flags)
 {
    int mods = 0;

-    if (flags & NSShiftKeyMask)
+    if (flags & NSEventModifierFlagShift)
        mods |= GLFW_MOD_SHIFT;
-    if (flags & NSControlKeyMask)
+    if (flags & NSEventModifierFlagControl)
        mods |= GLFW_MOD_CONTROL;
-    if (flags & NSAlternateKeyMask)
+    if (flags & NSEventModifierFlagOption)
        mods |= GLFW_MOD_ALT;
-    if (flags & NSCommandKeyMask)
+    if (flags & NSEventModifierFlagCommand)
        mods |= GLFW_MOD_SUPER;

    return mods;
 }

-// Translates a OS X keycode to a GLFW keycode
+// Translates a macOS keycode to a GLFW keycode
 //
 static int translateKey(unsigned int key)
 {
-    if (key >= sizeof(_glfw.ns.publicKeys) / sizeof(_glfw.ns.publicKeys[0]))
+    if (key >= sizeof(_glfw.ns.keycodes) / sizeof(_glfw.ns.keycodes[0]))
        return GLFW_KEY_UNKNOWN;

-    return _glfw.ns.publicKeys[key];
+    return _glfw.ns.keycodes[key];
 }

 // Translate a GLFW keycode to a Cocoa modifier flag
@@ -180,16 +198,16 @@ static NSUInteger translateKeyToModifierFlag(int key)
    {
        case GLFW_KEY_LEFT_SHIFT:
        case GLFW_KEY_RIGHT_SHIFT:
-            return NSShiftKeyMask;
+            return NSEventModifierFlagShift;
        case GLFW_KEY_LEFT_CONTROL:
        case GLFW_KEY_RIGHT_CONTROL:
-            return NSControlKeyMask;
+            return NSEventModifierFlagControl;
        case GLFW_KEY_LEFT_ALT:
        case GLFW_KEY_RIGHT_ALT:
-            return NSAlternateKeyMask;
+            return NSEventModifierFlagOption;
        case GLFW_KEY_LEFT_SUPER:
        case GLFW_KEY_RIGHT_SUPER:
-            return NSCommandKeyMask;
+            return NSEventModifierFlagCommand;
    }

    return 0;
@@ -238,6 +256,13 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
    if (_glfw.ns.disabledCursorWindow == window)
        centerCursor(window);

+    const int maximized = [window->ns.object isZoomed];
+    if (window->ns.maximized != maximized)
+    {
+        window->ns.maximized = maximized;
+        _glfwInputWindowMaximize(window, maximized);
+    }
+
    const NSRect contentRect = [window->ns.view frame];
    const NSRect fbRect = [window->ns.view convertRectToBacking:contentRect];

@@ -406,6 +431,16 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
    return YES;
 }

+- (BOOL)wantsUpdateLayer
+{
+    return YES;
+}
+
+- (id)makeBackingLayer
+{
+    return window->ns.layer;
+}
+
 - (void)cursorUpdate:(NSEvent *)event
 {
    updateCursorImage(window);
@@ -558,7 +593,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 {
    int action;
    const unsigned int modifierFlags =
-        [event modifierFlags] & NSDeviceIndependentModifierFlagsMask;
+        [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
    const int key = translateKey([event keyCode]);
    const int mods = translateFlags(modifierFlags);
    const NSUInteger keyFlag = translateKeyToModifierFlag(key);
@@ -753,7 +788,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };

 - (BOOL)canBecomeKeyWindow
 {
-    // Required for NSBorderlessWindowMask windows
+    // Required for NSWindowStyleMaskBorderless windows
    return YES;
 }

@@ -774,8 +809,11 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 // down the command key don't get sent to the key window.
 - (void)sendEvent:(NSEvent *)event
 {
-    if ([event type] == NSKeyUp && ([event modifierFlags] & NSCommandKeyMask))
+    if ([event type] == NSEventTypeKeyUp &&
+        ([event modifierFlags] & NSEventModifierFlagCommand))
+    {
        [[self keyWindow] sendEvent:event];
+    }
    else
        [super sendEvent:event];
 }
@@ -859,7 +897,7 @@ static void createMenuBar(void)
    [[appMenu addItemWithTitle:@"Hide Others"
                       action:@selector(hideOtherApplications:)
                keyEquivalent:@"h"]
-        setKeyEquivalentModifierMask:NSAlternateKeyMask | NSCommandKeyMask];
+        setKeyEquivalentModifierMask:NSEventModifierFlagOption | NSEventModifierFlagCommand];
    [appMenu addItemWithTitle:@"Show All"
                       action:@selector(unhideAllApplications:)
                keyEquivalent:@""];
@@ -891,7 +929,7 @@ static void createMenuBar(void)
    [[windowMenu addItemWithTitle:@"Enter Full Screen"
                           action:@selector(toggleFullScreen:)
                    keyEquivalent:@"f"]
-     setKeyEquivalentModifierMask:NSControlKeyMask | NSCommandKeyMask];
+     setKeyEquivalentModifierMask:NSEventModifierFlagControl | NSEventModifierFlagCommand];

    // Prior to Snow Leopard, we need to use this oddly-named semi-private API
    // to get the application menu working properly.
@@ -1000,15 +1038,14 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,

    window->ns.view = [[GLFWContentView alloc] initWithGlfwWindow:window];

-#if defined(_GLFW_USE_RETINA)
-    [window->ns.view setWantsBestResolutionOpenGLSurface:YES];
-#endif /*_GLFW_USE_RETINA*/
+    if (wndconfig->ns.retina)
+        [window->ns.view setWantsBestResolutionOpenGLSurface:YES];

+    [window->ns.object setContentView:window->ns.view];
    [window->ns.object makeFirstResponder:window->ns.view];
    [window->ns.object setTitle:[NSString stringWithUTF8String:wndconfig->title]];
    [window->ns.object setDelegate:window->ns.delegate];
    [window->ns.object setAcceptsMouseMovedEvents:YES];
-    [window->ns.object setContentView:window->ns.view];
    [window->ns.object setRestorable:NO];

    return GLFW_TRUE;
@@ -1155,7 +1192,7 @@ void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
 void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int numer, int denom)
 {
    if (numer == GLFW_DONT_CARE || denom == GLFW_DONT_CARE)
-        [window->ns.object setContentAspectRatio:NSMakeSize(0, 0)];
+        [window->ns.object setResizeIncrements:NSMakeSize(1.0, 1.0)];
    else
        [window->ns.object setContentAspectRatio:NSMakeSize(numer, denom)];
 }
@@ -1347,11 +1384,30 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
    return [window->ns.object isZoomed];
 }

+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    [window->ns.object setStyleMask:getStyleMask(window)];
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    [window->ns.object setStyleMask:getStyleMask(window)];
+    [window->ns.object makeFirstResponder:window->ns.view];
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    if (enabled)
+        [window->ns.object setLevel:NSFloatingWindowLevel];
+    else
+        [window->ns.object setLevel:NSNormalWindowLevel];
+}
+
 void _glfwPlatformPollEvents(void)
 {
    for (;;)
    {
-        NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
+        NSEvent* event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                            untilDate:[NSDate distantPast]
                                               inMode:NSDefaultRunLoopMode
                                              dequeue:YES];
@@ -1370,7 +1426,7 @@ void _glfwPlatformWaitEvents(void)
    // I wanted to pass NO to dequeue:, and rely on PollEvents to
    // dequeue and send.  For reasons not at all clear to me, passing
    // NO to dequeue: causes this method never to return.
-    NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask
+    NSEvent *event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                        untilDate:[NSDate distantFuture]
                                           inMode:NSDefaultRunLoopMode
                                          dequeue:YES];
@@ -1382,7 +1438,7 @@ void _glfwPlatformWaitEvents(void)
 void _glfwPlatformWaitEventsTimeout(double timeout)
 {
    NSDate* date = [NSDate dateWithTimeIntervalSinceNow:timeout];
-    NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
+    NSEvent* event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                        untilDate:date
                                           inMode:NSDefaultRunLoopMode
                                          dequeue:YES];
@@ -1395,7 +1451,7 @@ void _glfwPlatformWaitEventsTimeout(double timeout)
 void _glfwPlatformPostEmptyEvent(void)
 {
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
-    NSEvent* event = [NSEvent otherEventWithType:NSApplicationDefined
+    NSEvent* event = [NSEvent otherEventWithType:NSEventTypeApplicationDefined
                                        location:NSMakePoint(0, 0)
                                   modifierFlags:0
                                       timestamp:0
@@ -1472,9 +1528,9 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
 const char* _glfwPlatformGetKeyName(int key, int scancode)
 {
    if (key != GLFW_KEY_UNKNOWN)
-        scancode = _glfw.ns.nativeKeys[key];
+        scancode = _glfw.ns.scancodes[key];

-    if (!_glfwIsPrintable(_glfw.ns.publicKeys[scancode]))
+    if (!_glfwIsPrintable(_glfw.ns.keycodes[scancode]))
        return NULL;

    UInt32 deadKeyState = 0;
@@ -1511,6 +1567,11 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
    return _glfw.ns.keyName;
 }

+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.ns.scancodes[key];
+}
+
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                              const GLFWimage* image,
                              int xhot, int yhot)
@@ -1618,17 +1679,20 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
    return _glfw.ns.clipboardString;
 }

-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    *count = 0;
-    return NULL;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.MVK_macos_surface)
+        return;
+
+    extensions[0] = "VK_KHR_surface";
+    extensions[1] = "VK_MVK_macos_surface";
 }

 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                      VkPhysicalDevice device,
                                                      uint32_t queuefamily)
 {
-    return GLFW_FALSE;
+    return GLFW_TRUE;
 }

 VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
@@ -1636,7 +1700,57 @@ VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
                                          const VkAllocationCallbacks* allocator,
                                          VkSurfaceKHR* surface)
 {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101100
+    VkResult err;
+    VkMacOSSurfaceCreateInfoMVK sci;
+    PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
+
+    vkCreateMacOSSurfaceMVK = (PFN_vkCreateMacOSSurfaceMVK)
+        vkGetInstanceProcAddr(instance, "vkCreateMacOSSurfaceMVK");
+    if (!vkCreateMacOSSurfaceMVK)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "Cocoa: Vulkan instance missing VK_MVK_macos_surface extension");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    // HACK: Dynamically load Core Animation to avoid adding an extra
+    //       dependency for the majority who don't use MoltenVK
+    NSBundle* bundle = [NSBundle bundleWithPath:@"/System/Library/Frameworks/QuartzCore.framework"];
+    if (!bundle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to find QuartzCore.framework");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    // NOTE: Create the layer here as makeBackingLayer should not return nil
+    window->ns.layer = [[bundle classNamed:@"CAMetalLayer"] layer];
+    if (!window->ns.layer)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to create layer for view");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
+    [window->ns.view setWantsLayer:YES];
+
+    memset(&sci, 0, sizeof(sci));
+    sci.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
+    sci.pView = window->ns.view;
+
+    err = vkCreateMacOSSurfaceMVK(instance, &sci, allocator, surface);
+    if (err)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to create Vulkan surface: %s",
+                        _glfwGetVulkanResultString(err));
+    }
+
+    return err;
+#else
    return VK_ERROR_EXTENSION_NOT_PRESENT;
+#endif
 }


@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -315,37 +315,37 @@ GLFWbool _glfwInitEGL(void)

    _glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);

-    _glfw.egl.GetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC)
+    _glfw.egl.GetConfigAttrib = (PFN_eglGetConfigAttrib)
        _glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
-    _glfw.egl.GetConfigs = (PFNEGLGETCONFIGSPROC)
+    _glfw.egl.GetConfigs = (PFN_eglGetConfigs)
        _glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
-    _glfw.egl.GetDisplay = (PFNEGLGETDISPLAYPROC)
+    _glfw.egl.GetDisplay = (PFN_eglGetDisplay)
        _glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
-    _glfw.egl.GetError = (PFNEGLGETERRORPROC)
+    _glfw.egl.GetError = (PFN_eglGetError)
        _glfw_dlsym(_glfw.egl.handle, "eglGetError");
-    _glfw.egl.Initialize = (PFNEGLINITIALIZEPROC)
+    _glfw.egl.Initialize = (PFN_eglInitialize)
        _glfw_dlsym(_glfw.egl.handle, "eglInitialize");
-    _glfw.egl.Terminate = (PFNEGLTERMINATEPROC)
+    _glfw.egl.Terminate = (PFN_eglTerminate)
        _glfw_dlsym(_glfw.egl.handle, "eglTerminate");
-    _glfw.egl.BindAPI = (PFNEGLBINDAPIPROC)
+    _glfw.egl.BindAPI = (PFN_eglBindAPI)
        _glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
-    _glfw.egl.CreateContext = (PFNEGLCREATECONTEXTPROC)
+    _glfw.egl.CreateContext = (PFN_eglCreateContext)
        _glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
-    _glfw.egl.DestroySurface = (PFNEGLDESTROYSURFACEPROC)
+    _glfw.egl.DestroySurface = (PFN_eglDestroySurface)
        _glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
-    _glfw.egl.DestroyContext = (PFNEGLDESTROYCONTEXTPROC)
+    _glfw.egl.DestroyContext = (PFN_eglDestroyContext)
        _glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
-    _glfw.egl.CreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC)
+    _glfw.egl.CreateWindowSurface = (PFN_eglCreateWindowSurface)
        _glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
-    _glfw.egl.MakeCurrent = (PFNEGLMAKECURRENTPROC)
+    _glfw.egl.MakeCurrent = (PFN_eglMakeCurrent)
        _glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
-    _glfw.egl.SwapBuffers = (PFNEGLSWAPBUFFERSPROC)
+    _glfw.egl.SwapBuffers = (PFN_eglSwapBuffers)
        _glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
-    _glfw.egl.SwapInterval = (PFNEGLSWAPINTERVALPROC)
+    _glfw.egl.SwapInterval = (PFN_eglSwapInterval)
        _glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
-    _glfw.egl.QueryString = (PFNEGLQUERYSTRINGPROC)
+    _glfw.egl.QueryString = (PFN_eglQueryString)
        _glfw_dlsym(_glfw.egl.handle, "eglQueryString");
-    _glfw.egl.GetProcAddress = (PFNEGLGETPROCADDRESSPROC)
+    _glfw.egl.GetProcAddress = (PFN_eglGetProcAddress)
        _glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");

    if (!_glfw.egl.GetConfigAttrib ||
@@ -399,6 +399,8 @@ GLFWbool _glfwInitEGL(void)
        extensionSupportedEGL("EGL_KHR_create_context_no_error");
    _glfw.egl.KHR_gl_colorspace =
        extensionSupportedEGL("EGL_KHR_gl_colorspace");
+    _glfw.egl.KHR_get_all_proc_addresses =
+        extensionSupportedEGL("EGL_KHR_get_all_proc_addresses");

    return GLFW_TRUE;
 }
@@ -583,6 +585,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
    window->context.egl.config = config;

    // Load the appropriate client library
+    if (!_glfw.egl.KHR_get_all_proc_addresses)
    {
        int i;
        const char** sonames;
@@ -2,7 +2,7 @@
 // GLFW 3.3 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -116,22 +116,22 @@ typedef void* EGLDisplay;
 typedef void* EGLSurface;

 // EGL function pointer typedefs
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLGETCONFIGATTRIBPROC)(EGLDisplay,EGLConfig,EGLint,EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLGETCONFIGSPROC)(EGLDisplay,EGLConfig*,EGLint,EGLint*);
-typedef EGLDisplay (EGLAPIENTRY * PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType);
-typedef EGLint (EGLAPIENTRY * PFNEGLGETERRORPROC)(void);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLINITIALIZEPROC)(EGLDisplay,EGLint*,EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLTERMINATEPROC)(EGLDisplay);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLBINDAPIPROC)(EGLenum);
-typedef EGLContext (EGLAPIENTRY * PFNEGLCREATECONTEXTPROC)(EGLDisplay,EGLConfig,EGLContext,const EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLDESTROYSURFACEPROC)(EGLDisplay,EGLSurface);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLDESTROYCONTEXTPROC)(EGLDisplay,EGLContext);
-typedef EGLSurface (EGLAPIENTRY * PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay,EGLConfig,EGLNativeWindowType,const EGLint*);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLMAKECURRENTPROC)(EGLDisplay,EGLSurface,EGLSurface,EGLContext);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLSWAPBUFFERSPROC)(EGLDisplay,EGLSurface);
-typedef EGLBoolean (EGLAPIENTRY * PFNEGLSWAPINTERVALPROC)(EGLDisplay,EGLint);
-typedef const char* (EGLAPIENTRY * PFNEGLQUERYSTRINGPROC)(EGLDisplay,EGLint);
-typedef GLFWglproc (EGLAPIENTRY * PFNEGLGETPROCADDRESSPROC)(const char*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglGetConfigAttrib)(EGLDisplay,EGLConfig,EGLint,EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglGetConfigs)(EGLDisplay,EGLConfig*,EGLint,EGLint*);
+typedef EGLDisplay (EGLAPIENTRY * PFN_eglGetDisplay)(EGLNativeDisplayType);
+typedef EGLint (EGLAPIENTRY * PFN_eglGetError)(void);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglInitialize)(EGLDisplay,EGLint*,EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglTerminate)(EGLDisplay);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglBindAPI)(EGLenum);
+typedef EGLContext (EGLAPIENTRY * PFN_eglCreateContext)(EGLDisplay,EGLConfig,EGLContext,const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglDestroySurface)(EGLDisplay,EGLSurface);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglDestroyContext)(EGLDisplay,EGLContext);
+typedef EGLSurface (EGLAPIENTRY * PFN_eglCreateWindowSurface)(EGLDisplay,EGLConfig,EGLNativeWindowType,const EGLint*);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglMakeCurrent)(EGLDisplay,EGLSurface,EGLSurface,EGLContext);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapBuffers)(EGLDisplay,EGLSurface);
+typedef EGLBoolean (EGLAPIENTRY * PFN_eglSwapInterval)(EGLDisplay,EGLint);
+typedef const char* (EGLAPIENTRY * PFN_eglQueryString)(EGLDisplay,EGLint);
+typedef GLFWglproc (EGLAPIENTRY * PFN_eglGetProcAddress)(const char*);
 #define eglGetConfigAttrib _glfw.egl.GetConfigAttrib
 #define eglGetConfigs _glfw.egl.GetConfigs
 #define eglGetDisplay _glfw.egl.GetDisplay
@@ -176,25 +176,26 @@ typedef struct _GLFWlibraryEGL
    GLFWbool        KHR_create_context;
    GLFWbool        KHR_create_context_no_error;
    GLFWbool        KHR_gl_colorspace;
+    GLFWbool        KHR_get_all_proc_addresses;

    void*           handle;

-    PFNEGLGETCONFIGATTRIBPROC       GetConfigAttrib;
-    PFNEGLGETCONFIGSPROC            GetConfigs;
-    PFNEGLGETDISPLAYPROC            GetDisplay;
-    PFNEGLGETERRORPROC              GetError;
-    PFNEGLINITIALIZEPROC            Initialize;
-    PFNEGLTERMINATEPROC             Terminate;
-    PFNEGLBINDAPIPROC               BindAPI;
-    PFNEGLCREATECONTEXTPROC         CreateContext;
-    PFNEGLDESTROYSURFACEPROC        DestroySurface;
-    PFNEGLDESTROYCONTEXTPROC        DestroyContext;
-    PFNEGLCREATEWINDOWSURFACEPROC   CreateWindowSurface;
-    PFNEGLMAKECURRENTPROC           MakeCurrent;
-    PFNEGLSWAPBUFFERSPROC           SwapBuffers;
-    PFNEGLSWAPINTERVALPROC          SwapInterval;
-    PFNEGLQUERYSTRINGPROC           QueryString;
-    PFNEGLGETPROCADDRESSPROC        GetProcAddress;
+    PFN_eglGetConfigAttrib      GetConfigAttrib;
+    PFN_eglGetConfigs           GetConfigs;
+    PFN_eglGetDisplay           GetDisplay;
+    PFN_eglGetError             GetError;
+    PFN_eglInitialize           Initialize;
+    PFN_eglTerminate            Terminate;
+    PFN_eglBindAPI              BindAPI;
+    PFN_eglCreateContext        CreateContext;
+    PFN_eglDestroySurface       DestroySurface;
+    PFN_eglDestroyContext       DestroyContext;
+    PFN_eglCreateWindowSurface  CreateWindowSurface;
+    PFN_eglMakeCurrent          MakeCurrent;
+    PFN_eglSwapBuffers          SwapBuffers;
+    PFN_eglSwapInterval         SwapInterval;
+    PFN_eglQueryString          QueryString;
+    PFN_eglGetProcAddress       GetProcAddress;

 } _GLFWlibraryEGL;

@@ -1,7 +1,7 @@
 //========================================================================
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2010-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2010-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -44,6 +44,8 @@
 #cmakedefine _GLFW_WAYLAND
 // Define this to 1 if building GLFW for Mir
 #cmakedefine _GLFW_MIR
+// Define this to 1 if building GLFW for OSMesa
+#cmakedefine _GLFW_OSMESA

 // Define this to 1 if building as a shared library / dynamic library / DLL
 #cmakedefine _GLFW_BUILD_DLL
@@ -53,13 +55,8 @@
 // Define this to 1 to force use of high-performance GPU on hybrid systems
 #cmakedefine _GLFW_USE_HYBRID_HPG

-// Define this to 1 if the Xxf86vm X11 extension is available
-#cmakedefine _GLFW_HAS_XF86VM
-
 // Define this to 1 if glfwInit should change the current directory
 #cmakedefine _GLFW_USE_CHDIR
 // Define this to 1 if glfwCreateWindow should populate the menu bar
 #cmakedefine _GLFW_USE_MENUBAR
-// Define this to 1 if windows should use full resolution on Retina displays
-#cmakedefine _GLFW_USE_RETINA

@@ -2,7 +2,7 @@
 // GLFW 3.3 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -85,14 +85,15 @@ typedef const char* (*PFNGLXQUERYEXTENSIONSSTRINGPROC)(Display*,int);
 typedef GLXFBConfig* (*PFNGLXGETFBCONFIGSPROC)(Display*,int,int*);
 typedef GLXContext (*PFNGLXCREATENEWCONTEXTPROC)(Display*,GLXFBConfig,int,GLXContext,Bool);
 typedef __GLXextproc (* PFNGLXGETPROCADDRESSPROC)(const GLubyte *procName);
-typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
-typedef int (*PFNGLXSWAPINTERVALSGIPROC)(int);
 typedef void (*PFNGLXSWAPINTERVALEXTPROC)(Display*,GLXDrawable,int);
-typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display*,GLXFBConfig,GLXContext,Bool,const int*);
 typedef XVisualInfo* (*PFNGLXGETVISUALFROMFBCONFIGPROC)(Display*,GLXFBConfig);
 typedef GLXWindow (*PFNGLXCREATEWINDOWPROC)(Display*,GLXFBConfig,Window,const int*);
 typedef void (*PFNGLXDESTROYWINDOWPROC)(Display*,GLXWindow);

+typedef int (*PFNGLXSWAPINTERVALMESAPROC)(int);
+typedef int (*PFNGLXSWAPINTERVALSGIPROC)(int);
+typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSARBPROC)(Display*,GLXFBConfig,GLXContext,Bool,const int*);
+
 // libGL.so function pointer typedefs
 #define glXGetFBConfigs _glfw.glx.GetFBConfigs
 #define glXGetFBConfigAttrib _glfw.glx.GetFBConfigAttrib
@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -124,10 +124,10 @@ void _glfwInputDrop(_GLFWwindow* window, int count, const char** paths)
        window->callbacks.drop((GLFWwindow*) window, count, paths);
 }

-void _glfwInputJoystickChange(int joy, int event)
+void _glfwInputJoystickChange(int jid, int event)
 {
    if (_glfw.callbacks.joystick)
-        _glfw.callbacks.joystick(joy, event);
+        _glfw.callbacks.joystick(jid, event);
 }


@@ -256,6 +256,19 @@ GLFWAPI const char* glfwGetKeyName(int key, int scancode)
    return _glfwPlatformGetKeyName(key, scancode);
 }

+GLFWAPI int glfwGetKeyScancode(int key)
+{
+    _GLFW_REQUIRE_INIT_OR_RETURN(-1);
+
+    if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
+    {
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
+        return GLFW_RELEASE;
+    }
+
+    return _glfwPlatformGetKeyScancode(key);
+}
+
 GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -540,62 +553,62 @@ GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* handle, GLFWdropfun cbfun)
    return cbfun;
 }

-GLFWAPI int glfwJoystickPresent(int joy)
+GLFWAPI int glfwJoystickPresent(int jid)
 {
    _GLFW_REQUIRE_INIT_OR_RETURN(0);

-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
    {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", jid);
        return 0;
    }

-    return _glfwPlatformJoystickPresent(joy);
+    return _glfwPlatformJoystickPresent(jid);
 }

-GLFWAPI const float* glfwGetJoystickAxes(int joy, int* count)
+GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
 {
    assert(count != NULL);
    *count = 0;

    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
    {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", jid);
        return NULL;
    }

-    return _glfwPlatformGetJoystickAxes(joy, count);
+    return _glfwPlatformGetJoystickAxes(jid, count);
 }

-GLFWAPI const unsigned char* glfwGetJoystickButtons(int joy, int* count)
+GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count)
 {
    assert(count != NULL);
    *count = 0;

    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
    {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", jid);
        return NULL;
    }

-    return _glfwPlatformGetJoystickButtons(joy, count);
+    return _glfwPlatformGetJoystickButtons(jid, count);
 }

-GLFWAPI const char* glfwGetJoystickName(int joy)
+GLFWAPI const char* glfwGetJoystickName(int jid)
 {
    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

-    if (joy < 0 || joy > GLFW_JOYSTICK_LAST)
+    if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
    {
-        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", joy);
+        _glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick %i", jid);
        return NULL;
    }

-    return _glfwPlatformGetJoystickName(joy);
+    return _glfwPlatformGetJoystickName(jid);
 }

 GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun cbfun)
@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -69,6 +69,7 @@ typedef void (* _GLFWdestroycontextfun)(_GLFWwindow*);
 #define GL_VERSION 0x1f02
 #define GL_NONE	0
 #define GL_COLOR_BUFFER_BIT	0x00004000
+#define GL_UNSIGNED_BYTE 0x1401
 #define GL_EXTENSIONS 0x1f03
 #define GL_NUM_EXTENSIONS 0x821d
 #define GL_CONTEXT_FLAGS 0x821e
@@ -110,6 +111,7 @@ typedef enum VkStructureType
    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000053000,
    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;

@@ -171,6 +173,8 @@ typedef void (APIENTRY * PFN_vkVoidFunction)(void);
 #include "wl_platform.h"
 #elif defined(_GLFW_MIR)
 #include "mir_platform.h"
+#elif defined(_GLFW_OSMESA)
+ #include "osmesa_platform.h"
 #else
 #error "No supported window creation API selected"
 #endif
@@ -260,6 +264,9 @@ struct _GLFWwndconfig
    GLFWbool      autoIconify;
    GLFWbool      floating;
    GLFWbool      maximized;
+    struct {
+        GLFWbool  retina;
+    } ns;
 };

 /*! @brief Context configuration.
@@ -351,7 +358,7 @@ struct _GLFWwindow
    GLFWbool            decorated;
    GLFWbool            autoIconify;
    GLFWbool            floating;
-    GLFWbool            closed;
+    GLFWbool            shouldClose;
    void*               userPointer;
    GLFWvidmode         videoMode;
    _GLFWmonitor*       monitor;
@@ -378,6 +385,7 @@ struct _GLFWwindow
        GLFWwindowrefreshfun    refresh;
        GLFWwindowfocusfun      focus;
        GLFWwindowiconifyfun    iconify;
+        GLFWwindowmaximizefun   maximize;
        GLFWframebuffersizefun  fbsize;
        GLFWmousebuttonfun      mouseButton;
        GLFWcursorposfun        cursorPos;
@@ -449,18 +457,24 @@ struct _GLFWlibrary
    struct {
        GLFWbool        available;
        void*           handle;
-        char**          extensions;
-        uint32_t        extensionCount;
+        char*           extensions[2];
 #if !defined(_GLFW_VULKAN_STATIC)
        PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
        PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
 #endif
        GLFWbool        KHR_surface;
+#if defined(_GLFW_WIN32)
        GLFWbool        KHR_win32_surface;
+#elif defined(_GLFW_COCOA)
+        GLFWbool        MVK_macos_surface;
+#elif defined(_GLFW_X11)
        GLFWbool        KHR_xlib_surface;
        GLFWbool        KHR_xcb_surface;
+#elif defined(_GLFW_WAYLAND)
        GLFWbool        KHR_wayland_surface;
+#elif defined(_GLFW_MIR)
        GLFWbool        KHR_mir_surface;
+#endif
    } vk;

    struct {
@@ -543,6 +557,11 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode);
 */
 const char* _glfwPlatformGetKeyName(int key, int scancode);

+/*! @copydoc glfwGetKeyScancode
+ *  @ingroup platform
+ */
+int _glfwPlatformGetKeyScancode(int key);
+
 /*! @copydoc glfwGetMonitors
 *  @ingroup platform
 */
@@ -598,22 +617,22 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window);
 /*! @copydoc glfwJoystickPresent
 *  @ingroup platform
 */
-int _glfwPlatformJoystickPresent(int joy);
+int _glfwPlatformJoystickPresent(int jid);

 /*! @copydoc glfwGetJoystickAxes
 *  @ingroup platform
 */
-const float* _glfwPlatformGetJoystickAxes(int joy, int* count);
+const float* _glfwPlatformGetJoystickAxes(int jid, int* count);

 /*! @copydoc glfwGetJoystickButtons
 *  @ingroup platform
 */
-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count);
+const unsigned char* _glfwPlatformGetJoystickButtons(int jid, int* count);

 /*! @copydoc glfwGetJoystickName
 *  @ingroup platform
 */
-const char* _glfwPlatformGetJoystickName(int joy);
+const char* _glfwPlatformGetJoystickName(int jid);

 /*! @copydoc glfwGetTimerValue
 *  @ingroup platform
@@ -741,6 +760,21 @@ int _glfwPlatformWindowVisible(_GLFWwindow* window);
 */
 int _glfwPlatformWindowMaximized(_GLFWwindow* window);

+/*! @brief Sets whether the window is resizable by the user.
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled);
+
+/*! @brief Sets whether the window is decorated.
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled);
+
+/*! @brief Sets whether the window is floating.
+ *  @ingroup platform
+ */
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled);
+
 /*! @copydoc glfwPollEvents
 *  @ingroup platform
 */
@@ -792,7 +826,7 @@ void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor);

 /*! @ingroup platform
 */
-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count);
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions);

 /*! @ingroup platform
 */
@@ -847,6 +881,14 @@ void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height);
 */
 void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified);

+/*! @brief Notifies shared code of a window maximization event.
+ *  @param[in] window The window that received the event.
+ *  @param[in] maximized `GLFW_TRUE` if the window was maximized, or
+ *  `GLFW_FALSE` if it was restored.
+ *  @ingroup event
+ */
+void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized);
+
 /*! @brief Notifies shared code of a window damage event.
 *  @param[in] window The window that received the event.
 */
@@ -943,11 +985,11 @@ void _glfwInputError(int error, const char* format, ...);
 void _glfwInputDrop(_GLFWwindow* window, int count, const char** names);

 /*! @brief Notifies shared code of a joystick connection/disconnection event.
- *  @param[in] joy The joystick that was connected or disconnected.
+ *  @param[in] jid The joystick that was connected or disconnected.
 *  @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`.
 *  @ingroup event
 */
-void _glfwInputJoystickChange(int joy, int event);
+void _glfwInputJoystickChange(int jid, int event);


 //========================================================================
@@ -1042,7 +1084,7 @@ GLFWbool _glfwIsPrintable(int key);

 /*! @ingroup utility
 */
-GLFWbool _glfwInitVulkan(void);
+GLFWbool _glfwInitVulkan(int mode);

 /*! @ingroup utility
 */
@@ -2,7 +2,7 @@
 // GLFW 3.3 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -50,25 +50,25 @@ static GLFWbool openJoystickDevice(const char* path)
 {
    char axisCount, buttonCount;
    char name[256] = "";
-    int joy, fd, version;
+    int jid, fd, version;
    _GLFWjoystickLinux* js;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (!_glfw.linux_js.js[joy].present)
+        if (!_glfw.linux_js.js[jid].present)
            continue;

-        if (strcmp(_glfw.linux_js.js[joy].path, path) == 0)
+        if (strcmp(_glfw.linux_js.js[jid].path, path) == 0)
            return GLFW_FALSE;
    }

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (!_glfw.linux_js.js[joy].present)
+        if (!_glfw.linux_js.js[jid].present)
            break;
    }

-    if (joy > GLFW_JOYSTICK_LAST)
+    if (jid > GLFW_JOYSTICK_LAST)
        return GLFW_FALSE;

    fd = open(path, O_RDONLY | O_NONBLOCK);
@@ -87,7 +87,7 @@ static GLFWbool openJoystickDevice(const char* path)
    if (ioctl(fd, JSIOCGNAME(sizeof(name)), name) < 0)
        strncpy(name, "Unknown", sizeof(name));

-    js = _glfw.linux_js.js + joy;
+    js = _glfw.linux_js.js + jid;
    js->present = GLFW_TRUE;
    js->name = strdup(name);
    js->path = strdup(path);
@@ -101,7 +101,7 @@ static GLFWbool openJoystickDevice(const char* path)
    js->buttonCount = (int) buttonCount;
    js->buttons = calloc(buttonCount, 1);

-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
+    _glfwInputJoystickChange(jid, GLFW_CONNECTED);
    return GLFW_TRUE;
 }
 #endif // __linux__
@@ -304,15 +304,15 @@ void _glfwPollJoystickEvents(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////

-int _glfwPlatformJoystickPresent(int joy)
+int _glfwPlatformJoystickPresent(int jid)
 {
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + jid;
    return pollJoystickEvents(js);
 }

-const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+const float* _glfwPlatformGetJoystickAxes(int jid, int* count)
 {
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + jid;
    if (!pollJoystickEvents(js))
        return NULL;

@@ -320,9 +320,9 @@ const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
    return js->axes;
 }

-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+const unsigned char* _glfwPlatformGetJoystickButtons(int jid, int* count)
 {
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + jid;
    if (!pollJoystickEvents(js))
        return NULL;

@@ -330,9 +330,9 @@ const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
    return js->buttons;
 }

-const char* _glfwPlatformGetJoystickName(int joy)
+const char* _glfwPlatformGetJoystickName(int jid)
 {
-    _GLFWjoystickLinux* js = _glfw.linux_js.js + joy;
+    _GLFWjoystickLinux* js = _glfw.linux_js.js + jid;
    if (!pollJoystickEvents(js))
        return NULL;

@@ -35,124 +35,133 @@
 //
 static void createKeyTables(void)
 {
-    memset(_glfw.mir.publicKeys, -1, sizeof(_glfw.mir.publicKeys));
+    int scancode;

-    _glfw.mir.publicKeys[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.mir.publicKeys[KEY_1]          = GLFW_KEY_1;
-    _glfw.mir.publicKeys[KEY_2]          = GLFW_KEY_2;
-    _glfw.mir.publicKeys[KEY_3]          = GLFW_KEY_3;
-    _glfw.mir.publicKeys[KEY_4]          = GLFW_KEY_4;
-    _glfw.mir.publicKeys[KEY_5]          = GLFW_KEY_5;
-    _glfw.mir.publicKeys[KEY_6]          = GLFW_KEY_6;
-    _glfw.mir.publicKeys[KEY_7]          = GLFW_KEY_7;
-    _glfw.mir.publicKeys[KEY_8]          = GLFW_KEY_8;
-    _glfw.mir.publicKeys[KEY_9]          = GLFW_KEY_9;
-    _glfw.mir.publicKeys[KEY_0]          = GLFW_KEY_0;
-    _glfw.mir.publicKeys[KEY_MINUS]      = GLFW_KEY_MINUS;
-    _glfw.mir.publicKeys[KEY_EQUAL]      = GLFW_KEY_EQUAL;
-    _glfw.mir.publicKeys[KEY_Q]          = GLFW_KEY_Q;
-    _glfw.mir.publicKeys[KEY_W]          = GLFW_KEY_W;
-    _glfw.mir.publicKeys[KEY_E]          = GLFW_KEY_E;
-    _glfw.mir.publicKeys[KEY_R]          = GLFW_KEY_R;
-    _glfw.mir.publicKeys[KEY_T]          = GLFW_KEY_T;
-    _glfw.mir.publicKeys[KEY_Y]          = GLFW_KEY_Y;
-    _glfw.mir.publicKeys[KEY_U]          = GLFW_KEY_U;
-    _glfw.mir.publicKeys[KEY_I]          = GLFW_KEY_I;
-    _glfw.mir.publicKeys[KEY_O]          = GLFW_KEY_O;
-    _glfw.mir.publicKeys[KEY_P]          = GLFW_KEY_P;
-    _glfw.mir.publicKeys[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
-    _glfw.mir.publicKeys[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.mir.publicKeys[KEY_A]          = GLFW_KEY_A;
-    _glfw.mir.publicKeys[KEY_S]          = GLFW_KEY_S;
-    _glfw.mir.publicKeys[KEY_D]          = GLFW_KEY_D;
-    _glfw.mir.publicKeys[KEY_F]          = GLFW_KEY_F;
-    _glfw.mir.publicKeys[KEY_G]          = GLFW_KEY_G;
-    _glfw.mir.publicKeys[KEY_H]          = GLFW_KEY_H;
-    _glfw.mir.publicKeys[KEY_J]          = GLFW_KEY_J;
-    _glfw.mir.publicKeys[KEY_K]          = GLFW_KEY_K;
-    _glfw.mir.publicKeys[KEY_L]          = GLFW_KEY_L;
-    _glfw.mir.publicKeys[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
-    _glfw.mir.publicKeys[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
-    _glfw.mir.publicKeys[KEY_Z]          = GLFW_KEY_Z;
-    _glfw.mir.publicKeys[KEY_X]          = GLFW_KEY_X;
-    _glfw.mir.publicKeys[KEY_C]          = GLFW_KEY_C;
-    _glfw.mir.publicKeys[KEY_V]          = GLFW_KEY_V;
-    _glfw.mir.publicKeys[KEY_B]          = GLFW_KEY_B;
-    _glfw.mir.publicKeys[KEY_N]          = GLFW_KEY_N;
-    _glfw.mir.publicKeys[KEY_M]          = GLFW_KEY_M;
-    _glfw.mir.publicKeys[KEY_COMMA]      = GLFW_KEY_COMMA;
-    _glfw.mir.publicKeys[KEY_DOT]        = GLFW_KEY_PERIOD;
-    _glfw.mir.publicKeys[KEY_SLASH]      = GLFW_KEY_SLASH;
-    _glfw.mir.publicKeys[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
-    _glfw.mir.publicKeys[KEY_ESC]        = GLFW_KEY_ESCAPE;
-    _glfw.mir.publicKeys[KEY_TAB]        = GLFW_KEY_TAB;
-    _glfw.mir.publicKeys[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
-    _glfw.mir.publicKeys[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.mir.publicKeys[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
-    _glfw.mir.publicKeys[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.mir.publicKeys[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
-    _glfw.mir.publicKeys[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
-    _glfw.mir.publicKeys[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
-    _glfw.mir.publicKeys[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
-    _glfw.mir.publicKeys[KEY_MENU]       = GLFW_KEY_MENU;
-    _glfw.mir.publicKeys[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
-    _glfw.mir.publicKeys[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
-    _glfw.mir.publicKeys[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
-    _glfw.mir.publicKeys[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.mir.publicKeys[KEY_PAUSE]      = GLFW_KEY_PAUSE;
-    _glfw.mir.publicKeys[KEY_DELETE]     = GLFW_KEY_DELETE;
-    _glfw.mir.publicKeys[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
-    _glfw.mir.publicKeys[KEY_ENTER]      = GLFW_KEY_ENTER;
-    _glfw.mir.publicKeys[KEY_HOME]       = GLFW_KEY_HOME;
-    _glfw.mir.publicKeys[KEY_END]        = GLFW_KEY_END;
-    _glfw.mir.publicKeys[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
-    _glfw.mir.publicKeys[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
-    _glfw.mir.publicKeys[KEY_INSERT]     = GLFW_KEY_INSERT;
-    _glfw.mir.publicKeys[KEY_LEFT]       = GLFW_KEY_LEFT;
-    _glfw.mir.publicKeys[KEY_RIGHT]      = GLFW_KEY_RIGHT;
-    _glfw.mir.publicKeys[KEY_DOWN]       = GLFW_KEY_DOWN;
-    _glfw.mir.publicKeys[KEY_UP]         = GLFW_KEY_UP;
-    _glfw.mir.publicKeys[KEY_F1]         = GLFW_KEY_F1;
-    _glfw.mir.publicKeys[KEY_F2]         = GLFW_KEY_F2;
-    _glfw.mir.publicKeys[KEY_F3]         = GLFW_KEY_F3;
-    _glfw.mir.publicKeys[KEY_F4]         = GLFW_KEY_F4;
-    _glfw.mir.publicKeys[KEY_F5]         = GLFW_KEY_F5;
-    _glfw.mir.publicKeys[KEY_F6]         = GLFW_KEY_F6;
-    _glfw.mir.publicKeys[KEY_F7]         = GLFW_KEY_F7;
-    _glfw.mir.publicKeys[KEY_F8]         = GLFW_KEY_F8;
-    _glfw.mir.publicKeys[KEY_F9]         = GLFW_KEY_F9;
-    _glfw.mir.publicKeys[KEY_F10]        = GLFW_KEY_F10;
-    _glfw.mir.publicKeys[KEY_F11]        = GLFW_KEY_F11;
-    _glfw.mir.publicKeys[KEY_F12]        = GLFW_KEY_F12;
-    _glfw.mir.publicKeys[KEY_F13]        = GLFW_KEY_F13;
-    _glfw.mir.publicKeys[KEY_F14]        = GLFW_KEY_F14;
-    _glfw.mir.publicKeys[KEY_F15]        = GLFW_KEY_F15;
-    _glfw.mir.publicKeys[KEY_F16]        = GLFW_KEY_F16;
-    _glfw.mir.publicKeys[KEY_F17]        = GLFW_KEY_F17;
-    _glfw.mir.publicKeys[KEY_F18]        = GLFW_KEY_F18;
-    _glfw.mir.publicKeys[KEY_F19]        = GLFW_KEY_F19;
-    _glfw.mir.publicKeys[KEY_F20]        = GLFW_KEY_F20;
-    _glfw.mir.publicKeys[KEY_F21]        = GLFW_KEY_F21;
-    _glfw.mir.publicKeys[KEY_F22]        = GLFW_KEY_F22;
-    _glfw.mir.publicKeys[KEY_F23]        = GLFW_KEY_F23;
-    _glfw.mir.publicKeys[KEY_F24]        = GLFW_KEY_F24;
-    _glfw.mir.publicKeys[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
-    _glfw.mir.publicKeys[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
-    _glfw.mir.publicKeys[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
-    _glfw.mir.publicKeys[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
-    _glfw.mir.publicKeys[KEY_KP0]        = GLFW_KEY_KP_0;
-    _glfw.mir.publicKeys[KEY_KP1]        = GLFW_KEY_KP_1;
-    _glfw.mir.publicKeys[KEY_KP2]        = GLFW_KEY_KP_2;
-    _glfw.mir.publicKeys[KEY_KP3]        = GLFW_KEY_KP_3;
-    _glfw.mir.publicKeys[KEY_KP4]        = GLFW_KEY_KP_4;
-    _glfw.mir.publicKeys[KEY_KP5]        = GLFW_KEY_KP_5;
-    _glfw.mir.publicKeys[KEY_KP6]        = GLFW_KEY_KP_6;
-    _glfw.mir.publicKeys[KEY_KP7]        = GLFW_KEY_KP_7;
-    _glfw.mir.publicKeys[KEY_KP8]        = GLFW_KEY_KP_8;
-    _glfw.mir.publicKeys[KEY_KP9]        = GLFW_KEY_KP_9;
-    _glfw.mir.publicKeys[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
-    _glfw.mir.publicKeys[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
-    _glfw.mir.publicKeys[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+    memset(_glfw.mir.keycodes, -1, sizeof(_glfw.mir.keycodes));
+    memset(_glfw.mir.scancodes, -1, sizeof(_glfw.mir.scancodes));
+
+    _glfw.mir.keycodes[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.mir.keycodes[KEY_1]          = GLFW_KEY_1;
+    _glfw.mir.keycodes[KEY_2]          = GLFW_KEY_2;
+    _glfw.mir.keycodes[KEY_3]          = GLFW_KEY_3;
+    _glfw.mir.keycodes[KEY_4]          = GLFW_KEY_4;
+    _glfw.mir.keycodes[KEY_5]          = GLFW_KEY_5;
+    _glfw.mir.keycodes[KEY_6]          = GLFW_KEY_6;
+    _glfw.mir.keycodes[KEY_7]          = GLFW_KEY_7;
+    _glfw.mir.keycodes[KEY_8]          = GLFW_KEY_8;
+    _glfw.mir.keycodes[KEY_9]          = GLFW_KEY_9;
+    _glfw.mir.keycodes[KEY_0]          = GLFW_KEY_0;
+    _glfw.mir.keycodes[KEY_MINUS]      = GLFW_KEY_MINUS;
+    _glfw.mir.keycodes[KEY_EQUAL]      = GLFW_KEY_EQUAL;
+    _glfw.mir.keycodes[KEY_Q]          = GLFW_KEY_Q;
+    _glfw.mir.keycodes[KEY_W]          = GLFW_KEY_W;
+    _glfw.mir.keycodes[KEY_E]          = GLFW_KEY_E;
+    _glfw.mir.keycodes[KEY_R]          = GLFW_KEY_R;
+    _glfw.mir.keycodes[KEY_T]          = GLFW_KEY_T;
+    _glfw.mir.keycodes[KEY_Y]          = GLFW_KEY_Y;
+    _glfw.mir.keycodes[KEY_U]          = GLFW_KEY_U;
+    _glfw.mir.keycodes[KEY_I]          = GLFW_KEY_I;
+    _glfw.mir.keycodes[KEY_O]          = GLFW_KEY_O;
+    _glfw.mir.keycodes[KEY_P]          = GLFW_KEY_P;
+    _glfw.mir.keycodes[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
+    _glfw.mir.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.mir.keycodes[KEY_A]          = GLFW_KEY_A;
+    _glfw.mir.keycodes[KEY_S]          = GLFW_KEY_S;
+    _glfw.mir.keycodes[KEY_D]          = GLFW_KEY_D;
+    _glfw.mir.keycodes[KEY_F]          = GLFW_KEY_F;
+    _glfw.mir.keycodes[KEY_G]          = GLFW_KEY_G;
+    _glfw.mir.keycodes[KEY_H]          = GLFW_KEY_H;
+    _glfw.mir.keycodes[KEY_J]          = GLFW_KEY_J;
+    _glfw.mir.keycodes[KEY_K]          = GLFW_KEY_K;
+    _glfw.mir.keycodes[KEY_L]          = GLFW_KEY_L;
+    _glfw.mir.keycodes[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
+    _glfw.mir.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
+    _glfw.mir.keycodes[KEY_Z]          = GLFW_KEY_Z;
+    _glfw.mir.keycodes[KEY_X]          = GLFW_KEY_X;
+    _glfw.mir.keycodes[KEY_C]          = GLFW_KEY_C;
+    _glfw.mir.keycodes[KEY_V]          = GLFW_KEY_V;
+    _glfw.mir.keycodes[KEY_B]          = GLFW_KEY_B;
+    _glfw.mir.keycodes[KEY_N]          = GLFW_KEY_N;
+    _glfw.mir.keycodes[KEY_M]          = GLFW_KEY_M;
+    _glfw.mir.keycodes[KEY_COMMA]      = GLFW_KEY_COMMA;
+    _glfw.mir.keycodes[KEY_DOT]        = GLFW_KEY_PERIOD;
+    _glfw.mir.keycodes[KEY_SLASH]      = GLFW_KEY_SLASH;
+    _glfw.mir.keycodes[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
+    _glfw.mir.keycodes[KEY_ESC]        = GLFW_KEY_ESCAPE;
+    _glfw.mir.keycodes[KEY_TAB]        = GLFW_KEY_TAB;
+    _glfw.mir.keycodes[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
+    _glfw.mir.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.mir.keycodes[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
+    _glfw.mir.keycodes[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.mir.keycodes[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
+    _glfw.mir.keycodes[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
+    _glfw.mir.keycodes[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
+    _glfw.mir.keycodes[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
+    _glfw.mir.keycodes[KEY_MENU]       = GLFW_KEY_MENU;
+    _glfw.mir.keycodes[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
+    _glfw.mir.keycodes[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
+    _glfw.mir.keycodes[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
+    _glfw.mir.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.mir.keycodes[KEY_PAUSE]      = GLFW_KEY_PAUSE;
+    _glfw.mir.keycodes[KEY_DELETE]     = GLFW_KEY_DELETE;
+    _glfw.mir.keycodes[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
+    _glfw.mir.keycodes[KEY_ENTER]      = GLFW_KEY_ENTER;
+    _glfw.mir.keycodes[KEY_HOME]       = GLFW_KEY_HOME;
+    _glfw.mir.keycodes[KEY_END]        = GLFW_KEY_END;
+    _glfw.mir.keycodes[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
+    _glfw.mir.keycodes[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
+    _glfw.mir.keycodes[KEY_INSERT]     = GLFW_KEY_INSERT;
+    _glfw.mir.keycodes[KEY_LEFT]       = GLFW_KEY_LEFT;
+    _glfw.mir.keycodes[KEY_RIGHT]      = GLFW_KEY_RIGHT;
+    _glfw.mir.keycodes[KEY_DOWN]       = GLFW_KEY_DOWN;
+    _glfw.mir.keycodes[KEY_UP]         = GLFW_KEY_UP;
+    _glfw.mir.keycodes[KEY_F1]         = GLFW_KEY_F1;
+    _glfw.mir.keycodes[KEY_F2]         = GLFW_KEY_F2;
+    _glfw.mir.keycodes[KEY_F3]         = GLFW_KEY_F3;
+    _glfw.mir.keycodes[KEY_F4]         = GLFW_KEY_F4;
+    _glfw.mir.keycodes[KEY_F5]         = GLFW_KEY_F5;
+    _glfw.mir.keycodes[KEY_F6]         = GLFW_KEY_F6;
+    _glfw.mir.keycodes[KEY_F7]         = GLFW_KEY_F7;
+    _glfw.mir.keycodes[KEY_F8]         = GLFW_KEY_F8;
+    _glfw.mir.keycodes[KEY_F9]         = GLFW_KEY_F9;
+    _glfw.mir.keycodes[KEY_F10]        = GLFW_KEY_F10;
+    _glfw.mir.keycodes[KEY_F11]        = GLFW_KEY_F11;
+    _glfw.mir.keycodes[KEY_F12]        = GLFW_KEY_F12;
+    _glfw.mir.keycodes[KEY_F13]        = GLFW_KEY_F13;
+    _glfw.mir.keycodes[KEY_F14]        = GLFW_KEY_F14;
+    _glfw.mir.keycodes[KEY_F15]        = GLFW_KEY_F15;
+    _glfw.mir.keycodes[KEY_F16]        = GLFW_KEY_F16;
+    _glfw.mir.keycodes[KEY_F17]        = GLFW_KEY_F17;
+    _glfw.mir.keycodes[KEY_F18]        = GLFW_KEY_F18;
+    _glfw.mir.keycodes[KEY_F19]        = GLFW_KEY_F19;
+    _glfw.mir.keycodes[KEY_F20]        = GLFW_KEY_F20;
+    _glfw.mir.keycodes[KEY_F21]        = GLFW_KEY_F21;
+    _glfw.mir.keycodes[KEY_F22]        = GLFW_KEY_F22;
+    _glfw.mir.keycodes[KEY_F23]        = GLFW_KEY_F23;
+    _glfw.mir.keycodes[KEY_F24]        = GLFW_KEY_F24;
+    _glfw.mir.keycodes[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
+    _glfw.mir.keycodes[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
+    _glfw.mir.keycodes[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
+    _glfw.mir.keycodes[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
+    _glfw.mir.keycodes[KEY_KP0]        = GLFW_KEY_KP_0;
+    _glfw.mir.keycodes[KEY_KP1]        = GLFW_KEY_KP_1;
+    _glfw.mir.keycodes[KEY_KP2]        = GLFW_KEY_KP_2;
+    _glfw.mir.keycodes[KEY_KP3]        = GLFW_KEY_KP_3;
+    _glfw.mir.keycodes[KEY_KP4]        = GLFW_KEY_KP_4;
+    _glfw.mir.keycodes[KEY_KP5]        = GLFW_KEY_KP_5;
+    _glfw.mir.keycodes[KEY_KP6]        = GLFW_KEY_KP_6;
+    _glfw.mir.keycodes[KEY_KP7]        = GLFW_KEY_KP_7;
+    _glfw.mir.keycodes[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.mir.keycodes[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.mir.keycodes[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.mir.keycodes[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.mir.keycodes[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+
+    for (scancode = 0;  scancode < 256;  scancode++)
+    {
+        if (_glfw.mir.keycodes[scancode] > 0)
+            _glfw.mir.scancodes[_glfw.mir.keycodes[scancode]] = scancode;
+    }
 }


@@ -189,12 +198,13 @@ int _glfwPlatformInit(void)
    _glfwInitTimerPOSIX();

    // Need the default conf for when we set a NULL cursor
-    _glfw.mir.default_conf = mir_cursor_configuration_from_name(mir_arrow_cursor_name);
+    _glfw.mir.defaultConf  = mir_cursor_configuration_from_name(mir_default_cursor_name);
+    _glfw.mir.disabledConf = mir_cursor_configuration_from_name(mir_disabled_cursor_name);

-    _glfw.mir.event_queue = calloc(1, sizeof(EventQueue));
-    _glfwInitEventQueueMir(_glfw.mir.event_queue);
+    _glfw.mir.eventQueue = calloc(1, sizeof(EventQueue));
+    _glfwInitEventQueueMir(_glfw.mir.eventQueue);

-    error = pthread_mutex_init(&_glfw.mir.event_mutex, NULL);
+    error = pthread_mutex_init(&_glfw.mir.eventMutex, NULL);
    if (error)
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -212,9 +222,9 @@ void _glfwPlatformTerminate(void)
    _glfwTerminateJoysticksLinux();
    _glfwTerminateThreadLocalStoragePOSIX();

-    _glfwDeleteEventQueueMir(_glfw.mir.event_queue);
+    _glfwDeleteEventQueueMir(_glfw.mir.eventQueue);

-    pthread_mutex_destroy(&_glfw.mir.event_mutex);
+    pthread_mutex_destroy(&_glfw.mir.eventMutex);

    mir_connection_release(_glfw.mir.connection);
 }
@@ -59,8 +59,8 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)

            monitors[i]->mir.x         = out->position_x;
            monitors[i]->mir.y         = out->position_y;
-            monitors[i]->mir.output_id = out->output_id;
-            monitors[i]->mir.cur_mode  = out->current_mode;
+            monitors[i]->mir.outputId  = out->output_id;
+            monitors[i]->mir.curMode   = out->current_mode;

            monitors[i]->modes = _glfwPlatformGetVideoModes(monitors[i],
                                                            &monitors[i]->modeCount);
@@ -75,7 +75,7 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)

 GLFWbool _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
 {
-    return first->mir.output_id == second->mir.output_id;
+    return first->mir.outputId == second->mir.outputId;
 }

 void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
@@ -129,7 +129,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
    for (i = 0;  i < displayConfig->num_outputs;  i++)
    {
        const MirDisplayOutput* out = displayConfig->outputs + i;
-        if (out->output_id != monitor->mir.output_id)
+        if (out->output_id != monitor->mir.outputId)
            continue;

        modes = calloc(out->num_modes, sizeof(GLFWvidmode));
@@ -153,7 +153,7 @@ GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)

 void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
 {
-    *mode = monitor->modes[monitor->mir.cur_mode];
+    *mode = monitor->modes[monitor->mir.curMode];
 }

 void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
@@ -177,6 +177,6 @@ GLFWAPI int glfwGetMirMonitor(GLFWmonitor* handle)
 {
    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
    _GLFW_REQUIRE_INIT_OR_RETURN(0);
-    return monitor->mir.output_id;
+    return monitor->mir.outputId;
 }

@@ -84,6 +84,7 @@ typedef struct _GLFWwindowMir
    int                     width;
    int                     height;
    MirEGLNativeWindowType  window;
+    _GLFWcursor*            currentCursor;

 } _GLFWwindowMir;

@@ -91,8 +92,8 @@ typedef struct _GLFWwindowMir
 //
 typedef struct _GLFWmonitorMir
 {
-    int cur_mode;
-    int output_id;
+    int curMode;
+    int outputId;
    int x;
    int y;

@@ -104,13 +105,18 @@ typedef struct _GLFWlibraryMir
 {
    MirConnection*          connection;
    MirEGLNativeDisplayType display;
-    MirCursorConfiguration* default_conf;
-    EventQueue* event_queue;
+    MirCursorConfiguration* defaultConf;
+    MirCursorConfiguration* disabledConf;
+    EventQueue* eventQueue;

-    short int       publicKeys[256];
+    short int       keycodes[256];
+    short int       scancodes[GLFW_KEY_LAST + 1];

-    pthread_mutex_t event_mutex;
-    pthread_cond_t  event_cond;
+    pthread_mutex_t eventMutex;
+    pthread_cond_t  eventCond;
+
+    // The window whose disabled cursor mode is active
+    _GLFWwindow*    disabledCursorWindow;

 } _GLFWlibraryMir;

@@ -120,7 +126,7 @@ typedef struct _GLFWlibraryMir
 typedef struct _GLFWcursorMir
 {
    MirCursorConfiguration* conf;
-    MirBufferStream*        custom_cursor;
+    MirBufferStream*        customCursor;
 } _GLFWcursorMir;


@@ -54,37 +54,37 @@ static GLFWbool emptyEventQueue(EventQueue* queue)
 //      for single threaded event handling.
 static EventNode* newEventNode(const MirEvent* event, _GLFWwindow* context)
 {
-    EventNode* new_node = calloc(1, sizeof(EventNode));
-    new_node->event     = mir_event_ref(event);
-    new_node->window    = context;
+    EventNode* newNode = calloc(1, sizeof(EventNode));
+    newNode->event     = mir_event_ref(event);
+    newNode->window    = context;

-    return new_node;
+    return newNode;
 }

 static void enqueueEvent(const MirEvent* event, _GLFWwindow* context)
 {
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);

-    EventNode* new_node = newEventNode(event, context);
-    TAILQ_INSERT_TAIL(&_glfw.mir.event_queue->head, new_node, entries);
+    EventNode* newNode = newEventNode(event, context);
+    TAILQ_INSERT_TAIL(&_glfw.mir.eventQueue->head, newNode, entries);

-    pthread_cond_signal(&_glfw.mir.event_cond);
+    pthread_cond_signal(&_glfw.mir.eventCond);

-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);
 }

 static EventNode* dequeueEvent(EventQueue* queue)
 {
    EventNode* node = NULL;

-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);

    node = queue->head.tqh_first;

    if (node)
        TAILQ_REMOVE(&queue->head, node, entries);

-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);

    return node;
 }
@@ -132,8 +132,8 @@ static int mirModToGLFWMod(uint32_t mods)

 static int toGLFWKeyCode(uint32_t key)
 {
-    if (key < sizeof(_glfw.mir.publicKeys) / sizeof(_glfw.mir.publicKeys[0]))
-        return _glfw.mir.publicKeys[key];
+    if (key < sizeof(_glfw.mir.keycodes) / sizeof(_glfw.mir.keycodes[0]))
+        return _glfw.mir.keycodes[key];

    return GLFW_KEY_UNKNOWN;
 }
@@ -201,16 +201,31 @@ static void handlePointerButton(_GLFWwindow* window,
 static void handlePointerMotion(_GLFWwindow* window,
                                const MirPointerEvent* pointer_event)
 {
-    int current_x = window->virtualCursorPosX;
-    int current_y = window->virtualCursorPosY;
-    int x  = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_x);
-    int y  = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_y);
-    int dx = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_hscroll);
-    int dy = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_vscroll);
+    const int hscroll = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_hscroll);
+    const int vscroll = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_vscroll);

-    _glfwInputCursorPos(window, x, y);
-    if (dx != 0 || dy != 0)
-      _glfwInputScroll(window, dx, dy);
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
+    {
+        if (_glfw.mir.disabledCursorWindow != window)
+            return;
+
+        const int dx = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_relative_x);
+        const int dy = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_relative_y);
+        const int current_x = window->virtualCursorPosX;
+        const int current_y = window->virtualCursorPosY;
+
+        _glfwInputCursorPos(window, dx + current_x, dy + current_y);
+    }
+    else
+    {
+        const int x = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_x);
+        const int y = mir_pointer_event_axis_value(pointer_event, mir_pointer_axis_y);
+
+        _glfwInputCursorPos(window, x, y);
+    }
+
+    if (hscroll != 0 || vscroll != 0)
+      _glfwInputScroll(window, hscroll, vscroll);
 }

 static void handlePointerEvent(const MirPointerEvent* pointer_event,
@@ -234,7 +249,6 @@ static void handlePointerEvent(const MirPointerEvent* pointer_event,
              break;
          default:
              break;
-
    }
 }

@@ -286,7 +300,7 @@ static GLFWbool createSurface(_GLFWwindow* window)
                        "Mir: Unable to find a correct pixel format");
        return GLFW_FALSE;
    }
- 
+
    spec = mir_connection_create_spec_for_normal_surface(_glfw.mir.connection,
                                                         window->mir.width,
                                                         window->mir.height,
@@ -312,6 +326,17 @@ static GLFWbool createSurface(_GLFWwindow* window)
    return GLFW_TRUE;
 }

+static void setSurfaceConfinement(_GLFWwindow* window, MirPointerConfinementState state)
+{
+    MirSurfaceSpec* spec;
+
+    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    mir_surface_spec_set_pointer_confinement(spec, state);
+
+    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_surface_spec_release(spec);
+}
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -370,6 +395,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,

    window->mir.width  = wndconfig->width;
    window->mir.height = wndconfig->height;
+    window->mir.currentCursor = NULL;

    if (!createSurface(window))
        return GLFW_FALSE;
@@ -390,6 +416,9 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,

 void _glfwPlatformDestroyWindow(_GLFWwindow* window)
 {
+    if (_glfw.mir.disabledCursorWindow == window)
+        _glfw.mir.disabledCursorWindow = NULL;
+
    if (mir_surface_is_valid(window->mir.surface))
    {
        mir_surface_release_sync(window->mir.surface);
@@ -475,18 +504,35 @@ void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)

 void _glfwPlatformIconifyWindow(_GLFWwindow* window)
 {
-    mir_surface_set_state(window->mir.surface, mir_surface_state_minimized);
+    MirSurfaceSpec* spec;
+
+    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    mir_surface_spec_set_state(spec, mir_surface_state_minimized);
+
+    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_surface_spec_release(spec);
 }

 void _glfwPlatformRestoreWindow(_GLFWwindow* window)
 {
-    mir_surface_set_state(window->mir.surface, mir_surface_state_restored);
+    MirSurfaceSpec* spec;
+
+    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    mir_surface_spec_set_state(spec, mir_surface_state_restored);
+
+    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_surface_spec_release(spec);
 }

 void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+    MirSurfaceSpec* spec;
+
+    spec = mir_connection_create_spec_for_changes(_glfw.mir.connection);
+    mir_surface_spec_set_state(spec, mir_surface_state_maximized);
+
+    mir_surface_apply_spec(window->mir.surface, spec);
+    mir_surface_spec_release(spec);
 }

 void _glfwPlatformHideWindow(_GLFWwindow* window)
@@ -529,9 +575,7 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,

 int _glfwPlatformWindowFocused(_GLFWwindow* window)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
-    return GLFW_FALSE;
+    return mir_surface_get_focus(window->mir.surface) == mir_surface_focused;
 }

 int _glfwPlatformWindowIconified(_GLFWwindow* window)
@@ -547,49 +591,65 @@ int _glfwPlatformWindowVisible(_GLFWwindow* window)
 }

 int _glfwPlatformWindowMaximized(_GLFWwindow* window)
+{
+    return mir_surface_get_state(window->mir.surface) == mir_surface_state_maximized;
+}
+
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
 {
    _glfwInputError(GLFW_PLATFORM_ERROR,
                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
-    return GLFW_FALSE;
 }

 void _glfwPlatformPollEvents(void)
 {
    EventNode* node = NULL;

-    while ((node = dequeueEvent(_glfw.mir.event_queue)))
+    while ((node = dequeueEvent(_glfw.mir.eventQueue)))
    {
        handleEvent(node->event, node->window);
-        deleteNode(_glfw.mir.event_queue, node);
+        deleteNode(_glfw.mir.eventQueue, node);
    }
 }

 void _glfwPlatformWaitEvents(void)
 {
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);

-    if (emptyEventQueue(_glfw.mir.event_queue))
-        pthread_cond_wait(&_glfw.mir.event_cond, &_glfw.mir.event_mutex);
+    if (emptyEventQueue(_glfw.mir.eventQueue))
+        pthread_cond_wait(&_glfw.mir.eventCond, &_glfw.mir.eventMutex);

-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);

    _glfwPlatformPollEvents();
 }

 void _glfwPlatformWaitEventsTimeout(double timeout)
 {
-    pthread_mutex_lock(&_glfw.mir.event_mutex);
+    pthread_mutex_lock(&_glfw.mir.eventMutex);

-    if (emptyEventQueue(_glfw.mir.event_queue))
+    if (emptyEventQueue(_glfw.mir.eventQueue))
    {
        struct timespec time;
        clock_gettime(CLOCK_REALTIME, &time);
        time.tv_sec += (long) timeout;
        time.tv_nsec += (long) ((timeout - (long) timeout) * 1e9);
-        pthread_cond_timedwait(&_glfw.mir.event_cond, &_glfw.mir.event_mutex, &time);
+        pthread_cond_timedwait(&_glfw.mir.eventCond, &_glfw.mir.eventMutex, &time);
    }

-    pthread_mutex_unlock(&_glfw.mir.event_mutex);
+    pthread_mutex_unlock(&_glfw.mir.eventMutex);

    _glfwPlatformPollEvents();
 }
@@ -606,7 +666,6 @@ void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* heigh
        *height = window->mir.height;
 }

-// FIXME implement
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                              const GLFWimage* image,
                              int xhot, int yhot)
@@ -654,7 +713,7 @@ int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
        pixels += r_stride;
    }

-    cursor->mir.custom_cursor = stream;
+    cursor->mir.customCursor = stream;

    return GLFW_TRUE;
 }
@@ -686,8 +745,8 @@ int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)

    if (cursor_name)
    {
-        cursor->mir.conf          = mir_cursor_configuration_from_name(cursor_name);
-        cursor->mir.custom_cursor = NULL;
+        cursor->mir.conf         = mir_cursor_configuration_from_name(cursor_name);
+        cursor->mir.customCursor = NULL;

        return GLFW_TRUE;
    }
@@ -699,23 +758,25 @@ void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
 {
    if (cursor->mir.conf)
        mir_cursor_configuration_destroy(cursor->mir.conf);
-    if (cursor->mir.custom_cursor)
-        mir_buffer_stream_release_sync(cursor->mir.custom_cursor);
+    if (cursor->mir.customCursor)
+        mir_buffer_stream_release_sync(cursor->mir.customCursor);
 }

 void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
 {
    if (cursor && cursor->mir.conf)
    {
+        window->mir.currentCursor = cursor;
+
        mir_wait_for(mir_surface_configure_cursor(window->mir.surface, cursor->mir.conf));
-        if (cursor->mir.custom_cursor)
+        if (cursor->mir.customCursor)
        {
-            mir_buffer_stream_swap_buffers_sync(cursor->mir.custom_cursor);
+            mir_buffer_stream_swap_buffers_sync(cursor->mir.customCursor);
        }
    }
    else
    {
-        mir_wait_for(mir_surface_configure_cursor(window->mir.surface, _glfw.mir.default_conf));
+        mir_wait_for(mir_surface_configure_cursor(window->mir.surface, _glfw.mir.defaultConf));
    }
 }

@@ -733,8 +794,30 @@ void _glfwPlatformSetCursorPos(_GLFWwindow* window, double xpos, double ypos)

 void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
 {
-    _glfwInputError(GLFW_PLATFORM_ERROR,
-                    "Mir: Unsupported function %s", __PRETTY_FUNCTION__);
+    if (mode == GLFW_CURSOR_DISABLED)
+    {
+        _glfw.mir.disabledCursorWindow = window;
+        setSurfaceConfinement(window, mir_pointer_confined_to_surface);
+        mir_wait_for(mir_surface_configure_cursor(window->mir.surface, _glfw.mir.disabledConf));
+    }
+    else
+    {
+        // If we were disabled before lets undo that!
+        if (_glfw.mir.disabledCursorWindow == window)
+        {
+            _glfw.mir.disabledCursorWindow = NULL;
+            setSurfaceConfinement(window, mir_pointer_unconfined);
+        }
+
+        if (window->cursorMode == GLFW_CURSOR_NORMAL)
+        {
+            _glfwPlatformSetCursor(window, window->mir.currentCursor);
+        }
+        else if (window->cursorMode == GLFW_CURSOR_HIDDEN)
+        {
+            mir_wait_for(mir_surface_configure_cursor(window->mir.surface, _glfw.mir.disabledConf));
+        }
+    }
 }

 const char* _glfwPlatformGetKeyName(int key, int scancode)
@@ -744,6 +827,11 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
    return NULL;
 }

+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.mir.scancodes[key];
+}
+
 void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
 {
    _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -758,21 +846,13 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
    return NULL;
 }

-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    char** extensions;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_mir_surface)
+        return;

-    *count = 0;
-
-    if (!_glfw.vk.KHR_mir_surface)
-        return NULL;
-
-    extensions = calloc(2, sizeof(char*));
-    extensions[0] = strdup("VK_KHR_surface");
-    extensions[1] = strdup("VK_KHR_mir_surface");
-
-    *count = 2;
-    return extensions;
+    extensions[0] = "VK_KHR_surface";
+    extensions[1] = "VK_KHR_mir_surface";
 }

 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -175,10 +175,12 @@ void _glfwInputMonitorWindowChange(_GLFWmonitor* monitor, _GLFWwindow* window)
 _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM)
 {
    _GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
-    monitor->name = strdup(name);
    monitor->widthMM = widthMM;
    monitor->heightMM = heightMM;

+    if (name)
+        monitor->name = strdup(name);
+
    return monitor;
 }

@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -1,7 +1,7 @@
 //========================================================================
-// GLFW 3.3 OS X - www.glfw.org
+// GLFW 3.3 macOS - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -124,39 +124,32 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
    if (ctxconfig->client == GLFW_OPENGL_ES_API)
    {
        _glfwInputError(GLFW_API_UNAVAILABLE,
-                        "NSGL: OpenGL ES is not available on OS X");
-        return GLFW_FALSE;
-    }
-
-    if (ctxconfig->major == 3 && ctxconfig->minor < 2)
-    {
-        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                        "NSGL: The targeted version of OS X does not support OpenGL 3.0 or 3.1");
+                        "NSGL: OpenGL ES is not available on macOS");
        return GLFW_FALSE;
    }

    if (ctxconfig->major > 2)
    {
-        if (!ctxconfig->forward)
+        if (ctxconfig->major == 3 && ctxconfig->minor < 2)
        {
            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSGL: The targeted version of OS X only supports forward-compatible contexts for OpenGL 3.2 and above");
+                            "NSGL: The targeted version of macOS does not support OpenGL 3.0 or 3.1 but may support 3.2 and above");
            return GLFW_FALSE;
        }

-        if (ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE)
+        if (!ctxconfig->forward || ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE)
        {
            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
-                            "NSGL: The targeted version of OS X only supports core profile contexts for OpenGL 3.2 and above");
+                            "NSGL: The targeted version of macOS only supports forward-compatible core profile contexts for OpenGL 3.2 and above");
            return GLFW_FALSE;
        }
    }

    // Context robustness modes (GL_KHR_robustness) are not yet supported on
-    // OS X but are not a hard constraint, so ignore and continue
+    // macOS but are not a hard constraint, so ignore and continue

    // Context release behaviors (GL_KHR_context_flush_control) are not yet
-    // supported on OS X but are not a hard constraint, so ignore and continue
+    // supported on macOS but are not a hard constraint, so ignore and continue

 #define ADD_ATTR(x) { attributes[attributeCount++] = x; }
 #define ADD_ATTR2(x, y) { ADD_ATTR(x); ADD_ATTR(y); }
@@ -206,7 +199,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
                        fbconfig->greenBits +
                        fbconfig->blueBits;

-        // OS X needs non-zero color size, so set reasonable values
+        // macOS needs non-zero color size, so set reasonable values
        if (colorBits == 0)
            colorBits = 24;
        else if (colorBits < 15)
@@ -225,7 +218,15 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
        ADD_ATTR2(NSOpenGLPFAStencilSize, fbconfig->stencilBits);

    if (fbconfig->stereo)
+    {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+        _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
+                        "NSGL: Stereo rendering is deprecated");
+        return GLFW_FALSE;
+#else
        ADD_ATTR(NSOpenGLPFAStereo);
+#endif
+    }

    if (fbconfig->doublebuffer)
        ADD_ATTR(NSOpenGLPFADoubleBuffer);
@@ -0,0 +1,367 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "internal.h"
+
+
+static void makeContextCurrentOSMesa(_GLFWwindow* window)
+{
+    if (window)
+    {
+        // Check to see if we need to allocate a new buffer
+        if ((window->context.osmesa.buffer == NULL) ||
+            (window->osmesa.width != window->context.osmesa.width) ||
+            (window->osmesa.height != window->context.osmesa.height))
+        {
+            free(window->context.osmesa.buffer);
+
+            // Allocate the new buffer (width * height * 8-bit RGBA)
+            window->context.osmesa.buffer =
+                calloc(4, window->osmesa.width * window->osmesa.height);
+
+            window->context.osmesa.width = window->osmesa.width;
+            window->context.osmesa.height = window->osmesa.height;
+        }
+
+        if (!OSMesaMakeCurrent(window->context.osmesa.handle,
+                            window->context.osmesa.buffer,
+                            GL_UNSIGNED_BYTE,
+                            window->osmesa.width, window->osmesa.height))
+        {
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "OSMesa: Failed to make context current");
+            return;
+        }
+    }
+
+    _glfwPlatformSetCurrentContext(window);
+}
+
+static GLFWglproc getProcAddressOSMesa(const char* procname)
+{
+    return (GLFWglproc) OSMesaGetProcAddress(procname);
+}
+
+static void destroyContextOSMesa(_GLFWwindow* window)
+{
+    if (window->context.osmesa.handle)
+    {
+        OSMesaDestroyContext(window->context.osmesa.handle);
+        window->context.osmesa.handle = NULL;
+    }
+
+    if (window->context.osmesa.buffer)
+    {
+        free(window->context.osmesa.buffer);
+        window->context.osmesa.width = 0;
+        window->context.osmesa.height = 0;
+    }
+}
+
+static void swapBuffersOSMesa(_GLFWwindow* window)
+{
+    // No double buffering on OSMesa
+}
+
+static void swapIntervalOSMesa(int interval)
+{
+    // No swap interval on OSMesa
+}
+
+static int extensionSupportedOSMesa(const char* extension)
+{
+    // OSMesa does not have extensions
+    return GLFW_FALSE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWbool _glfwInitOSMesa(void)
+{
+    int i;
+    const char* sonames[] =
+    {
+#if defined(_WIN32)
+        "libOSMesa.dll",
+        "OSMesa.dll",
+#elif defined(__APPLE__)
+        "libOSMesa.8.dylib",
+#elif defined(__CYGWIN__)
+        "libOSMesa-8.so",
+#else
+        "libOSMesa.so.8",
+        "libOSMesa.so.6",
+#endif
+        NULL
+    };
+
+    if (_glfw.osmesa.handle)
+        return GLFW_TRUE;
+
+    for (i = 0;  sonames[i];  i++)
+    {
+        _glfw.osmesa.handle = _glfw_dlopen(sonames[i]);
+        if (_glfw.osmesa.handle)
+            break;
+    }
+
+    if (!_glfw.osmesa.handle)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE, "OSMesa: Library not found");
+        return GLFW_FALSE;
+    }
+
+    _glfw.osmesa.CreateContextExt = (PFN_OSMesaCreateContextExt)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaCreateContextExt");
+    _glfw.osmesa.CreateContextAttribs = (PFN_OSMesaCreateContextAttribs)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaCreateContextAttribs");
+    _glfw.osmesa.DestroyContext = (PFN_OSMesaDestroyContext)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaDestroyContext");
+    _glfw.osmesa.MakeCurrent = (PFN_OSMesaMakeCurrent)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaMakeCurrent");
+    _glfw.osmesa.GetColorBuffer = (PFN_OSMesaGetColorBuffer)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetColorBuffer");
+    _glfw.osmesa.GetDepthBuffer = (PFN_OSMesaGetDepthBuffer)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetDepthBuffer");
+    _glfw.osmesa.GetProcAddress = (PFN_OSMesaGetProcAddress)
+        _glfw_dlsym(_glfw.osmesa.handle, "OSMesaGetProcAddress");
+
+    if (!_glfw.osmesa.CreateContextExt ||
+        !_glfw.osmesa.DestroyContext ||
+        !_glfw.osmesa.MakeCurrent ||
+        !_glfw.osmesa.GetColorBuffer ||
+        !_glfw.osmesa.GetDepthBuffer ||
+        !_glfw.osmesa.GetProcAddress)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "OSMesa: Failed to load required entry points");
+
+        _glfwTerminateOSMesa();
+        return GLFW_FALSE;
+    }
+
+    return GLFW_TRUE;
+}
+
+void _glfwTerminateOSMesa(void)
+{
+    if (_glfw.osmesa.handle)
+    {
+        _glfw_dlclose(_glfw.osmesa.handle);
+        _glfw.osmesa.handle = NULL;
+    }
+}
+
+#define setAttrib(attribName, attribValue) \
+{ \
+    attribs[index++] = attribName; \
+    attribs[index++] = attribValue; \
+    assert((size_t) index < sizeof(attribs) / sizeof(attribs[0])); \
+}
+
+GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
+                                  const _GLFWctxconfig* ctxconfig,
+                                  const _GLFWfbconfig* fbconfig)
+{
+    OSMesaContext share = NULL;
+    const int accumBits = fbconfig->accumRedBits +
+                          fbconfig->accumGreenBits +
+                          fbconfig->accumBlueBits +
+                          fbconfig->accumAlphaBits;
+
+    if (ctxconfig->client == GLFW_OPENGL_ES_API)
+    {
+        _glfwInputError(GLFW_API_UNAVAILABLE,
+                        "OSMesa: OpenGL ES is not available on OSMesa");
+        return GLFW_FALSE;
+    }
+
+    if (ctxconfig->share)
+        share = ctxconfig->share->context.osmesa.handle;
+
+    if (OSMesaCreateContextAttribs)
+    {
+        int index = 0, attribs[40];
+
+        setAttrib(OSMESA_FORMAT, OSMESA_RGBA);
+        setAttrib(OSMESA_DEPTH_BITS, fbconfig->depthBits);
+        setAttrib(OSMESA_STENCIL_BITS, fbconfig->stencilBits);
+        setAttrib(OSMESA_ACCUM_BITS, accumBits);
+
+        if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
+        {
+            setAttrib(OSMESA_PROFILE, OSMESA_CORE_PROFILE);
+        }
+        else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
+        {
+            setAttrib(OSMESA_PROFILE, OSMESA_COMPAT_PROFILE);
+        }
+
+        if (ctxconfig->major != 1 || ctxconfig->minor != 0)
+        {
+            setAttrib(OSMESA_CONTEXT_MAJOR_VERSION, ctxconfig->major);
+            setAttrib(OSMESA_CONTEXT_MINOR_VERSION, ctxconfig->minor);
+        }
+
+        if (ctxconfig->forward)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "OSMesa: Foward-compatible contexts not supported");
+            return GLFW_FALSE;
+        }
+
+        setAttrib(0, 0);
+
+        window->context.osmesa.handle =
+            OSMesaCreateContextAttribs(attribs, share);
+    }
+    else
+    {
+        if (ctxconfig->profile)
+        {
+            _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                            "OSMesa: OpenGL profiles unavailable");
+            return GLFW_FALSE;
+        }
+
+        window->context.osmesa.handle =
+            OSMesaCreateContextExt(OSMESA_RGBA,
+                                   fbconfig->depthBits,
+                                   fbconfig->stencilBits,
+                                   accumBits,
+                                   share);
+    }
+
+    if (window->context.osmesa.handle == NULL)
+    {
+        _glfwInputError(GLFW_VERSION_UNAVAILABLE,
+                        "OSMesa: Failed to create context");
+        return GLFW_FALSE;
+    }
+
+    window->context.makeCurrent = makeContextCurrentOSMesa;
+    window->context.swapBuffers = swapBuffersOSMesa;
+    window->context.swapInterval = swapIntervalOSMesa;
+    window->context.extensionSupported = extensionSupportedOSMesa;
+    window->context.getProcAddress = getProcAddressOSMesa;
+    window->context.destroy = destroyContextOSMesa;
+
+    return GLFW_TRUE;
+}
+
+#undef setAttrib
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                        GLFW native API                       //////
+//////////////////////////////////////////////////////////////////////////
+
+GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
+                                     int* height, int* format, void** buffer)
+{
+    void* mesaBuffer;
+    GLint mesaWidth, mesaHeight, mesaFormat;
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (!OSMesaGetColorBuffer(window->context.osmesa.handle,
+                              &mesaWidth, &mesaHeight,
+                              &mesaFormat, &mesaBuffer))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "OSMesa: Failed to retrieve color buffer");
+        return GLFW_FALSE;
+    }
+
+    if (width)
+        *width = mesaWidth;
+    if (height)
+        *height = mesaHeight;
+    if (format)
+        *format = mesaFormat;
+    if (buffer)
+        *buffer = mesaBuffer;
+
+    return GLFW_TRUE;
+}
+
+GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
+                                     int* width, int* height,
+                                     int* bytesPerValue,
+                                     void** buffer)
+{
+    void* mesaBuffer;
+    GLint mesaWidth, mesaHeight, mesaBytes;
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
+    if (!OSMesaGetDepthBuffer(window->context.osmesa.handle,
+                              &mesaWidth, &mesaHeight,
+                              &mesaBytes, &mesaBuffer))
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "OSMesa: Failed to retrieve depth buffer");
+        return GLFW_FALSE;
+    }
+
+    if (width)
+        *width = mesaWidth;
+    if (height)
+        *height = mesaHeight;
+    if (bytesPerValue)
+        *bytesPerValue = mesaBytes;
+    if (buffer)
+        *buffer = mesaBuffer;
+
+    return GLFW_TRUE;
+}
+
+GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
+    if (window->context.client == GLFW_NO_API)
+    {
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return NULL;
+    }
+
+    return window->context.osmesa.handle;
+}
+
@@ -0,0 +1,98 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _glfw3_osmesa_context_h_
+#define _glfw3_osmesa_context_h_
+
+#define OSMESA_RGBA 0x1908
+#define OSMESA_FORMAT 0x22
+#define OSMESA_DEPTH_BITS 0x30
+#define OSMESA_STENCIL_BITS 0x31
+#define OSMESA_ACCUM_BITS 0x32
+#define OSMESA_PROFILE 0x33
+#define OSMESA_CORE_PROFILE 0x34
+#define OSMESA_COMPAT_PROFILE 0x35
+#define OSMESA_CONTEXT_MAJOR_VERSION 0x36
+#define OSMESA_CONTEXT_MINOR_VERSION 0x37
+
+typedef void* OSMesaContext;
+typedef void (*OSMESAproc)();
+
+typedef OSMesaContext (GLAPIENTRY * PFN_OSMesaCreateContextExt)(GLenum,GLint,GLint,GLint,OSMesaContext);
+typedef OSMesaContext (GLAPIENTRY * PFN_OSMesaCreateContextAttribs)(const int*,OSMesaContext);
+typedef void (GLAPIENTRY * PFN_OSMesaDestroyContext)(OSMesaContext);
+typedef int (GLAPIENTRY * PFN_OSMesaMakeCurrent)(OSMesaContext,void*,int,int,int);
+typedef int (GLAPIENTRY * PFN_OSMesaGetColorBuffer)(OSMesaContext,int*,int*,int*,void**);
+typedef int (GLAPIENTRY * PFN_OSMesaGetDepthBuffer)(OSMesaContext,int*,int*,int*,void**);
+typedef GLFWglproc (GLAPIENTRY * PFN_OSMesaGetProcAddress)(const char*);
+#define OSMesaCreateContextExt _glfw.osmesa.CreateContextExt
+#define OSMesaCreateContextAttribs _glfw.osmesa.CreateContextAttribs
+#define OSMesaDestroyContext _glfw.osmesa.DestroyContext
+#define OSMesaMakeCurrent _glfw.osmesa.MakeCurrent
+#define OSMesaGetColorBuffer _glfw.osmesa.GetColorBuffer
+#define OSMesaGetDepthBuffer _glfw.osmesa.GetDepthBuffer
+#define OSMesaGetProcAddress _glfw.osmesa.GetProcAddress
+
+#define _GLFW_PLATFORM_CONTEXT_STATE            _GLFWcontextOSMesa osmesa
+#define _GLFW_PLATFORM_LIBRARY_CONTEXT_STATE    _GLFWlibraryOSMesa osmesa
+
+
+// OSMesa-specific per-context data
+//
+typedef struct _GLFWcontextOSMesa
+{
+   OSMesaContext       handle;
+   int                 width;
+   int                 height;
+   void*               buffer;
+
+} _GLFWcontextOSMesa;
+
+// OSMesa-specific global data
+//
+typedef struct _GLFWlibraryOSMesa
+{
+    void*           handle;
+
+    PFN_OSMesaCreateContextExt      CreateContextExt;
+    PFN_OSMesaCreateContextAttribs  CreateContextAttribs;
+    PFN_OSMesaDestroyContext        DestroyContext;
+    PFN_OSMesaMakeCurrent           MakeCurrent;
+    PFN_OSMesaGetColorBuffer        GetColorBuffer;
+    PFN_OSMesaGetDepthBuffer        GetDepthBuffer;
+    PFN_OSMesaGetProcAddress        GetProcAddress;
+
+} _GLFWlibraryOSMesa;
+
+
+GLFWbool _glfwInitOSMesa(void);
+void _glfwTerminateOSMesa(void);
+GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
+                                  const _GLFWctxconfig* ctxconfig,
+                                  const _GLFWfbconfig* fbconfig);
+
+#endif // _glfw3_osmesa_context_h_
@@ -0,0 +1,54 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformInit(void)
+{
+    if (!_glfwInitThreadLocalStoragePOSIX())
+        return GLFW_FALSE;
+
+    _glfwInitTimerPOSIX();
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformTerminate(void)
+{
+    _glfwTerminateOSMesa();
+    _glfwTerminateThreadLocalStoragePOSIX();
+}
+
+const char* _glfwPlatformGetVersionString(void)
+{
+    return _GLFW_VERSION_NUMBER " none OSMesa";
+}
+
@@ -0,0 +1,67 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
+{
+    // OSMesa is headless, so no monitors
+    *count = 0;
+    return NULL;
+}
+
+int _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
+{
+    return GLFW_FALSE;
+}
+
+void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
+{
+}
+
+GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
+{
+    return NULL;
+}
+
+void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
+{
+}
+
+void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
+{
+}
+
+void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
+{
+}
+
@@ -0,0 +1,65 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#ifndef _glfw3_osmesa_platform_h_
+#define _glfw3_osmesa_platform_h_
+
+#include <dlfcn.h>
+
+#define _GLFW_PLATFORM_WINDOW_STATE _GLFWwindowOSMesa osmesa
+
+#define _GLFW_PLATFORM_MONITOR_STATE
+#define _GLFW_PLATFORM_CURSOR_STATE
+#define _GLFW_PLATFORM_LIBRARY_WINDOW_STATE
+#define _GLFW_PLATFORM_LIBRARY_JOYSTICK_STATE
+#define _GLFW_EGL_CONTEXT_STATE
+#define _GLFW_EGL_LIBRARY_CONTEXT_STATE
+
+#include "osmesa_context.h"
+#include "posix_time.h"
+#include "posix_tls.h"
+
+#if defined(_GLFW_WIN32)
+ #define _glfw_dlopen(name) LoadLibraryA(name)
+ #define _glfw_dlclose(handle) FreeLibrary((HMODULE) handle)
+ #define _glfw_dlsym(handle, name) GetProcAddress((HMODULE) handle, name)
+#else
+ #define _glfw_dlopen(name) dlopen(name, RTLD_LAZY | RTLD_LOCAL)
+ #define _glfw_dlclose(handle) dlclose(handle)
+ #define _glfw_dlsym(handle, name) dlsym(handle, name)
+#endif
+
+// OSMesa-specific per-window data
+//
+typedef struct _GLFWwindowOSMesa
+{
+    int width;
+    int height;
+} _GLFWwindowOSMesa;
+
+
+#endif // _glfw3_osmesa_platform_h_
@@ -0,0 +1,315 @@
+//========================================================================
+// GLFW 3.3 OSMesa - www.glfw.org
+//------------------------------------------------------------------------
+// Copyright (c) 2016 Google Inc.
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+
+#include "internal.h"
+
+
+static int createNativeWindow(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig)
+{
+    window->osmesa.width = wndconfig->width;
+    window->osmesa.height = wndconfig->height;
+
+    return GLFW_TRUE;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW platform API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+int _glfwPlatformCreateWindow(_GLFWwindow* window,
+                              const _GLFWwndconfig* wndconfig,
+                              const _GLFWctxconfig* ctxconfig,
+                              const _GLFWfbconfig* fbconfig)
+{
+    if (!createNativeWindow(window, wndconfig))
+        return GLFW_FALSE;
+
+    if (ctxconfig->client != GLFW_NO_API)
+    {
+        if (ctxconfig->source == GLFW_NATIVE_CONTEXT_API)
+        {
+            if (!_glfwInitOSMesa())
+                return GLFW_FALSE;
+            if (!_glfwCreateContextOSMesa(window, ctxconfig, fbconfig))
+                return GLFW_FALSE;
+        }
+        else
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE, "OSMesa: EGL not available");
+            return GLFW_FALSE;
+        }
+    }
+
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyWindow(_GLFWwindow* window)
+{
+    if (window->context.destroy)
+        window->context.destroy(window);
+}
+
+void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
+{
+}
+
+void _glfwPlatformSetWindowIcon(_GLFWwindow* window, int count,
+                                const GLFWimage* images)
+{
+}
+
+void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
+                                   _GLFWmonitor* monitor,
+                                   int xpos, int ypos,
+                                   int width, int height,
+                                   int refreshRate)
+{
+}
+
+void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
+{
+}
+
+void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
+{
+}
+
+void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
+{
+    if (width)
+        *width = window->osmesa.width;
+    if (height)
+        *height = window->osmesa.height;
+}
+
+void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
+{
+    window->osmesa.width = width;
+    window->osmesa.height = height;
+}
+
+void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
+                                      int minwidth, int minheight,
+                                      int maxwidth, int maxheight)
+{
+}
+
+void _glfwPlatformSetWindowAspectRatio(_GLFWwindow* window, int n, int d)
+{
+}
+
+void _glfwPlatformGetFramebufferSize(_GLFWwindow* window, int* width, int* height)
+{
+    if (width)
+        *width = window->osmesa.width;
+    if (height)
+        *height = window->osmesa.height;
+}
+
+void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
+                                     int* left, int* top,
+                                     int* right, int* bottom)
+{
+    if (right)
+        *right = window->osmesa.width;
+    if (bottom)
+        *top = window->osmesa.height;
+}
+
+void _glfwPlatformIconifyWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformRestoreWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
+{
+}
+
+int _glfwPlatformWindowMaximized(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+}
+
+void _glfwPlatformShowWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformUnhideWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformHideWindow(_GLFWwindow* window)
+{
+}
+
+void _glfwPlatformFocusWindow(_GLFWwindow* window)
+{
+}
+
+int _glfwPlatformWindowFocused(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+int _glfwPlatformWindowIconified(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+int _glfwPlatformWindowVisible(_GLFWwindow* window)
+{
+    return GLFW_FALSE;
+}
+
+void _glfwPlatformPollEvents(void)
+{
+}
+
+void _glfwPlatformWaitEvents(void)
+{
+}
+
+void _glfwPlatformWaitEventsTimeout(double timeout)
+{
+}
+
+void _glfwPlatformPostEmptyEvent(void)
+{
+}
+
+void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
+{
+}
+
+void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
+{
+}
+
+void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
+{
+}
+
+void _glfwPlatformApplyCursorMode(_GLFWwindow* window)
+{
+}
+
+int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
+                              const GLFWimage* image,
+                              int xhot, int yhot)
+{
+    return GLFW_TRUE;
+}
+
+int _glfwPlatformCreateStandardCursor(_GLFWcursor* cursor, int shape)
+{
+    return GLFW_TRUE;
+}
+
+void _glfwPlatformDestroyCursor(_GLFWcursor* cursor)
+{
+}
+
+void _glfwPlatformSetCursor(_GLFWwindow* window, _GLFWcursor* cursor)
+{
+}
+
+void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)
+{
+}
+
+const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
+{
+    return NULL;
+}
+
+const char* _glfwPlatformGetKeyName(int key, int scancode)
+{
+    return "";
+}
+
+int _glfwPlatformGetKeyScancode(int key)
+{
+    return -1;
+}
+
+int _glfwPlatformJoystickPresent(int joy)
+{
+    return GLFW_FALSE;
+}
+
+const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+{
+    return NULL;
+}
+
+const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+{
+    return NULL;
+}
+
+const char* _glfwPlatformGetJoystickName(int joy)
+{
+    return NULL;
+}
+
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
+{
+}
+
+int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
+                                                      VkPhysicalDevice device,
+                                                      uint32_t queuefamily)
+{
+    return GLFW_FALSE;
+}
+
+VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
+                                          _GLFWwindow* window,
+                                          const VkAllocationCallbacks* allocator,
+                                          VkSurfaceKHR* surface)
+{
+    // This seems like the most appropriate error to return here
+    return VK_ERROR_INITIALIZATION_FAILED;
+}
+
@@ -2,7 +2,7 @@
 // GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -31,37 +31,54 @@
 #include <string.h>
 #include <stdlib.h>

+#define _GLFW_FIND_LOADER    1
+#define _GLFW_REQUIRE_LOADER 2
+

 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////

-GLFWbool _glfwInitVulkan(void)
+GLFWbool _glfwInitVulkan(int mode)
 {
    VkResult err;
    VkExtensionProperties* ep;
    uint32_t i, count;

-#if !defined(_GLFW_VULKAN_STATIC)
-#if defined(_GLFW_WIN32)
-    const char* name = "vulkan-1.dll";
-#else
-    const char* name = "libvulkan.so.1";
-#endif
-
    if (_glfw.vk.available)
        return GLFW_TRUE;

-    _glfw.vk.handle = _glfw_dlopen(name);
+#if !defined(_GLFW_VULKAN_STATIC)
+#if defined(_GLFW_WIN32)
+    _glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
+#elif defined(_GLFW_COCOA)
+    // NULL maps to RTLD_DEFAULT, which searches all loaded binaries
+    _glfw.vk.handle = _glfw_dlopen(NULL);
+#else
+    _glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
+#endif
    if (!_glfw.vk.handle)
+    {
+        if (mode == _GLFW_REQUIRE_LOADER)
+            _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
+
        return GLFW_FALSE;
+    }

    _glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
        _glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
    if (!_glfw.vk.GetInstanceProcAddr)
    {
+#if defined(_GLFW_COCOA)
+        if (mode == _GLFW_REQUIRE_LOADER)
+        {
+            _glfwInputError(GLFW_API_UNAVAILABLE,
+                            "Vulkan: vkGetInstanceProcAddr not found in process");
+        }
+#else
        _glfwInputError(GLFW_API_UNAVAILABLE,
                        "Vulkan: Loader does not export vkGetInstanceProcAddr");
+#endif

        _glfwTerminateVulkan();
        return GLFW_FALSE;
@@ -108,41 +125,41 @@ GLFWbool _glfwInitVulkan(void)
    {
        if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
            _glfw.vk.KHR_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
+#if defined(_GLFW_WIN32)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
            _glfw.vk.KHR_win32_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
+#elif defined(_GLFW_COCOA)
+        else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
+            _glfw.vk.MVK_macos_surface = GLFW_TRUE;
+#elif defined(_GLFW_X11)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
            _glfw.vk.KHR_xlib_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
            _glfw.vk.KHR_xcb_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
+#elif defined(_GLFW_WAYLAND)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
            _glfw.vk.KHR_wayland_surface = GLFW_TRUE;
-        if (strcmp(ep[i].extensionName, "VK_KHR_mir_surface") == 0)
+#elif defined(_GLFW_MIR)
+        else if (strcmp(ep[i].extensionName, "VK_KHR_mir_surface") == 0)
            _glfw.vk.KHR_mir_surface = GLFW_TRUE;
+#endif
    }

    free(ep);

    _glfw.vk.available = GLFW_TRUE;

-    if (_glfw.vk.KHR_surface)
-    {
-        _glfw.vk.extensions =
-            _glfwPlatformGetRequiredInstanceExtensions(&_glfw.vk.extensionCount);
-    }
+    _glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);

    return GLFW_TRUE;
 }

 void _glfwTerminateVulkan(void)
 {
-    uint32_t i;
-
-    for (i = 0;  i < _glfw.vk.extensionCount;  i++)
-        free(_glfw.vk.extensions[i]);
-    free(_glfw.vk.extensions);
-
+#if !defined(_GLFW_VULKAN_STATIC)
    if (_glfw.vk.handle)
        _glfw_dlclose(_glfw.vk.handle);
+#endif
 }

 const char* _glfwGetVulkanResultString(VkResult result)
@@ -208,7 +225,7 @@ const char* _glfwGetVulkanResultString(VkResult result)
 GLFWAPI int glfwVulkanSupported(void)
 {
    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-    return _glfwInitVulkan();
+    return _glfwInitVulkan(_GLFW_FIND_LOADER);
 }

 GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count)
@@ -217,13 +234,13 @@ GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count)

    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

-    if (!_glfwInitVulkan())
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
        return NULL;
-    }

-    *count = _glfw.vk.extensionCount;
+    if (!_glfw.vk.extensions[0])
+        return NULL;
+
+    *count = 2;
    return (const char**) _glfw.vk.extensions;
 }

@@ -234,15 +251,20 @@ GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,

    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);

-    if (!_glfwInitVulkan())
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
        return NULL;
-    }

    proc = (GLFWvkproc) vkGetInstanceProcAddr(instance, procname);
+#if defined(_GLFW_VULKAN_STATIC)
+    if (!proc)
+    {
+        if (strcmp(procname, "vkGetInstanceProcAddr") == 0)
+            return (GLFWvkproc) vkGetInstanceProcAddr;
+    }
+#else
    if (!proc)
        proc = (GLFWvkproc) _glfw_dlsym(_glfw.vk.handle, procname);
+#endif

    return proc;
 }
@@ -253,13 +275,10 @@ GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
 {
    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);

-    if (!_glfwInitVulkan())
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
        return GLFW_FALSE;
-    }

-    if (!_glfw.vk.extensions)
+    if (!_glfw.vk.extensions[0])
    {
        _glfwInputError(GLFW_API_UNAVAILABLE,
                        "Vulkan: Window surface creation extensions not found");
@@ -284,13 +303,10 @@ GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,

    _GLFW_REQUIRE_INIT_OR_RETURN(VK_ERROR_INITIALIZATION_FAILED);

-    if (!_glfwInitVulkan())
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: API not available");
+    if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
        return VK_ERROR_INITIALIZATION_FAILED;
-    }

-    if (!_glfw.vk.extensions)
+    if (!_glfw.vk.extensions[0])
    {
        _glfwInputError(GLFW_API_UNAVAILABLE,
                        "Vulkan: Window surface creation extensions not found");
@@ -2,7 +2,7 @@
 // GLFW 3.3 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -434,17 +434,17 @@ GLFWbool _glfwInitWGL(void)
        return GLFW_FALSE;
    }

-    _glfw.wgl.CreateContext = (WGLCREATECONTEXT_T)
+    _glfw.wgl.CreateContext = (PFN_wglCreateContext)
        GetProcAddress(_glfw.wgl.instance, "wglCreateContext");
-    _glfw.wgl.DeleteContext = (WGLDELETECONTEXT_T)
+    _glfw.wgl.DeleteContext = (PFN_wglDeleteContext)
        GetProcAddress(_glfw.wgl.instance, "wglDeleteContext");
-    _glfw.wgl.GetProcAddress = (WGLGETPROCADDRESS_T)
+    _glfw.wgl.GetProcAddress = (PFN_wglGetProcAddress)
        GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress");
-    _glfw.wgl.GetCurrentDC = (WGLGETCURRENTDC_T)
+    _glfw.wgl.GetCurrentDC = (PFN_wglGetCurrentDC)
        GetProcAddress(_glfw.wgl.instance, "wglGetCurrentDC");
-    _glfw.wgl.MakeCurrent = (WGLMAKECURRENT_T)
+    _glfw.wgl.MakeCurrent = (PFN_wglMakeCurrent)
        GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent");
-    _glfw.wgl.ShareLists = (WGLSHARELISTS_T)
+    _glfw.wgl.ShareLists = (PFN_wglShareLists)
        GetProcAddress(_glfw.wgl.instance, "wglShareLists");

    return GLFW_TRUE;
@@ -2,7 +2,7 @@
 // GLFW 3.3 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -82,12 +82,12 @@ typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void);
 typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC);
 typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC)(HDC,HGLRC,const int*);

-typedef HGLRC (WINAPI * WGLCREATECONTEXT_T)(HDC);
-typedef BOOL (WINAPI * WGLDELETECONTEXT_T)(HGLRC);
-typedef PROC (WINAPI * WGLGETPROCADDRESS_T)(LPCSTR);
-typedef HDC (WINAPI * WGLGETCURRENTDC_T)(void);
-typedef BOOL (WINAPI * WGLMAKECURRENT_T)(HDC,HGLRC);
-typedef BOOL (WINAPI * WGLSHARELISTS_T)(HGLRC,HGLRC);
+typedef HGLRC (WINAPI * PFN_wglCreateContext)(HDC);
+typedef BOOL (WINAPI * PFN_wglDeleteContext)(HGLRC);
+typedef PROC (WINAPI * PFN_wglGetProcAddress)(LPCSTR);
+typedef HDC (WINAPI * PFN_wglGetCurrentDC)(void);
+typedef BOOL (WINAPI * PFN_wglMakeCurrent)(HDC,HGLRC);
+typedef BOOL (WINAPI * PFN_wglShareLists)(HGLRC,HGLRC);

 // opengl32.dll function pointer typedefs
 #define wglCreateContext _glfw.wgl.CreateContext
@@ -120,12 +120,12 @@ typedef struct _GLFWcontextWGL
 typedef struct _GLFWlibraryWGL
 {
    HINSTANCE                           instance;
-    WGLCREATECONTEXT_T                  CreateContext;
-    WGLDELETECONTEXT_T                  DeleteContext;
-    WGLGETPROCADDRESS_T                 GetProcAddress;
-    WGLGETCURRENTDC_T                   GetCurrentDC;
-    WGLMAKECURRENT_T                    MakeCurrent;
-    WGLSHARELISTS_T                     ShareLists;
+    PFN_wglCreateContext                CreateContext;
+    PFN_wglDeleteContext                DeleteContext;
+    PFN_wglGetProcAddress               GetProcAddress;
+    PFN_wglGetCurrentDC                 GetCurrentDC;
+    PFN_wglMakeCurrent                  MakeCurrent;
+    PFN_wglShareLists                   ShareLists;

    GLFWbool                            extensionsLoaded;

@@ -2,7 +2,7 @@
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -35,15 +35,15 @@ DEFINE_GUID(GUID_DEVINTERFACE_HID,0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0

 #if defined(_GLFW_USE_HYBRID_HPG) || defined(_GLFW_USE_OPTIMUS_HPG)

-// Applications exporting this symbol with this value will be automatically
-// directed to the high-performance GPU on Nvidia Optimus systems with
-// up-to-date drivers
+// Executables (but not DLLs) exporting this symbol with this value will be
+// automatically directed to the high-performance GPU on Nvidia Optimus systems
+// with up-to-date drivers
 //
 __declspec(dllexport) DWORD NvOptimusEnablement = 1;

-// Applications exporting this symbol with this value will be automatically
-// directed to the high-performance GPU on AMD PowerXpress systems with
-// up-to-date drivers
+// Executables (but not DLLs) exporting this symbol with this value will be
+// automatically directed to the high-performance GPU on AMD PowerXpress systems
+// with up-to-date drivers
 //
 __declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;

@@ -71,7 +71,7 @@ static GLFWbool loadLibraries(void)
        return GLFW_FALSE;
    }

-    _glfw.win32.winmm.timeGetTime = (TIMEGETTIME_T)
+    _glfw.win32.winmm.timeGetTime = (PFN_timeGetTime)
        GetProcAddress(_glfw.win32.winmm.instance, "timeGetTime");

    _glfw.win32.user32.instance = LoadLibraryA("user32.dll");
@@ -81,15 +81,15 @@ static GLFWbool loadLibraries(void)
        return GLFW_FALSE;
    }

-    _glfw.win32.user32.SetProcessDPIAware = (SETPROCESSDPIAWARE_T)
+    _glfw.win32.user32.SetProcessDPIAware = (PFN_SetProcessDPIAware)
        GetProcAddress(_glfw.win32.user32.instance, "SetProcessDPIAware");
-    _glfw.win32.user32.ChangeWindowMessageFilterEx = (CHANGEWINDOWMESSAGEFILTEREX_T)
+    _glfw.win32.user32.ChangeWindowMessageFilterEx = (PFN_ChangeWindowMessageFilterEx)
        GetProcAddress(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");

    _glfw.win32.dinput8.instance = LoadLibraryA("dinput8.dll");
    if (_glfw.win32.dinput8.instance)
    {
-        _glfw.win32.dinput8.DirectInput8Create = (DIRECTINPUT8CREATE_T)
+        _glfw.win32.dinput8.DirectInput8Create = (PFN_DirectInput8Create)
            GetProcAddress(_glfw.win32.dinput8.instance, "DirectInput8Create");
    }

@@ -110,9 +110,9 @@ static GLFWbool loadLibraries(void)
            _glfw.win32.xinput.instance = LoadLibraryA(names[i]);
            if (_glfw.win32.xinput.instance)
            {
-                _glfw.win32.xinput.XInputGetCapabilities = (XINPUTGETCAPABILITIES_T)
+                _glfw.win32.xinput.XInputGetCapabilities = (PFN_XInputGetCapabilities)
                    GetProcAddress(_glfw.win32.xinput.instance, "XInputGetCapabilities");
-                _glfw.win32.xinput.XInputGetState = (XINPUTGETSTATE_T)
+                _glfw.win32.xinput.XInputGetState = (PFN_XInputGetState)
                    GetProcAddress(_glfw.win32.xinput.instance, "XInputGetState");

                break;
@@ -123,16 +123,16 @@ static GLFWbool loadLibraries(void)
    _glfw.win32.dwmapi.instance = LoadLibraryA("dwmapi.dll");
    if (_glfw.win32.dwmapi.instance)
    {
-        _glfw.win32.dwmapi.DwmIsCompositionEnabled = (DWMISCOMPOSITIONENABLED_T)
+        _glfw.win32.dwmapi.DwmIsCompositionEnabled = (PFN_DwmIsCompositionEnabled)
            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmIsCompositionEnabled");
-        _glfw.win32.dwmapi.DwmFlush = (DWMFLUSH_T)
+        _glfw.win32.dwmapi.DwmFlush = (PFN_DwmFlush)
            GetProcAddress(_glfw.win32.dwmapi.instance, "DwmFlush");
    }

    _glfw.win32.shcore.instance = LoadLibraryA("shcore.dll");
    if (_glfw.win32.shcore.instance)
    {
-        _glfw.win32.shcore.SetProcessDpiAwareness = (SETPROCESSDPIAWARENESS_T)
+        _glfw.win32.shcore.SetProcessDpiAwareness = (PFN_SetProcessDpiAwareness)
            GetProcAddress(_glfw.win32.shcore.instance, "SetProcessDpiAwareness");
    }

@@ -168,135 +168,135 @@ static void createKeyTables(void)
 {
    int scancode;

-    memset(_glfw.win32.publicKeys, -1, sizeof(_glfw.win32.publicKeys));
-    memset(_glfw.win32.nativeKeys, -1, sizeof(_glfw.win32.nativeKeys));
+    memset(_glfw.win32.keycodes, -1, sizeof(_glfw.win32.keycodes));
+    memset(_glfw.win32.scancodes, -1, sizeof(_glfw.win32.scancodes));

-    _glfw.win32.publicKeys[0x00B] = GLFW_KEY_0;
-    _glfw.win32.publicKeys[0x002] = GLFW_KEY_1;
-    _glfw.win32.publicKeys[0x003] = GLFW_KEY_2;
-    _glfw.win32.publicKeys[0x004] = GLFW_KEY_3;
-    _glfw.win32.publicKeys[0x005] = GLFW_KEY_4;
-    _glfw.win32.publicKeys[0x006] = GLFW_KEY_5;
-    _glfw.win32.publicKeys[0x007] = GLFW_KEY_6;
-    _glfw.win32.publicKeys[0x008] = GLFW_KEY_7;
-    _glfw.win32.publicKeys[0x009] = GLFW_KEY_8;
-    _glfw.win32.publicKeys[0x00A] = GLFW_KEY_9;
-    _glfw.win32.publicKeys[0x01E] = GLFW_KEY_A;
-    _glfw.win32.publicKeys[0x030] = GLFW_KEY_B;
-    _glfw.win32.publicKeys[0x02E] = GLFW_KEY_C;
-    _glfw.win32.publicKeys[0x020] = GLFW_KEY_D;
-    _glfw.win32.publicKeys[0x012] = GLFW_KEY_E;
-    _glfw.win32.publicKeys[0x021] = GLFW_KEY_F;
-    _glfw.win32.publicKeys[0x022] = GLFW_KEY_G;
-    _glfw.win32.publicKeys[0x023] = GLFW_KEY_H;
-    _glfw.win32.publicKeys[0x017] = GLFW_KEY_I;
-    _glfw.win32.publicKeys[0x024] = GLFW_KEY_J;
-    _glfw.win32.publicKeys[0x025] = GLFW_KEY_K;
-    _glfw.win32.publicKeys[0x026] = GLFW_KEY_L;
-    _glfw.win32.publicKeys[0x032] = GLFW_KEY_M;
-    _glfw.win32.publicKeys[0x031] = GLFW_KEY_N;
-    _glfw.win32.publicKeys[0x018] = GLFW_KEY_O;
-    _glfw.win32.publicKeys[0x019] = GLFW_KEY_P;
-    _glfw.win32.publicKeys[0x010] = GLFW_KEY_Q;
-    _glfw.win32.publicKeys[0x013] = GLFW_KEY_R;
-    _glfw.win32.publicKeys[0x01F] = GLFW_KEY_S;
-    _glfw.win32.publicKeys[0x014] = GLFW_KEY_T;
-    _glfw.win32.publicKeys[0x016] = GLFW_KEY_U;
-    _glfw.win32.publicKeys[0x02F] = GLFW_KEY_V;
-    _glfw.win32.publicKeys[0x011] = GLFW_KEY_W;
-    _glfw.win32.publicKeys[0x02D] = GLFW_KEY_X;
-    _glfw.win32.publicKeys[0x015] = GLFW_KEY_Y;
-    _glfw.win32.publicKeys[0x02C] = GLFW_KEY_Z;
+    _glfw.win32.keycodes[0x00B] = GLFW_KEY_0;
+    _glfw.win32.keycodes[0x002] = GLFW_KEY_1;
+    _glfw.win32.keycodes[0x003] = GLFW_KEY_2;
+    _glfw.win32.keycodes[0x004] = GLFW_KEY_3;
+    _glfw.win32.keycodes[0x005] = GLFW_KEY_4;
+    _glfw.win32.keycodes[0x006] = GLFW_KEY_5;
+    _glfw.win32.keycodes[0x007] = GLFW_KEY_6;
+    _glfw.win32.keycodes[0x008] = GLFW_KEY_7;
+    _glfw.win32.keycodes[0x009] = GLFW_KEY_8;
+    _glfw.win32.keycodes[0x00A] = GLFW_KEY_9;
+    _glfw.win32.keycodes[0x01E] = GLFW_KEY_A;
+    _glfw.win32.keycodes[0x030] = GLFW_KEY_B;
+    _glfw.win32.keycodes[0x02E] = GLFW_KEY_C;
+    _glfw.win32.keycodes[0x020] = GLFW_KEY_D;
+    _glfw.win32.keycodes[0x012] = GLFW_KEY_E;
+    _glfw.win32.keycodes[0x021] = GLFW_KEY_F;
+    _glfw.win32.keycodes[0x022] = GLFW_KEY_G;
+    _glfw.win32.keycodes[0x023] = GLFW_KEY_H;
+    _glfw.win32.keycodes[0x017] = GLFW_KEY_I;
+    _glfw.win32.keycodes[0x024] = GLFW_KEY_J;
+    _glfw.win32.keycodes[0x025] = GLFW_KEY_K;
+    _glfw.win32.keycodes[0x026] = GLFW_KEY_L;
+    _glfw.win32.keycodes[0x032] = GLFW_KEY_M;
+    _glfw.win32.keycodes[0x031] = GLFW_KEY_N;
+    _glfw.win32.keycodes[0x018] = GLFW_KEY_O;
+    _glfw.win32.keycodes[0x019] = GLFW_KEY_P;
+    _glfw.win32.keycodes[0x010] = GLFW_KEY_Q;
+    _glfw.win32.keycodes[0x013] = GLFW_KEY_R;
+    _glfw.win32.keycodes[0x01F] = GLFW_KEY_S;
+    _glfw.win32.keycodes[0x014] = GLFW_KEY_T;
+    _glfw.win32.keycodes[0x016] = GLFW_KEY_U;
+    _glfw.win32.keycodes[0x02F] = GLFW_KEY_V;
+    _glfw.win32.keycodes[0x011] = GLFW_KEY_W;
+    _glfw.win32.keycodes[0x02D] = GLFW_KEY_X;
+    _glfw.win32.keycodes[0x015] = GLFW_KEY_Y;
+    _glfw.win32.keycodes[0x02C] = GLFW_KEY_Z;

-    _glfw.win32.publicKeys[0x028] = GLFW_KEY_APOSTROPHE;
-    _glfw.win32.publicKeys[0x02B] = GLFW_KEY_BACKSLASH;
-    _glfw.win32.publicKeys[0x033] = GLFW_KEY_COMMA;
-    _glfw.win32.publicKeys[0x00D] = GLFW_KEY_EQUAL;
-    _glfw.win32.publicKeys[0x029] = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.win32.publicKeys[0x01A] = GLFW_KEY_LEFT_BRACKET;
-    _glfw.win32.publicKeys[0x00C] = GLFW_KEY_MINUS;
-    _glfw.win32.publicKeys[0x034] = GLFW_KEY_PERIOD;
-    _glfw.win32.publicKeys[0x01B] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.win32.publicKeys[0x027] = GLFW_KEY_SEMICOLON;
-    _glfw.win32.publicKeys[0x035] = GLFW_KEY_SLASH;
-    _glfw.win32.publicKeys[0x056] = GLFW_KEY_WORLD_2;
+    _glfw.win32.keycodes[0x028] = GLFW_KEY_APOSTROPHE;
+    _glfw.win32.keycodes[0x02B] = GLFW_KEY_BACKSLASH;
+    _glfw.win32.keycodes[0x033] = GLFW_KEY_COMMA;
+    _glfw.win32.keycodes[0x00D] = GLFW_KEY_EQUAL;
+    _glfw.win32.keycodes[0x029] = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.win32.keycodes[0x01A] = GLFW_KEY_LEFT_BRACKET;
+    _glfw.win32.keycodes[0x00C] = GLFW_KEY_MINUS;
+    _glfw.win32.keycodes[0x034] = GLFW_KEY_PERIOD;
+    _glfw.win32.keycodes[0x01B] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.win32.keycodes[0x027] = GLFW_KEY_SEMICOLON;
+    _glfw.win32.keycodes[0x035] = GLFW_KEY_SLASH;
+    _glfw.win32.keycodes[0x056] = GLFW_KEY_WORLD_2;

-    _glfw.win32.publicKeys[0x00E] = GLFW_KEY_BACKSPACE;
-    _glfw.win32.publicKeys[0x153] = GLFW_KEY_DELETE;
-    _glfw.win32.publicKeys[0x14F] = GLFW_KEY_END;
-    _glfw.win32.publicKeys[0x01C] = GLFW_KEY_ENTER;
-    _glfw.win32.publicKeys[0x001] = GLFW_KEY_ESCAPE;
-    _glfw.win32.publicKeys[0x147] = GLFW_KEY_HOME;
-    _glfw.win32.publicKeys[0x152] = GLFW_KEY_INSERT;
-    _glfw.win32.publicKeys[0x15D] = GLFW_KEY_MENU;
-    _glfw.win32.publicKeys[0x151] = GLFW_KEY_PAGE_DOWN;
-    _glfw.win32.publicKeys[0x149] = GLFW_KEY_PAGE_UP;
-    _glfw.win32.publicKeys[0x045] = GLFW_KEY_PAUSE;
-    _glfw.win32.publicKeys[0x146] = GLFW_KEY_PAUSE;
-    _glfw.win32.publicKeys[0x039] = GLFW_KEY_SPACE;
-    _glfw.win32.publicKeys[0x00F] = GLFW_KEY_TAB;
-    _glfw.win32.publicKeys[0x03A] = GLFW_KEY_CAPS_LOCK;
-    _glfw.win32.publicKeys[0x145] = GLFW_KEY_NUM_LOCK;
-    _glfw.win32.publicKeys[0x046] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.win32.publicKeys[0x03B] = GLFW_KEY_F1;
-    _glfw.win32.publicKeys[0x03C] = GLFW_KEY_F2;
-    _glfw.win32.publicKeys[0x03D] = GLFW_KEY_F3;
-    _glfw.win32.publicKeys[0x03E] = GLFW_KEY_F4;
-    _glfw.win32.publicKeys[0x03F] = GLFW_KEY_F5;
-    _glfw.win32.publicKeys[0x040] = GLFW_KEY_F6;
-    _glfw.win32.publicKeys[0x041] = GLFW_KEY_F7;
-    _glfw.win32.publicKeys[0x042] = GLFW_KEY_F8;
-    _glfw.win32.publicKeys[0x043] = GLFW_KEY_F9;
-    _glfw.win32.publicKeys[0x044] = GLFW_KEY_F10;
-    _glfw.win32.publicKeys[0x057] = GLFW_KEY_F11;
-    _glfw.win32.publicKeys[0x058] = GLFW_KEY_F12;
-    _glfw.win32.publicKeys[0x064] = GLFW_KEY_F13;
-    _glfw.win32.publicKeys[0x065] = GLFW_KEY_F14;
-    _glfw.win32.publicKeys[0x066] = GLFW_KEY_F15;
-    _glfw.win32.publicKeys[0x067] = GLFW_KEY_F16;
-    _glfw.win32.publicKeys[0x068] = GLFW_KEY_F17;
-    _glfw.win32.publicKeys[0x069] = GLFW_KEY_F18;
-    _glfw.win32.publicKeys[0x06A] = GLFW_KEY_F19;
-    _glfw.win32.publicKeys[0x06B] = GLFW_KEY_F20;
-    _glfw.win32.publicKeys[0x06C] = GLFW_KEY_F21;
-    _glfw.win32.publicKeys[0x06D] = GLFW_KEY_F22;
-    _glfw.win32.publicKeys[0x06E] = GLFW_KEY_F23;
-    _glfw.win32.publicKeys[0x076] = GLFW_KEY_F24;
-    _glfw.win32.publicKeys[0x038] = GLFW_KEY_LEFT_ALT;
-    _glfw.win32.publicKeys[0x01D] = GLFW_KEY_LEFT_CONTROL;
-    _glfw.win32.publicKeys[0x02A] = GLFW_KEY_LEFT_SHIFT;
-    _glfw.win32.publicKeys[0x15B] = GLFW_KEY_LEFT_SUPER;
-    _glfw.win32.publicKeys[0x137] = GLFW_KEY_PRINT_SCREEN;
-    _glfw.win32.publicKeys[0x138] = GLFW_KEY_RIGHT_ALT;
-    _glfw.win32.publicKeys[0x11D] = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.win32.publicKeys[0x036] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.win32.publicKeys[0x15C] = GLFW_KEY_RIGHT_SUPER;
-    _glfw.win32.publicKeys[0x150] = GLFW_KEY_DOWN;
-    _glfw.win32.publicKeys[0x14B] = GLFW_KEY_LEFT;
-    _glfw.win32.publicKeys[0x14D] = GLFW_KEY_RIGHT;
-    _glfw.win32.publicKeys[0x148] = GLFW_KEY_UP;
+    _glfw.win32.keycodes[0x00E] = GLFW_KEY_BACKSPACE;
+    _glfw.win32.keycodes[0x153] = GLFW_KEY_DELETE;
+    _glfw.win32.keycodes[0x14F] = GLFW_KEY_END;
+    _glfw.win32.keycodes[0x01C] = GLFW_KEY_ENTER;
+    _glfw.win32.keycodes[0x001] = GLFW_KEY_ESCAPE;
+    _glfw.win32.keycodes[0x147] = GLFW_KEY_HOME;
+    _glfw.win32.keycodes[0x152] = GLFW_KEY_INSERT;
+    _glfw.win32.keycodes[0x15D] = GLFW_KEY_MENU;
+    _glfw.win32.keycodes[0x151] = GLFW_KEY_PAGE_DOWN;
+    _glfw.win32.keycodes[0x149] = GLFW_KEY_PAGE_UP;
+    _glfw.win32.keycodes[0x045] = GLFW_KEY_PAUSE;
+    _glfw.win32.keycodes[0x146] = GLFW_KEY_PAUSE;
+    _glfw.win32.keycodes[0x039] = GLFW_KEY_SPACE;
+    _glfw.win32.keycodes[0x00F] = GLFW_KEY_TAB;
+    _glfw.win32.keycodes[0x03A] = GLFW_KEY_CAPS_LOCK;
+    _glfw.win32.keycodes[0x145] = GLFW_KEY_NUM_LOCK;
+    _glfw.win32.keycodes[0x046] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.win32.keycodes[0x03B] = GLFW_KEY_F1;
+    _glfw.win32.keycodes[0x03C] = GLFW_KEY_F2;
+    _glfw.win32.keycodes[0x03D] = GLFW_KEY_F3;
+    _glfw.win32.keycodes[0x03E] = GLFW_KEY_F4;
+    _glfw.win32.keycodes[0x03F] = GLFW_KEY_F5;
+    _glfw.win32.keycodes[0x040] = GLFW_KEY_F6;
+    _glfw.win32.keycodes[0x041] = GLFW_KEY_F7;
+    _glfw.win32.keycodes[0x042] = GLFW_KEY_F8;
+    _glfw.win32.keycodes[0x043] = GLFW_KEY_F9;
+    _glfw.win32.keycodes[0x044] = GLFW_KEY_F10;
+    _glfw.win32.keycodes[0x057] = GLFW_KEY_F11;
+    _glfw.win32.keycodes[0x058] = GLFW_KEY_F12;
+    _glfw.win32.keycodes[0x064] = GLFW_KEY_F13;
+    _glfw.win32.keycodes[0x065] = GLFW_KEY_F14;
+    _glfw.win32.keycodes[0x066] = GLFW_KEY_F15;
+    _glfw.win32.keycodes[0x067] = GLFW_KEY_F16;
+    _glfw.win32.keycodes[0x068] = GLFW_KEY_F17;
+    _glfw.win32.keycodes[0x069] = GLFW_KEY_F18;
+    _glfw.win32.keycodes[0x06A] = GLFW_KEY_F19;
+    _glfw.win32.keycodes[0x06B] = GLFW_KEY_F20;
+    _glfw.win32.keycodes[0x06C] = GLFW_KEY_F21;
+    _glfw.win32.keycodes[0x06D] = GLFW_KEY_F22;
+    _glfw.win32.keycodes[0x06E] = GLFW_KEY_F23;
+    _glfw.win32.keycodes[0x076] = GLFW_KEY_F24;
+    _glfw.win32.keycodes[0x038] = GLFW_KEY_LEFT_ALT;
+    _glfw.win32.keycodes[0x01D] = GLFW_KEY_LEFT_CONTROL;
+    _glfw.win32.keycodes[0x02A] = GLFW_KEY_LEFT_SHIFT;
+    _glfw.win32.keycodes[0x15B] = GLFW_KEY_LEFT_SUPER;
+    _glfw.win32.keycodes[0x137] = GLFW_KEY_PRINT_SCREEN;
+    _glfw.win32.keycodes[0x138] = GLFW_KEY_RIGHT_ALT;
+    _glfw.win32.keycodes[0x11D] = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.win32.keycodes[0x036] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.win32.keycodes[0x15C] = GLFW_KEY_RIGHT_SUPER;
+    _glfw.win32.keycodes[0x150] = GLFW_KEY_DOWN;
+    _glfw.win32.keycodes[0x14B] = GLFW_KEY_LEFT;
+    _glfw.win32.keycodes[0x14D] = GLFW_KEY_RIGHT;
+    _glfw.win32.keycodes[0x148] = GLFW_KEY_UP;

-    _glfw.win32.publicKeys[0x052] = GLFW_KEY_KP_0;
-    _glfw.win32.publicKeys[0x04F] = GLFW_KEY_KP_1;
-    _glfw.win32.publicKeys[0x050] = GLFW_KEY_KP_2;
-    _glfw.win32.publicKeys[0x051] = GLFW_KEY_KP_3;
-    _glfw.win32.publicKeys[0x04B] = GLFW_KEY_KP_4;
-    _glfw.win32.publicKeys[0x04C] = GLFW_KEY_KP_5;
-    _glfw.win32.publicKeys[0x04D] = GLFW_KEY_KP_6;
-    _glfw.win32.publicKeys[0x047] = GLFW_KEY_KP_7;
-    _glfw.win32.publicKeys[0x048] = GLFW_KEY_KP_8;
-    _glfw.win32.publicKeys[0x049] = GLFW_KEY_KP_9;
-    _glfw.win32.publicKeys[0x04E] = GLFW_KEY_KP_ADD;
-    _glfw.win32.publicKeys[0x053] = GLFW_KEY_KP_DECIMAL;
-    _glfw.win32.publicKeys[0x135] = GLFW_KEY_KP_DIVIDE;
-    _glfw.win32.publicKeys[0x11C] = GLFW_KEY_KP_ENTER;
-    _glfw.win32.publicKeys[0x037] = GLFW_KEY_KP_MULTIPLY;
-    _glfw.win32.publicKeys[0x04A] = GLFW_KEY_KP_SUBTRACT;
+    _glfw.win32.keycodes[0x052] = GLFW_KEY_KP_0;
+    _glfw.win32.keycodes[0x04F] = GLFW_KEY_KP_1;
+    _glfw.win32.keycodes[0x050] = GLFW_KEY_KP_2;
+    _glfw.win32.keycodes[0x051] = GLFW_KEY_KP_3;
+    _glfw.win32.keycodes[0x04B] = GLFW_KEY_KP_4;
+    _glfw.win32.keycodes[0x04C] = GLFW_KEY_KP_5;
+    _glfw.win32.keycodes[0x04D] = GLFW_KEY_KP_6;
+    _glfw.win32.keycodes[0x047] = GLFW_KEY_KP_7;
+    _glfw.win32.keycodes[0x048] = GLFW_KEY_KP_8;
+    _glfw.win32.keycodes[0x049] = GLFW_KEY_KP_9;
+    _glfw.win32.keycodes[0x04E] = GLFW_KEY_KP_ADD;
+    _glfw.win32.keycodes[0x053] = GLFW_KEY_KP_DECIMAL;
+    _glfw.win32.keycodes[0x135] = GLFW_KEY_KP_DIVIDE;
+    _glfw.win32.keycodes[0x11C] = GLFW_KEY_KP_ENTER;
+    _glfw.win32.keycodes[0x037] = GLFW_KEY_KP_MULTIPLY;
+    _glfw.win32.keycodes[0x04A] = GLFW_KEY_KP_SUBTRACT;

    for (scancode = 0;  scancode < 512;  scancode++)
    {
-        if (_glfw.win32.publicKeys[scancode] > 0)
-            _glfw.win32.nativeKeys[_glfw.win32.publicKeys[scancode]] = scancode;
+        if (_glfw.win32.keycodes[scancode] > 0)
+            _glfw.win32.scancodes[_glfw.win32.keycodes[scancode]] = scancode;
    }
 }

@@ -304,6 +304,7 @@ static void createKeyTables(void)
 //
 static HWND createHelperWindow(void)
 {
+    MSG msg;
    HWND window = CreateWindowExW(WS_EX_OVERLAPPEDWINDOW,
                                  _GLFW_WNDCLASSNAME,
                                  L"GLFW helper window",
@@ -336,6 +337,12 @@ static HWND createHelperWindow(void)
                                    DEVICE_NOTIFY_WINDOW_HANDLE);
    }

+    while (PeekMessageW(&msg, _glfw.win32.helperWindowHandle, 0, 0, PM_REMOVE))
+    {
+        TranslateMessage(&msg);
+        DispatchMessageW(&msg);
+    }
+
   return window;
 }

@@ -423,8 +430,6 @@ int _glfwPlatformInit(void)
    if (!_glfw.win32.helperWindowHandle)
        return GLFW_FALSE;

-    _glfwPlatformPollEvents();
-
    _glfwInitTimerWin32();
    _glfwInitJoysticksWin32();

@@ -2,7 +2,7 @@
 // GLFW 3.1 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -332,26 +332,26 @@ static BOOL CALLBACK deviceObjectCallback(const DIDEVICEOBJECTINSTANCEW* doi,
 //
 static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
 {
-    int joy = 0;
+    int jid = 0;
    DIDEVCAPS dc;
    DIPROPDWORD dipd;
    IDirectInputDevice8* device;
    _GLFWobjenumWin32 data;
    _GLFWjoystickWin32* js;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (memcmp(&_glfw.win32_js[joy].guid, &di->guidInstance, sizeof(GUID)) == 0)
+        if (memcmp(&_glfw.win32_js[jid].guid, &di->guidInstance, sizeof(GUID)) == 0)
            return DIENUM_CONTINUE;
    }

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (!_glfw.win32_js[joy].present)
+        if (!_glfw.win32_js[jid].present)
            break;
    }

-    if (joy > GLFW_JOYSTICK_LAST)
+    if (jid > GLFW_JOYSTICK_LAST)
        return DIENUM_STOP;

    if (supportsXInput(&di->guidProduct))
@@ -362,14 +362,14 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
                                          &device,
                                          NULL)))
    {
-        _glfwInputError(GLFW_PLATFORM_ERROR, "DI: Failed to create device");
+        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to create device");
        return DIENUM_CONTINUE;
    }

    if (FAILED(IDirectInputDevice8_SetDataFormat(device, &_glfwDataFormat)))
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to set device data format");
+                        "Win32: Failed to set device data format");

        IDirectInputDevice8_Release(device);
        return DIENUM_CONTINUE;
@@ -381,7 +381,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
    if (FAILED(IDirectInputDevice8_GetCapabilities(device, &dc)))
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to query device capabilities");
+                        "Win32: Failed to query device capabilities");

        IDirectInputDevice8_Release(device);
        return DIENUM_CONTINUE;
@@ -398,7 +398,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
                                               &dipd.diph)))
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to set device axis mode");
+                        "Win32: Failed to set device axis mode");

        IDirectInputDevice8_Release(device);
        return DIENUM_CONTINUE;
@@ -415,7 +415,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
                                               DIDFT_AXIS | DIDFT_BUTTON | DIDFT_POV)))
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "DI: Failed to enumerate device objects");
+                        "Win32: Failed to enumerate device objects");

        IDirectInputDevice8_Release(device);
        free(data.objects);
@@ -426,7 +426,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
          sizeof(_GLFWjoyobjectWin32),
          compareJoystickObjects);

-    js = _glfw.win32_js + joy;
+    js = _glfw.win32_js + jid;
    js->device = device;
    js->guid = di->guidInstance;
    js->axisCount = data.axisCount + data.sliderCount;
@@ -438,7 +438,7 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
    js->name = _glfwCreateUTF8FromWideStringWin32(di->tszInstanceName);
    js->present = GLFW_TRUE;

-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
+    _glfwInputJoystickChange(jid, GLFW_CONNECTED);
    return DIENUM_CONTINUE;
 }

@@ -447,33 +447,33 @@ static BOOL CALLBACK deviceCallback(const DIDEVICEINSTANCE* di, void* user)
 //
 static GLFWbool openXinputDevice(DWORD index)
 {
-    int joy;
+    int jid;
    XINPUT_CAPABILITIES xic;
    _GLFWjoystickWin32* js;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (_glfw.win32_js[joy].present &&
-            _glfw.win32_js[joy].device == NULL &&
-            _glfw.win32_js[joy].index == index)
+        if (_glfw.win32_js[jid].present &&
+            _glfw.win32_js[jid].device == NULL &&
+            _glfw.win32_js[jid].index == index)
        {
            return GLFW_FALSE;
        }
    }

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
    {
-        if (!_glfw.win32_js[joy].present)
+        if (!_glfw.win32_js[jid].present)
            break;
    }

-    if (joy > GLFW_JOYSTICK_LAST)
+    if (jid > GLFW_JOYSTICK_LAST)
        return GLFW_FALSE;

    if (_glfw_XInputGetCapabilities(index, 0, &xic) != ERROR_SUCCESS)
        return GLFW_FALSE;

-    js = _glfw.win32_js + joy;
+    js = _glfw.win32_js + jid;
    js->axisCount = 6;
    js->axes = calloc(js->axisCount, sizeof(float));
    js->buttonCount = 14;
@@ -482,7 +482,7 @@ static GLFWbool openXinputDevice(DWORD index)
    js->name = strdup(getDeviceDescription(&xic));
    js->index = index;

-    _glfwInputJoystickChange(joy, GLFW_CONNECTED);
+    _glfwInputJoystickChange(jid, GLFW_CONNECTED);

    return GLFW_TRUE;
 }
@@ -603,9 +603,10 @@ static GLFWbool pollJoystickState(_GLFWjoystickWin32* js, int mode)
        if (mode == _GLFW_PRESENCE_ONLY)
            return GLFW_TRUE;

-        if (sqrt((double) (xis.Gamepad.sThumbLX * xis.Gamepad.sThumbLX +
-                           xis.Gamepad.sThumbLY * xis.Gamepad.sThumbLY)) >
-            (double) XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE)
+        if ((float) xis.Gamepad.sThumbLX * xis.Gamepad.sThumbLX +
+            (float) xis.Gamepad.sThumbLY * xis.Gamepad.sThumbLY >
+            (float) XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE *
+                    XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE)
        {
            js->axes[0] = (xis.Gamepad.sThumbLX + 0.5f) / 32767.f;
            js->axes[1] = (xis.Gamepad.sThumbLY + 0.5f) / 32767.f;
@@ -616,9 +617,10 @@ static GLFWbool pollJoystickState(_GLFWjoystickWin32* js, int mode)
            js->axes[1] = 0.f;
        }

-        if (sqrt((double) (xis.Gamepad.sThumbRX * xis.Gamepad.sThumbRX +
-                           xis.Gamepad.sThumbRY * xis.Gamepad.sThumbRY)) >
-            (double) XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE)
+        if ((float) xis.Gamepad.sThumbRX * xis.Gamepad.sThumbRX +
+            (float) xis.Gamepad.sThumbRY * xis.Gamepad.sThumbRY >
+            (float) XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE *
+                    XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE)
        {
            js->axes[2] = (xis.Gamepad.sThumbRX + 0.5f) / 32767.f;
            js->axes[3] = (xis.Gamepad.sThumbRY + 0.5f) / 32767.f;
@@ -664,7 +666,7 @@ void _glfwInitJoysticksWin32(void)
                                            NULL)))
        {
            _glfwInputError(GLFW_PLATFORM_ERROR,
-                            "DI: Failed to create interface");
+                            "Win32: Failed to create interface");
        }
    }

@@ -675,10 +677,10 @@ void _glfwInitJoysticksWin32(void)
 //
 void _glfwTerminateJoysticksWin32(void)
 {
-    int joy;
+    int jid;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
-        closeJoystick(_glfw.win32_js + joy);
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+        closeJoystick(_glfw.win32_js + jid);

    if (_glfw.win32.dinput8.api)
        IDirectInput8_Release(_glfw.win32.dinput8.api);
@@ -715,10 +717,10 @@ void _glfwDetectJoystickConnectionWin32(void)
 //
 void _glfwDetectJoystickDisconnectionWin32(void)
 {
-    int joy;
+    int jid;

-    for (joy = GLFW_JOYSTICK_1;  joy <= GLFW_JOYSTICK_LAST;  joy++)
-        pollJoystickState(_glfw.win32_js + joy, _GLFW_PRESENCE_ONLY);
+    for (jid = GLFW_JOYSTICK_1;  jid <= GLFW_JOYSTICK_LAST;  jid++)
+        pollJoystickState(_glfw.win32_js + jid, _GLFW_PRESENCE_ONLY);
 }


@@ -726,15 +728,15 @@ void _glfwDetectJoystickDisconnectionWin32(void)
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////

-int _glfwPlatformJoystickPresent(int joy)
+int _glfwPlatformJoystickPresent(int jid)
 {
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    _GLFWjoystickWin32* js = _glfw.win32_js + jid;
    return pollJoystickState(js, _GLFW_PRESENCE_ONLY);
 }

-const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
+const float* _glfwPlatformGetJoystickAxes(int jid, int* count)
 {
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    _GLFWjoystickWin32* js = _glfw.win32_js + jid;
    if (!pollJoystickState(js, _GLFW_UPDATE_STATE))
        return NULL;

@@ -742,9 +744,9 @@ const float* _glfwPlatformGetJoystickAxes(int joy, int* count)
    return js->axes;
 }

-const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
+const unsigned char* _glfwPlatformGetJoystickButtons(int jid, int* count)
 {
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    _GLFWjoystickWin32* js = _glfw.win32_js + jid;
    if (!pollJoystickState(js, _GLFW_UPDATE_STATE))
        return NULL;

@@ -752,9 +754,9 @@ const unsigned char* _glfwPlatformGetJoystickButtons(int joy, int* count)
    return js->buttons;
 }

-const char* _glfwPlatformGetJoystickName(int joy)
+const char* _glfwPlatformGetJoystickName(int jid)
 {
-    _GLFWjoystickWin32* js = _glfw.win32_js + joy;
+    _GLFWjoystickWin32* js = _glfw.win32_js + jid;
    if (!pollJoystickState(js, _GLFW_PRESENCE_ONLY))
        return NULL;

@@ -1,7 +1,7 @@
 //========================================================================
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -161,33 +161,33 @@ typedef enum PROCESS_DPI_AWARENESS
 #endif

 // winmm.dll function pointer typedefs
-typedef DWORD (WINAPI * TIMEGETTIME_T)(void);
+typedef DWORD (WINAPI * PFN_timeGetTime)(void);
 #define _glfw_timeGetTime _glfw.win32.winmm.timeGetTime

 // xinput.dll function pointer typedefs
-typedef DWORD (WINAPI * XINPUTGETCAPABILITIES_T)(DWORD,DWORD,XINPUT_CAPABILITIES*);
-typedef DWORD (WINAPI * XINPUTGETSTATE_T)(DWORD,XINPUT_STATE*);
+typedef DWORD (WINAPI * PFN_XInputGetCapabilities)(DWORD,DWORD,XINPUT_CAPABILITIES*);
+typedef DWORD (WINAPI * PFN_XInputGetState)(DWORD,XINPUT_STATE*);
 #define _glfw_XInputGetCapabilities _glfw.win32.xinput.XInputGetCapabilities
 #define _glfw_XInputGetState _glfw.win32.xinput.XInputGetState

 // dinput8.dll function pointer typedefs
-typedef HRESULT (WINAPI * DIRECTINPUT8CREATE_T)(HINSTANCE,DWORD,REFIID,LPVOID*,LPUNKNOWN);
+typedef HRESULT (WINAPI * PFN_DirectInput8Create)(HINSTANCE,DWORD,REFIID,LPVOID*,LPUNKNOWN);
 #define _glfw_DirectInput8Create _glfw.win32.dinput8.DirectInput8Create

 // user32.dll function pointer typedefs
-typedef BOOL (WINAPI * SETPROCESSDPIAWARE_T)(void);
-typedef BOOL (WINAPI * CHANGEWINDOWMESSAGEFILTEREX_T)(HWND,UINT,DWORD,PCHANGEFILTERSTRUCT);
+typedef BOOL (WINAPI * PFN_SetProcessDPIAware)(void);
+typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,PCHANGEFILTERSTRUCT);
 #define _glfw_SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware
 #define _glfw_ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx

 // dwmapi.dll function pointer typedefs
-typedef HRESULT (WINAPI * DWMISCOMPOSITIONENABLED_T)(BOOL*);
-typedef HRESULT (WINAPI * DWMFLUSH_T)(VOID);
+typedef HRESULT (WINAPI * PFN_DwmIsCompositionEnabled)(BOOL*);
+typedef HRESULT (WINAPI * PFN_DwmFlush)(VOID);
 #define _glfw_DwmIsCompositionEnabled _glfw.win32.dwmapi.DwmIsCompositionEnabled
 #define _glfw_DwmFlush _glfw.win32.dwmapi.DwmFlush

 // shcore.dll function pointer typedefs
-typedef HRESULT (WINAPI * SETPROCESSDPIAWARENESS_T)(PROCESS_DPI_AWARENESS);
+typedef HRESULT (WINAPI * PFN_SetProcessDpiAwareness)(PROCESS_DPI_AWARENESS);
 #define _glfw_SetProcessDpiAwareness _glfw.win32.shcore.SetProcessDpiAwareness

 typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
@@ -235,6 +235,7 @@ typedef struct _GLFWwindowWin32

    GLFWbool            cursorTracked;
    GLFWbool            iconified;
+    GLFWbool            maximized;

    // The last received cursor position, regardless of source
    int                 lastCursorPosX, lastCursorPosY;
@@ -249,45 +250,45 @@ typedef struct _GLFWlibraryWin32
    DWORD               foregroundLockTimeout;
    char*               clipboardString;
    char                keyName[64];
-    short int           publicKeys[512];
-    short int           nativeKeys[GLFW_KEY_LAST + 1];
+    short int           keycodes[512];
+    short int           scancodes[GLFW_KEY_LAST + 1];
    // Where to place the cursor when re-enabled
    double              restoreCursorPosX, restoreCursorPosY;
    // The window whose disabled cursor mode is active
    _GLFWwindow*        disabledCursorWindow;

    struct {
-        HINSTANCE       instance;
-        TIMEGETTIME_T   timeGetTime;
+        HINSTANCE                       instance;
+        PFN_timeGetTime                 timeGetTime;
    } winmm;

    struct {
-        HINSTANCE            instance;
-        DIRECTINPUT8CREATE_T DirectInput8Create;
-        IDirectInput8W*      api;
+        HINSTANCE                       instance;
+        PFN_DirectInput8Create          DirectInput8Create;
+        IDirectInput8W*                 api;
    } dinput8;

    struct {
-        HINSTANCE               instance;
-        XINPUTGETCAPABILITIES_T XInputGetCapabilities;
-        XINPUTGETSTATE_T        XInputGetState;
+        HINSTANCE                       instance;
+        PFN_XInputGetCapabilities       XInputGetCapabilities;
+        PFN_XInputGetState              XInputGetState;
    } xinput;

    struct {
-        HINSTANCE                     instance;
-        SETPROCESSDPIAWARE_T          SetProcessDPIAware;
-        CHANGEWINDOWMESSAGEFILTEREX_T ChangeWindowMessageFilterEx;
+        HINSTANCE                       instance;
+        PFN_SetProcessDPIAware          SetProcessDPIAware;
+        PFN_ChangeWindowMessageFilterEx ChangeWindowMessageFilterEx;
    } user32;

    struct {
-        HINSTANCE       instance;
-        DWMISCOMPOSITIONENABLED_T DwmIsCompositionEnabled;
-        DWMFLUSH_T      DwmFlush;
+        HINSTANCE                       instance;
+        PFN_DwmIsCompositionEnabled     DwmIsCompositionEnabled;
+        PFN_DwmFlush                    DwmFlush;
    } dwmapi;

    struct {
-        HINSTANCE       instance;
-        SETPROCESSDPIAWARENESS_T SetProcessDpiAwareness;
+        HINSTANCE                       instance;
+        PFN_SetProcessDpiAwareness      SetProcessDpiAwareness;
    } shcore;

 } _GLFWlibraryWin32;
@@ -310,7 +311,7 @@ typedef struct _GLFWmonitorWin32
 //
 typedef struct _GLFWcursorWin32
 {
-    HCURSOR handle;
+    HCURSOR             handle;

 } _GLFWcursorWin32;

@@ -327,8 +328,8 @@ typedef struct _GLFWtimeWin32
 //
 typedef struct _GLFWtlsWin32
 {
-    GLFWbool        allocated;
-    DWORD           context;
+    GLFWbool            allocated;
+    DWORD               context;

 } _GLFWtlsWin32;

@@ -2,7 +2,7 @@
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -2,7 +2,7 @@
 // GLFW 3.3 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -46,9 +46,11 @@ static DWORD getWindowStyle(const _GLFWwindow* window)
        style |= WS_POPUP;
    else
    {
+        style |= WS_SYSMENU | WS_MINIMIZEBOX;
+
        if (window->decorated)
        {
-            style |= WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+            style |= WS_CAPTION;

            if (window->resizable)
                style |= WS_MAXIMIZEBOX | WS_THICKFRAME;
@@ -278,6 +280,26 @@ static void updateClipRect(_GLFWwindow* window)
        ClipCursor(NULL);
 }

+// Update native window styles to match attributes
+//
+static void updateWindowStyles(const _GLFWwindow* window)
+{
+    RECT rect;
+    DWORD style = GetWindowLongW(window->win32.handle, GWL_STYLE);
+    style &= ~(WS_OVERLAPPEDWINDOW | WS_POPUP);
+    style |= getWindowStyle(window);
+
+    GetClientRect(window->win32.handle, &rect);
+    AdjustWindowRectEx(&rect, style, FALSE, getWindowExStyle(window));
+    ClientToScreen(window->win32.handle, (POINT*) &rect.left);
+    ClientToScreen(window->win32.handle, (POINT*) &rect.right);
+    SetWindowLongW(window->win32.handle, GWL_STYLE, style);
+    SetWindowPos(window->win32.handle, HWND_TOP,
+                 rect.left, rect.top,
+                 rect.right - rect.left, rect.bottom - rect.top,
+                 SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER);
+}
+
 // Translates a GLFW standard cursor to a resource ID
 //
 static LPWSTR translateCursorShape(int shape)
@@ -385,7 +407,7 @@ static int translateKey(WPARAM wParam, LPARAM lParam)
        return _GLFW_KEY_INVALID;
    }

-    return _glfw.win32.publicKeys[HIWORD(lParam) & 0x1FF];
+    return _glfw.win32.keycodes[HIWORD(lParam) & 0x1FF];
 }

 // Make the specified window and its video mode active on its monitor
@@ -666,7 +688,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,
        case WM_MOUSEHWHEEL:
        {
            // This message is only sent on Windows Vista and later
-            // NOTE: The X-axis is inverted for consistency with OS X and X11.
+            // NOTE: The X-axis is inverted for consistency with macOS and X11
            _glfwInputScroll(window, -((SHORT) HIWORD(wParam) / (double) WHEEL_DELTA), 0.0);
            return 0;
        }
@@ -691,36 +713,33 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg,

        case WM_SIZE:
        {
-            const GLFWbool iconified =
-                !window->win32.iconified && wParam == SIZE_MINIMIZED;
-            const GLFWbool restored =
-                window->win32.iconified &&
-                (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED);
+            const GLFWbool iconified = wParam == SIZE_MINIMIZED;
+            const GLFWbool maximized = wParam == SIZE_MAXIMIZED ||
+                                       (window->win32.maximized &&
+                                        wParam != SIZE_RESTORED);

            if (_glfw.win32.disabledCursorWindow == window)
                updateClipRect(window);

-            if (iconified)
-                _glfwInputWindowIconify(window, GLFW_TRUE);
-            else if (restored)
-                _glfwInputWindowIconify(window, GLFW_FALSE);
+            if (window->win32.iconified != iconified)
+                _glfwInputWindowIconify(window, iconified);
+
+            if (window->win32.maximized != maximized)
+                _glfwInputWindowMaximize(window, maximized);

            _glfwInputFramebufferSize(window, LOWORD(lParam), HIWORD(lParam));
            _glfwInputWindowSize(window, LOWORD(lParam), HIWORD(lParam));

-            if (iconified)
+            if (window->monitor && window->win32.iconified != iconified)
            {
-                window->win32.iconified = GLFW_TRUE;
-                if (window->monitor)
+                if (iconified)
                    releaseMonitor(window);
-            }
-            else if (restored)
-            {
-                window->win32.iconified = GLFW_FALSE;
-                if (window->monitor)
+                else
                    acquireMonitor(window);
            }

+            window->win32.iconified = iconified;
+            window->win32.maximized = maximized;
            return 0;
        }

@@ -1347,6 +1366,23 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
    return IsZoomed(window->win32.handle);
 }

+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    updateWindowStyles(window);
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    updateWindowStyles(window);
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    const HWND after = enabled ? HWND_TOPMOST : HWND_NOTOPMOST;
+    SetWindowPos(window->win32.handle, after, 0, 0, 0, 0,
+                 SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
+}
+
 void _glfwPlatformPollEvents(void)
 {
    MSG msg;
@@ -1432,8 +1468,7 @@ void _glfwPlatformWaitEventsTimeout(double timeout)

 void _glfwPlatformPostEmptyEvent(void)
 {
-    _GLFWwindow* window = _glfw.windowListHead;
-    PostMessage(window->win32.handle, WM_NULL, 0, 0);
+    PostMessage(_glfw.win32.helperWindowHandle, WM_NULL, 0, 0);
 }

 void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
@@ -1492,9 +1527,9 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
    WCHAR name[16];

    if (key != GLFW_KEY_UNKNOWN)
-        scancode = _glfw.win32.nativeKeys[key];
+        scancode = _glfw.win32.scancodes[key];

-    if (!_glfwIsPrintable(_glfw.win32.publicKeys[scancode]))
+    if (!_glfwIsPrintable(_glfw.win32.keycodes[scancode]))
        return NULL;

    if (!GetKeyNameTextW(scancode << 16, name, sizeof(name) / sizeof(WCHAR)))
@@ -1511,6 +1546,11 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
    return _glfw.win32.keyName;
 }

+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.win32.scancodes[key];
+}
+
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                              const GLFWimage* image,
                              int xhot, int yhot)
@@ -1642,21 +1682,13 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
    return _glfw.win32.clipboardString;
 }

-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    char** extensions;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_win32_surface)
+        return;

-    *count = 0;
-
-    if (!_glfw.vk.KHR_win32_surface)
-        return NULL;
-
-    extensions = calloc(2, sizeof(char*));
-    extensions[0] = strdup("VK_KHR_surface");
-    extensions[1] = strdup("VK_KHR_win32_surface");
-
-    *count = 2;
-    return extensions;
+    extensions[0] = "VK_KHR_surface";
+    extensions[1] = "VK_KHR_win32_surface";
 }

 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
@@ -2,7 +2,7 @@
 // GLFW 3.3 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
 //
 // This software is provided 'as-is', without any express or implied
@@ -86,6 +86,12 @@ void _glfwInputWindowIconify(_GLFWwindow* window, GLFWbool iconified)
        window->callbacks.iconify((GLFWwindow*) window, iconified);
 }

+void _glfwInputWindowMaximize(_GLFWwindow* window, GLFWbool maximized)
+{
+    if (window->callbacks.maximize)
+        window->callbacks.maximize((GLFWwindow*) window, maximized);
+}
+
 void _glfwInputFramebufferSize(_GLFWwindow* window, int width, int height)
 {
    if (window->callbacks.fbsize)
@@ -100,7 +106,7 @@ void _glfwInputWindowDamage(_GLFWwindow* window)

 void _glfwInputWindowCloseRequest(_GLFWwindow* window)
 {
-    window->closed = GLFW_TRUE;
+    window->shouldClose = GLFW_TRUE;

    if (window->callbacks.close)
        window->callbacks.close((GLFWwindow*) window);
@@ -260,6 +266,9 @@ void glfwDefaultWindowHints(void)

    // The default is to select the highest available refresh rate
    _glfw.hints.refreshRate = GLFW_DONT_CARE;
+
+    // The default is to use full Retina resolution framebuffers
+    _glfw.hints.window.ns.retina = GLFW_TRUE;
 }

 GLFWAPI void glfwWindowHint(int hint, int value)
@@ -334,6 +343,9 @@ GLFWAPI void glfwWindowHint(int hint, int value)
        case GLFW_VISIBLE:
            _glfw.hints.window.visible = value ? GLFW_TRUE : GLFW_FALSE;
            break;
+        case GLFW_COCOA_RETINA_FRAMEBUFFER:
+            _glfw.hints.window.ns.retina = value ? GLFW_TRUE : GLFW_FALSE;
+            break;
        case GLFW_CLIENT_API:
            _glfw.hints.context.client = value;
            break;
@@ -412,7 +424,7 @@ GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
    assert(window != NULL);

    _GLFW_REQUIRE_INIT_OR_RETURN(0);
-    return window->closed;
+    return window->shouldClose;
 }

 GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
@@ -421,7 +433,7 @@ GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
    assert(window != NULL);

    _GLFW_REQUIRE_INIT();
-    window->closed = value;
+    window->shouldClose = value;
 }

 GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
@@ -631,6 +643,10 @@ GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
    assert(window != NULL);

    _GLFW_REQUIRE_INIT();
+
+    if (window->monitor)
+        return;
+
    _glfwPlatformMaximizeWindow(window);
 }

@@ -694,6 +710,8 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
            return window->decorated;
        case GLFW_FLOATING:
            return window->floating;
+        case GLFW_AUTO_ICONIFY:
+            return window->autoIconify;
        case GLFW_CLIENT_API:
            return window->context.client;
        case GLFW_CONTEXT_CREATION_API:
@@ -722,6 +740,52 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
    return 0;
 }

+GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT();
+
+    value = value ? GLFW_TRUE : GLFW_FALSE;
+
+    switch (attrib)
+    {
+        case GLFW_RESIZABLE:
+            if (window->resizable != value)
+            {
+                window->resizable = value;
+                if (!window->monitor)
+                    _glfwPlatformSetWindowResizable(window, value);
+            }
+            return;
+
+        case GLFW_DECORATED:
+            if (window->decorated != value)
+            {
+                window->decorated = value;
+                if (!window->monitor)
+                    _glfwPlatformSetWindowDecorated(window, value);
+            }
+            return;
+
+        case GLFW_FLOATING:
+            if (window->floating != value)
+            {
+                window->floating = value;
+                if (!window->monitor)
+                    _glfwPlatformSetWindowFloating(window, value);
+            }
+            return;
+
+        case GLFW_AUTO_ICONIFY:
+            window->autoIconify = value;
+            return;
+    }
+
+    _glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute %i", attrib);
+}
+
 GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
 {
    _GLFWwindow* window = (_GLFWwindow*) handle;
@@ -852,6 +916,17 @@ GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
    return cbfun;
 }

+GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* handle,
+                                                            GLFWwindowmaximizefun cbfun)
+{
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+    _GLFW_SWAP_POINTERS(window->callbacks.maximize, cbfun);
+    return cbfun;
+}
+
 GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
                                                              GLFWframebuffersizefun cbfun)
 {
@@ -128,7 +128,7 @@ static void pointerHandleAxis(void* data,
                              wl_fixed_t value)
 {
    _GLFWwindow* window = _glfw.wl.pointerFocus;
-    double scroll_factor;
+    double scrollFactor;
    double x, y;

    if (!window)
@@ -137,17 +137,17 @@ static void pointerHandleAxis(void* data,
    /* Wayland scroll events are in pointer motion coordinate space (think
     * two finger scroll). The factor 10 is commonly used to convert to
     * "scroll step means 1.0. */
-    scroll_factor = 1.0/10.0;
+    scrollFactor = 1.0/10.0;

    switch (axis)
    {
        case WL_POINTER_AXIS_HORIZONTAL_SCROLL:
-            x = wl_fixed_to_double(value) * scroll_factor;
+            x = wl_fixed_to_double(value) * scrollFactor;
            y = 0.0;
            break;
        case WL_POINTER_AXIS_VERTICAL_SCROLL:
            x = 0.0;
-            y = wl_fixed_to_double(value) * scroll_factor;
+            y = wl_fixed_to_double(value) * scrollFactor;
            break;
        default:
            break;
@@ -172,7 +172,10 @@ static void keyboardHandleKeymap(void* data,
 {
    struct xkb_keymap* keymap;
    struct xkb_state* state;
+    struct xkb_compose_table* composeTable;
+    struct xkb_compose_state* composeState;
    char* mapStr;
+    const char* locale;

    if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
    {
@@ -186,10 +189,10 @@ static void keyboardHandleKeymap(void* data,
        return;
    }

-    keymap = xkb_map_new_from_string(_glfw.wl.xkb.context,
-                                     mapStr,
-                                     XKB_KEYMAP_FORMAT_TEXT_V1,
-                                     0);
+    keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
+                                        mapStr,
+                                        XKB_KEYMAP_FORMAT_TEXT_V1,
+                                        0);
    munmap(mapStr, size);
    close(fd);

@@ -205,23 +208,52 @@ static void keyboardHandleKeymap(void* data,
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
                        "Wayland: Failed to create XKB state");
-        xkb_map_unref(keymap);
+        xkb_keymap_unref(keymap);
        return;
    }

+    // Look up the preferred locale, falling back to "C" as default.
+    locale = getenv("LC_ALL");
+    if (!locale)
+        locale = getenv("LC_CTYPE");
+    if (!locale)
+        locale = getenv("LANG");
+    if (!locale)
+        locale = "C";
+
+    composeTable =
+        xkb_compose_table_new_from_locale(_glfw.wl.xkb.context, locale,
+                                          XKB_COMPOSE_COMPILE_NO_FLAGS);
+    if (composeTable)
+    {
+        composeState =
+            xkb_compose_state_new(composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
+        xkb_compose_table_unref(composeTable);
+        if (composeState)
+            _glfw.wl.xkb.composeState = composeState;
+        else
+            _glfwInputError(GLFW_PLATFORM_ERROR,
+                            "Wayland: Failed to create XKB compose state");
+    }
+    else
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: Failed to create XKB compose table");
+    }
+
    xkb_keymap_unref(_glfw.wl.xkb.keymap);
    xkb_state_unref(_glfw.wl.xkb.state);
    _glfw.wl.xkb.keymap = keymap;
    _glfw.wl.xkb.state = state;

-    _glfw.wl.xkb.control_mask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Control");
-    _glfw.wl.xkb.alt_mask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
-    _glfw.wl.xkb.shift_mask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
-    _glfw.wl.xkb.super_mask =
-        1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
+    _glfw.wl.xkb.controlMask =
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Control");
+    _glfw.wl.xkb.altMask =
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
+    _glfw.wl.xkb.shiftMask =
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
+    _glfw.wl.xkb.superMask =
+        1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
 }

 static void keyboardHandleEnter(void* data,
@@ -252,12 +284,55 @@ static void keyboardHandleLeave(void* data,

 static int toGLFWKeyCode(uint32_t key)
 {
-    if (key < sizeof(_glfw.wl.publicKeys) / sizeof(_glfw.wl.publicKeys[0]))
-        return _glfw.wl.publicKeys[key];
+    if (key < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
+        return _glfw.wl.keycodes[key];

    return GLFW_KEY_UNKNOWN;
 }

+static xkb_keysym_t composeSymbol(xkb_keysym_t sym)
+{
+    if (sym == XKB_KEY_NoSymbol)
+        return sym;
+    if (xkb_compose_state_feed(_glfw.wl.xkb.composeState, sym)
+            != XKB_COMPOSE_FEED_ACCEPTED)
+        return sym;
+    switch (xkb_compose_state_get_status(_glfw.wl.xkb.composeState))
+    {
+        case XKB_COMPOSE_COMPOSED:
+            return xkb_compose_state_get_one_sym(_glfw.wl.xkb.composeState);
+        case XKB_COMPOSE_COMPOSING:
+        case XKB_COMPOSE_CANCELLED:
+            return XKB_KEY_NoSymbol;
+        case XKB_COMPOSE_NOTHING:
+        default:
+            return sym;
+    }
+}
+
+static void inputChar(_GLFWwindow* window, uint32_t key)
+{
+    uint32_t code, numSyms;
+    long cp;
+    const xkb_keysym_t *syms;
+    xkb_keysym_t sym;
+
+    code = key + 8;
+    numSyms = xkb_state_key_get_syms(_glfw.wl.xkb.state, code, &syms);
+
+    if (numSyms == 1)
+    {
+        sym = composeSymbol(syms[0]);
+        cp = _glfwKeySym2Unicode(sym);
+        if (cp != -1)
+        {
+            const int mods = _glfw.wl.xkb.modifiers;
+            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
+            _glfwInputChar(window, cp, mods, plain);
+        }
+    }
+}
+
 static void keyboardHandleKey(void* data,
                              struct wl_keyboard* keyboard,
                              uint32_t serial,
@@ -265,11 +340,8 @@ static void keyboardHandleKey(void* data,
                              uint32_t key,
                              uint32_t state)
 {
-    uint32_t code, num_syms;
-    long cp;
    int keyCode;
    int action;
-    const xkb_keysym_t *syms;
    _GLFWwindow* window = _glfw.wl.keyboardFocus;

    if (!window)
@@ -282,19 +354,8 @@ static void keyboardHandleKey(void* data,
    _glfwInputKey(window, keyCode, key, action,
                  _glfw.wl.xkb.modifiers);

-    code = key + 8;
-    num_syms = xkb_key_get_syms(_glfw.wl.xkb.state, code, &syms);
-
-    if (num_syms == 1)
-    {
-        cp = _glfwKeySym2Unicode(syms[0]);
-        if (cp != -1)
-        {
-            const int mods = _glfw.wl.xkb.modifiers;
-            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
-            _glfwInputChar(window, cp, mods, plain);
-        }
-    }
+    if (action == GLFW_PRESS)
+        inputChar(window, key);
 }

 static void keyboardHandleModifiers(void* data,
@@ -320,15 +381,17 @@ static void keyboardHandleModifiers(void* data,
                          group);

    mask = xkb_state_serialize_mods(_glfw.wl.xkb.state,
-                                    XKB_STATE_DEPRESSED |
-                                    XKB_STATE_LATCHED);
-    if (mask & _glfw.wl.xkb.control_mask)
+                                    XKB_STATE_MODS_DEPRESSED |
+                                    XKB_STATE_LAYOUT_DEPRESSED |
+                                    XKB_STATE_MODS_LATCHED |
+                                    XKB_STATE_LAYOUT_LATCHED);
+    if (mask & _glfw.wl.xkb.controlMask)
        modifiers |= GLFW_MOD_CONTROL;
-    if (mask & _glfw.wl.xkb.alt_mask)
+    if (mask & _glfw.wl.xkb.altMask)
        modifiers |= GLFW_MOD_ALT;
-    if (mask & _glfw.wl.xkb.shift_mask)
+    if (mask & _glfw.wl.xkb.shiftMask)
        modifiers |= GLFW_MOD_SHIFT;
-    if (mask & _glfw.wl.xkb.super_mask)
+    if (mask & _glfw.wl.xkb.superMask)
        modifiers |= GLFW_MOD_SUPER;
    _glfw.wl.xkb.modifiers = modifiers;
 }
@@ -380,10 +443,10 @@ static void registryHandleGlobal(void* data,
 {
    if (strcmp(interface, "wl_compositor") == 0)
    {
-        _glfw.wl.wl_compositor_version = min(3, version);
+        _glfw.wl.compositorVersion = min(3, version);
        _glfw.wl.compositor =
            wl_registry_bind(registry, name, &wl_compositor_interface,
-                             _glfw.wl.wl_compositor_version);
+                             _glfw.wl.compositorVersion);
    }
    else if (strcmp(interface, "wl_shm") == 0)
    {
@@ -440,124 +503,133 @@ static const struct wl_registry_listener registryListener = {
 //
 static void createKeyTables(void)
 {
-    memset(_glfw.wl.publicKeys, -1, sizeof(_glfw.wl.publicKeys));
+    int scancode;

-    _glfw.wl.publicKeys[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
-    _glfw.wl.publicKeys[KEY_1]          = GLFW_KEY_1;
-    _glfw.wl.publicKeys[KEY_2]          = GLFW_KEY_2;
-    _glfw.wl.publicKeys[KEY_3]          = GLFW_KEY_3;
-    _glfw.wl.publicKeys[KEY_4]          = GLFW_KEY_4;
-    _glfw.wl.publicKeys[KEY_5]          = GLFW_KEY_5;
-    _glfw.wl.publicKeys[KEY_6]          = GLFW_KEY_6;
-    _glfw.wl.publicKeys[KEY_7]          = GLFW_KEY_7;
-    _glfw.wl.publicKeys[KEY_8]          = GLFW_KEY_8;
-    _glfw.wl.publicKeys[KEY_9]          = GLFW_KEY_9;
-    _glfw.wl.publicKeys[KEY_0]          = GLFW_KEY_0;
-    _glfw.wl.publicKeys[KEY_MINUS]      = GLFW_KEY_MINUS;
-    _glfw.wl.publicKeys[KEY_EQUAL]      = GLFW_KEY_EQUAL;
-    _glfw.wl.publicKeys[KEY_Q]          = GLFW_KEY_Q;
-    _glfw.wl.publicKeys[KEY_W]          = GLFW_KEY_W;
-    _glfw.wl.publicKeys[KEY_E]          = GLFW_KEY_E;
-    _glfw.wl.publicKeys[KEY_R]          = GLFW_KEY_R;
-    _glfw.wl.publicKeys[KEY_T]          = GLFW_KEY_T;
-    _glfw.wl.publicKeys[KEY_Y]          = GLFW_KEY_Y;
-    _glfw.wl.publicKeys[KEY_U]          = GLFW_KEY_U;
-    _glfw.wl.publicKeys[KEY_I]          = GLFW_KEY_I;
-    _glfw.wl.publicKeys[KEY_O]          = GLFW_KEY_O;
-    _glfw.wl.publicKeys[KEY_P]          = GLFW_KEY_P;
-    _glfw.wl.publicKeys[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
-    _glfw.wl.publicKeys[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
-    _glfw.wl.publicKeys[KEY_A]          = GLFW_KEY_A;
-    _glfw.wl.publicKeys[KEY_S]          = GLFW_KEY_S;
-    _glfw.wl.publicKeys[KEY_D]          = GLFW_KEY_D;
-    _glfw.wl.publicKeys[KEY_F]          = GLFW_KEY_F;
-    _glfw.wl.publicKeys[KEY_G]          = GLFW_KEY_G;
-    _glfw.wl.publicKeys[KEY_H]          = GLFW_KEY_H;
-    _glfw.wl.publicKeys[KEY_J]          = GLFW_KEY_J;
-    _glfw.wl.publicKeys[KEY_K]          = GLFW_KEY_K;
-    _glfw.wl.publicKeys[KEY_L]          = GLFW_KEY_L;
-    _glfw.wl.publicKeys[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
-    _glfw.wl.publicKeys[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
-    _glfw.wl.publicKeys[KEY_Z]          = GLFW_KEY_Z;
-    _glfw.wl.publicKeys[KEY_X]          = GLFW_KEY_X;
-    _glfw.wl.publicKeys[KEY_C]          = GLFW_KEY_C;
-    _glfw.wl.publicKeys[KEY_V]          = GLFW_KEY_V;
-    _glfw.wl.publicKeys[KEY_B]          = GLFW_KEY_B;
-    _glfw.wl.publicKeys[KEY_N]          = GLFW_KEY_N;
-    _glfw.wl.publicKeys[KEY_M]          = GLFW_KEY_M;
-    _glfw.wl.publicKeys[KEY_COMMA]      = GLFW_KEY_COMMA;
-    _glfw.wl.publicKeys[KEY_DOT]        = GLFW_KEY_PERIOD;
-    _glfw.wl.publicKeys[KEY_SLASH]      = GLFW_KEY_SLASH;
-    _glfw.wl.publicKeys[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
-    _glfw.wl.publicKeys[KEY_ESC]        = GLFW_KEY_ESCAPE;
-    _glfw.wl.publicKeys[KEY_TAB]        = GLFW_KEY_TAB;
-    _glfw.wl.publicKeys[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
-    _glfw.wl.publicKeys[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
-    _glfw.wl.publicKeys[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
-    _glfw.wl.publicKeys[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
-    _glfw.wl.publicKeys[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
-    _glfw.wl.publicKeys[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
-    _glfw.wl.publicKeys[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
-    _glfw.wl.publicKeys[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
-    _glfw.wl.publicKeys[KEY_MENU]       = GLFW_KEY_MENU;
-    _glfw.wl.publicKeys[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
-    _glfw.wl.publicKeys[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
-    _glfw.wl.publicKeys[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
-    _glfw.wl.publicKeys[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
-    _glfw.wl.publicKeys[KEY_PAUSE]      = GLFW_KEY_PAUSE;
-    _glfw.wl.publicKeys[KEY_DELETE]     = GLFW_KEY_DELETE;
-    _glfw.wl.publicKeys[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
-    _glfw.wl.publicKeys[KEY_ENTER]      = GLFW_KEY_ENTER;
-    _glfw.wl.publicKeys[KEY_HOME]       = GLFW_KEY_HOME;
-    _glfw.wl.publicKeys[KEY_END]        = GLFW_KEY_END;
-    _glfw.wl.publicKeys[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
-    _glfw.wl.publicKeys[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
-    _glfw.wl.publicKeys[KEY_INSERT]     = GLFW_KEY_INSERT;
-    _glfw.wl.publicKeys[KEY_LEFT]       = GLFW_KEY_LEFT;
-    _glfw.wl.publicKeys[KEY_RIGHT]      = GLFW_KEY_RIGHT;
-    _glfw.wl.publicKeys[KEY_DOWN]       = GLFW_KEY_DOWN;
-    _glfw.wl.publicKeys[KEY_UP]         = GLFW_KEY_UP;
-    _glfw.wl.publicKeys[KEY_F1]         = GLFW_KEY_F1;
-    _glfw.wl.publicKeys[KEY_F2]         = GLFW_KEY_F2;
-    _glfw.wl.publicKeys[KEY_F3]         = GLFW_KEY_F3;
-    _glfw.wl.publicKeys[KEY_F4]         = GLFW_KEY_F4;
-    _glfw.wl.publicKeys[KEY_F5]         = GLFW_KEY_F5;
-    _glfw.wl.publicKeys[KEY_F6]         = GLFW_KEY_F6;
-    _glfw.wl.publicKeys[KEY_F7]         = GLFW_KEY_F7;
-    _glfw.wl.publicKeys[KEY_F8]         = GLFW_KEY_F8;
-    _glfw.wl.publicKeys[KEY_F9]         = GLFW_KEY_F9;
-    _glfw.wl.publicKeys[KEY_F10]        = GLFW_KEY_F10;
-    _glfw.wl.publicKeys[KEY_F11]        = GLFW_KEY_F11;
-    _glfw.wl.publicKeys[KEY_F12]        = GLFW_KEY_F12;
-    _glfw.wl.publicKeys[KEY_F13]        = GLFW_KEY_F13;
-    _glfw.wl.publicKeys[KEY_F14]        = GLFW_KEY_F14;
-    _glfw.wl.publicKeys[KEY_F15]        = GLFW_KEY_F15;
-    _glfw.wl.publicKeys[KEY_F16]        = GLFW_KEY_F16;
-    _glfw.wl.publicKeys[KEY_F17]        = GLFW_KEY_F17;
-    _glfw.wl.publicKeys[KEY_F18]        = GLFW_KEY_F18;
-    _glfw.wl.publicKeys[KEY_F19]        = GLFW_KEY_F19;
-    _glfw.wl.publicKeys[KEY_F20]        = GLFW_KEY_F20;
-    _glfw.wl.publicKeys[KEY_F21]        = GLFW_KEY_F21;
-    _glfw.wl.publicKeys[KEY_F22]        = GLFW_KEY_F22;
-    _glfw.wl.publicKeys[KEY_F23]        = GLFW_KEY_F23;
-    _glfw.wl.publicKeys[KEY_F24]        = GLFW_KEY_F24;
-    _glfw.wl.publicKeys[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
-    _glfw.wl.publicKeys[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
-    _glfw.wl.publicKeys[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
-    _glfw.wl.publicKeys[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
-    _glfw.wl.publicKeys[KEY_KP0]        = GLFW_KEY_KP_0;
-    _glfw.wl.publicKeys[KEY_KP1]        = GLFW_KEY_KP_1;
-    _glfw.wl.publicKeys[KEY_KP2]        = GLFW_KEY_KP_2;
-    _glfw.wl.publicKeys[KEY_KP3]        = GLFW_KEY_KP_3;
-    _glfw.wl.publicKeys[KEY_KP4]        = GLFW_KEY_KP_4;
-    _glfw.wl.publicKeys[KEY_KP5]        = GLFW_KEY_KP_5;
-    _glfw.wl.publicKeys[KEY_KP6]        = GLFW_KEY_KP_6;
-    _glfw.wl.publicKeys[KEY_KP7]        = GLFW_KEY_KP_7;
-    _glfw.wl.publicKeys[KEY_KP8]        = GLFW_KEY_KP_8;
-    _glfw.wl.publicKeys[KEY_KP9]        = GLFW_KEY_KP_9;
-    _glfw.wl.publicKeys[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
-    _glfw.wl.publicKeys[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
-    _glfw.wl.publicKeys[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+    memset(_glfw.wl.keycodes, -1, sizeof(_glfw.wl.keycodes));
+    memset(_glfw.wl.scancodes, -1, sizeof(_glfw.wl.scancodes));
+
+    _glfw.wl.keycodes[KEY_GRAVE]      = GLFW_KEY_GRAVE_ACCENT;
+    _glfw.wl.keycodes[KEY_1]          = GLFW_KEY_1;
+    _glfw.wl.keycodes[KEY_2]          = GLFW_KEY_2;
+    _glfw.wl.keycodes[KEY_3]          = GLFW_KEY_3;
+    _glfw.wl.keycodes[KEY_4]          = GLFW_KEY_4;
+    _glfw.wl.keycodes[KEY_5]          = GLFW_KEY_5;
+    _glfw.wl.keycodes[KEY_6]          = GLFW_KEY_6;
+    _glfw.wl.keycodes[KEY_7]          = GLFW_KEY_7;
+    _glfw.wl.keycodes[KEY_8]          = GLFW_KEY_8;
+    _glfw.wl.keycodes[KEY_9]          = GLFW_KEY_9;
+    _glfw.wl.keycodes[KEY_0]          = GLFW_KEY_0;
+    _glfw.wl.keycodes[KEY_MINUS]      = GLFW_KEY_MINUS;
+    _glfw.wl.keycodes[KEY_EQUAL]      = GLFW_KEY_EQUAL;
+    _glfw.wl.keycodes[KEY_Q]          = GLFW_KEY_Q;
+    _glfw.wl.keycodes[KEY_W]          = GLFW_KEY_W;
+    _glfw.wl.keycodes[KEY_E]          = GLFW_KEY_E;
+    _glfw.wl.keycodes[KEY_R]          = GLFW_KEY_R;
+    _glfw.wl.keycodes[KEY_T]          = GLFW_KEY_T;
+    _glfw.wl.keycodes[KEY_Y]          = GLFW_KEY_Y;
+    _glfw.wl.keycodes[KEY_U]          = GLFW_KEY_U;
+    _glfw.wl.keycodes[KEY_I]          = GLFW_KEY_I;
+    _glfw.wl.keycodes[KEY_O]          = GLFW_KEY_O;
+    _glfw.wl.keycodes[KEY_P]          = GLFW_KEY_P;
+    _glfw.wl.keycodes[KEY_LEFTBRACE]  = GLFW_KEY_LEFT_BRACKET;
+    _glfw.wl.keycodes[KEY_RIGHTBRACE] = GLFW_KEY_RIGHT_BRACKET;
+    _glfw.wl.keycodes[KEY_A]          = GLFW_KEY_A;
+    _glfw.wl.keycodes[KEY_S]          = GLFW_KEY_S;
+    _glfw.wl.keycodes[KEY_D]          = GLFW_KEY_D;
+    _glfw.wl.keycodes[KEY_F]          = GLFW_KEY_F;
+    _glfw.wl.keycodes[KEY_G]          = GLFW_KEY_G;
+    _glfw.wl.keycodes[KEY_H]          = GLFW_KEY_H;
+    _glfw.wl.keycodes[KEY_J]          = GLFW_KEY_J;
+    _glfw.wl.keycodes[KEY_K]          = GLFW_KEY_K;
+    _glfw.wl.keycodes[KEY_L]          = GLFW_KEY_L;
+    _glfw.wl.keycodes[KEY_SEMICOLON]  = GLFW_KEY_SEMICOLON;
+    _glfw.wl.keycodes[KEY_APOSTROPHE] = GLFW_KEY_APOSTROPHE;
+    _glfw.wl.keycodes[KEY_Z]          = GLFW_KEY_Z;
+    _glfw.wl.keycodes[KEY_X]          = GLFW_KEY_X;
+    _glfw.wl.keycodes[KEY_C]          = GLFW_KEY_C;
+    _glfw.wl.keycodes[KEY_V]          = GLFW_KEY_V;
+    _glfw.wl.keycodes[KEY_B]          = GLFW_KEY_B;
+    _glfw.wl.keycodes[KEY_N]          = GLFW_KEY_N;
+    _glfw.wl.keycodes[KEY_M]          = GLFW_KEY_M;
+    _glfw.wl.keycodes[KEY_COMMA]      = GLFW_KEY_COMMA;
+    _glfw.wl.keycodes[KEY_DOT]        = GLFW_KEY_PERIOD;
+    _glfw.wl.keycodes[KEY_SLASH]      = GLFW_KEY_SLASH;
+    _glfw.wl.keycodes[KEY_BACKSLASH]  = GLFW_KEY_BACKSLASH;
+    _glfw.wl.keycodes[KEY_ESC]        = GLFW_KEY_ESCAPE;
+    _glfw.wl.keycodes[KEY_TAB]        = GLFW_KEY_TAB;
+    _glfw.wl.keycodes[KEY_LEFTSHIFT]  = GLFW_KEY_LEFT_SHIFT;
+    _glfw.wl.keycodes[KEY_RIGHTSHIFT] = GLFW_KEY_RIGHT_SHIFT;
+    _glfw.wl.keycodes[KEY_LEFTCTRL]   = GLFW_KEY_LEFT_CONTROL;
+    _glfw.wl.keycodes[KEY_RIGHTCTRL]  = GLFW_KEY_RIGHT_CONTROL;
+    _glfw.wl.keycodes[KEY_LEFTALT]    = GLFW_KEY_LEFT_ALT;
+    _glfw.wl.keycodes[KEY_RIGHTALT]   = GLFW_KEY_RIGHT_ALT;
+    _glfw.wl.keycodes[KEY_LEFTMETA]   = GLFW_KEY_LEFT_SUPER;
+    _glfw.wl.keycodes[KEY_RIGHTMETA]  = GLFW_KEY_RIGHT_SUPER;
+    _glfw.wl.keycodes[KEY_MENU]       = GLFW_KEY_MENU;
+    _glfw.wl.keycodes[KEY_NUMLOCK]    = GLFW_KEY_NUM_LOCK;
+    _glfw.wl.keycodes[KEY_CAPSLOCK]   = GLFW_KEY_CAPS_LOCK;
+    _glfw.wl.keycodes[KEY_PRINT]      = GLFW_KEY_PRINT_SCREEN;
+    _glfw.wl.keycodes[KEY_SCROLLLOCK] = GLFW_KEY_SCROLL_LOCK;
+    _glfw.wl.keycodes[KEY_PAUSE]      = GLFW_KEY_PAUSE;
+    _glfw.wl.keycodes[KEY_DELETE]     = GLFW_KEY_DELETE;
+    _glfw.wl.keycodes[KEY_BACKSPACE]  = GLFW_KEY_BACKSPACE;
+    _glfw.wl.keycodes[KEY_ENTER]      = GLFW_KEY_ENTER;
+    _glfw.wl.keycodes[KEY_HOME]       = GLFW_KEY_HOME;
+    _glfw.wl.keycodes[KEY_END]        = GLFW_KEY_END;
+    _glfw.wl.keycodes[KEY_PAGEUP]     = GLFW_KEY_PAGE_UP;
+    _glfw.wl.keycodes[KEY_PAGEDOWN]   = GLFW_KEY_PAGE_DOWN;
+    _glfw.wl.keycodes[KEY_INSERT]     = GLFW_KEY_INSERT;
+    _glfw.wl.keycodes[KEY_LEFT]       = GLFW_KEY_LEFT;
+    _glfw.wl.keycodes[KEY_RIGHT]      = GLFW_KEY_RIGHT;
+    _glfw.wl.keycodes[KEY_DOWN]       = GLFW_KEY_DOWN;
+    _glfw.wl.keycodes[KEY_UP]         = GLFW_KEY_UP;
+    _glfw.wl.keycodes[KEY_F1]         = GLFW_KEY_F1;
+    _glfw.wl.keycodes[KEY_F2]         = GLFW_KEY_F2;
+    _glfw.wl.keycodes[KEY_F3]         = GLFW_KEY_F3;
+    _glfw.wl.keycodes[KEY_F4]         = GLFW_KEY_F4;
+    _glfw.wl.keycodes[KEY_F5]         = GLFW_KEY_F5;
+    _glfw.wl.keycodes[KEY_F6]         = GLFW_KEY_F6;
+    _glfw.wl.keycodes[KEY_F7]         = GLFW_KEY_F7;
+    _glfw.wl.keycodes[KEY_F8]         = GLFW_KEY_F8;
+    _glfw.wl.keycodes[KEY_F9]         = GLFW_KEY_F9;
+    _glfw.wl.keycodes[KEY_F10]        = GLFW_KEY_F10;
+    _glfw.wl.keycodes[KEY_F11]        = GLFW_KEY_F11;
+    _glfw.wl.keycodes[KEY_F12]        = GLFW_KEY_F12;
+    _glfw.wl.keycodes[KEY_F13]        = GLFW_KEY_F13;
+    _glfw.wl.keycodes[KEY_F14]        = GLFW_KEY_F14;
+    _glfw.wl.keycodes[KEY_F15]        = GLFW_KEY_F15;
+    _glfw.wl.keycodes[KEY_F16]        = GLFW_KEY_F16;
+    _glfw.wl.keycodes[KEY_F17]        = GLFW_KEY_F17;
+    _glfw.wl.keycodes[KEY_F18]        = GLFW_KEY_F18;
+    _glfw.wl.keycodes[KEY_F19]        = GLFW_KEY_F19;
+    _glfw.wl.keycodes[KEY_F20]        = GLFW_KEY_F20;
+    _glfw.wl.keycodes[KEY_F21]        = GLFW_KEY_F21;
+    _glfw.wl.keycodes[KEY_F22]        = GLFW_KEY_F22;
+    _glfw.wl.keycodes[KEY_F23]        = GLFW_KEY_F23;
+    _glfw.wl.keycodes[KEY_F24]        = GLFW_KEY_F24;
+    _glfw.wl.keycodes[KEY_KPSLASH]    = GLFW_KEY_KP_DIVIDE;
+    _glfw.wl.keycodes[KEY_KPDOT]      = GLFW_KEY_KP_MULTIPLY;
+    _glfw.wl.keycodes[KEY_KPMINUS]    = GLFW_KEY_KP_SUBTRACT;
+    _glfw.wl.keycodes[KEY_KPPLUS]     = GLFW_KEY_KP_ADD;
+    _glfw.wl.keycodes[KEY_KP0]        = GLFW_KEY_KP_0;
+    _glfw.wl.keycodes[KEY_KP1]        = GLFW_KEY_KP_1;
+    _glfw.wl.keycodes[KEY_KP2]        = GLFW_KEY_KP_2;
+    _glfw.wl.keycodes[KEY_KP3]        = GLFW_KEY_KP_3;
+    _glfw.wl.keycodes[KEY_KP4]        = GLFW_KEY_KP_4;
+    _glfw.wl.keycodes[KEY_KP5]        = GLFW_KEY_KP_5;
+    _glfw.wl.keycodes[KEY_KP6]        = GLFW_KEY_KP_6;
+    _glfw.wl.keycodes[KEY_KP7]        = GLFW_KEY_KP_7;
+    _glfw.wl.keycodes[KEY_KP8]        = GLFW_KEY_KP_8;
+    _glfw.wl.keycodes[KEY_KP9]        = GLFW_KEY_KP_9;
+    _glfw.wl.keycodes[KEY_KPCOMMA]    = GLFW_KEY_KP_DECIMAL;
+    _glfw.wl.keycodes[KEY_KPEQUAL]    = GLFW_KEY_KP_EQUAL;
+    _glfw.wl.keycodes[KEY_KPENTER]    = GLFW_KEY_KP_ENTER;
+
+    for (scancode = 0;  scancode < 256;  scancode++)
+    {
+        if (_glfw.wl.keycodes[scancode] > 0)
+            _glfw.wl.scancodes[_glfw.wl.keycodes[scancode]] = scancode;
+    }
 }


@@ -627,16 +699,38 @@ void _glfwPlatformTerminate(void)
    _glfwTerminateJoysticksLinux();
    _glfwTerminateThreadLocalStoragePOSIX();

+    xkb_compose_state_unref(_glfw.wl.xkb.composeState);
+    xkb_keymap_unref(_glfw.wl.xkb.keymap);
+    xkb_state_unref(_glfw.wl.xkb.state);
+    xkb_context_unref(_glfw.wl.xkb.context);
+
    if (_glfw.wl.cursorTheme)
        wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
    if (_glfw.wl.cursorSurface)
        wl_surface_destroy(_glfw.wl.cursorSurface);
+    if (_glfw.wl.compositor)
+        wl_compositor_destroy(_glfw.wl.compositor);
+    if (_glfw.wl.shm)
+        wl_shm_destroy(_glfw.wl.shm);
+    if (_glfw.wl.shell)
+        wl_shell_destroy(_glfw.wl.shell);
+    if (_glfw.wl.pointer)
+        wl_pointer_destroy(_glfw.wl.pointer);
+    if (_glfw.wl.keyboard)
+        wl_keyboard_destroy(_glfw.wl.keyboard);
+    if (_glfw.wl.seat)
+        wl_seat_destroy(_glfw.wl.seat);
+    if (_glfw.wl.relativePointerManager)
+        zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
+    if (_glfw.wl.pointerConstraints)
+        zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
    if (_glfw.wl.registry)
        wl_registry_destroy(_glfw.wl.registry);
    if (_glfw.wl.display)
+    {
        wl_display_flush(_glfw.wl.display);
-    if (_glfw.wl.display)
        wl_display_disconnect(_glfw.wl.display);
+    }
 }

 const char* _glfwPlatformGetVersionString(void)
@@ -50,11 +50,21 @@ static void geometry(void* data,
                     int32_t transform)
 {
    struct _GLFWmonitor *monitor = data;
+    char* name;
+    size_t nameLength;

    monitor->wl.x = x;
    monitor->wl.y = y;
    monitor->widthMM = physicalWidth;
    monitor->heightMM = physicalHeight;
+
+    nameLength = strlen(make) + 1 + strlen(model) + 1;
+    name = realloc(monitor->name, nameLength);
+    if (name)
+    {
+        sprintf(name, "%s %s", make, model);
+        monitor->name = name;
+    }
 }

 static void mode(void* data,
@@ -102,7 +112,7 @@ static void scale(void* data,
    monitor->wl.scale = factor;
 }

-static const struct wl_output_listener output_listener = {
+static const struct wl_output_listener outputListener = {
    geometry,
    mode,
    done,
@@ -118,10 +128,6 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
 {
    _GLFWmonitor *monitor;
    struct wl_output *output;
-    char name_str[80];
-
-    memset(name_str, 0, sizeof(name_str));
-    snprintf(name_str, 79, "wl_output@%u", name);

    if (version < 2)
    {
@@ -130,7 +136,8 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
        return;
    }

-    monitor = _glfwAllocMonitor(name_str, 0, 0);
+    // The actual name of this output will be set in the geometry handler.
+    monitor = _glfwAllocMonitor(NULL, 0, 0);

    output = wl_registry_bind(_glfw.wl.registry,
                              name,
@@ -148,7 +155,7 @@ void _glfwAddOutputWayland(uint32_t name, uint32_t version)
    monitor->wl.scale = 1;

    monitor->wl.output = output;
-    wl_output_add_listener(output, &output_listener, monitor);
+    wl_output_add_listener(output, &outputListener, monitor);

    if (_glfw.wl.monitorsCount + 1 >= _glfw.wl.monitorsSize)
    {
@@ -29,6 +29,7 @@

 #include <wayland-client.h>
 #include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-compose.h>
 #include <dlfcn.h>

 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
@@ -83,7 +84,7 @@ typedef struct _GLFWwindowWayland
    GLFWbool                    maximized;
    struct wl_surface*          surface;
    struct wl_egl_window*       native;
-    struct wl_shell_surface*    shell_surface;
+    struct wl_shell_surface*    shellSurface;
    struct wl_callback*         callback;

    _GLFWcursor*                currentCursor;
@@ -119,7 +120,7 @@ typedef struct _GLFWlibraryWayland
    struct zwp_relative_pointer_manager_v1* relativePointerManager;
    struct zwp_pointer_constraints_v1*      pointerConstraints;

-    int                         wl_compositor_version;
+    int                         compositorVersion;

    struct wl_cursor_theme*     cursorTheme;
    struct wl_surface*          cursorSurface;
@@ -129,16 +130,18 @@ typedef struct _GLFWlibraryWayland
    int                         monitorsCount;
    int                         monitorsSize;

-    short int                   publicKeys[256];
+    short int                   keycodes[256];
+    short int                   scancodes[GLFW_KEY_LAST + 1];

    struct {
        struct xkb_context*     context;
        struct xkb_keymap*      keymap;
        struct xkb_state*       state;
-        xkb_mod_mask_t          control_mask;
-        xkb_mod_mask_t          alt_mask;
-        xkb_mod_mask_t          shift_mask;
-        xkb_mod_mask_t          super_mask;
+        struct xkb_compose_state* composeState;
+        xkb_mod_mask_t          controlMask;
+        xkb_mod_mask_t          altMask;
+        xkb_mod_mask_t          shiftMask;
+        xkb_mod_mask_t          superMask;
        unsigned int            modifiers;
    } xkb;

@@ -105,7 +105,7 @@ static void checkScaleChange(_GLFWwindow* window)
    int monitorScale;

    // Check if we will be able to set the buffer scale or not.
-    if (_glfw.wl.wl_compositor_version < 3)
+    if (_glfw.wl.compositorVersion < 3)
        return;

    // Get the scale factor from the highest scale monitor.
@@ -220,33 +220,33 @@ static GLFWbool createSurface(_GLFWwindow* window,

 static GLFWbool createShellSurface(_GLFWwindow* window)
 {
-    window->wl.shell_surface = wl_shell_get_shell_surface(_glfw.wl.shell,
-                                                          window->wl.surface);
-    if (!window->wl.shell_surface)
+    window->wl.shellSurface = wl_shell_get_shell_surface(_glfw.wl.shell,
+                                                         window->wl.surface);
+    if (!window->wl.shellSurface)
        return GLFW_FALSE;

-    wl_shell_surface_add_listener(window->wl.shell_surface,
+    wl_shell_surface_add_listener(window->wl.shellSurface,
                                  &shellSurfaceListener,
                                  window);

    if (window->wl.title)
-        wl_shell_surface_set_title(window->wl.shell_surface, window->wl.title);
+        wl_shell_surface_set_title(window->wl.shellSurface, window->wl.title);

    if (window->monitor)
    {
        wl_shell_surface_set_fullscreen(
-            window->wl.shell_surface,
+            window->wl.shellSurface,
            WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
            0,
            window->monitor->wl.output);
    }
    else if (window->wl.maximized)
    {
-        wl_shell_surface_set_maximized(window->wl.shell_surface, NULL);
+        wl_shell_surface_set_maximized(window->wl.shellSurface, NULL);
    }
    else
    {
-        wl_shell_surface_set_toplevel(window->wl.shell_surface);
+        wl_shell_surface_set_toplevel(window->wl.shellSurface);
    }

    return GLFW_TRUE;
@@ -411,7 +411,7 @@ int _glfwPlatformCreateWindow(_GLFWwindow* window,
    }
    else
    {
-        window->wl.shell_surface = NULL;
+        window->wl.shellSurface = NULL;
        window->wl.visible = GLFW_FALSE;
    }

@@ -443,8 +443,8 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)
    if (window->wl.native)
        wl_egl_window_destroy(window->wl.native);

-    if (window->wl.shell_surface)
-        wl_shell_surface_destroy(window->wl.shell_surface);
+    if (window->wl.shellSurface)
+        wl_shell_surface_destroy(window->wl.shellSurface);

    if (window->wl.surface)
        wl_surface_destroy(window->wl.surface);
@@ -458,8 +458,8 @@ void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
    if (window->wl.title)
        free(window->wl.title);
    window->wl.title = strdup(title);
-    if (window->wl.shell_surface)
-        wl_shell_surface_set_title(window->wl.shell_surface, title);
+    if (window->wl.shellSurface)
+        wl_shell_surface_set_title(window->wl.shellSurface, title);
 }

 void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
@@ -546,8 +546,8 @@ void _glfwPlatformRestoreWindow(_GLFWwindow* window)
    // TODO: also do the same for iconified.
    if (window->monitor || window->wl.maximized)
    {
-        if (window->wl.shell_surface)
-            wl_shell_surface_set_toplevel(window->wl.shell_surface);
+        if (window->wl.shellSurface)
+            wl_shell_surface_set_toplevel(window->wl.shellSurface);

        window->wl.maximized = GLFW_FALSE;
    }
@@ -557,10 +557,10 @@ void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
 {
    if (!window->monitor && !window->wl.maximized)
    {
-        if (window->wl.shell_surface)
+        if (window->wl.shellSurface)
        {
            // Let the compositor select the best output.
-            wl_shell_surface_set_maximized(window->wl.shell_surface, NULL);
+            wl_shell_surface_set_maximized(window->wl.shellSurface, NULL);
        }
        window->wl.maximized = GLFW_TRUE;
    }
@@ -570,7 +570,7 @@ void _glfwPlatformShowWindow(_GLFWwindow* window)
 {
    if (!window->monitor)
    {
-        if (!window->wl.shell_surface)
+        if (!window->wl.shellSurface)
            createShellSurface(window);
        window->wl.visible = GLFW_TRUE;
    }
@@ -580,8 +580,8 @@ void _glfwPlatformHideWindow(_GLFWwindow* window)
 {
    if (!window->monitor)
    {
-        if (window->wl.shell_surface)
-            wl_shell_surface_destroy(window->wl.shell_surface);
+        if (window->wl.shellSurface)
+            wl_shell_surface_destroy(window->wl.shellSurface);
        window->wl.visible = GLFW_FALSE;
    }
 }
@@ -601,14 +601,14 @@ void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
    if (monitor)
    {
        wl_shell_surface_set_fullscreen(
-            window->wl.shell_surface,
+            window->wl.shellSurface,
            WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
            refreshRate * 1000, // Convert Hz to mHz.
            monitor->wl.output);
    }
    else
    {
-        wl_shell_surface_set_toplevel(window->wl.shell_surface);
+        wl_shell_surface_set_toplevel(window->wl.shellSurface);
    }
    _glfwInputWindowMonitorChange(window, monitor);
 }
@@ -634,6 +634,27 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
    return window->wl.maximized;
 }

+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attribute setting not implemented yet");
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attribute setting not implemented yet");
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    // TODO
+    _glfwInputError(GLFW_PLATFORM_ERROR,
+                    "Wayland: Window attribute setting not implemented yet");
+}
+
 void _glfwPlatformPollEvents(void)
 {
    handleEvents(0);
@@ -686,6 +707,11 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
    return NULL;
 }

+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.wl.scancodes[key];
+}
+
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                              const GLFWimage* image,
                              int xhot, int yhot)
@@ -960,21 +986,13 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
    return NULL;
 }

-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    char** extensions;
+    if (!_glfw.vk.KHR_surface || !_glfw.vk.KHR_wayland_surface)
+        return;

-    *count = 0;
-
-    if (!_glfw.vk.KHR_wayland_surface)
-        return NULL;
-
-    extensions = calloc(2, sizeof(char*));
-    extensions[0] = strdup("VK_KHR_surface");
-    extensions[1] = strdup("VK_KHR_wayland_surface");
-
-    *count = 2;
-    return extensions;
+    extensions[0] = "VK_KHR_surface";
+    extensions[1] = "VK_KHR_wayland_surface";
 }

 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
@@ -2,7 +2,7 @@
 // GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -232,8 +232,8 @@ static void createKeyTables(void)
 {
    int scancode, key;

-    memset(_glfw.x11.publicKeys, -1, sizeof(_glfw.x11.publicKeys));
-    memset(_glfw.x11.nativeKeys, -1, sizeof(_glfw.x11.nativeKeys));
+    memset(_glfw.x11.keycodes, -1, sizeof(_glfw.x11.keycodes));
+    memset(_glfw.x11.scancodes, -1, sizeof(_glfw.x11.scancodes));

    if (_glfw.x11.xkb.available)
    {
@@ -305,7 +305,7 @@ static void createKeyTables(void)
            else key = GLFW_KEY_UNKNOWN;

            if ((scancode >= 0) && (scancode < 256))
-                _glfw.x11.publicKeys[scancode] = key;
+                _glfw.x11.keycodes[scancode] = key;
        }

        XkbFreeNames(desc, XkbKeyNamesMask, True);
@@ -316,12 +316,12 @@ static void createKeyTables(void)
    {
        // Translate the un-translated key codes using traditional X11 KeySym
        // lookups
-        if (_glfw.x11.publicKeys[scancode] < 0)
-            _glfw.x11.publicKeys[scancode] = translateKeyCode(scancode);
+        if (_glfw.x11.keycodes[scancode] < 0)
+            _glfw.x11.keycodes[scancode] = translateKeyCode(scancode);

        // Store the reverse translation for faster key name lookup
-        if (_glfw.x11.publicKeys[scancode] > 0)
-            _glfw.x11.nativeKeys[_glfw.x11.publicKeys[scancode]] = scancode;
+        if (_glfw.x11.keycodes[scancode] > 0)
+            _glfw.x11.scancodes[_glfw.x11.keycodes[scancode]] = scancode;
    }
 }

@@ -462,13 +462,23 @@ static void detectEWMH(void)
 //
 static GLFWbool initExtensions(void)
 {
-#if defined(_GLFW_HAS_XF86VM)
-    // Check for XF86VidMode extension
-    _glfw.x11.vidmode.available =
-        XF86VidModeQueryExtension(_glfw.x11.display,
-                                  &_glfw.x11.vidmode.eventBase,
-                                  &_glfw.x11.vidmode.errorBase);
-#endif /*_GLFW_HAS_XF86VM*/
+    _glfw.x11.vidmode.handle = dlopen("libXxf86vm.so", RTLD_LAZY | RTLD_GLOBAL);
+    if (_glfw.x11.vidmode.handle)
+    {
+        _glfw.x11.vidmode.QueryExtension = (PFN_XF86VidModeQueryExtension)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeQueryExtension");
+        _glfw.x11.vidmode.GetGammaRamp = (PFN_XF86VidModeGetGammaRamp)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeGetGammaRamp");
+        _glfw.x11.vidmode.SetGammaRamp = (PFN_XF86VidModeSetGammaRamp)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeSetGammaRamp");
+        _glfw.x11.vidmode.GetGammaRampSize = (PFN_XF86VidModeGetGammaRampSize)
+            dlsym(_glfw.x11.vidmode.handle, "XF86VidModeGetGammaRampSize");
+
+        _glfw.x11.vidmode.available =
+            XF86VidModeQueryExtension(_glfw.x11.display,
+                                      &_glfw.x11.vidmode.eventBase,
+                                      &_glfw.x11.vidmode.errorBase);
+    }

    // Check for RandR extension
    if (XRRQueryExtension(_glfw.x11.display,
@@ -492,8 +502,8 @@ static GLFWbool initExtensions(void)

    if (_glfw.x11.randr.available)
    {
-        XRRScreenResources* sr = XRRGetScreenResources(_glfw.x11.display,
-                                                       _glfw.x11.root);
+        XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.display,
+                                                              _glfw.x11.root);

        if (!sr->ncrtc || !XRRGetCrtcGammaSize(_glfw.x11.display, sr->crtcs[0]))
        {
@@ -545,7 +555,7 @@ static GLFWbool initExtensions(void)
    _glfw.x11.x11xcb.handle = dlopen("libX11-xcb.so", RTLD_LAZY | RTLD_GLOBAL);
    if (_glfw.x11.x11xcb.handle)
    {
-        _glfw.x11.x11xcb.XGetXCBConnection = (XGETXCBCONNECTION_T)
+        _glfw.x11.x11xcb.XGetXCBConnection = (PFN_XGetXCBConnection)
            dlsym(_glfw.x11.x11xcb.handle, "XGetXCBConnection");
    }

@@ -630,6 +640,20 @@ static Cursor createHiddenCursor(void)
    return _glfwCreateCursorX11(&image, 0, 0);
 }

+// Create a helper window for IPC
+//
+static Window createHelperWindow(void)
+{
+    XSetWindowAttributes wa;
+    wa.event_mask = PropertyChangeMask;
+
+    return XCreateWindow(_glfw.x11.display, _glfw.x11.root,
+                         0, 0, 1, 1, 0, 0,
+                         InputOnly,
+                         DefaultVisual(_glfw.x11.display, _glfw.x11.screen),
+                         CWEventMask, &wa);
+}
+
 // X error handler
 //
 static int errorHandler(Display *display, XErrorEvent* event)
@@ -741,12 +765,12 @@ int _glfwPlatformInit(void)
    _glfw.x11.screen = DefaultScreen(_glfw.x11.display);
    _glfw.x11.root = RootWindow(_glfw.x11.display, _glfw.x11.screen);
    _glfw.x11.context = XUniqueContext();
+    _glfw.x11.helperWindowHandle = createHelperWindow();
+    _glfw.x11.hiddenCursorHandle = createHiddenCursor();

    if (!initExtensions())
        return GLFW_FALSE;

-    _glfw.x11.cursor = createHiddenCursor();
-
    if (XSupportsLocale())
    {
        XSetLocaleModifiers("");
@@ -781,10 +805,22 @@ void _glfwPlatformTerminate(void)
        _glfw.x11.x11xcb.handle = NULL;
    }

-    if (_glfw.x11.cursor)
+    if (_glfw.x11.helperWindowHandle)
    {
-        XFreeCursor(_glfw.x11.display, _glfw.x11.cursor);
-        _glfw.x11.cursor = (Cursor) 0;
+        if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
+            _glfw.x11.helperWindowHandle)
+        {
+            _glfwPushSelectionToManagerX11();
+        }
+
+        XDestroyWindow(_glfw.x11.display, _glfw.x11.helperWindowHandle);
+        _glfw.x11.helperWindowHandle = None;
+    }
+
+    if (_glfw.x11.hiddenCursorHandle)
+    {
+        XFreeCursor(_glfw.x11.display, _glfw.x11.hiddenCursorHandle);
+        _glfw.x11.hiddenCursorHandle = (Cursor) 0;
    }

    free(_glfw.x11.clipboardString);
@@ -822,9 +858,6 @@ const char* _glfwPlatformGetVersionString(void)
 #if defined(__linux__)
        " /dev/js"
 #endif
-#if defined(_GLFW_HAS_XF86VM)
-        " Xf86vm"
-#endif
 #if defined(_GLFW_BUILD_DLL)
        " shared"
 #endif
@@ -2,7 +2,7 @@
 // GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -114,7 +114,7 @@ GLFWbool _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired)
        if (_glfwCompareVideoModes(&current, best) == 0)
            return GLFW_TRUE;

-        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
        oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);

@@ -174,7 +174,7 @@ void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
        if (monitor->x11.oldMode == None)
            return;

-        sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
+        sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
        ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);

        XRRSetCrtcConfig(_glfw.x11.display,
@@ -209,8 +209,8 @@ _GLFWmonitor** _glfwPlatformGetMonitors(int* count)
    {
        int screenCount = 0;
        XineramaScreenInfo* screens = NULL;
-        XRRScreenResources* sr = XRRGetScreenResources(_glfw.x11.display,
-                                                       _glfw.x11.root);
+        XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.display,
+                                                              _glfw.x11.root);
        RROutput primary = XRRGetOutputPrimary(_glfw.x11.display,
                                               _glfw.x11.root);

@@ -429,7 +429,6 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)

        XRRFreeGamma(gamma);
    }
-#if defined(_GLFW_HAS_XF86VM)
    else if (_glfw.x11.vidmode.available)
    {
        int size;
@@ -441,7 +440,6 @@ void _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
                                _glfw.x11.screen,
                                ramp->size, ramp->red, ramp->green, ramp->blue);
    }
-#endif /*_GLFW_HAS_XF86VM*/
 }

 void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
@@ -457,7 +455,6 @@ void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
        XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
        XRRFreeGamma(gamma);
    }
-#if defined(_GLFW_HAS_XF86VM)
    else if (_glfw.x11.vidmode.available)
    {
        XF86VidModeSetGammaRamp(_glfw.x11.display,
@@ -467,7 +464,6 @@ void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
                                (unsigned short*) ramp->green,
                                (unsigned short*) ramp->blue);
    }
-#endif /*_GLFW_HAS_XF86VM*/
 }


@@ -2,7 +2,7 @@
 // GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -47,15 +47,19 @@
 // The Xinerama extension provides legacy monitor indices
 #include <X11/extensions/Xinerama.h>

-#if defined(_GLFW_HAS_XF86VM)
- // The Xf86VidMode extension provides fallback gamma control
- #include <X11/extensions/xf86vmode.h>
-#endif
-
 typedef XID xcb_window_t;
 typedef XID xcb_visualid_t;
 typedef struct xcb_connection_t xcb_connection_t;
-typedef xcb_connection_t* (* XGETXCBCONNECTION_T)(Display*);
+typedef xcb_connection_t* (* PFN_XGetXCBConnection)(Display*);
+
+typedef Bool (* PFN_XF86VidModeQueryExtension)(Display*,int*,int*);
+typedef Bool (* PFN_XF86VidModeGetGammaRamp)(Display*,int,int,unsigned short*,unsigned short*,unsigned short*);
+typedef Bool (* PFN_XF86VidModeSetGammaRamp)(Display*,int,int,unsigned short*,unsigned short*,unsigned short*);
+typedef Bool (* PFN_XF86VidModeGetGammaRampSize)(Display*,int,int*);
+#define XF86VidModeQueryExtension _glfw.x11.vidmode.QueryExtension
+#define XF86VidModeGetGammaRamp _glfw.x11.vidmode.GetGammaRamp
+#define XF86VidModeSetGammaRamp _glfw.x11.vidmode.SetGammaRamp
+#define XF86VidModeGetGammaRampSize _glfw.x11.vidmode.GetGammaRampSize

 typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
 typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
@@ -112,6 +116,8 @@ typedef struct _GLFWwindowX11
    XIC             ic;

    GLFWbool        overrideRedirect;
+    GLFWbool        iconified;
+    GLFWbool        maximized;

    // Cached position and size used to filter out duplicate events
    int             width, height;
@@ -136,8 +142,10 @@ typedef struct _GLFWlibraryX11
    int             screen;
    Window          root;

+    // Helper window for IPC
+    Window          helperWindowHandle;
    // Invisible cursor for hidden cursor mode
-    Cursor          cursor;
+    Cursor          hiddenCursorHandle;
    // Context for mapping window XIDs to _GLFWwindow pointers
    XContext        context;
    // XIM input method
@@ -149,15 +157,13 @@ typedef struct _GLFWlibraryX11
    // Key name string
    char            keyName[64];
    // X11 keycode to GLFW key LUT
-    short int       publicKeys[256];
+    short int       keycodes[256];
    // GLFW key to X11 keycode LUT
-    short int       nativeKeys[GLFW_KEY_LAST + 1];
+    short int       scancodes[GLFW_KEY_LAST + 1];
    // Where to place the cursor when re-enabled
    double          restoreCursorPosX, restoreCursorPosY;
    // The window whose disabled cursor mode is active
    _GLFWwindow*    disabledCursorWindow;
-    // The last received event time
-    int             lastEventTime;

    // Window manager atoms
    Atom            WM_PROTOCOLS;
@@ -245,16 +251,19 @@ typedef struct _GLFWlibraryX11

    struct {
        void*       handle;
-        XGETXCBCONNECTION_T XGetXCBConnection;
+        PFN_XGetXCBConnection XGetXCBConnection;
    } x11xcb;

-#if defined(_GLFW_HAS_XF86VM)
    struct {
        GLFWbool    available;
+        void*       handle;
        int         eventBase;
        int         errorBase;
+        PFN_XF86VidModeQueryExtension QueryExtension;
+        PFN_XF86VidModeGetGammaRamp GetGammaRamp;
+        PFN_XF86VidModeSetGammaRamp SetGammaRamp;
+        PFN_XF86VidModeGetGammaRampSize GetGammaRampSize;
    } vidmode;
-#endif /*_GLFW_HAS_XF86VM*/

 } _GLFWlibraryX11;

@@ -295,4 +304,6 @@ void _glfwGrabErrorHandlerX11(void);
 void _glfwReleaseErrorHandlerX11(void);
 void _glfwInputErrorX11(int error, const char* message);

+void _glfwPushSelectionToManagerX11(void);
+
 #endif // _glfw3_x11_platform_h_
@@ -2,7 +2,7 @@
 // GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -138,6 +138,9 @@ static int getWindowState(_GLFWwindow* window)
 //
 static Bool isSelectionEvent(Display* display, XEvent* event, XPointer pointer)
 {
+    if (event->xany.window != _glfw.x11.helperWindowHandle)
+        return False;
+
    return event->type == SelectionRequest ||
           event->type == SelectionNotify ||
           event->type == SelectionClear;
@@ -203,7 +206,7 @@ static int translateKey(int scancode)
    if (scancode < 0 || scancode > 255)
        return GLFW_KEY_UNKNOWN;

-    return _glfw.x11.publicKeys[scancode];
+    return _glfw.x11.keycodes[scancode];
 }

 // Return the GLFW window corresponding to the specified X11 window
@@ -458,7 +461,10 @@ static void updateCursorImage(_GLFWwindow* window)
            XUndefineCursor(_glfw.x11.display, window->x11.handle);
    }
    else
-        XDefineCursor(_glfw.x11.display, window->x11.handle, _glfw.x11.cursor);
+    {
+        XDefineCursor(_glfw.x11.display, window->x11.handle,
+                      _glfw.x11.hiddenCursorHandle);
+    }
 }

 // Create the X11 window (and its colormap)
@@ -514,26 +520,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
    }

    if (!wndconfig->decorated)
-    {
-        struct
-        {
-            unsigned long flags;
-            unsigned long functions;
-            unsigned long decorations;
-            long input_mode;
-            unsigned long status;
-        } hints;
-
-        hints.flags = 2;       // Set decorations
-        hints.decorations = 0; // No decorations
-
-        XChangeProperty(_glfw.x11.display, window->x11.handle,
-                        _glfw.x11.MOTIF_WM_HINTS,
-                        _glfw.x11.MOTIF_WM_HINTS, 32,
-                        PropModeReplace,
-                        (unsigned char*) &hints,
-                        sizeof(hints) / sizeof(long));
-    }
+        _glfwPlatformSetWindowDecorated(window, GLFW_FALSE);

    if (_glfw.x11.NET_WM_STATE && !window->monitor)
    {
@@ -553,6 +540,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
            {
                states[count++] = _glfw.x11.NET_WM_STATE_MAXIMIZED_VERT;
                states[count++] = _glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ;
+                window->x11.maximized = GLFW_TRUE;
            }
        }

@@ -812,51 +800,6 @@ static void handleSelectionRequest(XEvent* event)
    XSendEvent(_glfw.x11.display, request->requestor, False, 0, &reply);
 }

-static void pushSelectionToManager(_GLFWwindow* window)
-{
-    XConvertSelection(_glfw.x11.display,
-                      _glfw.x11.CLIPBOARD_MANAGER,
-                      _glfw.x11.SAVE_TARGETS,
-                      None,
-                      window->x11.handle,
-                      _glfw.x11.lastEventTime);
-
-    for (;;)
-    {
-        XEvent event;
-
-        while (XCheckIfEvent(_glfw.x11.display, &event, isSelectionEvent, NULL))
-        {
-            switch (event.type)
-            {
-                case SelectionRequest:
-                    handleSelectionRequest(&event);
-                    break;
-
-                case SelectionClear:
-                    handleSelectionClear(&event);
-                    break;
-
-                case SelectionNotify:
-                {
-                    if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
-                    {
-                        // This means one of two things; either the selection was
-                        // not owned, which means there is no clipboard manager, or
-                        // the transfer to the clipboard manager has completed
-                        // In either case, it means we are done here
-                        return;
-                    }
-
-                    break;
-                }
-            }
-        }
-
-        waitForEvent(NULL);
-    }
-}
-
 // Make the specified window and its video mode active on its monitor
 //
 static GLFWbool acquireMonitor(_GLFWwindow* window)
@@ -986,8 +929,6 @@ static void processEvent(XEvent *event)
    {
        case KeyPress:
        {
-            _glfw.x11.lastEventTime = event->xkey.time;
-
            const int key = translateKey(keycode);
            const int mods = translateState(event->xkey.state);
            const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
@@ -1083,8 +1024,6 @@ static void processEvent(XEvent *event)

        case KeyRelease:
        {
-            _glfw.x11.lastEventTime = event->xkey.time;
-
            const int key = translateKey(keycode);
            const int mods = translateState(event->xkey.state);

@@ -1126,8 +1065,6 @@ static void processEvent(XEvent *event)

        case ButtonPress:
        {
-            _glfw.x11.lastEventTime = event->xbutton.time;
-
            const int mods = translateState(event->xbutton.state);

            if (event->xbutton.button == Button1)
@@ -1162,8 +1099,6 @@ static void processEvent(XEvent *event)

        case ButtonRelease:
        {
-            _glfw.x11.lastEventTime = event->xbutton.time;
-
            const int mods = translateState(event->xbutton.state);

            if (event->xbutton.button == Button1)
@@ -1202,8 +1137,6 @@ static void processEvent(XEvent *event)

        case EnterNotify:
        {
-            _glfw.x11.lastEventTime = event->xcrossing.time;
-
            // HACK: This is a workaround for WMs (KWM, Fluxbox) that otherwise
            //       ignore the defined cursor for hidden cursor mode
            if (window->cursorMode == GLFW_CURSOR_HIDDEN)
@@ -1215,15 +1148,12 @@ static void processEvent(XEvent *event)

        case LeaveNotify:
        {
-            _glfw.x11.lastEventTime = event->xcrossing.time;
            _glfwInputCursorEnter(window, GLFW_FALSE);
            return;
        }

        case MotionNotify:
        {
-            _glfw.x11.lastEventTime = event->xmotion.time;
-
            const int x = event->xmotion.x;
            const int y = event->xmotion.y;

@@ -1336,8 +1266,7 @@ static void processEvent(XEvent *event)
                                  _glfw.x11.XdndSelection,
                                  _glfw.x11.UTF8_STRING,
                                  _glfw.x11.XdndSelection,
-                                  window->x11.handle,
-                                  _glfw.x11.lastEventTime);
+                                  window->x11.handle, CurrentTime);
            }
            else if (event->xclient.message_type == _glfw.x11.XdndPosition)
            {
@@ -1373,8 +1302,6 @@ static void processEvent(XEvent *event)

        case SelectionNotify:
        {
-            _glfw.x11.lastEventTime = event->xselection.time;
-
            if (event->xselection.property)
            {
                // The converted data from the drag operation has arrived
@@ -1470,25 +1397,37 @@ static void processEvent(XEvent *event)

        case PropertyNotify:
        {
-            _glfw.x11.lastEventTime = event->xproperty.time;
+            if (event->xproperty.state != PropertyNewValue)
+                return;

-            if (event->xproperty.atom == _glfw.x11.WM_STATE &&
-                event->xproperty.state == PropertyNewValue)
+            if (event->xproperty.atom == _glfw.x11.WM_STATE)
            {
                const int state = getWindowState(window);
-                if (state == IconicState)
+                if (state != IconicState && state != NormalState)
+                    return;
+
+                const GLFWbool iconified = (state == IconicState);
+                if (window->x11.iconified != iconified)
                {
                    if (window->monitor)
-                        releaseMonitor(window);
+                    {
+                        if (iconified)
+                            releaseMonitor(window);
+                        else
+                            acquireMonitor(window);
+                    }

-                    _glfwInputWindowIconify(window, GLFW_TRUE);
+                    window->x11.iconified = iconified;
+                    _glfwInputWindowIconify(window, iconified);
                }
-                else if (state == NormalState)
+            }
+            else if (event->xproperty.atom == _glfw.x11.NET_WM_STATE)
+            {
+                const GLFWbool maximized = _glfwPlatformWindowMaximized(window);
+                if (window->x11.maximized != maximized)
                {
-                    if (window->monitor)
-                        acquireMonitor(window);
-
-                    _glfwInputWindowIconify(window, GLFW_FALSE);
+                    window->x11.maximized = maximized;
+                    _glfwInputWindowMaximize(window, maximized);
                }
            }

@@ -1497,14 +1436,12 @@ static void processEvent(XEvent *event)

        case SelectionClear:
        {
-            _glfw.x11.lastEventTime = event->xselectionclear.time;
            handleSelectionClear(event);
            return;
        }

        case SelectionRequest:
        {
-            _glfw.x11.lastEventTime = event->xselectionrequest.time;
            handleSelectionRequest(event);
            return;
        }
@@ -1550,6 +1487,53 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
    return itemCount;
 }

+// Push contents of our selection to clipboard manager
+//
+void _glfwPushSelectionToManagerX11(void)
+{
+    XConvertSelection(_glfw.x11.display,
+                      _glfw.x11.CLIPBOARD_MANAGER,
+                      _glfw.x11.SAVE_TARGETS,
+                      None,
+                      _glfw.x11.helperWindowHandle,
+                      CurrentTime);
+
+    for (;;)
+    {
+        XEvent event;
+
+        while (XCheckIfEvent(_glfw.x11.display, &event, isSelectionEvent, NULL))
+        {
+            switch (event.type)
+            {
+                case SelectionRequest:
+                    handleSelectionRequest(&event);
+                    break;
+
+                case SelectionClear:
+                    handleSelectionClear(&event);
+                    break;
+
+                case SelectionNotify:
+                {
+                    if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
+                    {
+                        // This means one of two things; either the selection was
+                        // not owned, which means there is no clipboard manager, or
+                        // the transfer to the clipboard manager has completed
+                        // In either case, it means we are done here
+                        return;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        waitForEvent(NULL);
+    }
+}
+

 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -1636,12 +1620,6 @@ void _glfwPlatformDestroyWindow(_GLFWwindow* window)

    if (window->x11.handle)
    {
-        if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
-            window->x11.handle)
-        {
-            pushSelectionToManager(window);
-        }
-
        XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
        XUnmapWindow(_glfw.x11.display, window->x11.handle);
        XDestroyWindow(_glfw.x11.display, window->x11.handle);
@@ -1972,7 +1950,7 @@ void _glfwPlatformFocusWindow(_GLFWwindow* window)
    {
        XRaiseWindow(_glfw.x11.display, window->x11.handle);
        XSetInputFocus(_glfw.x11.display, window->x11.handle,
-                       RevertToParent, _glfw.x11.lastEventTime);
+                       RevertToParent, CurrentTime);
    }

    XFlush(_glfw.x11.display);
@@ -2068,6 +2046,107 @@ int _glfwPlatformWindowMaximized(_GLFWwindow* window)
    return maximized;
 }

+void _glfwPlatformSetWindowResizable(_GLFWwindow* window, GLFWbool enabled)
+{
+    int width, height;
+    _glfwPlatformGetWindowSize(window, &width, &height);
+    updateNormalHints(window, width, height);
+}
+
+void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
+{
+    if (enabled)
+    {
+        XDeleteProperty(_glfw.x11.display,
+                        window->x11.handle,
+                        _glfw.x11.MOTIF_WM_HINTS);
+    }
+    else
+    {
+        struct
+        {
+            unsigned long flags;
+            unsigned long functions;
+            unsigned long decorations;
+            long input_mode;
+            unsigned long status;
+        } hints;
+
+        hints.flags = 2;       // Set decorations
+        hints.decorations = 0; // No decorations
+
+        XChangeProperty(_glfw.x11.display, window->x11.handle,
+                        _glfw.x11.MOTIF_WM_HINTS,
+                        _glfw.x11.MOTIF_WM_HINTS, 32,
+                        PropModeReplace,
+                        (unsigned char*) &hints,
+                        sizeof(hints) / sizeof(long));
+    }
+}
+
+void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
+{
+    if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
+        return;
+
+    if (_glfwPlatformWindowVisible(window))
+    {
+        const Atom action = enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
+        sendEventToWM(window,
+                      _glfw.x11.NET_WM_STATE,
+                      action,
+                      _glfw.x11.NET_WM_STATE_ABOVE,
+                      0, 1, 0);
+    }
+    else
+    {
+        Atom* states;
+        unsigned long i, count;
+
+        count = _glfwGetWindowPropertyX11(window->x11.handle,
+                                          _glfw.x11.NET_WM_STATE,
+                                          XA_ATOM,
+                                          (unsigned char**) &states);
+
+        if (enabled)
+        {
+            for (i = 0;  i < count;  i++)
+            {
+                if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
+                    break;
+            }
+
+            if (i == count)
+            {
+                XChangeProperty(_glfw.x11.display, window->x11.handle,
+                                _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
+                                PropModeAppend,
+                                (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
+                                1);
+            }
+        }
+        else
+        {
+            for (i = 0;  i < count;  i++)
+            {
+                if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
+                {
+                    states[i] = states[count - 1];
+                    count--;
+                }
+            }
+
+            XChangeProperty(_glfw.x11.display, window->x11.handle,
+                            _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
+                            PropModeReplace, (unsigned char*) &states, count);
+        }
+
+        XFree(states);
+    }
+
+    XFlush(_glfw.x11.display);
+}
+
 void _glfwPlatformPollEvents(void)
 {
    _glfwPollJoystickEvents();
@@ -2108,15 +2187,14 @@ void _glfwPlatformWaitEventsTimeout(double timeout)
 void _glfwPlatformPostEmptyEvent(void)
 {
    XEvent event;
-    _GLFWwindow* window = _glfw.windowListHead;

    memset(&event, 0, sizeof(event));
    event.type = ClientMessage;
-    event.xclient.window = window->x11.handle;
+    event.xclient.window = _glfw.x11.helperWindowHandle;
    event.xclient.format = 32; // Data is 32-bit longs
    event.xclient.message_type = _glfw.x11.NULL_;

-    XSendEvent(_glfw.x11.display, window->x11.handle, False, 0, &event);
+    XSendEvent(_glfw.x11.display, _glfw.x11.helperWindowHandle, False, 0, &event);
    XFlush(_glfw.x11.display);
 }

@@ -2160,13 +2238,14 @@ void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
        XGrabPointer(_glfw.x11.display, window->x11.handle, True,
                     ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
                     GrabModeAsync, GrabModeAsync,
-                     window->x11.handle, _glfw.x11.cursor,
-                     _glfw.x11.lastEventTime);
+                     window->x11.handle,
+                     _glfw.x11.hiddenCursorHandle,
+                     CurrentTime);
    }
    else if (_glfw.x11.disabledCursorWindow == window)
    {
        _glfw.x11.disabledCursorWindow = NULL;
-        XUngrabPointer(_glfw.x11.display, _glfw.x11.lastEventTime);
+        XUngrabPointer(_glfw.x11.display, CurrentTime);
        _glfwPlatformSetCursorPos(window,
                                  _glfw.x11.restoreCursorPosX,
                                  _glfw.x11.restoreCursorPosY);
@@ -2185,9 +2264,9 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
        return NULL;

    if (key != GLFW_KEY_UNKNOWN)
-        scancode = _glfw.x11.nativeKeys[key];
+        scancode = _glfw.x11.scancodes[key];

-    if (!_glfwIsPrintable(_glfw.x11.publicKeys[scancode]))
+    if (!_glfwIsPrintable(_glfw.x11.keycodes[scancode]))
        return NULL;

    keysym = XkbKeycodeToKeysym(_glfw.x11.display, scancode, 0, 0);
@@ -2204,6 +2283,11 @@ const char* _glfwPlatformGetKeyName(int key, int scancode)
    return _glfw.x11.keyName;
 }

+int _glfwPlatformGetKeyScancode(int key)
+{
+    return _glfw.x11.scancodes[key];
+}
+
 int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
                              const GLFWimage* image,
                              int xhot, int yhot)
@@ -2251,11 +2335,11 @@ void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string)

    XSetSelectionOwner(_glfw.x11.display,
                       _glfw.x11.CLIPBOARD,
-                       window->x11.handle,
-                       _glfw.x11.lastEventTime);
+                       _glfw.x11.helperWindowHandle,
+                       CurrentTime);

    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) !=
-        window->x11.handle)
+        _glfw.x11.helperWindowHandle)
    {
        _glfwInputError(GLFW_PLATFORM_ERROR,
                        "X11: Failed to become owner of clipboard selection");
@@ -2270,8 +2354,8 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
                             XA_STRING };
    const size_t formatCount = sizeof(formats) / sizeof(formats[0]);

-    if (findWindowByHandle(XGetSelectionOwner(_glfw.x11.display,
-                                              _glfw.x11.CLIPBOARD)))
+    if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
+        _glfw.x11.helperWindowHandle)
    {
        // Instead of doing a large number of X round-trips just to put this
        // string into a window property and then read it back, just return it
@@ -2290,11 +2374,16 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
                          _glfw.x11.CLIPBOARD,
                          formats[i],
                          _glfw.x11.GLFW_SELECTION,
-                          window->x11.handle,
-                          _glfw.x11.lastEventTime);
+                          _glfw.x11.helperWindowHandle,
+                          CurrentTime);

-        while (!XCheckTypedEvent(_glfw.x11.display, SelectionNotify, &event))
+        while (!XCheckTypedWindowEvent(_glfw.x11.display,
+                                       _glfw.x11.helperWindowHandle,
+                                       SelectionNotify,
+                                       &event))
+        {
            waitForEvent(NULL);
+        }

        if (event.xselection.property == None)
            continue;
@@ -2326,28 +2415,25 @@ const char* _glfwPlatformGetClipboardString(_GLFWwindow* window)
    return _glfw.x11.clipboardString;
 }

-char** _glfwPlatformGetRequiredInstanceExtensions(uint32_t* count)
+void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
 {
-    char** extensions;
-
-    *count = 0;
+    if (!_glfw.vk.KHR_surface)
+        return;

    if (!_glfw.vk.KHR_xcb_surface || !_glfw.x11.x11xcb.handle)
    {
        if (!_glfw.vk.KHR_xlib_surface)
-            return NULL;
+            return;
    }

-    extensions = calloc(2, sizeof(char*));
-    extensions[0] = strdup("VK_KHR_surface");
+    extensions[0] = "VK_KHR_surface";

+    // NOTE: VK_KHR_xcb_surface is preferred due to some early ICDs exposing but
+    //       not correctly implementing VK_KHR_xlib_surface
    if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
-        extensions[1] = strdup("VK_KHR_xcb_surface");
+        extensions[1] = "VK_KHR_xcb_surface";
    else
-        extensions[1] = strdup("VK_KHR_xlib_surface");
-
-    *count = 2;
-    return extensions;
+        extensions[1] = "VK_KHR_xlib_surface";
 }

 int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
@@ -2,7 +2,7 @@
 // GLFW 3.3 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
-// Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+// Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -1,6 +1,8 @@

 link_libraries(glfw)

+include_directories(${glfw_INCLUDE_DIRS} "${GLFW_SOURCE_DIR}/deps")
+
 if (BUILD_SHARED_LIBS)
    link_libraries("${MATH_LIBRARY}")
 endif()
@@ -9,8 +11,6 @@ if (MSVC)
    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()

-include_directories("${GLFW_SOURCE_DIR}/deps")
-
 set(GLAD "${GLFW_SOURCE_DIR}/deps/glad/glad.h"
         "${GLFW_SOURCE_DIR}/deps/glad.c")
 set(GETOPT "${GLFW_SOURCE_DIR}/deps/getopt.h"
@@ -21,17 +21,17 @@ set(TINYCTHREAD "${GLFW_SOURCE_DIR}/deps/tinycthread.h"
 add_executable(clipboard clipboard.c ${GETOPT} ${GLAD})
 add_executable(events events.c ${GETOPT} ${GLAD})
 add_executable(msaa msaa.c ${GETOPT} ${GLAD})
-add_executable(gamma gamma.c ${GETOPT} ${GLAD})
 add_executable(glfwinfo glfwinfo.c ${GETOPT} ${GLAD})
 add_executable(iconify iconify.c ${GETOPT} ${GLAD})
-add_executable(joysticks joysticks.c ${GLAD})
 add_executable(monitors monitors.c ${GETOPT} ${GLAD})
 add_executable(reopen reopen.c ${GLAD})
 add_executable(cursor cursor.c ${GLAD})

 add_executable(empty WIN32 MACOSX_BUNDLE empty.c ${TINYCTHREAD} ${GLAD})
+add_executable(gamma WIN32 MACOSX_BUNDLE gamma.c ${GLAD})
 add_executable(icon WIN32 MACOSX_BUNDLE icon.c ${GLAD})
-add_executable(sharing WIN32 MACOSX_BUNDLE sharing.c ${GLAD})
+add_executable(joysticks WIN32 MACOSX_BUNDLE joysticks.c ${GLAD})
+add_executable(sharing WIN32 MACOSX_BUNDLE sharing.c ${GETOPT} ${GLAD})
 add_executable(tearing WIN32 MACOSX_BUNDLE tearing.c ${GETOPT} ${GLAD})
 add_executable(threads WIN32 MACOSX_BUNDLE threads.c ${TINYCTHREAD} ${GLAD})
 add_executable(timeout WIN32 MACOSX_BUNDLE timeout.c ${GLAD})
@@ -41,15 +41,16 @@ add_executable(windows WIN32 MACOSX_BUNDLE windows.c ${GETOPT} ${GLAD})
 target_link_libraries(empty "${CMAKE_THREAD_LIBS_INIT}" "${RT_LIBRARY}")
 target_link_libraries(threads "${CMAKE_THREAD_LIBS_INIT}" "${RT_LIBRARY}")

-set(WINDOWS_BINARIES empty icon sharing tearing threads timeout title windows)
-set(CONSOLE_BINARIES clipboard events msaa gamma glfwinfo
-                     iconify joysticks monitors reopen cursor)
+set(WINDOWS_BINARIES empty gamma icon joysticks sharing tearing threads timeout
+                     title windows)
+set(CONSOLE_BINARIES clipboard events msaa glfwinfo iconify monitors reopen
+                     cursor)

 if (VULKAN_FOUND)
    add_executable(vulkan WIN32 vulkan.c ${ICON})
    target_include_directories(vulkan PRIVATE "${VULKAN_INCLUDE_DIR}")
    if (NOT GLFW_VULKAN_STATIC)
-        target_link_libraries(vulkan "${VULKAN_LIBRARY}")
+        target_link_libraries(vulkan "${VULKAN_LIBRARY}" ${GLFW_VULKAN_DEPS})
    endif()
    list(APPEND WINDOWS_BINARIES vulkan)
 endif()
@@ -65,6 +66,8 @@ endif()

 if (APPLE)
    set_target_properties(empty PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Empty Event")
+    set_target_properties(gamma PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Gamma")
+    set_target_properties(joysticks PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Joysticks")
    set_target_properties(sharing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Sharing")
    set_target_properties(tearing PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Tearing")
    set_target_properties(threads PROPERTIES MACOSX_BUNDLE_BUNDLE_NAME "Threads")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Camilla Berglund	70297aeb49	Metal example code cleanup	2016-12-19 13:50:57 +01:00
Camilla Berglund	8eb2345347	Add Metal guide	2016-12-19 13:49:57 +01:00
Keith Bauer	97b652c584	Initial Metal example	2016-12-19 13:49:57 +01:00
Camilla Löwy	0f488ac286	Win32: Fix underflow in deadzone logic Fixes #910.	2016-12-19 13:13:46 +01:00
Camilla Löwy	e649708cb2	X11: Make more use of XRRGetScreenResourcesCurrent Closes #877.	2016-12-18 15:49:17 +01:00
Camilla Löwy	f656d95339	Documentation work	2016-12-15 20:21:07 +01:00
Camilla Löwy	6eae8f22dc	X11: Load Xxf86vm at run-time	2016-12-11 00:05:15 +01:00
Camilla Löwy	21eeaffc23	Documentation fix Doxygen cannot handle line breaks in Markdown links.	2016-12-09 01:32:09 +01:00
Camilla Löwy	831426ca63	Documentation work [ci skip]	2016-12-08 17:08:53 +01:00
Camilla Löwy	58ceab5f1e	Add GLFW_COCOA_RETINA_FRAMEBUFFER Look, a can of worms! I wonder what's inside. This adds the first platform specific window hint, transforming a compile-time option to a run-time per-window one.	2016-12-08 16:56:05 +01:00
Camilla Löwy	766a9dc9fd	Documentation work Related to glfw/website#34.	2016-12-08 16:56:05 +01:00
Camilla Löwy	0e8ba24f32	Formatting	2016-12-08 16:56:05 +01:00
Camilla Löwy	744cee6ec9	Cleanup	2016-12-08 16:56:05 +01:00
Camilla Löwy	32eb50b75e	Move to Vulkan style function typedefs PFN_FunctionName is more readable than SCREAMSOUP_T. Context creation API function typedefs are kept as-is where the original header provided them, for compatibility and familiarity reasons.	2016-12-08 16:56:05 +01:00
Camilla Löwy	887e58bd21	Cleanup Related to #882.	2016-12-06 17:39:51 +01:00
Sergey Tikhomirov	11a2413476	Cocoa: Fix issue with application sandboxing Fixes #816. Closes #882.	2016-12-06 17:39:51 +01:00
Camilla Löwy	be4eb6fb2b	OSMesa: Add missing stubs	2016-12-06 16:11:38 +01:00
Camilla Löwy	9e56099edd	Add glfwSetWindowAttrib This function allows updating the GLFW_DECORATED, GLFW_RESIZABLE, GLFW_FLOATING and GLFW_AUTO_ICONIFY attributes for existing windows. Fixes #537.	2016-12-06 15:59:18 +01:00
Camilla Löwy	d92bb41e25	Fix typo [ci skip]	2016-12-06 13:59:04 +01:00
Camilla Löwy	69e351b44a	Cleanup [ci skip]	2016-12-06 13:58:52 +01:00
Camilla Löwy	ce161c2c02	Documentation work [ci skip]	2016-12-06 13:58:45 +01:00
Camilla Löwy	f383f7721c	Fix warnings in Nuklear	2016-12-05 14:17:33 +01:00
Camilla Löwy	1252016b9c	Add remaining GLSL version directives Related to #864.	2016-12-05 14:16:56 +01:00
A. Tombs	1b17a5293c	Add version directives to GLSL shaders Although not technically required, I believe it is best practice for shaders to specify which version of the GLSL spec they conform to. Closes #864.	2016-12-05 14:06:39 +01:00
Camilla Löwy	3e4752f99e	Fix warnings in Nuklear GL2 backend	2016-12-03 20:46:36 +01:00
Camilla Löwy	f44307da4e	Update Nuklear to 1.18 Fixes #907.	2016-12-03 20:35:17 +01:00
Camilla Löwy	fd127d59fa	Cocoa: Improve OpenGL version restriction messages Fixes #904.	2016-12-03 20:15:26 +01:00
Camilla Löwy	29b72c59f3	Documentation work Related to #902. [ci skip]	2016-12-03 20:15:26 +01:00
Camilla Löwy	11376a2dd0	Cleanup	2016-12-03 20:06:24 +01:00
Camilla Löwy	cc9168bda1	Win32: Fix build on VC++ 2008 This is not official support for VC++ 2008. Fixes #821.	2016-12-03 20:06:23 +01:00
Camilla Löwy	f4d0c83181	Paperwork done	2016-11-30 14:00:41 +01:00
Camilla Berglund	096efdf798	Documentation work	2016-11-16 17:05:12 +01:00
Camilla Berglund	20735bf840	Add offscreen example to IDE folder	2016-11-16 17:04:23 +01:00
Camilla Berglund	e3c3e780ae	Update .gitignore	2016-11-16 15:13:20 +01:00
Camilla Berglund	9190cf8796	Cocoa: Disable deprecated function on macOS 10.12+ CGDisplayModeCopyPixelEncoding is deprecated starting with macOS 10.12.	2016-11-16 15:10:29 +01:00
Camilla Berglund	d19a21bd01	Cocoa: Monitor name cleanup Only retrieve the display info dictionary once. Remove non-standard function name.	2016-11-16 15:09:07 +01:00
Matthew Henry	94b8486d4b	Cocoa: Replace deprecated CGDisplayIOServicePort This replaces CGDisplayIOServicePort with manually finding a service port with matching vendor and product IDs. This may technically not be the one corresponding to the display ID, but it is only used to retrieve the human-readable make/model string. This could be cleaned up and refined a bit by comparing more display attributes when available, but it gets the job done. Fixes #165. Closes #192. Closes #508. Closes #511.	2016-11-16 15:06:37 +01:00
Denis	cce430fbfa	Cocoa: Fix typo Closes #897.	2016-11-16 04:07:16 +01:00
Camilla Berglund	5b8051581e	OSMesa: Allow cursor creation	2016-11-09 01:36:24 +01:00
Camilla Berglund	0e8d129efb	OSMesa: Context creation compliance fixes	2016-11-09 01:36:24 +01:00
Camilla Berglund	62012e3c68	OSMesa: Add fallback to OSMesaCreateContextExt	2016-11-09 01:36:23 +01:00
Camilla Berglund	b8c71e7f2d	Add offscreen rendering example	2016-11-09 01:36:23 +01:00
Camilla Berglund	ac83639631	Add stb_image_write	2016-11-09 01:36:23 +01:00
Camilla Berglund	fef21361c5	OSMesa: Cleanup Fixes formatting, semantics and documentation. Adds glfwGetOSMesaContext. Adds support for OSMesa context attributes. Updates changelog and credits. Adds license and copyright headers. Removes superfluous code (the shared code provides many conveniences). Removes loading of unused OSMesa functions. Removes empty platform structs. Fixes version string format. Removes build dependency on the OSMesa header and library (only the library is needed and only at runtime). Closes #850.	2016-11-09 01:36:21 +01:00
Jason Daly	368fa9475d	Add headless OSMesa backend Allows creation and drawing to in-memory OpenGL contexts. This backend does not provide input. Related to #850.	2016-11-09 01:23:43 +01:00
Camilla Berglund	a90ee65f7b	Add definition of GLAPIENTRY	2016-11-08 12:39:18 +01:00
Camilla Berglund	e83be1d73a	Note that mode switching does not affect context	2016-11-08 12:19:06 +01:00
Camilla Berglund	e8c3e54dda	Documentation work [ci skip]	2016-11-07 19:53:42 +01:00
Camilla Berglund	2aee114950	Clarify glfwinfo output for no Vulkan extensions	2016-11-07 19:53:30 +01:00
Camilla Berglund	4d322a97e1	Fix Vulkan extension count when none were found	2016-11-07 19:53:30 +01:00
Emmanuel Gil Peyrot	8210f89b12	Wayland: Set a proper name for outputs. glfwGetMonitorName()’s documentation says “this function returns a human-readable name”, which “typically reflects the make and model of the monitor”. We get these two strings in the geometry event, so we only set the name at this point.	2016-11-04 09:58:45 +00:00
Emmanuel Gil Peyrot	a28baabefe	Allow a monitor to be created without a name.	2016-11-04 09:57:59 +00:00
Camilla Berglund	e94d16667b	Cocoa: Add basic support for Vulkan via MoltenVK This adds basic support for MoltenVK, a Vulkan implementation on top of Metal, on macOS 10.11 and later. It looks for MoltenVK in the process via RTLD_DEFAULT symbol lookup if _GLFW_VULKAN_STATIC is disabled. glfwCreateWindowSurface now creates and sets a CAMetalLayer for the window content view, which is required for MoltenVK to function. You must help CMake find MoltenVK for the Vulkan test to be built. Fixes #870.	2016-11-01 21:39:54 +01:00
Camilla Berglund	c3db1cae3f	Fix glfwGetInstanceProcAddress for static linking	2016-11-01 21:34:26 +01:00
Camilla Berglund	017162e3fd	Cocoa: Stop searching for system frameworks	2016-11-01 21:34:26 +01:00
Camilla Berglund	fef25ea934	Emit all Vulkan init errors from init function	2016-11-01 21:34:26 +01:00
Camilla Berglund	a9282bad29	Disable all dl* calls for _GLFW_VULKAN_STATIC	2016-11-01 21:34:26 +01:00
Camilla Berglund	67931bdeb2	Replace last @remarks with @remark	2016-11-01 21:34:26 +01:00
Camilla Berglund	85f867983f	Update Vulkan test to 1.0.26.0 Fixes #727. Fixes #758.	2016-11-01 21:34:26 +01:00
Camilla Berglund	ec17161651	Note that mode switching does not affect context	2016-11-01 21:34:26 +01:00
Camilla Berglund	3d4bd9667a	Win32: Fix joystick error message prefix	2016-10-25 21:28:21 +02:00
Camilla Berglund	7420814fe2	Win32: Poll only helper window messages at init	2016-10-25 21:25:04 +02:00
Camilla Berglund	8d6f265441	Update default name from OS X to macOS Note that earlier releases are still referred to by their proper names; OS X <version> or Mac OS X <version>.	2016-10-20 00:53:37 +02:00
linkmauve	bc8b0480e9	Wayland: Document when behaviour differs This should describe all of the Wayland-specific points, mostly in three categories: - Missing GLFW features, for example window frame, screensaver inhibition, clipboard or file drop. - Missing protocols, like setting gamma on a monitor or specifying a window icon. - Fundamental incompatibilities with Wayland concepts, like trying to handle global positioning of a window in a 2D space, trying to bring a window to front, or trying to change the monitor’s mode. Closes #881.	2016-10-16 16:52:39 +02:00
Emmanuel Gil Peyrot	046d281abc	Wayland: Implement compose key for character input This commit has been copied almost verbatim from Bryce Harrington’s patch against Weston’s toytoolkit[1]. He gave his agreement to relicense it under zlib[2]. [1] https://patchwork.freedesktop.org/patch/114661/ [2] https://github.com/glfw/glfw/pull/879#issuecomment-252988257	2016-10-16 13:51:59 +01:00
Camilla Berglund	efc6b35615	Rename joystick ID variables	2016-10-16 14:07:18 +02:00
Camilla Berglund	bf747e32b4	Remove unused variables in gamma test	2016-10-16 14:07:18 +02:00
Camilla Berglund	ef15735161	Make Escape exit threads test	2016-10-16 14:07:18 +02:00
Camilla Berglund	99c65bb67c	Cleanup Related to #883.	2016-10-16 13:59:21 +02:00
Sergey Tikhomirov	967e837c73	Cocoa: Fix 'first responder' error on macOS 10.12 Error message is displayed during the startup because Cocoa view is set as the first responder for window but this view isn't in this window (actually it is not in any window at all). Fixes #876. Closes #883.	2016-10-16 13:58:52 +02:00
Camilla Berglund	ca084d40c1	Cleanup Related to #852.	2016-10-14 01:05:23 +02:00
Mário Freitas	238ebb600d	Cocoa: Fix assert on disabling window aspect ratio When disabling window aspect ratio, a system assert would trigger. The correct way to disable window aspect ratio is to set a resize increment. Closes #852.	2016-10-14 01:05:23 +02:00
Emmanuel Gil Peyrot	a49601ba87	Wayland: Rename snake_case identifiers to camelCase for consistency	2016-10-12 14:13:52 +01:00
Emmanuel Gil Peyrot	aa10ec6e45	Wayland: Replace all deprecated xkbcommon aliases.	2016-10-11 01:49:23 +01:00
Emmanuel Gil Peyrot	be935debe9	Wayland: Properly unref all xkbcommon objects.	2016-10-11 01:49:23 +01:00
Emmanuel Gil Peyrot	1c8a74b661	Wayland: Properly destroy all bound objects.	2016-10-11 01:49:23 +01:00
Camilla Berglund	73ddbc3acd	Cocoa: Add workaround for hasty deprecation	2016-10-09 13:11:52 +02:00
Camilla Berglund	7f9840cecf	Cocoa: Fix macOS 10.12 deprecation warnings	2016-10-09 01:39:31 +02:00
Camilla Berglund	cc3036860a	Add list window to joystick test	2016-10-06 19:08:35 +02:00
Camilla Berglund	2af40c3fe6	Update Nuklear to 1.156	2016-10-06 19:07:47 +02:00
Camilla Berglund	ea1958a948	Replace sprintf with snprintf	2016-09-30 05:31:07 +02:00
Camilla Berglund	9d42e146e7	Add aspect ratio to monitor test mode listing	2016-09-30 03:44:13 +02:00
Camilla Berglund	c156b50e4c	Add glfwSetWindowMaximizeCallback Fixes #778.	2016-09-29 01:24:56 +02:00
Camilla Berglund	3752d68e7d	Fix Clang warnings in Nuklear	2016-09-29 01:24:56 +02:00
Camilla Berglund	cb860e8150	Fix gamma test rendering using wrong unit	2016-09-29 01:24:56 +02:00
Camilla Berglund	434238fcd4	Fix checks for Vulkan surface extension presence	2016-09-29 01:24:56 +02:00
Camilla Berglund	2d10547266	Add missing changelog issue number	2016-09-29 01:06:40 +02:00
Camilla Berglund	f9a21281c4	Cleanup Related to #871.	2016-09-28 23:51:08 +02:00
Kyle Brenneman	d590eb074f	Add support for EGL_KHR_get_all_proc_addresses If EGL_KHR_get_all_proc_addresses extension is supported, then don't try to load a separate client library. Instead, just use eglGetProcAddress to load everything. This can also avoid problems with trying to use OpenGL functions from libGL.so.1 (which is the GLX library) when an EGL context is current. Closes #871.	2016-09-28 22:50:22 +02:00
Camilla Berglund	66ff4aae89	Convert joystick test to Nuklear	2016-09-27 02:13:55 +02:00
Camilla Berglund	450d0d69af	Convert gamma test to Nuklear	2016-09-27 02:13:42 +02:00
Camilla Berglund	28889954ef	Use glad booleans in glfwinfo	2016-09-26 14:55:55 +02:00
Camilla Berglund	f0a55df963	Cleanup	2016-09-26 13:26:36 +02:00
Camilla Berglund	40fff219b5	Add Nuklear	2016-09-25 14:12:04 +02:00
Camilla Berglund	2ed818bc03	Move to GL_KHR_debug Thank you, @linkmauve.	2016-09-23 14:27:20 +02:00
Camilla Berglund	9017eaee08	Add debug extension support to sharing test	2016-09-22 01:43:26 +02:00
Camilla Berglund	38aae024cd	Update glad, add debug extensions	2016-09-22 01:09:36 +02:00
Camilla Berglund	1fc11c27e7	Fix broken GLSL in sharing test Thank you, Intel, for sticking to the spec.	2016-09-21 18:19:15 +02:00
Camilla Berglund	c4a8930909	Cleanup	2016-09-21 16:23:38 +02:00
Camilla Berglund	a280c97321	Convert reopen test to GL2	2016-09-21 16:21:03 +02:00
Camilla Berglund	dfd1c85916	Clarify sharing test output	2016-09-21 16:20:04 +02:00
Camilla Berglund	fc86d741db	Fix copypaste mistake	2016-09-20 15:01:15 +02:00
Camilla Berglund	ca38af0d83	Convert sharing test to GL2	2016-09-20 15:00:18 +02:00
Camilla Berglund	f7584bf14c	Convert cursor test to GL2	2016-09-19 22:19:20 +02:00
Camilla Berglund	0090ce3df7	Update Vulkan headers to 1.0.26.0 SDK	2016-09-14 23:27:34 +02:00
Camilla Berglund	433db8f9f9	Allow combining Vulkan and GL/GLES header macros	2016-09-14 22:59:12 +02:00
Camilla Berglund	7e9e321c38	Add @ref tags for Vim syntax highlighting	2016-09-14 22:59:11 +02:00
Camilla Berglund	6ac1ed18ea	Formatting	2016-09-14 22:59:10 +02:00
Camilla Berglund	54930ddd33	Check only for relevant Vulkan extensions Related to #858.	2016-09-14 22:59:03 +02:00
Camilla Berglund	3e59b7345c	Fix early-out in Vulkan extension check Related to #858.	2016-09-14 18:15:09 +02:00
Camilla Berglund	838c4e938c	Win32: Allow iconifying undecorated windows Fixes #861.	2016-09-14 18:12:21 +02:00
Camilla Berglund	f79a52fe9b	Win32: Make glfwPostEmptyEvent use helper window	2016-09-14 13:07:52 +02:00
Emmanuel Gil Peyrot	2eb1657d91	Wayland: Only input a character on GLFW_PRESS action Closes #804.	2016-09-13 13:09:25 +09:00
Camilla Berglund	e6a32db7b9	Cleanup	2016-09-07 16:49:29 +02:00
Brandon Schaefer	acce7ec9cf	Mir: Add cursor mode support Implements a few other missing functions. Cleaning up naming convention as well. Fix FindMir.cmake was not finding the correct mirclient.so when you wanted something other then the system library. Closes #839.	2016-09-07 16:49:29 +02:00
Camilla Berglund	fbb2d5e10d	Convert tearing test to GL2	2016-09-07 16:49:29 +02:00
Camilla Berglund	f86edf8d3c	Remove GL1 from gamma test	2016-09-07 16:49:28 +02:00
Camilla Berglund	08ba147241	Remove GL1 from clipboard test	2016-09-07 16:49:28 +02:00
Camilla Berglund	2b6a139526	Make Escape exit msaa test	2016-09-07 16:49:28 +02:00
Camilla Berglund	9f60cd18e3	Convert msaa test to GL2	2016-09-07 16:49:28 +02:00
Camilla Berglund	ac7b3e405c	Cleanup	2016-09-07 16:49:28 +02:00
Camilla Berglund	bb3cb8f233	Cleanup Clean up code and documentation for glfwGetKeyScancode and add implementation for Wayland and Mir. Related to #830.	2016-09-07 16:46:48 +02:00
Michael Stocker	e745b0dd47	Add glfwGetKeyScancode Allows retrieval of platform scancode from GLFW_KEY_*. Implemented for Win32, Cocoa and X11. Stubs for Mir and Wayland. Closes #830.	2016-09-07 16:38:22 +02:00
Camilla Berglund	f17d60da64	Add scancode arrays for Wayland and Mir Related to #830.	2016-09-07 16:33:41 +02:00
Camilla Berglund	afb6e485b7	X11: Make selection event checks include window	2016-09-07 16:33:41 +02:00
Camilla Berglund	ccfd6dde45	X11: Make clipboard IPC use helper window	2016-09-07 16:33:41 +02:00
Camilla Berglund	706868dad8	X11: Make glfwPostEmptyEvent use helper window	2016-09-07 16:33:41 +02:00
Camilla Berglund	3b3a1390ad	X11: Add IPC helper window	2016-09-07 16:33:41 +02:00
Camilla Berglund	fafe1732b5	Cleanup	2016-09-07 16:33:41 +02:00
Camilla Berglund	5ff7d9505f	Simplify Vulkan extension checks Related to #478.	2016-09-07 16:31:18 +02:00
Camilla Berglund	2e6a110181	Add credit Add missing credit for `1592b40e25`.	2016-08-22 16:12:04 +02:00
Camilla Berglund	1592b40e25	Fix particles stutter caused by malformed timeout Closes #836.	2016-08-22 15:55:29 +02:00
Camilla Berglund	9cd0c101f0	Fix glfwMaximizeWindow not checking window mode	2016-08-21 17:43:40 +02:00