Merge commit '708ba1ce3f79570553a7eccbdd69cb75eda78bfb'

72 files changed, 11455 insertions, 11523 deletions

diff --git a/subprojects/nk_pugl/VERSION b/subprojects/nk_pugl/VERSION
index a63a9fe..ae51b49 100644
--- a/subprojects/nk_pugl/VERSION
+++ b/subprojects/nk_pugl/VERSION
@@ -1 +1 @@
-0.1.159
+0.1.169
diff --git a/subprojects/nk_pugl/meson.build b/subprojects/nk_pugl/meson.build
index 5783420..19b855f 100644
--- a/subprojects/nk_pugl/meson.build
+++ b/subprojects/nk_pugl/meson.build
@@ -61,6 +61,7 @@ else
 endif
 
 nk_pugl_gl = declare_dependency(
+	compile_args : ['-DPUGL_STATIC'],
 	include_directories : inc_dir,
 	dependencies : deps,
 	link_args : links,
diff --git a/subprojects/nk_pugl/pugl/.clang-format b/subprojects/nk_pugl/pugl/.clang-format
index a505e26..7b30bd2 100644
--- a/subprojects/nk_pugl/pugl/.clang-format
+++ b/subprojects/nk_pugl/pugl/.clang-format
@@ -1,127 +1,28 @@
 ---
-# Language:        Cpp
-# BasedOnStyle:  Mozilla
-AccessModifierOffset: -4
-AlignAfterOpenBracket: Align
 AlignConsecutiveAssignments: true
 AlignConsecutiveDeclarations: true
-AlignEscapedNewlines: Left
-AlignOperands:   true
-AlignTrailingComments: true
-AllowAllArgumentsOnNextLine: true
-AllowAllConstructorInitializersOnNextLine: false
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: Inline
-AllowShortLambdasOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: TopLevel
-AlwaysBreakAfterReturnType: TopLevel
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: Yes
-BinPackArguments: false
-BinPackParameters: false
+AlignEscapedNewlinesLeft: true
+BasedOnStyle: Mozilla
 BraceWrapping:
-  AfterCaseLabel:  false
-  AfterClass:      true
-  AfterControlStatement: false
-  AfterEnum:       false
-  AfterFunction:   true
-  AfterNamespace:  false
-  AfterObjCDeclaration: true
-  AfterStruct:     false
-  AfterUnion:      false
+  AfterNamespace: false
+  AfterClass: true
+  AfterEnum: false
   AfterExternBlock: false
-  BeforeCatch:     false
-  BeforeElse:      false
-  IndentBraces:    false
-  SplitEmptyFunction: true
+  AfterFunction: true
+  AfterStruct: false
+  SplitEmptyFunction: false
   SplitEmptyRecord: false
-  SplitEmptyNamespace: true
-BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
-BreakBeforeInheritanceComma: false
-BreakInheritanceList: BeforeComma
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakConstructorInitializers: BeforeComma
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     80
-CommentPragmas:  '^ IWYU pragma:'
-CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
 Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: true
-ForEachMacros:
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-IncludeBlocks:   Preserve
-IncludeCategories:
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-    Priority:        2
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
-    Priority:        3
-  - Regex:           '.*'
-    Priority:        1
-IncludeIsMainRegex: '(Test)?$'
 IndentCaseLabels: false
 IndentPPDirectives: AfterHash
-IndentWidth:     4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBinPackProtocolList: Auto
-ObjCBlockIndentWidth: 4
-ObjCSpaceAfterProperty: true
-ObjCSpaceBeforeProtocolList: false
-PenaltyBreakAssignment: 100
-PenaltyBreakBeforeFirstCallParameter: 100
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyBreakTemplateDeclaration: 10
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 0
-PointerAlignment: Left
-ReflowComments:  true
-SortIncludes:    true
-SortUsingDeclarations: true
-SpaceAfterCStyleCast: false
-SpaceAfterLogicalNot: false
-SpaceAfterTemplateKeyword: false
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCpp11BracedList: false
-SpaceBeforeCtorInitializerColon: true
-SpaceBeforeInheritanceColon: true
-SpaceBeforeParens: ControlStatements
-SpaceBeforeRangeBasedForLoopColon: true
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-Standard:        Cpp11
+KeepEmptyLinesAtTheStartOfBlocks: false
+SpacesInContainerLiterals: false
 StatementMacros:
   - PUGL_API
+  - PUGL_CONST_API
+  - PUGL_CONST_FUNC
   - PUGL_DEPRECATED_BY
   - PUGL_UNUSED
-TabWidth:        4
-UseTab:          ForIndentation
+  - _Pragma
 ...
-
diff --git a/subprojects/nk_pugl/pugl/.clant.json b/subprojects/nk_pugl/pugl/.clant.json
new file mode 100644
index 0000000..6f48901
--- /dev/null
+++ b/subprojects/nk_pugl/pugl/.clant.json
@@ -0,0 +1,13 @@
+{
+  "version": "1.0.0",
+  "include_dirs": [
+    "bindings/cxx/include",
+    "include"
+  ],
+  "exclude_patterns": [
+    "glad\\.c"
+  ],
+  "mapping_files": [
+    ".includes.imp"
+  ]
+}
diff --git a/subprojects/nk_pugl/pugl/.editorconfig b/subprojects/nk_pugl/pugl/.editorconfig
index 5213b6b..c2d35dd 100644
--- a/subprojects/nk_pugl/pugl/.editorconfig
+++ b/subprojects/nk_pugl/pugl/.editorconfig
@@ -7,7 +7,8 @@ trim_trailing_whitespace = true
 insert_final_newline = true
 
 [*.{c,h,m,cpp,hpp,mm,glsl,frag,vert}]
-indent_style = tab
+indent_style = space
+indent_size = 2
 
 [wscript]
 indent_style = space
diff --git a/subprojects/nk_pugl/pugl/.includes.imp b/subprojects/nk_pugl/pugl/.includes.imp
new file mode 100644
index 0000000..74a3105
--- /dev/null
+++ b/subprojects/nk_pugl/pugl/.includes.imp
@@ -0,0 +1,4 @@
+[
+  { "include": [ "<ext/alloc_traits.h>", "private", "<string>", "public", ] },
+  { "include": [ "<ext/alloc_traits.h>", "private", "<vector>", "public", ] }
+]
diff --git a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/cairo.hpp b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/cairo.hpp
index 7416589..126bfe3 100644
--- a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/cairo.hpp
+++ b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/cairo.hpp
@@ -33,7 +33,7 @@ namespace pugl {
 inline const PuglBackend*
 cairoBackend() noexcept
 {
-	return puglCairoBackend();
+  return puglCairoBackend();
 }
 
 /**
diff --git a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/gl.hpp b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/gl.hpp
index d8459a8..c845d80 100644
--- a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/gl.hpp
+++ b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/gl.hpp
@@ -37,28 +37,28 @@ using GlFunc = PuglGlFunc;
 inline GlFunc
 getProcAddress(const char* name) noexcept
 {
-	return puglGetProcAddress(name);
+  return puglGetProcAddress(name);
 }
 
 /// @copydoc puglEnterContext
 inline Status
 enterContext(View& view) noexcept
 {
-	return static_cast<Status>(puglEnterContext(view.cobj()));
+  return static_cast<Status>(puglEnterContext(view.cobj()));
 }
 
 /// @copydoc puglLeaveContext
 inline Status
 leaveContext(View& view) noexcept
 {
-	return static_cast<Status>(puglLeaveContext(view.cobj()));
+  return static_cast<Status>(puglLeaveContext(view.cobj()));
 }
 
 /// @copydoc puglGlBackend
 inline const PuglBackend*
 glBackend() noexcept
 {
-	return puglGlBackend();
+  return puglGlBackend();
 }
 
 /**
diff --git a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/pugl.hpp b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/pugl.hpp
index 1a07734..9e65589 100644
--- a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/pugl.hpp
+++ b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/pugl.hpp
@@ -22,9 +22,9 @@
 #include <cstdint>
 
 #if defined(PUGL_HPP_THROW_FAILED_CONSTRUCTION)
-#	include <exception>
+#  include <exception>
 #elif defined(PUGL_HPP_ASSERT_CONSTRUCTION)
-#	include <cassert>
+#  include <cassert>
 #endif
 
 namespace pugl {
@@ -46,34 +46,34 @@ template<class T, FreeFunc<T> Free>
 class Wrapper
 {
 public:
-	Wrapper(const Wrapper&) = delete;
-	Wrapper& operator=(const Wrapper&) = delete;
+  Wrapper(const Wrapper&) = delete;
+  Wrapper& operator=(const Wrapper&) = delete;
 
-	Wrapper(Wrapper&& wrapper) noexcept
-	    : _ptr{wrapper._ptr}
-	{
-		wrapper._ptr = nullptr;
-	}
+  Wrapper(Wrapper&& wrapper) noexcept
+    : _ptr{wrapper._ptr}
+  {
+    wrapper._ptr = nullptr;
+  }
 
-	Wrapper& operator=(Wrapper&& wrapper) noexcept
-	{
-		_ptr         = wrapper._ptr;
-		wrapper._ptr = nullptr;
-		return *this;
-	}
+  Wrapper& operator=(Wrapper&& wrapper) noexcept
+  {
+    _ptr         = wrapper._ptr;
+    wrapper._ptr = nullptr;
+    return *this;
+  }
 
-	~Wrapper() noexcept { Free(_ptr); }
+  ~Wrapper() noexcept { Free(_ptr); }
 
-	T*       cobj() noexcept { return _ptr; }
-	const T* cobj() const noexcept { return _ptr; }
+  T*       cobj() noexcept { return _ptr; }
+  const T* cobj() const noexcept { return _ptr; }
 
 protected:
-	explicit Wrapper(T* ptr) noexcept
-	    : _ptr{ptr}
-	{}
+  explicit Wrapper(T* ptr) noexcept
+    : _ptr{ptr}
+  {}
 
 private:
-	T* _ptr;
+  T* _ptr;
 };
 
 } // namespace detail
@@ -97,11 +97,11 @@ using Rect = PuglRect; ///< @copydoc PuglRect
 */
 template<PuglEventType t, class Base>
 struct Event final : Base {
-	/// The type of the corresponding C event structure
-	using BaseEvent = Base;
+  /// The type of the corresponding C event structure
+  using BaseEvent = Base;
 
-	/// The `type` field of the corresponding C event structure
-	static constexpr const PuglEventType type = t;
+  /// The `type` field of the corresponding C event structure
+  static constexpr const PuglEventType type = t;
 };
 
 using Mod          = PuglMod;          ///< @copydoc PuglMod
@@ -189,18 +189,18 @@ using LoopLeaveEvent = Event<PUGL_LOOP_LEAVE, PuglEventLoopLeave>;
 
 /// @copydoc PuglStatus
 enum class Status {
-	success,             ///< @copydoc PUGL_SUCCESS
-	failure,             ///< @copydoc PUGL_FAILURE
-	unknownError,        ///< @copydoc PUGL_UNKNOWN_ERROR
-	badBackend,          ///< @copydoc PUGL_BAD_BACKEND
-	badConfiguration,    ///< @copydoc PUGL_BAD_CONFIGURATION
-	badParameter,        ///< @copydoc PUGL_BAD_PARAMETER
-	backendFailed,       ///< @copydoc PUGL_BACKEND_FAILED
-	registrationFailed,  ///< @copydoc PUGL_REGISTRATION_FAILED
-	realizeFailed,       ///< @copydoc PUGL_REALIZE_FAILED
-	setFormatFailed,     ///< @copydoc PUGL_SET_FORMAT_FAILED
-	createContextFailed, ///< @copydoc PUGL_CREATE_CONTEXT_FAILED
-	unsupportedType,     ///< @copydoc PUGL_UNSUPPORTED_TYPE
+  success,             ///< @copydoc PUGL_SUCCESS
+  failure,             ///< @copydoc PUGL_FAILURE
+  unknownError,        ///< @copydoc PUGL_UNKNOWN_ERROR
+  badBackend,          ///< @copydoc PUGL_BAD_BACKEND
+  badConfiguration,    ///< @copydoc PUGL_BAD_CONFIGURATION
+  badParameter,        ///< @copydoc PUGL_BAD_PARAMETER
+  backendFailed,       ///< @copydoc PUGL_BACKEND_FAILED
+  registrationFailed,  ///< @copydoc PUGL_REGISTRATION_FAILED
+  realizeFailed,       ///< @copydoc PUGL_REALIZE_FAILED
+  setFormatFailed,     ///< @copydoc PUGL_SET_FORMAT_FAILED
+  createContextFailed, ///< @copydoc PUGL_CREATE_CONTEXT_FAILED
+  unsupportedType,     ///< @copydoc PUGL_UNSUPPORTED_TYPE
 };
 
 static_assert(Status(PUGL_UNSUPPORTED_TYPE) == Status::unsupportedType, "");
@@ -209,7 +209,7 @@ static_assert(Status(PUGL_UNSUPPORTED_TYPE) == Status::unsupportedType, "");
 inline const char*
 strerror(const Status status) noexcept
 {
-	return puglStrerror(static_cast<PuglStatus>(status));
+  return puglStrerror(static_cast<PuglStatus>(status));
 }
 
 /**
@@ -220,15 +220,15 @@ strerror(const Status status) noexcept
 
 /// @copydoc PuglWorldType
 enum class WorldType {
-	program, ///< @copydoc PUGL_PROGRAM
-	module,  ///< @copydoc PUGL_MODULE
+  program, ///< @copydoc PUGL_PROGRAM
+  module,  ///< @copydoc PUGL_MODULE
 };
 
 static_assert(WorldType(PUGL_MODULE) == WorldType::module, "");
 
 /// @copydoc PuglWorldFlag
 enum class WorldFlag {
-	threads = PUGL_WORLD_THREADS, ///< @copydoc PUGL_WORLD_THREADS
+  threads = PUGL_WORLD_THREADS, ///< @copydoc PUGL_WORLD_THREADS
 };
 
 static_assert(WorldFlag(PUGL_WORLD_THREADS) == WorldFlag::threads, "");
@@ -241,25 +241,25 @@ using WorldFlags = PuglWorldFlags; ///< @copydoc PuglWorldFlags
 class FailedConstructionError : public std::exception
 {
 public:
-	FailedConstructionError(const char* const msg) noexcept
-	    : _msg{msg}
-	{}
+  FailedConstructionError(const char* const msg) noexcept
+    : _msg{msg}
+  {}
 
-	virtual const char* what() const noexcept override;
+  virtual const char* what() const noexcept override;
 
 private:
-	const char* _msg;
+  const char* _msg;
 };
 
-#	define PUGL_CHECK_CONSTRUCTION(cond, msg)      \
-		do {                                        \
-			if (!(cond)) {                          \
-				throw FailedConstructionError(msg); \
-			}                                       \
-		} while (0)
+#  define PUGL_CHECK_CONSTRUCTION(cond, msg) \
+    do {                                     \
+      if (!(cond)) {                         \
+        throw FailedConstructionError(msg);  \
+      }                                      \
+    } while (0)
 
 #elif defined(PUGL_HPP_ASSERT_CONSTRUCTION)
-#	define PUGL_CHECK_CONSTRUCTION(cond, msg) assert(cond);
+#  define PUGL_CHECK_CONSTRUCTION(cond, msg) assert(cond);
 #else
 /**
    Configurable macro for handling construction failure.
@@ -272,55 +272,55 @@ private:
 
    Otherwise, this does nothing.
 */
-#	define PUGL_CHECK_CONSTRUCTION(cond, msg)
+#  define PUGL_CHECK_CONSTRUCTION(cond, msg)
 #endif
 
 /// @copydoc PuglWorld
 class World : public detail::Wrapper<PuglWorld, puglFreeWorld>
 {
 public:
-	World(const World&) = delete;
-	World& operator=(const World&) = delete;
-
-	World(World&&) = delete;
-	World& operator=(World&&) = delete;
-
-	~World() = default;
-
-	World(WorldType type, WorldFlag flag)
-	    : Wrapper{puglNewWorld(static_cast<PuglWorldType>(type),
-	                           static_cast<PuglWorldFlags>(flag))}
-	{
-		PUGL_CHECK_CONSTRUCTION(cobj(), "Failed to create pugl::World");
-	}
-
-	World(WorldType type, WorldFlags flags)
-	    : Wrapper{puglNewWorld(static_cast<PuglWorldType>(type), flags)}
-	{
-		PUGL_CHECK_CONSTRUCTION(cobj(), "Failed to create pugl::World");
-	}
-
-	explicit World(WorldType type)
-	    : World{type, WorldFlags{}}
-	{}
-
-	/// @copydoc puglGetNativeWorld
-	void* nativeWorld() noexcept { return puglGetNativeWorld(cobj()); }
-
-	/// @copydoc puglSetClassName
-	Status setClassName(const char* const name) noexcept
-	{
-		return static_cast<Status>(puglSetClassName(cobj(), name));
-	}
-
-	/// @copydoc puglGetTime
-	double time() const noexcept { return puglGetTime(cobj()); }
-
-	/// @copydoc puglUpdate
-	Status update(const double timeout) noexcept
-	{
-		return static_cast<Status>(puglUpdate(cobj(), timeout));
-	}
+  World(const World&) = delete;
+  World& operator=(const World&) = delete;
+
+  World(World&&) = delete;
+  World& operator=(World&&) = delete;
+
+  ~World() = default;
+
+  World(WorldType type, WorldFlag flag)
+    : Wrapper{puglNewWorld(static_cast<PuglWorldType>(type),
+                           static_cast<PuglWorldFlags>(flag))}
+  {
+    PUGL_CHECK_CONSTRUCTION(cobj(), "Failed to create pugl::World");
+  }
+
+  World(WorldType type, WorldFlags flags)
+    : Wrapper{puglNewWorld(static_cast<PuglWorldType>(type), flags)}
+  {
+    PUGL_CHECK_CONSTRUCTION(cobj(), "Failed to create pugl::World");
+  }
+
+  explicit World(WorldType type)
+    : World{type, WorldFlags{}}
+  {}
+
+  /// @copydoc puglGetNativeWorld
+  void* nativeWorld() noexcept { return puglGetNativeWorld(cobj()); }
+
+  /// @copydoc puglSetClassName
+  Status setClassName(const char* const name) noexcept
+  {
+    return static_cast<Status>(puglSetClassName(cobj(), name));
+  }
+
+  /// @copydoc puglGetTime
+  double time() const noexcept { return puglGetTime(cobj()); }
+
+  /// @copydoc puglUpdate
+  Status update(const double timeout) noexcept
+  {
+    return static_cast<Status>(puglUpdate(cobj(), timeout));
+  }
 };
 
 /**
@@ -334,22 +334,22 @@ using NativeView = PuglNativeView; ///< @copydoc PuglNativeView
 
 /// @copydoc PuglViewHint
 enum class ViewHint {
-	useCompatProfile,    ///< @copydoc PUGL_USE_COMPAT_PROFILE
-	useDebugContext,     ///< @copydoc PUGL_USE_DEBUG_CONTEXT
-	contextVersionMajor, ///< @copydoc PUGL_CONTEXT_VERSION_MAJOR
-	contextVersionMinor, ///< @copydoc PUGL_CONTEXT_VERSION_MINOR
-	redBits,             ///< @copydoc PUGL_RED_BITS
-	greenBits,           ///< @copydoc PUGL_GREEN_BITS
-	blueBits,            ///< @copydoc PUGL_BLUE_BITS
-	alphaBits,           ///< @copydoc PUGL_ALPHA_BITS
-	depthBits,           ///< @copydoc PUGL_DEPTH_BITS
-	stencilBits,         ///< @copydoc PUGL_STENCIL_BITS
-	samples,             ///< @copydoc PUGL_SAMPLES
-	doubleBuffer,        ///< @copydoc PUGL_DOUBLE_BUFFER
-	swapInterval,        ///< @copydoc PUGL_SWAP_INTERVAL
-	resizable,           ///< @copydoc PUGL_RESIZABLE
-	ignoreKeyRepeat,     ///< @copydoc PUGL_IGNORE_KEY_REPEAT
-	refreshRate,         ///< @copydoc PUGL_REFRESH_RATE
+  useCompatProfile,    ///< @copydoc PUGL_USE_COMPAT_PROFILE
+  useDebugContext,     ///< @copydoc PUGL_USE_DEBUG_CONTEXT
+  contextVersionMajor, ///< @copydoc PUGL_CONTEXT_VERSION_MAJOR
+  contextVersionMinor, ///< @copydoc PUGL_CONTEXT_VERSION_MINOR
+  redBits,             ///< @copydoc PUGL_RED_BITS
+  greenBits,           ///< @copydoc PUGL_GREEN_BITS
+  blueBits,            ///< @copydoc PUGL_BLUE_BITS
+  alphaBits,           ///< @copydoc PUGL_ALPHA_BITS
+  depthBits,           ///< @copydoc PUGL_DEPTH_BITS
+  stencilBits,         ///< @copydoc PUGL_STENCIL_BITS
+  samples,             ///< @copydoc PUGL_SAMPLES
+  doubleBuffer,        ///< @copydoc PUGL_DOUBLE_BUFFER
+  swapInterval,        ///< @copydoc PUGL_SWAP_INTERVAL
+  resizable,           ///< @copydoc PUGL_RESIZABLE
+  ignoreKeyRepeat,     ///< @copydoc PUGL_IGNORE_KEY_REPEAT
+  refreshRate,         ///< @copydoc PUGL_REFRESH_RATE
 };
 
 static_assert(ViewHint(PUGL_REFRESH_RATE) == ViewHint::refreshRate, "");
@@ -358,13 +358,13 @@ using ViewHintValue = PuglViewHintValue; ///< @copydoc PuglViewHintValue
 
 /// @copydoc PuglCursor
 enum class Cursor {
-	arrow,     ///< @copydoc PUGL_CURSOR_ARROW
-	caret,     ///< @copydoc PUGL_CURSOR_CARET
-	crosshair, ///< @copydoc PUGL_CURSOR_CROSSHAIR
-	hand,      ///< @copydoc PUGL_CURSOR_HAND
-	no,        ///< @copydoc PUGL_CURSOR_NO
-	leftRight, ///< @copydoc PUGL_CURSOR_LEFT_RIGHT
-	upDown,    ///< @copydoc PUGL_CURSOR_UP_DOWN
+  arrow,     ///< @copydoc PUGL_CURSOR_ARROW
+  caret,     ///< @copydoc PUGL_CURSOR_CARET
+  crosshair, ///< @copydoc PUGL_CURSOR_CROSSHAIR
+  hand,      ///< @copydoc PUGL_CURSOR_HAND
+  no,        ///< @copydoc PUGL_CURSOR_NO
+  leftRight, ///< @copydoc PUGL_CURSOR_LEFT_RIGHT
+  upDown,    ///< @copydoc PUGL_CURSOR_UP_DOWN
 };
 
 static_assert(Cursor(PUGL_CURSOR_UP_DOWN) == Cursor::upDown, "");
@@ -373,332 +373,312 @@ static_assert(Cursor(PUGL_CURSOR_UP_DOWN) == Cursor::upDown, "");
 class View : protected detail::Wrapper<PuglView, puglFreeView>
 {
 public:
-	/**
-	   @name Setup
-	   Methods for creating and destroying a view.
-	   @{
-	*/
-
-	explicit View(World& world)
-	    : Wrapper{puglNewView(world.cobj())}
-	    , _world(world)
-	{
-		PUGL_CHECK_CONSTRUCTION(cobj(), "Failed to create pugl::View");
-	}
-
-	const World& world() const noexcept { return _world; }
-	World&       world() noexcept { return _world; }
-
-	/**
-	   Set the object that will be called to handle events.
-
-	   This is a type-safe wrapper for the C functions puglSetHandle() and
-	   puglSetEventFunc() that will automatically dispatch events to the
-	   `onEvent` method of `handler` that takes the appropriate event type.
-	   The handler must have such a method defined for every event type, but if
-	   the handler is the view itself, a `using` declaration can be used to
-	   "inherit" the default implementation to avoid having to define every
-	   method.  For example:
-
-	   @code
-	   class MyView : public pugl::View
-	   {
-	   public:
-	       explicit MyView(pugl::World& world)
-	           : pugl::View{world}
-	       {
-	           setEventHandler(*this);
-	       }
-
-	       using pugl::View::onEvent;
-
-	       pugl::Status onEvent(const pugl::ConfigureEvent& event) noexcept;
-	       pugl::Status onEvent(const pugl::ExposeEvent& event) noexcept;
-	   };
-	   @endcode
-
-	   This facility is just a convenience, applications may use the C API
-	   directly to set a handle and event function to set up a different
-	   approach for event handling.
-	*/
-	template<class Handler>
-	Status setEventHandler(Handler& handler)
-	{
-		puglSetHandle(cobj(), &handler);
-		return static_cast<Status>(
-		    puglSetEventFunc(cobj(), eventFunc<Handler>));
-	}
-
-	/// @copydoc puglSetBackend
-	Status setBackend(const PuglBackend* backend) noexcept
-	{
-		return static_cast<Status>(puglSetBackend(cobj(), backend));
-	}
-
-	/// @copydoc puglSetViewHint
-	Status setHint(ViewHint hint, int value) noexcept
-	{
-		return static_cast<Status>(
-		    puglSetViewHint(cobj(), static_cast<PuglViewHint>(hint), value));
-	}
-
-	/// @copydoc puglGetViewHint
-	int getHint(ViewHint hint) noexcept
-	{
-		return puglGetViewHint(cobj(), static_cast<PuglViewHint>(hint));
-	}
-
-	/**
-	   @}
-	   @name Frame
-	   Methods for working with the position and size of a view.
-	   @{
-	*/
-
-	/// @copydoc puglGetFrame
-	Rect frame() const noexcept { return puglGetFrame(cobj()); }
-
-	/// @copydoc puglSetFrame
-	Status setFrame(Rect frame) noexcept
-	{
-		return static_cast<Status>(puglSetFrame(cobj(), frame));
-	}
-
-	/// @copydoc puglSetDefaultSize
-	Status setDefaultSize(int width, int height) noexcept
-	{
-		return static_cast<Status>(puglSetDefaultSize(cobj(), width, height));
-	}
-
-	/// @copydoc puglSetMinSize
-	Status setMinSize(int width, int height) noexcept
-	{
-		return static_cast<Status>(puglSetMinSize(cobj(), width, height));
-	}
-
-	/// @copydoc puglSetMaxSize
-	Status setMaxSize(int width, int height) noexcept
-	{
-		return static_cast<Status>(puglSetMaxSize(cobj(), width, height));
-	}
-
-	/// @copydoc puglSetAspectRatio
-	Status setAspectRatio(int minX, int minY, int maxX, int maxY) noexcept
-	{
-		return static_cast<Status>(
-		    puglSetAspectRatio(cobj(), minX, minY, maxX, maxY));
-	}
-
-	/**
-	   @}
-	   @name Windows
-	   Methods for working with top-level windows.
-	   @{
-	*/
-
-	/// @copydoc puglSetWindowTitle
-	Status setWindowTitle(const char* title) noexcept
-	{
-		return static_cast<Status>(puglSetWindowTitle(cobj(), title));
-	}
-
-	/// @copydoc puglSetParentWindow
-	Status setParentWindow(NativeView parent) noexcept
-	{
-		return static_cast<Status>(puglSetParentWindow(cobj(), parent));
-	}
-
-	/// @copydoc puglSetTransientFor
-	Status setTransientFor(NativeView parent) noexcept
-	{
-		return static_cast<Status>(puglSetTransientFor(cobj(), parent));
-	}
-
-	/// @copydoc puglRealize
-	Status realize() noexcept
-	{
-		return static_cast<Status>(puglRealize(cobj()));
-	}
-
-	/// @copydoc puglShow
-	Status show() noexcept
-	{
-		return static_cast<Status>(puglShow(cobj()));
-	}
-
-	/// @copydoc puglHide
-	Status hide() noexcept
-	{
-		return static_cast<Status>(puglHide(cobj()));
-	}
-
-	/// @copydoc puglGetVisible
-	bool visible() const noexcept { return puglGetVisible(cobj()); }
-
-	/// @copydoc puglGetNativeWindow
-	NativeView nativeWindow() noexcept { return puglGetNativeWindow(cobj()); }
-
-	/**
-	   @}
-	   @name Graphics
-	   Methods for working with the graphics context and scheduling
-	   redisplays.
-	   @{
-	*/
-
-	/// @copydoc puglGetContext
-	void* context() noexcept { return puglGetContext(cobj()); }
-
-	/// @copydoc puglPostRedisplay
-	Status postRedisplay() noexcept
-	{
-		return static_cast<Status>(puglPostRedisplay(cobj()));
-	}
-
-	/// @copydoc puglPostRedisplayRect
-	Status postRedisplayRect(const Rect rect) noexcept
-	{
-		return static_cast<Status>(puglPostRedisplayRect(cobj(), rect));
-	}
-
-	/**
-	   @}
-	   @name Interaction
-	   Methods for interacting with the user and window system.
-	   @{
-	*/
-
-	/// @copydoc puglGrabFocus
-	Status grabFocus() noexcept
-	{
-		return static_cast<Status>(puglGrabFocus(cobj()));
-	}
-
-	/// @copydoc puglHasFocus
-	bool hasFocus() const noexcept { return puglHasFocus(cobj()); }
-
-	/// @copydoc puglSetCursor
-	Status setCursor(const Cursor cursor) noexcept
-	{
-		return static_cast<Status>(
-		    puglSetCursor(cobj(), static_cast<PuglCursor>(cursor)));
-	}
-
-	/// @copydoc puglRequestAttention
-	Status requestAttention() noexcept
-	{
-		return static_cast<Status>(puglRequestAttention(cobj()));
-	}
-
-	/// @copydoc puglStartTimer
-	Status startTimer(const uintptr_t id, const double timeout) noexcept
-	{
-		return static_cast<Status>(puglStartTimer(cobj(), id, timeout));
-	}
-
-	/// @copydoc puglStopTimer
-	Status stopTimer(const uintptr_t id) noexcept
-	{
-		return static_cast<Status>(puglStopTimer(cobj(), id));
-	}
-
-	/**
-	   @}
-	*/
-
-	PuglView*       cobj() noexcept { return Wrapper::cobj(); }
-	const PuglView* cobj() const noexcept { return Wrapper::cobj(); }
+  /**
+     @name Setup
+     Methods for creating and destroying a view.
+     @{
+  */
+
+  explicit View(World& world)
+    : Wrapper{puglNewView(world.cobj())}
+    , _world(world)
+  {
+    PUGL_CHECK_CONSTRUCTION(cobj(), "Failed to create pugl::View");
+  }
+
+  const World& world() const noexcept { return _world; }
+  World&       world() noexcept { return _world; }
+
+  /**
+     Set the object that will be called to handle events.
+
+     This is a type-safe wrapper for the C functions puglSetHandle() and
+     puglSetEventFunc() that will automatically dispatch events to the
+     `onEvent` method of `handler` that takes the appropriate event type.
+     The handler must have such a method defined for every event type, but if
+     the handler is the view itself, a `using` declaration can be used to
+     "inherit" the default implementation to avoid having to define every
+     method.  For example:
+
+     @code
+     class MyView : public pugl::View
+     {
+     public:
+       explicit MyView(pugl::World& world)
+         : pugl::View{world}
+       {
+         setEventHandler(*this);
+       }
+
+       using pugl::View::onEvent;
+
+       pugl::Status onEvent(const pugl::ConfigureEvent& event) noexcept;
+       pugl::Status onEvent(const pugl::ExposeEvent& event) noexcept;
+     };
+     @endcode
+
+     This facility is just a convenience, applications may use the C API
+     directly to set a handle and event function to set up a different
+     approach for event handling.
+  */
+  template<class Handler>
+  Status setEventHandler(Handler& handler)
+  {
+    puglSetHandle(cobj(), &handler);
+    return static_cast<Status>(puglSetEventFunc(cobj(), eventFunc<Handler>));
+  }
+
+  /// @copydoc puglSetBackend
+  Status setBackend(const PuglBackend* backend) noexcept
+  {
+    return static_cast<Status>(puglSetBackend(cobj(), backend));
+  }
+
+  /// @copydoc puglSetViewHint
+  Status setHint(ViewHint hint, int value) noexcept
+  {
+    return static_cast<Status>(
+      puglSetViewHint(cobj(), static_cast<PuglViewHint>(hint), value));
+  }
+
+  /// @copydoc puglGetViewHint
+  int getHint(ViewHint hint) noexcept
+  {
+    return puglGetViewHint(cobj(), static_cast<PuglViewHint>(hint));
+  }
+
+  /**
+     @}
+     @name Frame
+     Methods for working with the position and size of a view.
+     @{
+  */
+
+  /// @copydoc puglGetFrame
+  Rect frame() const noexcept { return puglGetFrame(cobj()); }
+
+  /// @copydoc puglSetFrame
+  Status setFrame(Rect frame) noexcept
+  {
+    return static_cast<Status>(puglSetFrame(cobj(), frame));
+  }
+
+  /// @copydoc puglSetDefaultSize
+  Status setDefaultSize(int width, int height) noexcept
+  {
+    return static_cast<Status>(puglSetDefaultSize(cobj(), width, height));
+  }
+
+  /// @copydoc puglSetMinSize
+  Status setMinSize(int width, int height) noexcept
+  {
+    return static_cast<Status>(puglSetMinSize(cobj(), width, height));
+  }
+
+  /// @copydoc puglSetMaxSize
+  Status setMaxSize(int width, int height) noexcept
+  {
+    return static_cast<Status>(puglSetMaxSize(cobj(), width, height));
+  }
+
+  /// @copydoc puglSetAspectRatio
+  Status setAspectRatio(int minX, int minY, int maxX, int maxY) noexcept
+  {
+    return static_cast<Status>(
+      puglSetAspectRatio(cobj(), minX, minY, maxX, maxY));
+  }
+
+  /**
+     @}
+     @name Windows
+     Methods for working with top-level windows.
+     @{
+  */
+
+  /// @copydoc puglSetWindowTitle
+  Status setWindowTitle(const char* title) noexcept
+  {
+    return static_cast<Status>(puglSetWindowTitle(cobj(), title));
+  }
+
+  /// @copydoc puglSetParentWindow
+  Status setParentWindow(NativeView parent) noexcept
+  {
+    return static_cast<Status>(puglSetParentWindow(cobj(), parent));
+  }
+
+  /// @copydoc puglSetTransientFor
+  Status setTransientFor(NativeView parent) noexcept
+  {
+    return static_cast<Status>(puglSetTransientFor(cobj(), parent));
+  }
+
+  /// @copydoc puglRealize
+  Status realize() noexcept { return static_cast<Status>(puglRealize(cobj())); }
+
+  /// @copydoc puglShow
+  Status show() noexcept { return static_cast<Status>(puglShow(cobj())); }
+
+  /// @copydoc puglHide
+  Status hide() noexcept { return static_cast<Status>(puglHide(cobj())); }
+
+  /// @copydoc puglGetVisible
+  bool visible() const noexcept { return puglGetVisible(cobj()); }
+
+  /// @copydoc puglGetNativeWindow
+  NativeView nativeWindow() noexcept { return puglGetNativeWindow(cobj()); }
+
+  /**
+     @}
+     @name Graphics
+     Methods for working with the graphics context and scheduling
+     redisplays.
+     @{
+  */
+
+  /// @copydoc puglGetContext
+  void* context() noexcept { return puglGetContext(cobj()); }
+
+  /// @copydoc puglPostRedisplay
+  Status postRedisplay() noexcept
+  {
+    return static_cast<Status>(puglPostRedisplay(cobj()));
+  }
+
+  /// @copydoc puglPostRedisplayRect
+  Status postRedisplayRect(const Rect rect) noexcept
+  {
+    return static_cast<Status>(puglPostRedisplayRect(cobj(), rect));
+  }
+
+  /**
+     @}
+     @name Interaction
+     Methods for interacting with the user and window system.
+     @{
+  */
+
+  /// @copydoc puglGrabFocus
+  Status grabFocus() noexcept
+  {
+    return static_cast<Status>(puglGrabFocus(cobj()));
+  }
+
+  /// @copydoc puglHasFocus
+  bool hasFocus() const noexcept { return puglHasFocus(cobj()); }
+
+  /// @copydoc puglSetCursor
+  Status setCursor(const Cursor cursor) noexcept
+  {
+    return static_cast<Status>(
+      puglSetCursor(cobj(), static_cast<PuglCursor>(cursor)));
+  }
+
+  /// @copydoc puglRequestAttention
+  Status requestAttention() noexcept
+  {
+    return static_cast<Status>(puglRequestAttention(cobj()));
+  }
+
+  /// @copydoc puglStartTimer
+  Status startTimer(const uintptr_t id, const double timeout) noexcept
+  {
+    return static_cast<Status>(puglStartTimer(cobj(), id, timeout));
+  }
+
+  /// @copydoc puglStopTimer
+  Status stopTimer(const uintptr_t id) noexcept
+  {
+    return static_cast<Status>(puglStopTimer(cobj(), id));
+  }
+
+  /**
+     @}
+  */
+
+  PuglView*       cobj() noexcept { return Wrapper::cobj(); }
+  const PuglView* cobj() const noexcept { return Wrapper::cobj(); }
 
 private:
-	template<class Target>
-	static Status dispatch(Target& target, const PuglEvent* event)
-	{
-		switch (event->type) {
-		case PUGL_NOTHING:
-			return Status::success;
-		case PUGL_CREATE:
-			return target.onEvent(static_cast<const CreateEvent&>(event->any));
-		case PUGL_DESTROY:
-			return target.onEvent(static_cast<const DestroyEvent&>(event->any));
-		case PUGL_CONFIGURE:
-			return target.onEvent(
-			    static_cast<const ConfigureEvent&>(event->configure));
-		case PUGL_MAP:
-			return target.onEvent(static_cast<const MapEvent&>(event->any));
-		case PUGL_UNMAP:
-			return target.onEvent(static_cast<const UnmapEvent&>(event->any));
-		case PUGL_UPDATE:
-			return target.onEvent(static_cast<const UpdateEvent&>(event->any));
-		case PUGL_EXPOSE:
-			return target.onEvent(
-			    static_cast<const ExposeEvent&>(event->expose));
-		case PUGL_CLOSE:
-			return target.onEvent(static_cast<const CloseEvent&>(event->any));
-		case PUGL_FOCUS_IN:
-			return target.onEvent(
-			    static_cast<const FocusInEvent&>(event->focus));
-		case PUGL_FOCUS_OUT:
-			return target.onEvent(
-			    static_cast<const FocusOutEvent&>(event->focus));
-		case PUGL_KEY_PRESS:
-			return target.onEvent(
-			    static_cast<const KeyPressEvent&>(event->key));
-		case PUGL_KEY_RELEASE:
-			return target.onEvent(
-			    static_cast<const KeyReleaseEvent&>(event->key));
-		case PUGL_TEXT:
-			return target.onEvent(static_cast<const TextEvent&>(event->text));
-		case PUGL_POINTER_IN:
-			return target.onEvent(
-			    static_cast<const PointerInEvent&>(event->crossing));
-		case PUGL_POINTER_OUT:
-			return target.onEvent(
-			    static_cast<const PointerOutEvent&>(event->crossing));
-		case PUGL_BUTTON_PRESS:
-			return target.onEvent(
-			    static_cast<const ButtonPressEvent&>(event->button));
-		case PUGL_BUTTON_RELEASE:
-			return target.onEvent(
-			    static_cast<const ButtonReleaseEvent&>(event->button));
-		case PUGL_MOTION:
-			return target.onEvent(
-			    static_cast<const MotionEvent&>(event->motion));
-		case PUGL_SCROLL:
-			return target.onEvent(
-			    static_cast<const ScrollEvent&>(event->scroll));
-		case PUGL_CLIENT:
-			return target.onEvent(
-			    static_cast<const ClientEvent&>(event->client));
-		case PUGL_TIMER:
-			return target.onEvent(static_cast<const TimerEvent&>(event->timer));
-		case PUGL_LOOP_ENTER:
-			return target.onEvent(
-			    static_cast<const LoopEnterEvent&>(event->any));
-		case PUGL_LOOP_LEAVE:
-			return target.onEvent(
-			    static_cast<const LoopLeaveEvent&>(event->any));
-		}
-
-		return Status::failure;
-	}
-
-	template<class Target>
-	static PuglStatus eventFunc(PuglView* view, const PuglEvent* event) noexcept
-	{
-		auto* target = static_cast<Target*>(puglGetHandle(view));
+  template<class Target>
+  static Status dispatch(Target& target, const PuglEvent* event)
+  {
+    switch (event->type) {
+    case PUGL_NOTHING:
+      return Status::success;
+    case PUGL_CREATE:
+      return target.onEvent(static_cast<const CreateEvent&>(event->any));
+    case PUGL_DESTROY:
+      return target.onEvent(static_cast<const DestroyEvent&>(event->any));
+    case PUGL_CONFIGURE:
+      return target.onEvent(
+        static_cast<const ConfigureEvent&>(event->configure));
+    case PUGL_MAP:
+      return target.onEvent(static_cast<const MapEvent&>(event->any));
+    case PUGL_UNMAP:
+      return target.onEvent(static_cast<const UnmapEvent&>(event->any));
+    case PUGL_UPDATE:
+      return target.onEvent(static_cast<const UpdateEvent&>(event->any));
+    case PUGL_EXPOSE:
+      return target.onEvent(static_cast<const ExposeEvent&>(event->expose));
+    case PUGL_CLOSE:
+      return target.onEvent(static_cast<const CloseEvent&>(event->any));
+    case PUGL_FOCUS_IN:
+      return target.onEvent(static_cast<const FocusInEvent&>(event->focus));
+    case PUGL_FOCUS_OUT:
+      return target.onEvent(static_cast<const FocusOutEvent&>(event->focus));
+    case PUGL_KEY_PRESS:
+      return target.onEvent(static_cast<const KeyPressEvent&>(event->key));
+    case PUGL_KEY_RELEASE:
+      return target.onEvent(static_cast<const KeyReleaseEvent&>(event->key));
+    case PUGL_TEXT:
+      return target.onEvent(static_cast<const TextEvent&>(event->text));
+    case PUGL_POINTER_IN:
+      return target.onEvent(
+        static_cast<const PointerInEvent&>(event->crossing));
+    case PUGL_POINTER_OUT:
+      return target.onEvent(
+        static_cast<const PointerOutEvent&>(event->crossing));
+    case PUGL_BUTTON_PRESS:
+      return target.onEvent(
+        static_cast<const ButtonPressEvent&>(event->button));
+    case PUGL_BUTTON_RELEASE:
+      return target.onEvent(
+        static_cast<const ButtonReleaseEvent&>(event->button));
+    case PUGL_MOTION:
+      return target.onEvent(static_cast<const MotionEvent&>(event->motion));
+    case PUGL_SCROLL:
+      return target.onEvent(static_cast<const ScrollEvent&>(event->scroll));
+    case PUGL_CLIENT:
+      return target.onEvent(static_cast<const ClientEvent&>(event->client));
+    case PUGL_TIMER:
+      return target.onEvent(static_cast<const TimerEvent&>(event->timer));
+    case PUGL_LOOP_ENTER:
+      return target.onEvent(static_cast<const LoopEnterEvent&>(event->any));
+    case PUGL_LOOP_LEAVE:
+      return target.onEvent(static_cast<const LoopLeaveEvent&>(event->any));
+    }
+
+    return Status::failure;
+  }
+
+  template<class Target>
+  static PuglStatus eventFunc(PuglView* view, const PuglEvent* event) noexcept
+  {
+    auto* target = static_cast<Target*>(puglGetHandle(view));
 
 #ifdef __cpp_exceptions
-		try {
-			return static_cast<PuglStatus>(dispatch(*target, event));
-		} catch (...) {
-			return PUGL_UNKNOWN_ERROR;
-		}
+    try {
+      return static_cast<PuglStatus>(dispatch(*target, event));
+    } catch (...) {
+      return PUGL_UNKNOWN_ERROR;
+    }
 #else
-		return static_cast<PuglStatus>(pugl::dispatch(*target, event));
+    return static_cast<PuglStatus>(pugl::dispatch(*target, event));
 #endif
-	}
+  }
 
-	World& _world;
+  World& _world;
 };
 
 /**
diff --git a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/stub.hpp b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/stub.hpp
index 8b37da4..6946fe0 100644
--- a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/stub.hpp
+++ b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/stub.hpp
@@ -33,7 +33,7 @@ namespace pugl {
 inline const PuglBackend*
 stubBackend() noexcept
 {
-	return puglStubBackend();
+  return puglStubBackend();
 }
 
 /**
diff --git a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/vulkan.hpp b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/vulkan.hpp
index 65d1e57..2612578 100644
--- a/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/vulkan.hpp
+++ b/subprojects/nk_pugl/pugl/bindings/cxx/include/pugl/vulkan.hpp
@@ -1,5 +1,5 @@
 /*
-  Copyright 2012-2020 David Robillard <http://drobilla.net>
+  Copyright 2012-2020 David Robillard <d@drobilla.net>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
@@ -49,48 +49,48 @@ namespace pugl {
 
 /// @copydoc PuglVulkanLoader
 class VulkanLoader final
-    : public detail::Wrapper<PuglVulkanLoader, puglFreeVulkanLoader>
+  : public detail::Wrapper<PuglVulkanLoader, puglFreeVulkanLoader>
 {
 public:
-	/**
-	   Create a new dynamic loader for Vulkan functions.
-
-	   This dynamically loads the Vulkan library and gets the load functions
-	   from it.
-
-	   Note that this constructor does not throw exceptions, though failure is
-	   possible.  To check if the Vulkan library failed to load, test this
-	   loader, which is explicitly convertible to `bool`.  It is safe to use a
-	   failed loader, but the accessors will always return null.
-	*/
-	explicit VulkanLoader(World& world) noexcept
-	    : Wrapper{puglNewVulkanLoader(world.cobj())}
-	{}
-
-	/**
-	   Return the `vkGetInstanceProcAddr` function.
-
-	   @return Null if the Vulkan library failed to load, or does not contain
-	   this function (which is unlikely and indicates a broken system).
-	*/
-	PFN_vkGetInstanceProcAddr getInstanceProcAddrFunc() const noexcept
-	{
-		return cobj() ? puglGetInstanceProcAddrFunc(cobj()) : nullptr;
-	}
-
-	/**
-	   Return the `vkGetDeviceProcAddr` function.
-
-	   @return Null if the Vulkan library failed to load, or does not contain
-	   this function (which is unlikely and indicates a broken system).
-	*/
-	PFN_vkGetDeviceProcAddr getDeviceProcAddrFunc() const noexcept
-	{
-		return cobj() ? puglGetDeviceProcAddrFunc(cobj()) : nullptr;
-	}
-
-	/// Return true if this loader is valid to use
-	explicit operator bool() const noexcept { return cobj(); }
+  /**
+     Create a new dynamic loader for Vulkan functions.
+
+     This dynamically loads the Vulkan library and gets the load functions
+     from it.
+
+     Note that this constructor does not throw exceptions, though failure is
+     possible.  To check if the Vulkan library failed to load, test this
+     loader, which is explicitly convertible to `bool`.  It is safe to use a
+     failed loader, but the accessors will always return null.
+  */
+  explicit VulkanLoader(World& world) noexcept
+    : Wrapper{puglNewVulkanLoader(world.cobj())}
+  {}
+
+  /**
+     Return the `vkGetInstanceProcAddr` function.
+
+     @return Null if the Vulkan library failed to load, or does not contain
+     this function (which is unlikely and indicates a broken system).
+  */
+  PFN_vkGetInstanceProcAddr getInstanceProcAddrFunc() const noexcept
+  {
+    return cobj() ? puglGetInstanceProcAddrFunc(cobj()) : nullptr;
+  }
+
+  /**
+     Return the `vkGetDeviceProcAddr` function.
+
+     @return Null if the Vulkan library failed to load, or does not contain
+     this function (which is unlikely and indicates a broken system).
+  */
+  PFN_vkGetDeviceProcAddr getDeviceProcAddrFunc() const noexcept
+  {
+    return cobj() ? puglGetDeviceProcAddrFunc(cobj()) : nullptr;
+  }
+
+  /// Return true if this loader is valid to use
+  explicit operator bool() const noexcept { return cobj(); }
 };
 
 /**
@@ -102,23 +102,23 @@ public:
 class StaticStringArray final
 {
 public:
-	using value_type     = const char*;
-	using const_iterator = const char* const*;
-	using size_type      = uint32_t;
+  using value_type     = const char*;
+  using const_iterator = const char* const*;
+  using size_type      = uint32_t;
 
-	StaticStringArray(const char* const* strings, const uint32_t size) noexcept
-	    : _strings{strings}
-	    , _size{size}
-	{}
+  StaticStringArray(const char* const* strings, const uint32_t size) noexcept
+    : _strings{strings}
+    , _size{size}
+  {}
 
-	const char* const* begin() const noexcept { return _strings; }
-	const char* const* end() const noexcept { return _strings + _size; }
-	const char* const* data() const noexcept { return _strings; }
-	uint32_t           size() const noexcept { return _size; }
+  const char* const* begin() const noexcept { return _strings; }
+  const char* const* end() const noexcept { return _strings + _size; }
+  const char* const* data() const noexcept { return _strings; }
+  uint32_t           size() const noexcept { return _size; }
 
 private:
-	const char* const* _strings;
-	uint32_t           _size;
+  const char* const* _strings;
+  uint32_t           _size;
 };
 
 /**
@@ -132,10 +132,10 @@ private:
 inline StaticStringArray
 getInstanceExtensions() noexcept
 {
-	uint32_t                 count      = 0;
-	const char* const* const extensions = puglGetInstanceExtensions(&count);
+  uint32_t                 count      = 0;
+  const char* const* const extensions = puglGetInstanceExtensions(&count);
 
-	return StaticStringArray{extensions, count};
+  return StaticStringArray{extensions, count};
 }
 
 /// @copydoc puglCreateSurface
@@ -146,17 +146,17 @@ createSurface(PFN_vkGetInstanceProcAddr          vkGetInstanceProcAddr,
               const VkAllocationCallbacks* const allocator,
               VkSurfaceKHR* const                surface) noexcept
 {
-	const VkResult r = puglCreateSurface(
-	    vkGetInstanceProcAddr, view.cobj(), instance, allocator, surface);
+  const VkResult r = puglCreateSurface(
+    vkGetInstanceProcAddr, view.cobj(), instance, allocator, surface);
 
-	return (!r && !surface) ? VK_ERROR_INITIALIZATION_FAILED : r;
+  return (!r && !surface) ? VK_ERROR_INITIALIZATION_FAILED : r;
 }
 
 /// @copydoc puglVulkanBackend
 inline const PuglBackend*
 vulkanBackend() noexcept
 {
-	return puglVulkanBackend();
+  return puglVulkanBackend();
 }
 
 /**
diff --git a/subprojects/nk_pugl/pugl/doc/c/Doxyfile b/subprojects/nk_pugl/pugl/doc/c/Doxyfile
index fe56f0b..bdc3a46 100644
--- a/subprojects/nk_pugl/pugl/doc/c/Doxyfile
+++ b/subprojects/nk_pugl/pugl/doc/c/Doxyfile
@@ -19,7 +19,7 @@ XML_PROGRAMLISTING     = NO
 SHOW_FILES             = NO
 
 MACRO_EXPANSION        = YES
-PREDEFINED             = PUGL_API PUGL_DISABLE_DEPRECATED PUGL_CONST_FUNC=
+PREDEFINED             = PUGL_API PUGL_DISABLE_DEPRECATED PUGL_CONST_API= PUGL_CONST_FUNC=
 
 INPUT                  = ../../include/pugl/cairo.h \
                          ../../include/pugl/gl.h \
diff --git a/subprojects/nk_pugl/pugl/doc/cpp/Doxyfile b/subprojects/nk_pugl/pugl/doc/cpp/Doxyfile
index 2bb0f9f..0f5f636 100644
--- a/subprojects/nk_pugl/pugl/doc/cpp/Doxyfile
+++ b/subprojects/nk_pugl/pugl/doc/cpp/Doxyfile
@@ -24,7 +24,7 @@ XML_PROGRAMLISTING     = NO
 SHOW_FILES             = NO
 
 MACRO_EXPANSION        = YES
-PREDEFINED             = PUGL_API PUGL_DISABLE_DEPRECATED PUGL_CONST_FUNC=
+PREDEFINED             = PUGL_API PUGL_DISABLE_DEPRECATED PUGL_CONST_API= PUGL_CONST_FUNC=
 
 INPUT                  = ../../include/pugl/cairo.h \
                          ../../include/pugl/gl.h \
diff --git a/subprojects/nk_pugl/pugl/examples/.clang-tidy b/subprojects/nk_pugl/pugl/examples/.clang-tidy
index ad5b75a..fdfa4ea 100644
--- a/subprojects/nk_pugl/pugl/examples/.clang-tidy
+++ b/subprojects/nk_pugl/pugl/examples/.clang-tidy
@@ -1,9 +1,11 @@
 Checks: >
   *,
+  -*-non-private-member-variables-in-classes,
   -*avoid-c-arrays,
   -*magic-numbers,
   -*uppercase-literal-suffix,
   -android-cloexec-fopen,
+  -bugprone-macro-parentheses,
   -bugprone-reserved-identifier,
   -bugprone-suspicious-string-compare,
   -cert-dcl37-c,
@@ -12,26 +14,26 @@ Checks: >
   -clang-analyzer-alpha.*,
   -clang-analyzer-security.FloatLoopCounter,
   -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-macro-usage,
   -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
   -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-static-cast-downcast,
   -cppcoreguidelines-pro-type-vararg,
   -fuchsia-default-arguments,
   -fuchsia-default-arguments-calls,
+  -fuchsia-overloaded-operator,
   -google-runtime-references,
   -hicpp-multiway-paths-covered,
   -hicpp-named-parameter,
   -hicpp-no-array-decay,
   -hicpp-signed-bitwise,
   -hicpp-vararg,
-  -llvm-else-after-return,
   -llvm-header-guard,
   -llvmlibc-*,
   -misc-misplaced-const,
-  -misc-non-private-member-variables-in-classes,
   -modernize-use-trailing-return-type,
-  -readability-else-after-return,
   -readability-implicit-bool-conversion,
   -readability-named-parameter,
 FormatStyle: file
diff --git a/subprojects/nk_pugl/pugl/examples/cube_view.h b/subprojects/nk_pugl/pugl/examples/cube_view.h
index 87bf3b5..71ae88d 100644
--- a/subprojects/nk_pugl/pugl/examples/cube_view.h
+++ b/subprojects/nk_pugl/pugl/examples/cube_view.h
@@ -22,52 +22,55 @@
 #include "demo_utils.h"
 
 #include "pugl/gl.h"
+#include "pugl/pugl.h"
+
+#include <stdbool.h>
 
 // clang-format off
 
 static const float cubeStripVertices[] = {
-	-1.0f,  1.0f,  1.0f, // Front top left
-	 1.0f,  1.0f,  1.0f, // Front top right
-	-1.0f, -1.0f,  1.0f, // Front bottom left
-	 1.0f, -1.0f,  1.0f, // Front bottom right
-	 1.0f, -1.0f, -1.0f, // Back bottom right
-	 1.0f,  1.0f,  1.0f, // Front top right
-	 1.0f,  1.0f, -1.0f, // Back top right
-	-1.0f,  1.0f,  1.0f, // Front top left
-	-1.0f,  1.0f, -1.0f, // Back top left
-	-1.0f, -1.0f,  1.0f, // Front bottom left
-	-1.0f, -1.0f, -1.0f, // Back bottom left
-	 1.0f, -1.0f, -1.0f, // Back bottom right
-	-1.0f,  1.0f, -1.0f, // Back top left
-	 1.0f,  1.0f, -1.0f  // Back top right
+  -1.0f,  1.0f,  1.0f, // Front top left
+  1.0f,  1.0f,  1.0f, // Front top right
+  -1.0f, -1.0f,  1.0f, // Front bottom left
+  1.0f, -1.0f,  1.0f, // Front bottom right
+  1.0f, -1.0f, -1.0f, // Back bottom right
+  1.0f,  1.0f,  1.0f, // Front top right
+  1.0f,  1.0f, -1.0f, // Back top right
+  -1.0f,  1.0f,  1.0f, // Front top left
+  -1.0f,  1.0f, -1.0f, // Back top left
+  -1.0f, -1.0f,  1.0f, // Front bottom left
+  -1.0f, -1.0f, -1.0f, // Back bottom left
+  1.0f, -1.0f, -1.0f, // Back bottom right
+  -1.0f,  1.0f, -1.0f, // Back top left
+  1.0f,  1.0f, -1.0f  // Back top right
 };
 
 static const float cubeFrontLineLoop[] = {
-	-1.0f,  1.0f,  1.0f, // Front top left
-	 1.0f,  1.0f,  1.0f, // Front top right
-	 1.0f, -1.0f,  1.0f, // Front bottom right
-	-1.0f, -1.0f,  1.0f, // Front bottom left
+  -1.0f,  1.0f,  1.0f, // Front top left
+  1.0f,  1.0f,  1.0f, // Front top right
+  1.0f, -1.0f,  1.0f, // Front bottom right
+  -1.0f, -1.0f,  1.0f, // Front bottom left
 };
 
 static const float cubeBackLineLoop[] = {
-	-1.0f,  1.0f, -1.0f, // Back top left
-	 1.0f,  1.0f, -1.0f, // Back top right
-	 1.0f, -1.0f, -1.0f, // Back bottom right
-	-1.0f, -1.0f, -1.0f, // Back bottom left
+  -1.0f,  1.0f, -1.0f, // Back top left
+  1.0f,  1.0f, -1.0f, // Back top right
+  1.0f, -1.0f, -1.0f, // Back bottom right
+  -1.0f, -1.0f, -1.0f, // Back bottom left
 };
 
 static const float cubeSideLines[] = {
-	-1.0f,  1.0f,  1.0f, // Front top left
-	-1.0f,  1.0f, -1.0f, // Back top left
+  -1.0f,  1.0f,  1.0f, // Front top left
+  -1.0f,  1.0f, -1.0f, // Back top left
 
-	-1.0f, -1.0f,  1.0f, // Front bottom left
-	-1.0f, -1.0f, -1.0f, // Back bottom left
+  -1.0f, -1.0f,  1.0f, // Front bottom left
+  -1.0f, -1.0f, -1.0f, // Back bottom left
 
-	 1.0f,  1.0f,  1.0f, // Front top right
-	 1.0f,  1.0f, -1.0f, // Back top right
+  1.0f,  1.0f,  1.0f, // Front top right
+  1.0f,  1.0f, -1.0f, // Back top right
 
-	 1.0f, -1.0f,  1.0f, // Front bottom right
-	 1.0f, -1.0f, -1.0f, // Back bottom right
+  1.0f, -1.0f,  1.0f, // Front bottom right
+  1.0f, -1.0f, -1.0f, // Back bottom right
 };
 
 // clang-format on
@@ -75,19 +78,19 @@ static const float cubeSideLines[] = {
 static inline void
 reshapeCube(const float width, const float height)
 {
-	const float aspect = width / height;
+  const float aspect = width / height;
 
-	glEnable(GL_DEPTH_TEST);
-	glDepthFunc(GL_LESS);
-	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LESS);
+  glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
 
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glViewport(0, 0, (int)width, (int)height);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glViewport(0, 0, (int)width, (int)height);
 
-	float projection[16];
-	perspective(projection, 1.8f, aspect, 1.0f, 100.0f);
-	glLoadMatrixf(projection);
+  float projection[16];
+  perspective(projection, 1.8f, aspect, 1.0f, 100.0f);
+  glLoadMatrixf(projection);
 }
 
 static inline void
@@ -97,40 +100,40 @@ displayCube(PuglView* const view,
             const float     yAngle,
             const bool      entered)
 {
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-	glTranslatef(0.0f, 0.0f, distance * -1.0f);
-	glRotatef(xAngle, 0.0f, 1.0f, 0.0f);
-	glRotatef(yAngle, 1.0f, 0.0f, 0.0f);
-
-	const float bg = entered ? 0.2f : 0.0f;
-	glClearColor(bg, bg, bg, 1.0f);
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-	if (puglHasFocus(view)) {
-		// Draw cube surfaces
-		glEnableClientState(GL_VERTEX_ARRAY);
-		glEnableClientState(GL_COLOR_ARRAY);
-		glVertexPointer(3, GL_FLOAT, 0, cubeStripVertices);
-		glColorPointer(3, GL_FLOAT, 0, cubeStripVertices);
-		glDrawArrays(GL_TRIANGLE_STRIP, 0, 14);
-		glDisableClientState(GL_COLOR_ARRAY);
-		glDisableClientState(GL_VERTEX_ARRAY);
-
-		glColor3f(0.0f, 0.0f, 0.0f);
-	} else {
-		glColor3f(1.0f, 1.0f, 1.0f);
-	}
-
-	// Draw cube wireframe
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glVertexPointer(3, GL_FLOAT, 0, cubeFrontLineLoop);
-	glDrawArrays(GL_LINE_LOOP, 0, 4);
-	glVertexPointer(3, GL_FLOAT, 0, cubeBackLineLoop);
-	glDrawArrays(GL_LINE_LOOP, 0, 4);
-	glVertexPointer(3, GL_FLOAT, 0, cubeSideLines);
-	glDrawArrays(GL_LINES, 0, 8);
-	glDisableClientState(GL_VERTEX_ARRAY);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+  glTranslatef(0.0f, 0.0f, distance * -1.0f);
+  glRotatef(xAngle, 0.0f, 1.0f, 0.0f);
+  glRotatef(yAngle, 1.0f, 0.0f, 0.0f);
+
+  const float bg = entered ? 0.2f : 0.0f;
+  glClearColor(bg, bg, bg, 1.0f);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+  if (puglHasFocus(view)) {
+    // Draw cube surfaces
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glVertexPointer(3, GL_FLOAT, 0, cubeStripVertices);
+    glColorPointer(3, GL_FLOAT, 0, cubeStripVertices);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 14);
+    glDisableClientState(GL_COLOR_ARRAY);
+    glDisableClientState(GL_VERTEX_ARRAY);
+
+    glColor3f(0.0f, 0.0f, 0.0f);
+  } else {
+    glColor3f(1.0f, 1.0f, 1.0f);
+  }
+
+  // Draw cube wireframe
+  glEnableClientState(GL_VERTEX_ARRAY);
+  glVertexPointer(3, GL_FLOAT, 0, cubeFrontLineLoop);
+  glDrawArrays(GL_LINE_LOOP, 0, 4);
+  glVertexPointer(3, GL_FLOAT, 0, cubeBackLineLoop);
+  glDrawArrays(GL_LINE_LOOP, 0, 4);
+  glVertexPointer(3, GL_FLOAT, 0, cubeSideLines);
+  glDrawArrays(GL_LINES, 0, 8);
+  glDisableClientState(GL_VERTEX_ARRAY);
 }
 
 #endif // EXAMPLES_CUBE_VIEW_H
diff --git a/subprojects/nk_pugl/pugl/examples/demo_utils.h b/subprojects/nk_pugl/pugl/examples/demo_utils.h
index 9057a32..2dda756 100644
--- a/subprojects/nk_pugl/pugl/examples/demo_utils.h
+++ b/subprojects/nk_pugl/pugl/examples/demo_utils.h
@@ -20,12 +20,10 @@
 #include "pugl/pugl.h"
 
 #include <math.h>
-#include <stdint.h>
 #include <stdio.h>
-#include <string.h>
 
 typedef struct {
-	double lastReportTime;
+  double lastReportTime;
 } PuglFpsPrinter;
 
 typedef float vec4[4];
@@ -34,32 +32,32 @@ typedef vec4  mat4[4];
 static inline void
 mat4Identity(mat4 m)
 {
-	for (int c = 0; c < 4; ++c) {
-		for (int r = 0; r < 4; ++r) {
-			m[c][r] = c == r ? 1.0f : 0.0f;
-		}
-	}
+  for (int c = 0; c < 4; ++c) {
+    for (int r = 0; r < 4; ++r) {
+      m[c][r] = c == r ? 1.0f : 0.0f;
+    }
+  }
 }
 
 static inline void
 mat4Translate(mat4 m, const float x, const float y, const float z)
 {
-	m[3][0] = x;
-	m[3][1] = y;
-	m[3][2] = z;
+  m[3][0] = x;
+  m[3][1] = y;
+  m[3][2] = z;
 }
 
 static inline void
 mat4Mul(mat4 m, mat4 a, mat4 b)
 {
-	for (int c = 0; c < 4; ++c) {
-		for (int r = 0; r < 4; ++r) {
-			m[c][r] = 0.0f;
-			for (int k = 0; k < 4; ++k) {
-				m[c][r] += a[k][r] * b[c][k];
-			}
-		}
-	}
+  for (int c = 0; c < 4; ++c) {
+    for (int r = 0; r < 4; ++r) {
+      m[c][r] = 0.0f;
+      for (int k = 0; k < 4; ++k) {
+        m[c][r] += a[k][r] * b[c][k];
+      }
+    }
+  }
 }
 
 static inline void
@@ -71,37 +69,37 @@ mat4Ortho(mat4        m,
           const float n,
           const float f)
 {
-	m[0][0] = 2.0f / (r - l);
-	m[0][1] = m[0][2] = m[0][3] = 0.0f;
+  m[0][0] = 2.0f / (r - l);
+  m[0][1] = m[0][2] = m[0][3] = 0.0f;
 
-	m[1][1] = 2.0f / (t - b);
-	m[1][0] = m[1][2] = m[1][3] = 0.0f;
+  m[1][1] = 2.0f / (t - b);
+  m[1][0] = m[1][2] = m[1][3] = 0.0f;
 
-	m[2][2] = -2.0f / (f - n);
-	m[2][0] = m[2][1] = m[2][3] = 0.0f;
+  m[2][2] = -2.0f / (f - n);
+  m[2][0] = m[2][1] = m[2][3] = 0.0f;
 
-	m[3][0] = -(r + l) / (r - l);
-	m[3][1] = -(t + b) / (t - b);
-	m[3][2] = -(f + n) / (f - n);
-	m[3][3] = 1.0f;
+  m[3][0] = -(r + l) / (r - l);
+  m[3][1] = -(t + b) / (t - b);
+  m[3][2] = -(f + n) / (f - n);
+  m[3][3] = 1.0f;
 }
 
 /// Calculate a projection matrix for a given perspective
 static inline void
 perspective(float* m, float fov, float aspect, float zNear, float zFar)
 {
-	const float h     = tanf(fov);
-	const float w     = h / aspect;
-	const float depth = zNear - zFar;
-	const float q     = (zFar + zNear) / depth;
-	const float qn    = 2 * zFar * zNear / depth;
-
-	// clang-format off
-	m[0]  = w;  m[1]  = 0;  m[2]  = 0;   m[3]  = 0;
-	m[4]  = 0;  m[5]  = h;  m[6]  = 0;   m[7]  = 0;
-	m[8]  = 0;  m[9]  = 0;  m[10] = q;   m[11] = -1;
-	m[12] = 0;  m[13] = 0;  m[14] = qn;  m[15] = 0;
-	// clang-format on
+  const float h     = tanf(fov);
+  const float w     = h / aspect;
+  const float depth = zNear - zFar;
+  const float q     = (zFar + zNear) / depth;
+  const float qn    = 2 * zFar * zNear / depth;
+
+  // clang-format off
+  m[0]  = w;  m[1]  = 0;  m[2]  = 0;   m[3]  = 0;
+  m[4]  = 0;  m[5]  = h;  m[6]  = 0;   m[7]  = 0;
+  m[8]  = 0;  m[9]  = 0;  m[10] = q;   m[11] = -1;
+  m[12] = 0;  m[13] = 0;  m[14] = qn;  m[15] = 0;
+  // clang-format on
 }
 
 static inline void
@@ -109,18 +107,18 @@ puglPrintFps(const PuglWorld* world,
              PuglFpsPrinter*  printer,
              unsigned* const  framesDrawn)
 {
-	const double thisTime = puglGetTime(world);
-	if (thisTime > printer->lastReportTime + 5) {
-		const double fps = *framesDrawn / (thisTime - printer->lastReportTime);
-		fprintf(stderr,
-		        "FPS: %.2f (%u frames in %.0f seconds)\n",
-		        fps,
-		        *framesDrawn,
-		        thisTime - printer->lastReportTime);
-
-		printer->lastReportTime = thisTime;
-		*framesDrawn            = 0;
-	}
+  const double thisTime = puglGetTime(world);
+  if (thisTime > printer->lastReportTime + 5) {
+    const double fps = *framesDrawn / (thisTime - printer->lastReportTime);
+    fprintf(stderr,
+            "FPS: %.2f (%u frames in %.0f seconds)\n",
+            fps,
+            *framesDrawn,
+            thisTime - printer->lastReportTime);
+
+    printer->lastReportTime = thisTime;
+    *framesDrawn            = 0;
+  }
 }
 
 #endif // EXAMPLES_DEMO_UTILS_H
diff --git a/subprojects/nk_pugl/pugl/examples/file_utils.c b/subprojects/nk_pugl/pugl/examples/file_utils.c
index 2b00bdc..8ecbca4 100644
--- a/subprojects/nk_pugl/pugl/examples/file_utils.c
+++ b/subprojects/nk_pugl/pugl/examples/file_utils.c
@@ -15,18 +15,18 @@
 */
 
 #if !defined(__APPLE__) && !defined(_GNU_SOURCE)
-#	define _GNU_SOURCE
+#  define _GNU_SOURCE
 #endif
 
 #include "file_utils.h"
 
 #ifdef _WIN32
-#	include <io.h>
-#	include <windows.h>
-#	define F_OK 0
+#  include <io.h>
+#  include <windows.h>
+#  define F_OK 0
 #else
-#	include <libgen.h>
-#	include <unistd.h>
+#  include <libgen.h>
+#  include <unistd.h>
 #endif
 
 #include <stdio.h>
@@ -36,33 +36,33 @@
 char*
 resourcePath(const char* const programPath, const char* const name)
 {
-	char* const binary = strdup(programPath);
+  char* const binary = strdup(programPath);
 
 #ifdef _WIN32
-	char programDir[_MAX_DIR];
-	_splitpath(binary, programDir, NULL, NULL, NULL);
-	_splitpath(binary, NULL, programDir + strlen(programDir), NULL, NULL);
-	programDir[strlen(programDir) - 1] = '\0';
+  char programDir[_MAX_DIR];
+  _splitpath(binary, programDir, NULL, NULL, NULL);
+  _splitpath(binary, NULL, programDir + strlen(programDir), NULL, NULL);
+  programDir[strlen(programDir) - 1] = '\0';
 #else
-	char* const programDir = dirname(binary);
+  char* const programDir = dirname(binary);
 #endif
 
-	const size_t programDirLen = strlen(programDir);
-	const size_t nameLen       = strlen(name);
-	const size_t totalLen      = programDirLen + nameLen + 4;
+  const size_t programDirLen = strlen(programDir);
+  const size_t nameLen       = strlen(name);
+  const size_t totalLen      = programDirLen + nameLen + 4;
 
-	char* const programRelative = (char*)calloc(totalLen, 1);
-	snprintf(programRelative, totalLen, "%s/%s", programDir, name);
-	if (!access(programRelative, F_OK)) {
-		free(binary);
-		return programRelative;
-	}
+  char* const programRelative = (char*)calloc(totalLen, 1);
+  snprintf(programRelative, totalLen, "%s/%s", programDir, name);
+  if (!access(programRelative, F_OK)) {
+    free(binary);
+    return programRelative;
+  }
 
-	free(programRelative);
-	free(binary);
+  free(programRelative);
+  free(binary);
 
-	const size_t sysPathLen = strlen(PUGL_DATA_DIR) + nameLen + 4;
-	char* const  sysPath    = (char*)calloc(sysPathLen, 1);
-	snprintf(sysPath, sysPathLen, "%s/%s", PUGL_DATA_DIR, name);
-	return sysPath;
+  const size_t sysPathLen = strlen(PUGL_DATA_DIR) + nameLen + 4;
+  char* const  sysPath    = (char*)calloc(sysPathLen, 1);
+  snprintf(sysPath, sysPathLen, "%s/%s", PUGL_DATA_DIR, name);
+  return sysPath;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_cairo_demo.c b/subprojects/nk_pugl/pugl/examples/pugl_cairo_demo.c
index 48a02db..4da0caf 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_cairo_demo.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_cairo_demo.c
@@ -28,20 +28,20 @@
 #include <string.h>
 
 typedef struct {
-	PuglWorld*      world;
-	PuglTestOptions opts;
-	unsigned        framesDrawn;
-	int             quit;
-	bool            entered;
-	bool            mouseDown;
+  PuglWorld*      world;
+  PuglTestOptions opts;
+  unsigned        framesDrawn;
+  int             quit;
+  bool            entered;
+  bool            mouseDown;
 } PuglTestApp;
 
 typedef struct {
-	int         x;
-	int         y;
-	int         w;
-	int         h;
-	const char* label;
+  int         x;
+  int         y;
+  int         w;
+  int         h;
+  const char* label;
 } Button;
 
 static const Button buttons[] = {{128, 128, 64, 64, "1"},
@@ -53,213 +53,208 @@ static const Button buttons[] = {{128, 128, 64, 64, "1"},
 static void
 roundedBox(cairo_t* cr, double x, double y, double w, double h)
 {
-	static const double radius  = 10;
-	static const double degrees = 3.14159265 / 180.0;
-
-	cairo_new_sub_path(cr);
-	cairo_arc(cr,
-	          x + w - radius,
-	          y + radius,
-	          radius, -90 * degrees, 0 * degrees);
-	cairo_arc(cr,
-	          x + w - radius, y + h - radius,
-	          radius, 0 * degrees, 90 * degrees);
-	cairo_arc(cr,
-	          x + radius, y + h - radius,
-	          radius, 90 * degrees, 180 * degrees);
-	cairo_arc(cr,
-	          x + radius, y + radius,
-	          radius, 180 * degrees, 270 * degrees);
-	cairo_close_path(cr);
+  static const double radius  = 10;
+  static const double degrees = 3.14159265 / 180.0;
+
+  cairo_new_sub_path(cr);
+  cairo_arc(cr, x + w - radius, y + radius, radius, -90 * degrees, 0 * degrees);
+
+  cairo_arc(
+    cr, x + w - radius, y + h - radius, radius, 0 * degrees, 90 * degrees);
+
+  cairo_arc(
+    cr, x + radius, y + h - radius, radius, 90 * degrees, 180 * degrees);
+
+  cairo_arc(cr, x + radius, y + radius, radius, 180 * degrees, 270 * degrees);
+  cairo_close_path(cr);
 }
 
 static void
 buttonDraw(PuglTestApp* app, cairo_t* cr, const Button* but, const double time)
 {
-	cairo_save(cr);
-	cairo_translate(cr, but->x, but->y);
-	cairo_rotate(cr, sin(time) * 3.141592);
-
-	// Draw base
-	if (app->mouseDown) {
-		cairo_set_source_rgba(cr, 0.4, 0.9, 0.1, 1);
-	} else {
-		cairo_set_source_rgba(cr, 0.3, 0.5, 0.1, 1);
-	}
-	roundedBox(cr, 0, 0, but->w, but->h);
-	cairo_fill_preserve(cr);
-
-	// Draw border
-	cairo_set_source_rgba(cr, 0.4, 0.9, 0.1, 1);
-	cairo_set_line_width(cr, 4.0);
-	cairo_stroke(cr);
-
-	// Draw label
-	cairo_text_extents_t extents;
-	cairo_set_font_size(cr, 32.0);
-	cairo_text_extents(cr, but->label, &extents);
-	cairo_move_to(cr,
-	              (but->w / 2.0) - extents.width / 2,
-	              (but->h / 2.0) + extents.height / 2);
-	cairo_set_source_rgba(cr, 0, 0, 0, 1);
-	cairo_show_text(cr, but->label);
-
-	cairo_restore(cr);
+  cairo_save(cr);
+  cairo_translate(cr, but->x, but->y);
+  cairo_rotate(cr, sin(time) * 3.141592);
+
+  // Draw base
+  if (app->mouseDown) {
+    cairo_set_source_rgba(cr, 0.4, 0.9, 0.1, 1);
+  } else {
+    cairo_set_source_rgba(cr, 0.3, 0.5, 0.1, 1);
+  }
+  roundedBox(cr, 0, 0, but->w, but->h);
+  cairo_fill_preserve(cr);
+
+  // Draw border
+  cairo_set_source_rgba(cr, 0.4, 0.9, 0.1, 1);
+  cairo_set_line_width(cr, 4.0);
+  cairo_stroke(cr);
+
+  // Draw label
+  cairo_text_extents_t extents;
+  cairo_set_font_size(cr, 32.0);
+  cairo_text_extents(cr, but->label, &extents);
+  cairo_move_to(cr,
+                (but->w / 2.0) - extents.width / 2,
+                (but->h / 2.0) + extents.height / 2);
+  cairo_set_source_rgba(cr, 0, 0, 0, 1);
+  cairo_show_text(cr, but->label);
+
+  cairo_restore(cr);
 }
 
 static void
 postButtonRedisplay(PuglView* view)
 {
-	const PuglRect frame  = puglGetFrame(view);
-	const double   width  = frame.width;
-	const double   height = frame.height;
-	const double   scaleX = (width - (512 / width)) / 512.0;
-	const double   scaleY = (height - (512 / height)) / 512.0;
-
-	for (const Button* b = buttons; b->label; ++b) {
-		const double   span = sqrt(b->w * b->w + b->h * b->h);
-		const PuglRect rect = {(b->x - span) * scaleX,
-		                       (b->y - span) * scaleY,
-		                       span * 2.0 * scaleX,
-		                       span * 2.0 * scaleY};
-
-		puglPostRedisplayRect(view, rect);
-	}
+  const PuglRect frame  = puglGetFrame(view);
+  const double   width  = frame.width;
+  const double   height = frame.height;
+  const double   scaleX = (width - (512 / width)) / 512.0;
+  const double   scaleY = (height - (512 / height)) / 512.0;
+
+  for (const Button* b = buttons; b->label; ++b) {
+    const double   span = sqrt(b->w * b->w + b->h * b->h);
+    const PuglRect rect = {(b->x - span) * scaleX,
+                           (b->y - span) * scaleY,
+                           span * 2.0 * scaleX,
+                           span * 2.0 * scaleY};
+
+    puglPostRedisplayRect(view, rect);
+  }
 }
 
 static void
 onDisplay(PuglTestApp* app, PuglView* view, const PuglEventExpose* event)
 {
-	cairo_t* cr = (cairo_t*)puglGetContext(view);
-
-	cairo_rectangle(cr, event->x, event->y, event->width, event->height);
-	cairo_clip_preserve(cr);
-
-	// Draw background
-	const PuglRect frame  = puglGetFrame(view);
-	const double   width  = frame.width;
-	const double   height = frame.height;
-	if (app->entered) {
-		cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
-	} else {
-		cairo_set_source_rgb(cr, 0, 0, 0);
-	}
-	cairo_fill(cr);
-
-	// Scale to view size
-	const double scaleX = (width - (512 / width)) / 512.0;
-	const double scaleY = (height - (512 / height)) / 512.0;
-	cairo_scale(cr, scaleX, scaleY);
-
-	// Draw button
-	for (const Button* b = buttons; b->label; ++b) {
-		buttonDraw(app,
-		           cr,
-		           b,
-		           app->opts.continuous ? puglGetTime(app->world) : 0.0);
-	}
-
-	++app->framesDrawn;
+  cairo_t* cr = (cairo_t*)puglGetContext(view);
+
+  cairo_rectangle(cr, event->x, event->y, event->width, event->height);
+  cairo_clip_preserve(cr);
+
+  // Draw background
+  const PuglRect frame  = puglGetFrame(view);
+  const double   width  = frame.width;
+  const double   height = frame.height;
+  if (app->entered) {
+    cairo_set_source_rgb(cr, 0.1, 0.1, 0.1);
+  } else {
+    cairo_set_source_rgb(cr, 0, 0, 0);
+  }
+  cairo_fill(cr);
+
+  // Scale to view size
+  const double scaleX = (width - (512 / width)) / 512.0;
+  const double scaleY = (height - (512 / height)) / 512.0;
+  cairo_scale(cr, scaleX, scaleY);
+
+  // Draw button
+  for (const Button* b = buttons; b->label; ++b) {
+    buttonDraw(
+      app, cr, b, app->opts.continuous ? puglGetTime(app->world) : 0.0);
+  }
+
+  ++app->framesDrawn;
 }
 
 static void
 onClose(PuglView* view)
 {
-	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+  PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
 
-	app->quit = 1;
+  app->quit = 1;
 }
 
 static PuglStatus
 onEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
-
-	printEvent(event, "Event: ", app->opts.verbose);
-
-	switch (event->type) {
-	case PUGL_KEY_PRESS:
-		if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
-			app->quit = 1;
-		}
-		break;
-	case PUGL_BUTTON_PRESS:
-		app->mouseDown = true;
-		postButtonRedisplay(view);
-		break;
-	case PUGL_BUTTON_RELEASE:
-		app->mouseDown = false;
-		postButtonRedisplay(view);
-		break;
-	case PUGL_POINTER_IN:
-		app->entered = true;
-		puglPostRedisplay(view);
-		break;
-	case PUGL_POINTER_OUT:
-		app->entered = false;
-		puglPostRedisplay(view);
-		break;
-	case PUGL_UPDATE:
-		if (app->opts.continuous) {
-			puglPostRedisplay(view);
-		}
-		break;
-	case PUGL_EXPOSE:
-		onDisplay(app, view, &event->expose);
-		break;
-	case PUGL_CLOSE:
-		onClose(view);
-		break;
-	default: break;
-	}
-
-	return PUGL_SUCCESS;
+  PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+
+  printEvent(event, "Event: ", app->opts.verbose);
+
+  switch (event->type) {
+  case PUGL_KEY_PRESS:
+    if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
+      app->quit = 1;
+    }
+    break;
+  case PUGL_BUTTON_PRESS:
+    app->mouseDown = true;
+    postButtonRedisplay(view);
+    break;
+  case PUGL_BUTTON_RELEASE:
+    app->mouseDown = false;
+    postButtonRedisplay(view);
+    break;
+  case PUGL_POINTER_IN:
+    app->entered = true;
+    puglPostRedisplay(view);
+    break;
+  case PUGL_POINTER_OUT:
+    app->entered = false;
+    puglPostRedisplay(view);
+    break;
+  case PUGL_UPDATE:
+    if (app->opts.continuous) {
+      puglPostRedisplay(view);
+    }
+    break;
+  case PUGL_EXPOSE:
+    onDisplay(app, view, &event->expose);
+    break;
+  case PUGL_CLOSE:
+    onClose(view);
+    break;
+  default:
+    break;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 int
 main(int argc, char** argv)
 {
-	PuglTestApp app;
-	memset(&app, 0, sizeof(app));
-
-	app.opts = puglParseTestOptions(&argc, &argv);
-	if (app.opts.help) {
-		puglPrintTestUsage("pugl_test", "");
-		return 1;
-	}
-
-	app.world = puglNewWorld(PUGL_PROGRAM, 0);
-	puglSetClassName(app.world, "PuglCairoTest");
-
-	PuglView* view = puglNewView(app.world);
-
-	puglSetWindowTitle(view, "Pugl Cairo Demo");
-	puglSetDefaultSize(view, 512, 512);
-	puglSetMinSize(view, 256, 256);
-	puglSetViewHint(view, PUGL_RESIZABLE, app.opts.resizable);
-	puglSetHandle(view, &app);
-	puglSetBackend(view, puglCairoBackend());
-	puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, app.opts.ignoreKeyRepeat);
-	puglSetEventFunc(view, onEvent);
-
-	PuglStatus st = puglRealize(view);
-	if (st) {
-		return logError("Failed to create window (%s)\n", puglStrerror(st));
-	}
-
-	puglShow(view);
-
-	PuglFpsPrinter fpsPrinter = { puglGetTime(app.world) };
-	const double   timeout    = app.opts.continuous ? (1 / 60.0) : -1.0;
-	while (!app.quit) {
-		puglUpdate(app.world, timeout);
-
-		if (app.opts.continuous) {
-			puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
-		}
-	}
-
-	puglFreeView(view);
-	puglFreeWorld(app.world);
-	return 0;
+  PuglTestApp app;
+  memset(&app, 0, sizeof(app));
+
+  app.opts = puglParseTestOptions(&argc, &argv);
+  if (app.opts.help) {
+    puglPrintTestUsage("pugl_test", "");
+    return 1;
+  }
+
+  app.world = puglNewWorld(PUGL_PROGRAM, 0);
+  puglSetClassName(app.world, "PuglCairoTest");
+
+  PuglView* view = puglNewView(app.world);
+
+  puglSetWindowTitle(view, "Pugl Cairo Demo");
+  puglSetDefaultSize(view, 512, 512);
+  puglSetMinSize(view, 256, 256);
+  puglSetViewHint(view, PUGL_RESIZABLE, app.opts.resizable);
+  puglSetHandle(view, &app);
+  puglSetBackend(view, puglCairoBackend());
+  puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, app.opts.ignoreKeyRepeat);
+  puglSetEventFunc(view, onEvent);
+
+  PuglStatus st = puglRealize(view);
+  if (st) {
+    return logError("Failed to create window (%s)\n", puglStrerror(st));
+  }
+
+  puglShow(view);
+
+  PuglFpsPrinter fpsPrinter = {puglGetTime(app.world)};
+  const double   timeout    = app.opts.continuous ? (1 / 60.0) : -1.0;
+  while (!app.quit) {
+    puglUpdate(app.world, timeout);
+
+    if (app.opts.continuous) {
+      puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
+    }
+  }
+
+  puglFreeView(view);
+  puglFreeWorld(app.world);
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_cursor_demo.c b/subprojects/nk_pugl/pugl/examples/pugl_cursor_demo.c
index f20b0ea..60ec3d3 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_cursor_demo.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_cursor_demo.c
@@ -26,143 +26,143 @@ static const int N_ROWS    = 2;
 static const int N_COLS    = 4;
 
 typedef struct {
-	PuglWorld*      world;
-	PuglTestOptions opts;
-	bool            quit;
+  PuglWorld*      world;
+  PuglTestOptions opts;
+  bool            quit;
 } PuglTestApp;
 
 static void
 onConfigure(const double width, const double height)
 {
-	glEnable(GL_DEPTH_TEST);
-	glDepthFunc(GL_LESS);
-	glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LESS);
+  glClearColor(0.2f, 0.2f, 0.2f, 1.0f);
 
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	glViewport(0, 0, (int)width, (int)height);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glViewport(0, 0, (int)width, (int)height);
 }
 
 static void
 onExpose(void)
 {
-	glMatrixMode(GL_MODELVIEW);
-	glLoadIdentity();
-
-	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	glColor3f(0.6f, 0.6f, 0.6f);
-
-	for (int row = 1; row < N_ROWS; ++row) {
-		const float y = (float)row * (2.0f / (float)N_ROWS) - 1.0f;
-		glBegin(GL_LINES);
-		glVertex2f(-1.0f, y);
-		glVertex2f(1.0f, y);
-		glEnd();
-	}
-
-	for (int col = 1; col < N_COLS; ++col) {
-		const float x = (float)col * (2.0f / (float)N_COLS) - 1.0f;
-		glBegin(GL_LINES);
-		glVertex2f(x, -1.0f);
-		glVertex2f(x, 1.0f);
-		glEnd();
-	}
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glColor3f(0.6f, 0.6f, 0.6f);
+
+  for (int row = 1; row < N_ROWS; ++row) {
+    const float y = (float)row * (2.0f / (float)N_ROWS) - 1.0f;
+    glBegin(GL_LINES);
+    glVertex2f(-1.0f, y);
+    glVertex2f(1.0f, y);
+    glEnd();
+  }
+
+  for (int col = 1; col < N_COLS; ++col) {
+    const float x = (float)col * (2.0f / (float)N_COLS) - 1.0f;
+    glBegin(GL_LINES);
+    glVertex2f(x, -1.0f);
+    glVertex2f(x, 1.0f);
+    glEnd();
+  }
 }
 
 static void
 onMotion(PuglView* view, double x, double y)
 {
-	const PuglRect frame = puglGetFrame(view);
-	int            row   = (int)(y * N_ROWS / frame.height);
-	int            col   = (int)(x * N_COLS / frame.width);
+  const PuglRect frame = puglGetFrame(view);
+  int            row   = (int)(y * N_ROWS / frame.height);
+  int            col   = (int)(x * N_COLS / frame.width);
 
-	row = (row < 0) ? 0 : (row >= N_ROWS) ? (N_ROWS - 1) : row;
-	col = (col < 0) ? 0 : (col >= N_COLS) ? (N_COLS - 1) : col;
+  row = (row < 0) ? 0 : (row >= N_ROWS) ? (N_ROWS - 1) : row;
+  col = (col < 0) ? 0 : (col >= N_COLS) ? (N_COLS - 1) : col;
 
-	const PuglCursor cursor = (PuglCursor)((row * N_COLS + col) % N_CURSORS);
-	puglSetCursor(view, cursor);
+  const PuglCursor cursor = (PuglCursor)((row * N_COLS + col) % N_CURSORS);
+  puglSetCursor(view, cursor);
 }
 
 static PuglStatus
 onEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
-
-	printEvent(event, "Event: ", app->opts.verbose);
-
-	switch (event->type) {
-	case PUGL_CONFIGURE:
-		onConfigure(event->configure.width, event->configure.height);
-		break;
-	case PUGL_KEY_PRESS:
-		if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
-			app->quit = 1;
-		}
-		break;
-	case PUGL_MOTION:
-		onMotion(view, event->motion.x, event->motion.y);
-		break;
-	case PUGL_EXPOSE:
-		onExpose();
-		break;
-	case PUGL_POINTER_OUT:
-		puglSetCursor(view, PUGL_CURSOR_ARROW);
-		break;
-	case PUGL_CLOSE:
-		app->quit = 1;
-		break;
-	default:
-		break;
-	}
-
-	return PUGL_SUCCESS;
+  PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+
+  printEvent(event, "Event: ", app->opts.verbose);
+
+  switch (event->type) {
+  case PUGL_CONFIGURE:
+    onConfigure(event->configure.width, event->configure.height);
+    break;
+  case PUGL_KEY_PRESS:
+    if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
+      app->quit = 1;
+    }
+    break;
+  case PUGL_MOTION:
+    onMotion(view, event->motion.x, event->motion.y);
+    break;
+  case PUGL_EXPOSE:
+    onExpose();
+    break;
+  case PUGL_POINTER_OUT:
+    puglSetCursor(view, PUGL_CURSOR_ARROW);
+    break;
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  default:
+    break;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 int
 main(int argc, char** argv)
 {
-	PuglTestApp app = {0};
+  PuglTestApp app = {0};
 
-	app.opts = puglParseTestOptions(&argc, &argv);
-	if (app.opts.help) {
-		puglPrintTestUsage(argv[0], "");
-		return 1;
-	}
+  app.opts = puglParseTestOptions(&argc, &argv);
+  if (app.opts.help) {
+    puglPrintTestUsage(argv[0], "");
+    return 1;
+  }
 
-	app.world = puglNewWorld(PUGL_PROGRAM, 0);
+  app.world = puglNewWorld(PUGL_PROGRAM, 0);
 
-	puglSetWorldHandle(app.world, &app);
-	puglSetClassName(app.world, "Pugl Test");
+  puglSetWorldHandle(app.world, &app);
+  puglSetClassName(app.world, "Pugl Test");
 
-	PuglView* view = puglNewView(app.world);
+  PuglView* view = puglNewView(app.world);
 
-	puglSetWindowTitle(view, "Pugl Window Demo");
-	puglSetDefaultSize(view, 512, 256);
-	puglSetMinSize(view, 128, 64);
-	puglSetBackend(view, puglGlBackend());
+  puglSetWindowTitle(view, "Pugl Window Demo");
+  puglSetDefaultSize(view, 512, 256);
+  puglSetMinSize(view, 128, 64);
+  puglSetBackend(view, puglGlBackend());
 
-	puglSetViewHint(view, PUGL_USE_DEBUG_CONTEXT, app.opts.errorChecking);
-	puglSetViewHint(view, PUGL_RESIZABLE, app.opts.resizable);
-	puglSetViewHint(view, PUGL_SAMPLES, app.opts.samples);
-	puglSetViewHint(view, PUGL_DOUBLE_BUFFER, app.opts.doubleBuffer);
-	puglSetViewHint(view, PUGL_SWAP_INTERVAL, app.opts.sync);
-	puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, app.opts.ignoreKeyRepeat);
-	puglSetHandle(view, &app);
-	puglSetEventFunc(view, onEvent);
+  puglSetViewHint(view, PUGL_USE_DEBUG_CONTEXT, app.opts.errorChecking);
+  puglSetViewHint(view, PUGL_RESIZABLE, app.opts.resizable);
+  puglSetViewHint(view, PUGL_SAMPLES, app.opts.samples);
+  puglSetViewHint(view, PUGL_DOUBLE_BUFFER, app.opts.doubleBuffer);
+  puglSetViewHint(view, PUGL_SWAP_INTERVAL, app.opts.sync);
+  puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, app.opts.ignoreKeyRepeat);
+  puglSetHandle(view, &app);
+  puglSetEventFunc(view, onEvent);
 
-	const PuglStatus st = puglRealize(view);
-	if (st) {
-		return logError("Failed to create window (%s)\n", puglStrerror(st));
-	}
+  const PuglStatus st = puglRealize(view);
+  if (st) {
+    return logError("Failed to create window (%s)\n", puglStrerror(st));
+  }
 
-	puglShow(view);
+  puglShow(view);
 
-	while (!app.quit) {
-		puglUpdate(app.world, -1.0);
-	}
+  while (!app.quit) {
+    puglUpdate(app.world, -1.0);
+  }
 
-	puglFreeView(view);
-	puglFreeWorld(app.world);
+  puglFreeView(view);
+  puglFreeWorld(app.world);
 
-	return 0;
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_cxx_demo.cpp b/subprojects/nk_pugl/pugl/examples/pugl_cxx_demo.cpp
index 8269ae4..4914724 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_cxx_demo.cpp
+++ b/subprojects/nk_pugl/pugl/examples/pugl_cxx_demo.cpp
@@ -27,121 +27,121 @@
 class CubeView : public pugl::View
 {
 public:
-	explicit CubeView(pugl::World& world)
-	    : pugl::View{world}
-	{
-		setEventHandler(*this);
-	}
-
-	template<PuglEventType t, class Base>
-	pugl::Status onEvent(const pugl::Event<t, Base>&) noexcept
-	{
-		return pugl::Status::success;
-	}
-
-	static pugl::Status onEvent(const pugl::ConfigureEvent& event) noexcept;
-	pugl::Status        onEvent(const pugl::UpdateEvent& event) noexcept;
-	pugl::Status        onEvent(const pugl::ExposeEvent& event) noexcept;
-	pugl::Status        onEvent(const pugl::KeyPressEvent& event) noexcept;
-	pugl::Status        onEvent(const pugl::CloseEvent& event) noexcept;
-
-	bool quit() const { return _quit; }
+  explicit CubeView(pugl::World& world)
+    : pugl::View{world}
+  {
+    setEventHandler(*this);
+  }
+
+  template<PuglEventType t, class Base>
+  pugl::Status onEvent(const pugl::Event<t, Base>&) noexcept
+  {
+    return pugl::Status::success;
+  }
+
+  static pugl::Status onEvent(const pugl::ConfigureEvent& event) noexcept;
+  pugl::Status        onEvent(const pugl::UpdateEvent& event) noexcept;
+  pugl::Status        onEvent(const pugl::ExposeEvent& event) noexcept;
+  pugl::Status        onEvent(const pugl::KeyPressEvent& event) noexcept;
+  pugl::Status        onEvent(const pugl::CloseEvent& event) noexcept;
+
+  bool quit() const { return _quit; }
 
 private:
-	double _xAngle{0.0};
-	double _yAngle{0.0};
-	double _lastDrawTime{0.0};
-	bool   _quit{false};
+  double _xAngle{0.0};
+  double _yAngle{0.0};
+  double _lastDrawTime{0.0};
+  bool   _quit{false};
 };
 
 pugl::Status
 CubeView::onEvent(const pugl::ConfigureEvent& event) noexcept
 {
-	reshapeCube(static_cast<float>(event.width),
-	            static_cast<float>(event.height));
+  reshapeCube(static_cast<float>(event.width),
+              static_cast<float>(event.height));
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 CubeView::onEvent(const pugl::UpdateEvent&) noexcept
 {
-	return postRedisplay();
+  return postRedisplay();
 }
 
 pugl::Status
 CubeView::onEvent(const pugl::ExposeEvent&) noexcept
 {
-	const double thisTime = world().time();
-	const double dTime    = thisTime - _lastDrawTime;
-	const double dAngle   = dTime * 100.0;
+  const double thisTime = world().time();
+  const double dTime    = thisTime - _lastDrawTime;
+  const double dAngle   = dTime * 100.0;
 
-	_xAngle = fmod(_xAngle + dAngle, 360.0);
-	_yAngle = fmod(_yAngle + dAngle, 360.0);
-	displayCube(cobj(),
-	            8.0f,
-	            static_cast<float>(_xAngle),
-	            static_cast<float>(_yAngle),
-	            false);
+  _xAngle = fmod(_xAngle + dAngle, 360.0);
+  _yAngle = fmod(_yAngle + dAngle, 360.0);
+  displayCube(cobj(),
+              8.0f,
+              static_cast<float>(_xAngle),
+              static_cast<float>(_yAngle),
+              false);
 
-	_lastDrawTime = thisTime;
+  _lastDrawTime = thisTime;
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 CubeView::onEvent(const pugl::KeyPressEvent& event) noexcept
 {
-	if (event.key == PUGL_KEY_ESCAPE || event.key == 'q') {
-		_quit = true;
-	}
+  if (event.key == PUGL_KEY_ESCAPE || event.key == 'q') {
+    _quit = true;
+  }
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 CubeView::onEvent(const pugl::CloseEvent&) noexcept
 {
-	_quit = true;
+  _quit = true;
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 int
 main(int argc, char** argv)
 {
-	const PuglTestOptions opts = puglParseTestOptions(&argc, &argv);
-	if (opts.help) {
-		puglPrintTestUsage("pugl_cxx_demo", "");
-		return 1;
-	}
-
-	pugl::World    world{pugl::WorldType::program};
-	CubeView       view{world};
-	PuglFpsPrinter fpsPrinter{};
-
-	world.setClassName("PuglCppTest");
-
-	view.setWindowTitle("Pugl C++ Test");
-	view.setDefaultSize(512, 512);
-	view.setMinSize(64, 64);
-	view.setAspectRatio(1, 1, 16, 9);
-	view.setBackend(pugl::glBackend());
-	view.setHint(pugl::ViewHint::resizable, opts.resizable);
-	view.setHint(pugl::ViewHint::samples, opts.samples);
-	view.setHint(pugl::ViewHint::doubleBuffer, opts.doubleBuffer);
-	view.setHint(pugl::ViewHint::swapInterval, opts.sync);
-	view.setHint(pugl::ViewHint::ignoreKeyRepeat, opts.ignoreKeyRepeat);
-	view.realize();
-	view.show();
-
-	unsigned framesDrawn = 0;
-	while (!view.quit()) {
-		world.update(0.0);
-
-		++framesDrawn;
-		puglPrintFps(world.cobj(), &fpsPrinter, &framesDrawn);
-	}
-
-	return 0;
+  const PuglTestOptions opts = puglParseTestOptions(&argc, &argv);
+  if (opts.help) {
+    puglPrintTestUsage("pugl_cxx_demo", "");
+    return 1;
+  }
+
+  pugl::World    world{pugl::WorldType::program};
+  CubeView       view{world};
+  PuglFpsPrinter fpsPrinter{};
+
+  world.setClassName("PuglCppTest");
+
+  view.setWindowTitle("Pugl C++ Test");
+  view.setDefaultSize(512, 512);
+  view.setMinSize(64, 64);
+  view.setAspectRatio(1, 1, 16, 9);
+  view.setBackend(pugl::glBackend());
+  view.setHint(pugl::ViewHint::resizable, opts.resizable);
+  view.setHint(pugl::ViewHint::samples, opts.samples);
+  view.setHint(pugl::ViewHint::doubleBuffer, opts.doubleBuffer);
+  view.setHint(pugl::ViewHint::swapInterval, opts.sync);
+  view.setHint(pugl::ViewHint::ignoreKeyRepeat, opts.ignoreKeyRepeat);
+  view.realize();
+  view.show();
+
+  unsigned framesDrawn = 0;
+  while (!view.quit()) {
+    world.update(0.0);
+
+    ++framesDrawn;
+    puglPrintFps(world.cobj(), &fpsPrinter, &framesDrawn);
+  }
+
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_embed_demo.c b/subprojects/nk_pugl/pugl/examples/pugl_embed_demo.c
index 55480f6..0e12ddb 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_embed_demo.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_embed_demo.c
@@ -30,333 +30,325 @@
 static const int       borderWidth    = 64;
 static const uintptr_t reverseTimerId = 1u;
 
-typedef struct
-{
-	PuglWorld* world;
-	PuglView*  parent;
-	PuglView*  child;
-	double     xAngle;
-	double     yAngle;
-	double     lastMouseX;
-	double     lastMouseY;
-	double     lastDrawTime;
-	float      dist;
-	int        quit;
-	bool       continuous;
-	bool       mouseEntered;
-	bool       verbose;
-	bool       reversing;
+typedef struct {
+  PuglWorld* world;
+  PuglView*  parent;
+  PuglView*  child;
+  double     xAngle;
+  double     yAngle;
+  double     lastMouseX;
+  double     lastMouseY;
+  double     lastDrawTime;
+  float      dist;
+  int        quit;
+  bool       continuous;
+  bool       mouseEntered;
+  bool       verbose;
+  bool       reversing;
 } PuglTestApp;
 
+// clang-format off
 static const float backgroundVertices[] = {
-	-1.0f,  1.0f,  -1.0f, // Top left
-	 1.0f,  1.0f,  -1.0f, // Top right
-	-1.0f, -1.0f,  -1.0f, // Bottom left
-	 1.0f, -1.0f,  -1.0f, // Bottom right
+  -1.0f,  1.0f,  -1.0f, // Top left
+   1.0f,  1.0f,  -1.0f, // Top right
+  -1.0f, -1.0f,  -1.0f, // Bottom left
+   1.0f, -1.0f,  -1.0f, // Bottom right
 };
+// clang-format on
 
 static PuglRect
 getChildFrame(const PuglRect parentFrame)
 {
-	const PuglRect childFrame = {
-		borderWidth,
-		borderWidth,
-		parentFrame.width - 2 * borderWidth,
-		parentFrame.height - 2 * borderWidth
-	};
-
-	return childFrame;
+  const PuglRect childFrame = {borderWidth,
+                               borderWidth,
+                               parentFrame.width - 2 * borderWidth,
+                               parentFrame.height - 2 * borderWidth};
+
+  return childFrame;
 }
 
 static void
 onDisplay(PuglView* view)
 {
-	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+  PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
 
-	const double thisTime = puglGetTime(app->world);
-	if (app->continuous) {
-		const double dTime = (thisTime - app->lastDrawTime) *
-		                     (app->reversing ? -1.0 : 1.0);
+  const double thisTime = puglGetTime(app->world);
+  if (app->continuous) {
+    const double dTime =
+      (thisTime - app->lastDrawTime) * (app->reversing ? -1.0 : 1.0);
 
-		app->xAngle = fmod(app->xAngle + dTime * 100.0, 360.0);
-		app->yAngle = fmod(app->yAngle + dTime * 100.0, 360.0);
-	}
+    app->xAngle = fmod(app->xAngle + dTime * 100.0, 360.0);
+    app->yAngle = fmod(app->yAngle + dTime * 100.0, 360.0);
+  }
 
-	displayCube(view,
-	            app->dist,
-	            (float)app->xAngle,
-	            (float)app->yAngle,
-	            app->mouseEntered);
+  displayCube(
+    view, app->dist, (float)app->xAngle, (float)app->yAngle, app->mouseEntered);
 
-	app->lastDrawTime = thisTime;
+  app->lastDrawTime = thisTime;
 }
 
 static void
 swapFocus(PuglTestApp* app)
 {
-	if (puglHasFocus(app->parent)) {
-		puglGrabFocus(app->child);
-	} else {
-		puglGrabFocus(app->parent);
-	}
-
-	if (!app->continuous) {
-		puglPostRedisplay(app->parent);
-		puglPostRedisplay(app->child);
-	}
+  if (puglHasFocus(app->parent)) {
+    puglGrabFocus(app->child);
+  } else {
+    puglGrabFocus(app->parent);
+  }
+
+  if (!app->continuous) {
+    puglPostRedisplay(app->parent);
+    puglPostRedisplay(app->child);
+  }
 }
 
 static void
 onKeyPress(PuglView* view, const PuglEventKey* event, const char* prefix)
 {
-	PuglTestApp* app   = (PuglTestApp*)puglGetHandle(view);
-	PuglRect     frame = puglGetFrame(view);
-
-	if (event->key == '\t') {
-		swapFocus(app);
-	} else if (event->key == 'q' || event->key == PUGL_KEY_ESCAPE) {
-		app->quit = 1;
-	} else if (event->state & PUGL_MOD_CTRL && event->key == 'c') {
-		puglSetClipboard(view, NULL, "Pugl test", strlen("Pugl test") + 1);
-		fprintf(stderr, "%sCopy \"Pugl test\"\n", prefix);
-	} else if (event->state & PUGL_MOD_CTRL && event->key == 'v') {
-		const char* type = NULL;
-		size_t      len  = 0;
-		const char* text = (const char*)puglGetClipboard(view, &type, &len);
-		fprintf(stderr, "%sPaste \"%s\"\n", prefix, text);
-	} else if (event->state & PUGL_MOD_SHIFT) {
-		if (event->key == PUGL_KEY_UP) {
-			frame.height += 10;
-		} else if (event->key == PUGL_KEY_DOWN) {
-			frame.height -= 10;
-		} else if (event->key == PUGL_KEY_LEFT) {
-			frame.width -= 10;
-		} else if (event->key == PUGL_KEY_RIGHT) {
-			frame.width += 10;
-		} else {
-			return;
-		}
-		puglSetFrame(view, frame);
-	} else {
-		if (event->key == PUGL_KEY_UP) {
-			frame.y -= 10;
-		} else if (event->key == PUGL_KEY_DOWN) {
-			frame.y += 10;
-		} else if (event->key == PUGL_KEY_LEFT) {
-			frame.x -= 10;
-		} else if (event->key == PUGL_KEY_RIGHT) {
-			frame.x += 10;
-		} else {
-			return;
-		}
-		puglSetFrame(view, frame);
-	}
+  PuglTestApp* app   = (PuglTestApp*)puglGetHandle(view);
+  PuglRect     frame = puglGetFrame(view);
+
+  if (event->key == '\t') {
+    swapFocus(app);
+  } else if (event->key == 'q' || event->key == PUGL_KEY_ESCAPE) {
+    app->quit = 1;
+  } else if (event->state & PUGL_MOD_CTRL && event->key == 'c') {
+    puglSetClipboard(view, NULL, "Pugl test", strlen("Pugl test") + 1);
+    fprintf(stderr, "%sCopy \"Pugl test\"\n", prefix);
+  } else if (event->state & PUGL_MOD_CTRL && event->key == 'v') {
+    const char* type = NULL;
+    size_t      len  = 0;
+    const char* text = (const char*)puglGetClipboard(view, &type, &len);
+    fprintf(stderr, "%sPaste \"%s\"\n", prefix, text);
+  } else if (event->state & PUGL_MOD_SHIFT) {
+    if (event->key == PUGL_KEY_UP) {
+      frame.height += 10;
+    } else if (event->key == PUGL_KEY_DOWN) {
+      frame.height -= 10;
+    } else if (event->key == PUGL_KEY_LEFT) {
+      frame.width -= 10;
+    } else if (event->key == PUGL_KEY_RIGHT) {
+      frame.width += 10;
+    } else {
+      return;
+    }
+    puglSetFrame(view, frame);
+  } else {
+    if (event->key == PUGL_KEY_UP) {
+      frame.y -= 10;
+    } else if (event->key == PUGL_KEY_DOWN) {
+      frame.y += 10;
+    } else if (event->key == PUGL_KEY_LEFT) {
+      frame.x -= 10;
+    } else if (event->key == PUGL_KEY_RIGHT) {
+      frame.x += 10;
+    } else {
+      return;
+    }
+    puglSetFrame(view, frame);
+  }
 }
 
 static PuglStatus
 onParentEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglTestApp*   app         = (PuglTestApp*)puglGetHandle(view);
-	const PuglRect parentFrame = puglGetFrame(view);
-
-	printEvent(event, "Parent: ", app->verbose);
-
-	switch (event->type) {
-	case PUGL_CONFIGURE:
-		reshapeCube((float)event->configure.width,
-		            (float)event->configure.height);
-
-		puglSetFrame(app->child, getChildFrame(parentFrame));
-		break;
-	case PUGL_UPDATE:
-		if (app->continuous) {
-			puglPostRedisplay(view);
-		}
-		break;
-	case PUGL_EXPOSE:
-		if (puglHasFocus(app->parent)) {
-			glMatrixMode(GL_MODELVIEW);
-			glLoadIdentity();
-			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-			glEnableClientState(GL_VERTEX_ARRAY);
-			glEnableClientState(GL_COLOR_ARRAY);
-			glVertexPointer(3, GL_FLOAT, 0, backgroundVertices);
-			glColorPointer(3, GL_FLOAT, 0, backgroundVertices);
-			glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-			glDisableClientState(GL_COLOR_ARRAY);
-			glDisableClientState(GL_VERTEX_ARRAY);
-		} else {
-			glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-		}
-		break;
-	case PUGL_KEY_PRESS:
-		onKeyPress(view, &event->key, "Parent: ");
-		break;
-	case PUGL_MOTION:
-		break;
-	case PUGL_CLOSE:
-		app->quit = 1;
-		break;
-	default:
-		break;
-	}
-
-	return PUGL_SUCCESS;
+  PuglTestApp*   app         = (PuglTestApp*)puglGetHandle(view);
+  const PuglRect parentFrame = puglGetFrame(view);
+
+  printEvent(event, "Parent: ", app->verbose);
+
+  switch (event->type) {
+  case PUGL_CONFIGURE:
+    reshapeCube((float)event->configure.width, (float)event->configure.height);
+
+    puglSetFrame(app->child, getChildFrame(parentFrame));
+    break;
+  case PUGL_UPDATE:
+    if (app->continuous) {
+      puglPostRedisplay(view);
+    }
+    break;
+  case PUGL_EXPOSE:
+    if (puglHasFocus(app->parent)) {
+      glMatrixMode(GL_MODELVIEW);
+      glLoadIdentity();
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+      glEnableClientState(GL_VERTEX_ARRAY);
+      glEnableClientState(GL_COLOR_ARRAY);
+      glVertexPointer(3, GL_FLOAT, 0, backgroundVertices);
+      glColorPointer(3, GL_FLOAT, 0, backgroundVertices);
+      glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+      glDisableClientState(GL_COLOR_ARRAY);
+      glDisableClientState(GL_VERTEX_ARRAY);
+    } else {
+      glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    }
+    break;
+  case PUGL_KEY_PRESS:
+    onKeyPress(view, &event->key, "Parent: ");
+    break;
+  case PUGL_MOTION:
+    break;
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  default:
+    break;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
 onEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
-
-	printEvent(event, "Child:  ", app->verbose);
-
-	switch (event->type) {
-	case PUGL_CONFIGURE:
-		reshapeCube((float)event->configure.width,
-		            (float)event->configure.height);
-		break;
-	case PUGL_UPDATE:
-		if (app->continuous) {
-			puglPostRedisplay(view);
-		}
-		break;
-	case PUGL_EXPOSE:
-		onDisplay(view);
-		break;
-	case PUGL_CLOSE:
-		app->quit = 1;
-		break;
-	case PUGL_KEY_PRESS:
-		onKeyPress(view, &event->key, "Child:  ");
-		break;
-	case PUGL_MOTION:
-		app->xAngle -= event->motion.x - app->lastMouseX;
-		app->yAngle += event->motion.y - app->lastMouseY;
-		app->lastMouseX = event->motion.x;
-		app->lastMouseY = event->motion.y;
-		if (!app->continuous) {
-			puglPostRedisplay(view);
-			puglPostRedisplay(app->parent);
-		}
-		break;
-	case PUGL_SCROLL:
-		app->dist = fmaxf(10.0f, app->dist + (float)event->scroll.dy);
-		if (!app->continuous) {
-			puglPostRedisplay(view);
-		}
-		break;
-	case PUGL_POINTER_IN:
-		app->mouseEntered = true;
-		break;
-	case PUGL_POINTER_OUT:
-		app->mouseEntered = false;
-		break;
-	case PUGL_TIMER:
-		app->reversing = !app->reversing;
-		break;
-	default:
-		break;
-	}
-
-	return PUGL_SUCCESS;
+  PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+
+  printEvent(event, "Child:  ", app->verbose);
+
+  switch (event->type) {
+  case PUGL_CONFIGURE:
+    reshapeCube((float)event->configure.width, (float)event->configure.height);
+    break;
+  case PUGL_UPDATE:
+    if (app->continuous) {
+      puglPostRedisplay(view);
+    }
+    break;
+  case PUGL_EXPOSE:
+    onDisplay(view);
+    break;
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  case PUGL_KEY_PRESS:
+    onKeyPress(view, &event->key, "Child:  ");
+    break;
+  case PUGL_MOTION:
+    app->xAngle -= event->motion.x - app->lastMouseX;
+    app->yAngle += event->motion.y - app->lastMouseY;
+    app->lastMouseX = event->motion.x;
+    app->lastMouseY = event->motion.y;
+    if (!app->continuous) {
+      puglPostRedisplay(view);
+      puglPostRedisplay(app->parent);
+    }
+    break;
+  case PUGL_SCROLL:
+    app->dist = fmaxf(10.0f, app->dist + (float)event->scroll.dy);
+    if (!app->continuous) {
+      puglPostRedisplay(view);
+    }
+    break;
+  case PUGL_POINTER_IN:
+    app->mouseEntered = true;
+    break;
+  case PUGL_POINTER_OUT:
+    app->mouseEntered = false;
+    break;
+  case PUGL_TIMER:
+    app->reversing = !app->reversing;
+    break;
+  default:
+    break;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 int
 main(int argc, char** argv)
 {
-	PuglTestApp app = {0};
-
-	app.dist = 10;
-
-	const PuglTestOptions opts = puglParseTestOptions(&argc, &argv);
-	if (opts.help) {
-		puglPrintTestUsage("pugl_test", "");
-		return 1;
-	}
-
-	app.continuous = opts.continuous;
-	app.verbose    = opts.verbose;
-
-	app.world  = puglNewWorld(PUGL_PROGRAM, 0);
-	app.parent = puglNewView(app.world);
-	app.child  = puglNewView(app.world);
-
-	puglSetClassName(app.world, "Pugl Test");
-
-	const PuglRect parentFrame = { 0, 0, 512, 512 };
-	puglSetDefaultSize(app.parent, 512, 512);
-	puglSetMinSize(app.parent, borderWidth * 3, borderWidth * 3);
-	puglSetMaxSize(app.parent, 1024, 1024);
-	puglSetAspectRatio(app.parent, 1, 1, 16, 9);
-	puglSetBackend(app.parent, puglGlBackend());
-
-	puglSetViewHint(app.parent, PUGL_USE_DEBUG_CONTEXT, opts.errorChecking);
-	puglSetViewHint(app.parent, PUGL_RESIZABLE, opts.resizable);
-	puglSetViewHint(app.parent, PUGL_SAMPLES, opts.samples);
-	puglSetViewHint(app.parent, PUGL_DOUBLE_BUFFER, opts.doubleBuffer);
-	puglSetViewHint(app.parent, PUGL_SWAP_INTERVAL, opts.sync);
-	puglSetViewHint(app.parent, PUGL_IGNORE_KEY_REPEAT, opts.ignoreKeyRepeat);
-	puglSetHandle(app.parent, &app);
-	puglSetEventFunc(app.parent, onParentEvent);
-
-	PuglStatus st         = PUGL_SUCCESS;
-	const uint8_t title[] = { 'P', 'u', 'g', 'l', ' ',
-	                          'P', 'r', 0xC3, 0xBC, 'f', 'u', 'n', 'g', 0 };
-
-	puglSetWindowTitle(app.parent, (const char*)title);
-
-	if ((st = puglRealize(app.parent))) {
-		return logError("Failed to create parent window (%s)\n",
-		                puglStrerror(st));
-	}
-
-	puglSetFrame(app.child, getChildFrame(parentFrame));
-	puglSetParentWindow(app.child, puglGetNativeWindow(app.parent));
-
-	puglSetViewHint(app.child, PUGL_USE_DEBUG_CONTEXT, opts.errorChecking);
-	puglSetViewHint(app.child, PUGL_SAMPLES, opts.samples);
-	puglSetViewHint(app.child, PUGL_DOUBLE_BUFFER, opts.doubleBuffer);
-	puglSetViewHint(app.child, PUGL_SWAP_INTERVAL, opts.sync);
-	puglSetBackend(app.child, puglGlBackend());
-	puglSetViewHint(app.child, PUGL_IGNORE_KEY_REPEAT, opts.ignoreKeyRepeat);
-	puglSetHandle(app.child, &app);
-	puglSetEventFunc(app.child, onEvent);
-
-	if ((st = puglRealize(app.child))) {
-		return logError("Failed to create child window (%s)\n",
-		                puglStrerror(st));
-	}
-
-	puglShow(app.parent);
-	puglShow(app.child);
-
-	puglStartTimer(app.child, reverseTimerId, 3.6);
-
-	PuglFpsPrinter fpsPrinter         = { puglGetTime(app.world) };
-	unsigned       framesDrawn        = 0;
-	bool           requestedAttention = false;
-	while (!app.quit) {
-		const double thisTime = puglGetTime(app.world);
-
-		puglUpdate(app.world, app.continuous ? 0.0 : -1.0);
-		++framesDrawn;
-
-		if (!requestedAttention && thisTime > 5.0) {
-			puglRequestAttention(app.parent);
-			requestedAttention = true;
-		}
-
-		if (app.continuous) {
-			puglPrintFps(app.world, &fpsPrinter, &framesDrawn);
-		}
-	}
-
-	puglFreeView(app.child);
-	puglFreeView(app.parent);
-	puglFreeWorld(app.world);
-
-	return 0;
+  PuglTestApp app = {0};
+
+  app.dist = 10;
+
+  const PuglTestOptions opts = puglParseTestOptions(&argc, &argv);
+  if (opts.help) {
+    puglPrintTestUsage("pugl_test", "");
+    return 1;
+  }
+
+  app.continuous = opts.continuous;
+  app.verbose    = opts.verbose;
+
+  app.world  = puglNewWorld(PUGL_PROGRAM, 0);
+  app.parent = puglNewView(app.world);
+  app.child  = puglNewView(app.world);
+
+  puglSetClassName(app.world, "Pugl Test");
+
+  const PuglRect parentFrame = {0, 0, 512, 512};
+  puglSetDefaultSize(app.parent, 512, 512);
+  puglSetMinSize(app.parent, borderWidth * 3, borderWidth * 3);
+  puglSetMaxSize(app.parent, 1024, 1024);
+  puglSetAspectRatio(app.parent, 1, 1, 16, 9);
+  puglSetBackend(app.parent, puglGlBackend());
+
+  puglSetViewHint(app.parent, PUGL_USE_DEBUG_CONTEXT, opts.errorChecking);
+  puglSetViewHint(app.parent, PUGL_RESIZABLE, opts.resizable);
+  puglSetViewHint(app.parent, PUGL_SAMPLES, opts.samples);
+  puglSetViewHint(app.parent, PUGL_DOUBLE_BUFFER, opts.doubleBuffer);
+  puglSetViewHint(app.parent, PUGL_SWAP_INTERVAL, opts.sync);
+  puglSetViewHint(app.parent, PUGL_IGNORE_KEY_REPEAT, opts.ignoreKeyRepeat);
+  puglSetHandle(app.parent, &app);
+  puglSetEventFunc(app.parent, onParentEvent);
+
+  PuglStatus    st      = PUGL_SUCCESS;
+  const uint8_t title[] = {
+    'P', 'u', 'g', 'l', ' ', 'P', 'r', 0xC3, 0xBC, 'f', 'u', 'n', 'g', 0};
+
+  puglSetWindowTitle(app.parent, (const char*)title);
+
+  if ((st = puglRealize(app.parent))) {
+    return logError("Failed to create parent window (%s)\n", puglStrerror(st));
+  }
+
+  puglSetFrame(app.child, getChildFrame(parentFrame));
+  puglSetParentWindow(app.child, puglGetNativeWindow(app.parent));
+
+  puglSetViewHint(app.child, PUGL_USE_DEBUG_CONTEXT, opts.errorChecking);
+  puglSetViewHint(app.child, PUGL_SAMPLES, opts.samples);
+  puglSetViewHint(app.child, PUGL_DOUBLE_BUFFER, opts.doubleBuffer);
+  puglSetViewHint(app.child, PUGL_SWAP_INTERVAL, opts.sync);
+  puglSetBackend(app.child, puglGlBackend());
+  puglSetViewHint(app.child, PUGL_IGNORE_KEY_REPEAT, opts.ignoreKeyRepeat);
+  puglSetHandle(app.child, &app);
+  puglSetEventFunc(app.child, onEvent);
+
+  if ((st = puglRealize(app.child))) {
+    return logError("Failed to create child window (%s)\n", puglStrerror(st));
+  }
+
+  puglShow(app.parent);
+  puglShow(app.child);
+
+  puglStartTimer(app.child, reverseTimerId, 3.6);
+
+  PuglFpsPrinter fpsPrinter         = {puglGetTime(app.world)};
+  unsigned       framesDrawn        = 0;
+  bool           requestedAttention = false;
+  while (!app.quit) {
+    const double thisTime = puglGetTime(app.world);
+
+    puglUpdate(app.world, app.continuous ? 0.0 : -1.0);
+    ++framesDrawn;
+
+    if (!requestedAttention && thisTime > 5.0) {
+      puglRequestAttention(app.parent);
+      requestedAttention = true;
+    }
+
+    if (app.continuous) {
+      puglPrintFps(app.world, &fpsPrinter, &framesDrawn);
+    }
+  }
+
+  puglFreeView(app.child);
+  puglFreeView(app.parent);
+  puglFreeWorld(app.world);
+
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_print_events.c b/subprojects/nk_pugl/pugl/examples/pugl_print_events.c
index 8f8874b..dfa217e 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_print_events.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_print_events.c
@@ -22,56 +22,58 @@
 #include <stdbool.h>
 #include <stdio.h>
 
-typedef struct
-{
-	PuglWorld* world;
-	PuglView*  view;
-	int        quit;
+typedef struct {
+  PuglWorld* world;
+  PuglView*  view;
+  int        quit;
 } PuglPrintEventsApp;
 
 static PuglStatus
 onEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglPrintEventsApp* app = (PuglPrintEventsApp*)puglGetHandle(view);
+  PuglPrintEventsApp* app = (PuglPrintEventsApp*)puglGetHandle(view);
 
-	printEvent(event, "Event: ", true);
+  printEvent(event, "Event: ", true);
 
-	switch (event->type) {
-	case PUGL_CLOSE: app->quit = 1; break;
-	default: break;
-	}
+  switch (event->type) {
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  default:
+    break;
+  }
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 int
 main(void)
 {
-	PuglPrintEventsApp app = {NULL, NULL, 0};
+  PuglPrintEventsApp app = {NULL, NULL, 0};
 
-	app.world = puglNewWorld(PUGL_PROGRAM, 0);
-	app.view  = puglNewView(app.world);
+  app.world = puglNewWorld(PUGL_PROGRAM, 0);
+  app.view  = puglNewView(app.world);
 
-	puglSetClassName(app.world, "Pugl Print Events");
-	puglSetWindowTitle(app.view, "Pugl Event Printer");
-	puglSetDefaultSize(app.view, 512, 512);
-	puglSetBackend(app.view, puglStubBackend());
-	puglSetHandle(app.view, &app);
-	puglSetEventFunc(app.view, onEvent);
+  puglSetClassName(app.world, "Pugl Print Events");
+  puglSetWindowTitle(app.view, "Pugl Event Printer");
+  puglSetDefaultSize(app.view, 512, 512);
+  puglSetBackend(app.view, puglStubBackend());
+  puglSetHandle(app.view, &app);
+  puglSetEventFunc(app.view, onEvent);
 
-	PuglStatus st = puglRealize(app.view);
-	if (st) {
-		return logError("Failed to create window (%s)\n", puglStrerror(st));
-	}
+  PuglStatus st = puglRealize(app.view);
+  if (st) {
+    return logError("Failed to create window (%s)\n", puglStrerror(st));
+  }
 
-	puglShow(app.view);
+  puglShow(app.view);
 
-	while (!app.quit) {
-		puglUpdate(app.world, -1.0);
-	}
+  while (!app.quit) {
+    puglUpdate(app.world, -1.0);
+  }
 
-	puglFreeView(app.view);
-	puglFreeWorld(app.world);
+  puglFreeView(app.view);
+  puglFreeWorld(app.world);
 
-	return 0;
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_shader_demo.c b/subprojects/nk_pugl/pugl/examples/pugl_shader_demo.c
index 8ebbe60..087afc5 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_shader_demo.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_shader_demo.c
@@ -56,30 +56,28 @@ static const int       defaultWidth  = 512;
 static const int       defaultHeight = 512;
 static const uintptr_t resizeTimerId = 1u;
 
-typedef struct
-{
-	mat4 projection;
+typedef struct {
+  mat4 projection;
 } RectUniforms;
 
-typedef struct
-{
-	const char*     programPath;
-	PuglWorld*      world;
-	PuglView*       view;
-	PuglTestOptions opts;
-	size_t          numRects;
-	Rect*           rects;
-	Program         drawRect;
-	GLuint          vao;
-	GLuint          vbo;
-	GLuint          instanceVbo;
-	GLuint          ibo;
-	double          lastDrawDuration;
-	double          lastFrameEndTime;
-	unsigned        framesDrawn;
-	int             glMajorVersion;
-	int             glMinorVersion;
-	int             quit;
+typedef struct {
+  const char*     programPath;
+  PuglWorld*      world;
+  PuglView*       view;
+  PuglTestOptions opts;
+  size_t          numRects;
+  Rect*           rects;
+  Program         drawRect;
+  GLuint          vao;
+  GLuint          vbo;
+  GLuint          instanceVbo;
+  GLuint          ibo;
+  double          lastDrawDuration;
+  double          lastFrameEndTime;
+  unsigned        framesDrawn;
+  int             glMajorVersion;
+  int             glMinorVersion;
+  int             quit;
 } PuglTestApp;
 
 static PuglStatus
@@ -91,393 +89,381 @@ teardownGl(PuglTestApp* app);
 static void
 onConfigure(PuglView* view, double width, double height)
 {
-	(void)view;
+  (void)view;
 
-	glEnable(GL_BLEND);
-	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
-	glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-	glViewport(0, 0, (int)width, (int)height);
+  glEnable(GL_BLEND);
+  glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+  glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+  glViewport(0, 0, (int)width, (int)height);
 }
 
 static void
 onExpose(PuglView* view)
 {
-	PuglTestApp*   app    = (PuglTestApp*)puglGetHandle(view);
-	const PuglRect frame  = puglGetFrame(view);
-	const float    width  = (float)frame.width;
-	const float    height = (float)frame.height;
-	const double   time   = puglGetTime(puglGetWorld(view));
-
-	// Construct projection matrix for 2D window surface (in pixels)
-	mat4 proj;
-	mat4Ortho(proj,
-	          0.0f,
-	          (float)frame.width,
-	          0.0f,
-	          (float)frame.height,
-	          -1.0f,
-	          1.0f);
-
-	// Clear and bind everything that is the same for every rect
-	glClear(GL_COLOR_BUFFER_BIT);
-	glUseProgram(app->drawRect.program);
-	glBindVertexArray(app->vao);
-
-	for (size_t i = 0; i < app->numRects; ++i) {
-		moveRect(&app->rects[i], i, app->numRects, width, height, time);
-	}
-
-	glBufferData(GL_UNIFORM_BUFFER, sizeof(proj), &proj, GL_STREAM_DRAW);
-
-	glBufferSubData(GL_ARRAY_BUFFER,
-	                0,
-	                (GLsizeiptr)(app->numRects * sizeof(Rect)),
-	                app->rects);
-
-	glDrawElementsInstanced(GL_TRIANGLE_STRIP,
-	                        4,
-	                        GL_UNSIGNED_INT,
-	                        NULL,
-	                        (GLsizei)(app->numRects * 4));
-
-	++app->framesDrawn;
-
-	app->lastFrameEndTime = puglGetTime(puglGetWorld(view));
-	app->lastDrawDuration = app->lastFrameEndTime - time;
+  PuglTestApp*   app    = (PuglTestApp*)puglGetHandle(view);
+  const PuglRect frame  = puglGetFrame(view);
+  const float    width  = (float)frame.width;
+  const float    height = (float)frame.height;
+  const double   time   = puglGetTime(puglGetWorld(view));
+
+  // Construct projection matrix for 2D window surface (in pixels)
+  mat4 proj;
+  mat4Ortho(
+    proj, 0.0f, (float)frame.width, 0.0f, (float)frame.height, -1.0f, 1.0f);
+
+  // Clear and bind everything that is the same for every rect
+  glClear(GL_COLOR_BUFFER_BIT);
+  glUseProgram(app->drawRect.program);
+  glBindVertexArray(app->vao);
+
+  for (size_t i = 0; i < app->numRects; ++i) {
+    moveRect(&app->rects[i], i, app->numRects, width, height, time);
+  }
+
+  glBufferData(GL_UNIFORM_BUFFER, sizeof(proj), &proj, GL_STREAM_DRAW);
+
+  glBufferSubData(
+    GL_ARRAY_BUFFER, 0, (GLsizeiptr)(app->numRects * sizeof(Rect)), app->rects);
+
+  glDrawElementsInstanced(
+    GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_INT, NULL, (GLsizei)(app->numRects * 4));
+
+  ++app->framesDrawn;
+
+  app->lastFrameEndTime = puglGetTime(puglGetWorld(view));
+  app->lastDrawDuration = app->lastFrameEndTime - time;
 }
 
 static PuglStatus
 onEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
-
-	printEvent(event, "Event: ", app->opts.verbose);
-
-	switch (event->type) {
-	case PUGL_CREATE:
-		setupGl(app);
-		break;
-	case PUGL_DESTROY:
-		teardownGl(app);
-		break;
-	case PUGL_CONFIGURE:
-		onConfigure(view, event->configure.width, event->configure.height);
-		break;
-	case PUGL_UPDATE:
-		puglPostRedisplay(view);
-		break;
-	case PUGL_EXPOSE: onExpose(view); break;
-	case PUGL_CLOSE: app->quit = 1; break;
-	case PUGL_LOOP_ENTER:
-		puglStartTimer(view,
-		               resizeTimerId,
-		               1.0 / (double)puglGetViewHint(view, PUGL_REFRESH_RATE));
-		break;
-	case PUGL_LOOP_LEAVE:
-		puglStopTimer(view, resizeTimerId);
-		break;
-	case PUGL_KEY_PRESS:
-		if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
-			app->quit = 1;
-		}
-		break;
-	case PUGL_TIMER:
-		if (event->timer.id == resizeTimerId) {
-			puglPostRedisplay(view);
-		}
-		break;
-	default: break;
-	}
-
-	return PUGL_SUCCESS;
+  PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+
+  printEvent(event, "Event: ", app->opts.verbose);
+
+  switch (event->type) {
+  case PUGL_CREATE:
+    setupGl(app);
+    break;
+  case PUGL_DESTROY:
+    teardownGl(app);
+    break;
+  case PUGL_CONFIGURE:
+    onConfigure(view, event->configure.width, event->configure.height);
+    break;
+  case PUGL_UPDATE:
+    puglPostRedisplay(view);
+    break;
+  case PUGL_EXPOSE:
+    onExpose(view);
+    break;
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  case PUGL_LOOP_ENTER:
+    puglStartTimer(view,
+                   resizeTimerId,
+                   1.0 / (double)puglGetViewHint(view, PUGL_REFRESH_RATE));
+    break;
+  case PUGL_LOOP_LEAVE:
+    puglStopTimer(view, resizeTimerId);
+    break;
+  case PUGL_KEY_PRESS:
+    if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
+      app->quit = 1;
+    }
+    break;
+  case PUGL_TIMER:
+    if (event->timer.id == resizeTimerId) {
+      puglPostRedisplay(view);
+    }
+    break;
+  default:
+    break;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 static Rect*
 makeRects(const size_t numRects)
 {
-	Rect* rects = (Rect*)calloc(numRects, sizeof(Rect));
-	for (size_t i = 0; i < numRects; ++i) {
-		rects[i] = makeRect(i, (float)defaultWidth);
-	}
+  Rect* rects = (Rect*)calloc(numRects, sizeof(Rect));
+  for (size_t i = 0; i < numRects; ++i) {
+    rects[i] = makeRect(i, (float)defaultWidth);
+  }
 
-	return rects;
+  return rects;
 }
 
 static char*
 loadShader(const char* const programPath, const char* const name)
 {
-	char* const path = resourcePath(programPath, name);
-	fprintf(stderr, "Loading shader %s\n", path);
+  char* const path = resourcePath(programPath, name);
+  fprintf(stderr, "Loading shader %s\n", path);
 
-	FILE* const file = fopen(path, "r");
-	if (!file) {
-		logError("Failed to open '%s'\n", path);
-		return NULL;
-	}
+  FILE* const file = fopen(path, "r");
+  if (!file) {
+    logError("Failed to open '%s'\n", path);
+    return NULL;
+  }
 
-	free(path);
-	fseek(file, 0, SEEK_END);
-	const size_t fileSize = (size_t)ftell(file);
+  free(path);
+  fseek(file, 0, SEEK_END);
+  const size_t fileSize = (size_t)ftell(file);
 
-	fseek(file, 0, SEEK_SET);
-	char* source = (char*)calloc(1, fileSize + 1u);
+  fseek(file, 0, SEEK_SET);
+  char* source = (char*)calloc(1, fileSize + 1u);
 
-	fread(source, 1, fileSize, file);
-	fclose(file);
+  fread(source, 1, fileSize, file);
+  fclose(file);
 
-	return source;
+  return source;
 }
 
 static int
 parseOptions(PuglTestApp* app, int argc, char** argv)
 {
-	char* endptr = NULL;
-
-	// Parse command line options
-	app->numRects = 1024;
-	app->opts     = puglParseTestOptions(&argc, &argv);
-	if (app->opts.help) {
-		return 1;
-	}
-
-	// Parse number of rectangles argument, if given
-	if (argc >= 1) {
-		app->numRects = (size_t)strtol(argv[0], &endptr, 10);
-		if (endptr != argv[0] + strlen(argv[0])) {
-			logError("Invalid number of rectangles: %s\n", argv[0]);
-			return 1;
-		}
-	}
-
-	// Parse OpenGL major version argument, if given
-	if (argc >= 2) {
-		app->glMajorVersion = (int)strtol(argv[1], &endptr, 10);
-		if (endptr != argv[1] + strlen(argv[1])) {
-			logError("Invalid GL major version: %s\n", argv[1]);
-			return 1;
-		} else if (app->glMajorVersion == 4) {
-			app->glMinorVersion = 2;
-		} else if (app->glMajorVersion != 3) {
-			logError("Unsupported GL major version %d\n", app->glMajorVersion);
-			return 1;
-		}
-	}
-
-	return 0;
+  char* endptr = NULL;
+
+  // Parse command line options
+  app->numRects = 1024;
+  app->opts     = puglParseTestOptions(&argc, &argv);
+  if (app->opts.help) {
+    return 1;
+  }
+
+  // Parse number of rectangles argument, if given
+  if (argc >= 1) {
+    app->numRects = (size_t)strtol(argv[0], &endptr, 10);
+    if (endptr != argv[0] + strlen(argv[0])) {
+      logError("Invalid number of rectangles: %s\n", argv[0]);
+      return 1;
+    }
+  }
+
+  // Parse OpenGL major version argument, if given
+  if (argc >= 2) {
+    app->glMajorVersion = (int)strtol(argv[1], &endptr, 10);
+    if (endptr != argv[1] + strlen(argv[1])) {
+      logError("Invalid GL major version: %s\n", argv[1]);
+      return 1;
+    }
+
+    if (app->glMajorVersion == 4) {
+      app->glMinorVersion = 2;
+    } else if (app->glMajorVersion != 3) {
+      logError("Unsupported GL major version %d\n", app->glMajorVersion);
+      return 1;
+    }
+  }
+
+  return 0;
 }
 
 static void
 setupPugl(PuglTestApp* app)
 {
-	// Create world, view, and rect data
-	app->world = puglNewWorld(PUGL_PROGRAM, 0);
-	app->view  = puglNewView(app->world);
-	app->rects = makeRects(app->numRects);
-
-	// Set up world and view
-	puglSetClassName(app->world, "PuglGL3Demo");
-	puglSetWindowTitle(app->view, "Pugl OpenGL 3");
-	puglSetDefaultSize(app->view, defaultWidth, defaultHeight);
-	puglSetMinSize(app->view, defaultWidth / 4, defaultHeight / 4);
-	puglSetAspectRatio(app->view, 1, 1, 16, 9);
-	puglSetBackend(app->view, puglGlBackend());
-	puglSetViewHint(app->view, PUGL_USE_COMPAT_PROFILE, PUGL_FALSE);
-	puglSetViewHint(app->view, PUGL_USE_DEBUG_CONTEXT, app->opts.errorChecking);
-	puglSetViewHint(app->view, PUGL_CONTEXT_VERSION_MAJOR, app->glMajorVersion);
-	puglSetViewHint(app->view, PUGL_CONTEXT_VERSION_MINOR, app->glMinorVersion);
-	puglSetViewHint(app->view, PUGL_RESIZABLE, app->opts.resizable);
-	puglSetViewHint(app->view, PUGL_SAMPLES, app->opts.samples);
-	puglSetViewHint(app->view, PUGL_DOUBLE_BUFFER, app->opts.doubleBuffer);
-	puglSetViewHint(app->view, PUGL_SWAP_INTERVAL, app->opts.sync);
-	puglSetViewHint(app->view, PUGL_IGNORE_KEY_REPEAT, PUGL_TRUE);
-	puglSetHandle(app->view, app);
-	puglSetEventFunc(app->view, onEvent);
+  // Create world, view, and rect data
+  app->world = puglNewWorld(PUGL_PROGRAM, 0);
+  app->view  = puglNewView(app->world);
+  app->rects = makeRects(app->numRects);
+
+  // Set up world and view
+  puglSetClassName(app->world, "PuglGL3Demo");
+  puglSetWindowTitle(app->view, "Pugl OpenGL 3");
+  puglSetDefaultSize(app->view, defaultWidth, defaultHeight);
+  puglSetMinSize(app->view, defaultWidth / 4, defaultHeight / 4);
+  puglSetAspectRatio(app->view, 1, 1, 16, 9);
+  puglSetBackend(app->view, puglGlBackend());
+  puglSetViewHint(app->view, PUGL_USE_COMPAT_PROFILE, PUGL_FALSE);
+  puglSetViewHint(app->view, PUGL_USE_DEBUG_CONTEXT, app->opts.errorChecking);
+  puglSetViewHint(app->view, PUGL_CONTEXT_VERSION_MAJOR, app->glMajorVersion);
+  puglSetViewHint(app->view, PUGL_CONTEXT_VERSION_MINOR, app->glMinorVersion);
+  puglSetViewHint(app->view, PUGL_RESIZABLE, app->opts.resizable);
+  puglSetViewHint(app->view, PUGL_SAMPLES, app->opts.samples);
+  puglSetViewHint(app->view, PUGL_DOUBLE_BUFFER, app->opts.doubleBuffer);
+  puglSetViewHint(app->view, PUGL_SWAP_INTERVAL, app->opts.sync);
+  puglSetViewHint(app->view, PUGL_IGNORE_KEY_REPEAT, PUGL_TRUE);
+  puglSetHandle(app->view, app);
+  puglSetEventFunc(app->view, onEvent);
 }
 
 static PuglStatus
 setupGl(PuglTestApp* app)
 {
-	// Load GL functions via GLAD
-	if (!gladLoadGLLoader((GLADloadproc)&puglGetProcAddress)) {
-		logError("Failed to load GL\n");
-		return PUGL_FAILURE;
-	}
-
-	const char* const headerFile = (app->glMajorVersion == 3
-	                                ? "shaders/header_330.glsl"
-	                                : "shaders/header_420.glsl");
-
-	// Load shader sources
-	char* const headerSource = loadShader(app->programPath, headerFile);
-
-	char* const vertexSource = loadShader(app->programPath,
-	                                      "shaders/rect.vert");
-
-	char* const fragmentSource = loadShader(app->programPath,
-	                                        "shaders/rect.frag");
-
-	if (!vertexSource || !fragmentSource) {
-		logError("Failed to load shader sources\n");
-		return PUGL_FAILURE;
-	}
-
-	// Compile rectangle shaders and program
-	app->drawRect = compileProgram(headerSource, vertexSource, fragmentSource);
-	free(fragmentSource);
-	free(vertexSource);
-	free(headerSource);
-	if (!app->drawRect.program) {
-		return PUGL_FAILURE;
-	}
-
-	// Get location of rectangle shader uniform block
-	const GLuint globalsIndex = glGetUniformBlockIndex(app->drawRect.program,
-	                                                   "UniformBufferObject");
-
-	// Generate/bind a uniform buffer for setting rectangle properties
-	GLuint uboHandle = 0;
-	glGenBuffers(1, &uboHandle);
-	glBindBuffer(GL_UNIFORM_BUFFER, uboHandle);
-	glBindBufferBase(GL_UNIFORM_BUFFER, globalsIndex, uboHandle);
-
-	// Generate/bind a VAO to track state
-	glGenVertexArrays(1, &app->vao);
-	glBindVertexArray(app->vao);
-
-	// Generate/bind a VBO to store vertex position data
-	glGenBuffers(1, &app->vbo);
-	glBindBuffer(GL_ARRAY_BUFFER, app->vbo);
-	glBufferData(GL_ARRAY_BUFFER,
-	             sizeof(rectVertices),
-	             rectVertices,
-	             GL_STATIC_DRAW);
-
-	// Attribute 0 is position, 2 floats from the VBO
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), NULL);
-
-	// Generate/bind a VBO to store instance attribute data
-	glGenBuffers(1, &app->instanceVbo);
-	glBindBuffer(GL_ARRAY_BUFFER, app->instanceVbo);
-	glBufferData(GL_ARRAY_BUFFER,
-	             (GLsizeiptr)(app->numRects * sizeof(Rect)),
-	             app->rects,
-	             GL_STREAM_DRAW);
-
-	// Attribute 1 is Rect::position
-	glEnableVertexAttribArray(1);
-	glVertexAttribDivisor(1, 4);
-	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Rect), NULL);
-
-	// Attribute 2 is Rect::size
-	glEnableVertexAttribArray(2);
-	glVertexAttribDivisor(2, 4);
-	glVertexAttribPointer(2,
-	                      2,
-	                      GL_FLOAT,
-	                      GL_FALSE,
-	                      sizeof(Rect),
-	                      (const void*)offsetof(Rect, size));
-
-	// Attribute 3 is Rect::fillColor
-	glEnableVertexAttribArray(3);
-	glVertexAttribDivisor(3, 4);
-	glVertexAttribPointer(3,
-	                      4,
-	                      GL_FLOAT,
-	                      GL_FALSE,
-	                      sizeof(Rect),
-	                      (const void*)offsetof(Rect, fillColor));
-
-	// Set up the IBO to index into the VBO
-	glGenBuffers(1, &app->ibo);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, app->ibo);
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
-	             sizeof(rectIndices),
-	             rectIndices,
-	             GL_STATIC_DRAW);
-
-	return PUGL_SUCCESS;
+  // Load GL functions via GLAD
+  if (!gladLoadGLLoader((GLADloadproc)&puglGetProcAddress)) {
+    logError("Failed to load GL\n");
+    return PUGL_FAILURE;
+  }
+
+  const char* const headerFile =
+    (app->glMajorVersion == 3 ? "shaders/header_330.glsl"
+                              : "shaders/header_420.glsl");
+
+  // Load shader sources
+  char* const headerSource = loadShader(app->programPath, headerFile);
+
+  char* const vertexSource = loadShader(app->programPath, "shaders/rect.vert");
+
+  char* const fragmentSource =
+    loadShader(app->programPath, "shaders/rect.frag");
+
+  if (!vertexSource || !fragmentSource) {
+    logError("Failed to load shader sources\n");
+    return PUGL_FAILURE;
+  }
+
+  // Compile rectangle shaders and program
+  app->drawRect = compileProgram(headerSource, vertexSource, fragmentSource);
+  free(fragmentSource);
+  free(vertexSource);
+  free(headerSource);
+  if (!app->drawRect.program) {
+    return PUGL_FAILURE;
+  }
+
+  // Get location of rectangle shader uniform block
+  const GLuint globalsIndex =
+    glGetUniformBlockIndex(app->drawRect.program, "UniformBufferObject");
+
+  // Generate/bind a uniform buffer for setting rectangle properties
+  GLuint uboHandle = 0;
+  glGenBuffers(1, &uboHandle);
+  glBindBuffer(GL_UNIFORM_BUFFER, uboHandle);
+  glBindBufferBase(GL_UNIFORM_BUFFER, globalsIndex, uboHandle);
+
+  // Generate/bind a VAO to track state
+  glGenVertexArrays(1, &app->vao);
+  glBindVertexArray(app->vao);
+
+  // Generate/bind a VBO to store vertex position data
+  glGenBuffers(1, &app->vbo);
+  glBindBuffer(GL_ARRAY_BUFFER, app->vbo);
+  glBufferData(
+    GL_ARRAY_BUFFER, sizeof(rectVertices), rectVertices, GL_STATIC_DRAW);
+
+  // Attribute 0 is position, 2 floats from the VBO
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), NULL);
+
+  // Generate/bind a VBO to store instance attribute data
+  glGenBuffers(1, &app->instanceVbo);
+  glBindBuffer(GL_ARRAY_BUFFER, app->instanceVbo);
+  glBufferData(GL_ARRAY_BUFFER,
+               (GLsizeiptr)(app->numRects * sizeof(Rect)),
+               app->rects,
+               GL_STREAM_DRAW);
+
+  // Attribute 1 is Rect::position
+  glEnableVertexAttribArray(1);
+  glVertexAttribDivisor(1, 4);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Rect), NULL);
+
+  // Attribute 2 is Rect::size
+  glEnableVertexAttribArray(2);
+  glVertexAttribDivisor(2, 4);
+  glVertexAttribPointer(
+    2, 2, GL_FLOAT, GL_FALSE, sizeof(Rect), (const void*)offsetof(Rect, size));
+
+  // Attribute 3 is Rect::fillColor
+  glEnableVertexAttribArray(3);
+  glVertexAttribDivisor(3, 4);
+  glVertexAttribPointer(3,
+                        4,
+                        GL_FLOAT,
+                        GL_FALSE,
+                        sizeof(Rect),
+                        (const void*)offsetof(Rect, fillColor));
+
+  // Set up the IBO to index into the VBO
+  glGenBuffers(1, &app->ibo);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, app->ibo);
+  glBufferData(
+    GL_ELEMENT_ARRAY_BUFFER, sizeof(rectIndices), rectIndices, GL_STATIC_DRAW);
+
+  return PUGL_SUCCESS;
 }
 
 static void
 teardownGl(PuglTestApp* app)
 {
-	glDeleteBuffers(1, &app->ibo);
-	glDeleteBuffers(1, &app->vbo);
-	glDeleteBuffers(1, &app->instanceVbo);
-	glDeleteVertexArrays(1, &app->vao);
-	deleteProgram(app->drawRect);
+  glDeleteBuffers(1, &app->ibo);
+  glDeleteBuffers(1, &app->vbo);
+  glDeleteBuffers(1, &app->instanceVbo);
+  glDeleteVertexArrays(1, &app->vao);
+  deleteProgram(app->drawRect);
 }
 
 int
 main(int argc, char** argv)
 {
-	PuglTestApp app = {0};
-
-	app.programPath    = argv[0];
-	app.glMajorVersion = 3;
-	app.glMinorVersion = 3;
-
-	// Parse command line options
-	if (parseOptions(&app, argc, argv)) {
-		puglPrintTestUsage("pugl_shader_demo", "[NUM_RECTS] [GL_MAJOR]");
-		return 1;
-	}
-
-	// Create and configure world and view
-	setupPugl(&app);
-
-	// Create window (which will send a PUGL_CREATE event)
-	const PuglStatus st = puglRealize(app.view);
-	if (st) {
-		return logError("Failed to create window (%s)\n", puglStrerror(st));
-	}
-
-	// Show window
-	printViewHints(app.view);
-	puglShow(app.view);
-
-	// Calculate ideal frame duration to drive the main loop at a good rate
-	const int    refreshRate   = puglGetViewHint(app.view, PUGL_REFRESH_RATE);
-	const double frameDuration = 1.0 / (double)refreshRate;
-
-	// Grind away, drawing continuously
-	const double   startTime  = puglGetTime(app.world);
-	PuglFpsPrinter fpsPrinter = {startTime};
-	while (!app.quit) {
-		/* To minimize input latency and get smooth performance during window
-		   resizing, we want to poll for events as long as possible before
-		   starting to draw the next frame.  This ensures that as many events
-		   are consumed as possible before starting to draw, or, equivalently,
-		   that the next rendered frame represents the latest events possible.
-		   This is particularly important for mouse input and "live" window
-		   resizing, where many events tend to pile up within a frame.
-
-		   To do this, we keep track of the time when the last frame was
-		   finished drawing, and how long it took to expose (and assume this is
-		   relatively stable).  Then, we can calculate how much time there is
-		   from now until the time when we should start drawing to not miss the
-		   deadline, and use that as the timeout for puglUpdate().
-		*/
-
-		const double now              = puglGetTime(app.world);
-		const double nextFrameEndTime = app.lastFrameEndTime + frameDuration;
-		const double nextExposeTime   = nextFrameEndTime - app.lastDrawDuration;
-		const double timeUntilNext    = nextExposeTime - now;
-		const double timeout          = app.opts.sync ? timeUntilNext : 0.0;
-
-		puglUpdate(app.world, fmax(0.0, timeout));
-		puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
-	}
-
-	// Destroy window (which will send a PUGL_DESTROY event)
-	puglFreeView(app.view);
-
-	// Free everything else
-	puglFreeWorld(app.world);
-	free(app.rects);
-
-	return 0;
+  PuglTestApp app = {0};
+
+  app.programPath    = argv[0];
+  app.glMajorVersion = 3;
+  app.glMinorVersion = 3;
+
+  // Parse command line options
+  if (parseOptions(&app, argc, argv)) {
+    puglPrintTestUsage("pugl_shader_demo", "[NUM_RECTS] [GL_MAJOR]");
+    return 1;
+  }
+
+  // Create and configure world and view
+  setupPugl(&app);
+
+  // Create window (which will send a PUGL_CREATE event)
+  const PuglStatus st = puglRealize(app.view);
+  if (st) {
+    return logError("Failed to create window (%s)\n", puglStrerror(st));
+  }
+
+  // Show window
+  printViewHints(app.view);
+  puglShow(app.view);
+
+  // Calculate ideal frame duration to drive the main loop at a good rate
+  const int    refreshRate   = puglGetViewHint(app.view, PUGL_REFRESH_RATE);
+  const double frameDuration = 1.0 / (double)refreshRate;
+
+  // Grind away, drawing continuously
+  const double   startTime  = puglGetTime(app.world);
+  PuglFpsPrinter fpsPrinter = {startTime};
+  while (!app.quit) {
+    /* To minimize input latency and get smooth performance during window
+       resizing, we want to poll for events as long as possible before
+       starting to draw the next frame.  This ensures that as many events
+       are consumed as possible before starting to draw, or, equivalently,
+       that the next rendered frame represents the latest events possible.
+       This is particularly important for mouse input and "live" window
+       resizing, where many events tend to pile up within a frame.
+
+       To do this, we keep track of the time when the last frame was
+       finished drawing, and how long it took to expose (and assume this is
+       relatively stable).  Then, we can calculate how much time there is
+       from now until the time when we should start drawing to not miss the
+       deadline, and use that as the timeout for puglUpdate().
+    */
+
+    const double now              = puglGetTime(app.world);
+    const double nextFrameEndTime = app.lastFrameEndTime + frameDuration;
+    const double nextExposeTime   = nextFrameEndTime - app.lastDrawDuration;
+    const double timeUntilNext    = nextExposeTime - now;
+    const double timeout          = app.opts.sync ? timeUntilNext : 0.0;
+
+    puglUpdate(app.world, fmax(0.0, timeout));
+    puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
+  }
+
+  // Destroy window (which will send a PUGL_DESTROY event)
+  puglFreeView(app.view);
+
+  // Free everything else
+  puglFreeWorld(app.world);
+  free(app.rects);
+
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_vulkan_cxx_demo.cpp b/subprojects/nk_pugl/pugl/examples/pugl_vulkan_cxx_demo.cpp
index 21fd4df..e816091 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_vulkan_cxx_demo.cpp
+++ b/subprojects/nk_pugl/pugl/examples/pugl_vulkan_cxx_demo.cpp
@@ -1,5 +1,5 @@
 /*
-  Copyright 2019-2020 David Robillard <http://drobilla.net>
+  Copyright 2019-2020 David Robillard <d@drobilla.net>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
@@ -39,7 +39,6 @@
 #include "pugl/vulkan.hpp"
 
 #include <vulkan/vk_platform.h>
-#include <vulkan/vulkan_core.h>
 
 #include <algorithm>
 #include <array>
@@ -61,152 +60,154 @@ namespace {
 constexpr uintptr_t resizeTimerId = 1u;
 
 struct PhysicalDeviceSelection {
-	sk::PhysicalDevice physicalDevice;
-	uint32_t           graphicsFamilyIndex;
+  sk::PhysicalDevice physicalDevice;
+  uint32_t           graphicsFamilyIndex;
 };
 
 /// Basic Vulkan context associated with the window
 struct VulkanContext {
-	VkResult init(pugl::VulkanLoader& loader, const PuglTestOptions& opts);
+  VkResult init(pugl::VulkanLoader& loader, const PuglTestOptions& opts);
 
-	sk::VulkanApi              vk;
-	sk::Instance               instance;
-	sk::DebugReportCallbackEXT debugCallback;
+  sk::VulkanApi              vk;
+  sk::Instance               instance;
+  sk::DebugReportCallbackEXT debugCallback;
 };
 
 /// Basic setup of graphics device
 struct GraphicsDevice {
-	VkResult init(const pugl::VulkanLoader& loader,
-	              const VulkanContext&      context,
-	              pugl::View&               view,
-	              const PuglTestOptions&    opts);
-
-	sk::SurfaceKHR     surface;
-	sk::PhysicalDevice physicalDevice{};
-	uint32_t           graphicsIndex{};
-	VkSurfaceFormatKHR surfaceFormat{};
-	VkPresentModeKHR   presentMode{};
-	VkPresentModeKHR   resizePresentMode{};
-	sk::Device         device{};
-	sk::Queue          graphicsQueue{};
-	sk::CommandPool    commandPool{};
+  VkResult init(const pugl::VulkanLoader& loader,
+                const VulkanContext&      context,
+                pugl::View&               view,
+                const PuglTestOptions&    opts);
+
+  sk::SurfaceKHR     surface;
+  sk::PhysicalDevice physicalDevice{};
+  uint32_t           graphicsIndex{};
+  VkSurfaceFormatKHR surfaceFormat{};
+  VkPresentModeKHR   presentMode{};
+  VkPresentModeKHR   resizePresentMode{};
+  sk::Device         device{};
+  sk::Queue          graphicsQueue{};
+  sk::CommandPool    commandPool{};
 };
 
 /// Buffer allocated on the GPU
 struct Buffer {
-	VkResult init(const sk::VulkanApi&  vk,
-	              const GraphicsDevice& gpu,
-	              VkDeviceSize          size,
-	              VkBufferUsageFlags    usage,
-	              VkMemoryPropertyFlags properties);
-
-	sk::Buffer       buffer;
-	sk::DeviceMemory deviceMemory;
+  VkResult init(const sk::VulkanApi&  vk,
+                const GraphicsDevice& gpu,
+                VkDeviceSize          size,
+                VkBufferUsageFlags    usage,
+                VkMemoryPropertyFlags properties);
+
+  sk::Buffer       buffer;
+  sk::DeviceMemory deviceMemory;
 };
 
 /// A set of frames that can be rendered concurrently
 struct Swapchain {
-	VkResult init(const sk::VulkanApi&     vk,
-	              const GraphicsDevice&    gpu,
-	              VkSurfaceCapabilitiesKHR capabilities,
-	              VkExtent2D               extent,
-	              VkSwapchainKHR           oldSwapchain,
-	              bool                     resizing);
-
-	VkSurfaceCapabilitiesKHR   capabilities{};
-	VkExtent2D                 extent{};
-	sk::SwapchainKHR           swapchain{};
-	std::vector<sk::ImageView> imageViews{};
+  VkResult init(const sk::VulkanApi&     vk,
+                const GraphicsDevice&    gpu,
+                VkSurfaceCapabilitiesKHR capabilities,
+                VkExtent2D               extent,
+                VkSwapchainKHR           oldSwapchain,
+                bool                     resizing);
+
+  VkSurfaceCapabilitiesKHR   capabilities{};
+  VkExtent2D                 extent{};
+  sk::SwapchainKHR           swapchain{};
+  std::vector<sk::ImageView> imageViews{};
 };
 
 /// A pass that renders to a target
 struct RenderPass {
-	VkResult init(const sk::VulkanApi&  vk,
-	              const GraphicsDevice& gpu,
-	              const Swapchain&      swapchain);
+  VkResult init(const sk::VulkanApi&  vk,
+                const GraphicsDevice& gpu,
+                const Swapchain&      swapchain);
 
-	sk::RenderPass                                   renderPass;
-	std::vector<sk::Framebuffer>                     framebuffers;
-	sk::CommandBuffers<std::vector<VkCommandBuffer>> commandBuffers;
+  sk::RenderPass                                   renderPass;
+  std::vector<sk::Framebuffer>                     framebuffers;
+  sk::CommandBuffers<std::vector<VkCommandBuffer>> commandBuffers;
 };
 
 /// Uniform buffer for constant data used in shaders
 struct UniformBufferObject {
-	mat4 projection;
+  mat4 projection;
 };
 
 /// Rectangle data that does not depend on renderer configuration
 struct RectData {
-	VkResult
-	init(const sk::VulkanApi& vk, const GraphicsDevice& gpu, size_t nRects);
-
-	sk::DescriptorSetLayout descriptorSetLayout{};
-	Buffer                  uniformBuffer{};
-	sk::MappedMemory        uniformData{};
-	Buffer                  modelBuffer{};
-	Buffer                  instanceBuffer{};
-	sk::MappedMemory        vertexData{};
-	size_t                  numRects{};
+  VkResult init(const sk::VulkanApi&  vk,
+                const GraphicsDevice& gpu,
+                size_t                nRects);
+
+  sk::DescriptorSetLayout descriptorSetLayout{};
+  Buffer                  uniformBuffer{};
+  sk::MappedMemory        uniformData{};
+  Buffer                  modelBuffer{};
+  Buffer                  instanceBuffer{};
+  sk::MappedMemory        vertexData{};
+  size_t                  numRects{};
 };
 
 /// Shader modules for drawing rectangles
 struct RectShaders {
-	VkResult init(const sk::VulkanApi&  vk,
-	              const GraphicsDevice& gpu,
-	              const std::string&    programPath);
+  VkResult init(const sk::VulkanApi&  vk,
+                const GraphicsDevice& gpu,
+                const std::string&    programPath);
 
-	sk::ShaderModule vert{};
-	sk::ShaderModule frag{};
+  sk::ShaderModule vert{};
+  sk::ShaderModule frag{};
 };
 
 /// A pipeline to render rectangles with our shaders
 struct RectPipeline {
-	VkResult init(const sk::VulkanApi&  vk,
-	              const GraphicsDevice& gpu,
-	              const RectData&       rectData,
-	              const RectShaders&    shaders,
-	              const Swapchain&      swapchain,
-	              const RenderPass&     renderPass);
-
-	sk::DescriptorPool                               descriptorPool{};
-	sk::DescriptorSets<std::vector<VkDescriptorSet>> descriptorSets{};
-	sk::PipelineLayout                               pipelineLayout{};
-	std::array<sk::Pipeline, 1>                      pipelines{};
-	uint32_t                                         numImages{};
+  VkResult init(const sk::VulkanApi&  vk,
+                const GraphicsDevice& gpu,
+                const RectData&       rectData,
+                const RectShaders&    shaders,
+                const Swapchain&      swapchain,
+                const RenderPass&     renderPass);
+
+  sk::DescriptorPool                               descriptorPool{};
+  sk::DescriptorSets<std::vector<VkDescriptorSet>> descriptorSets{};
+  sk::PipelineLayout                               pipelineLayout{};
+  std::array<sk::Pipeline, 1>                      pipelines{};
+  uint32_t                                         numImages{};
 };
 
 /// Synchronization primitives used to coordinate drawing frames
 struct RenderSync {
-	VkResult
-	init(const sk::VulkanApi& vk, const sk::Device& device, uint32_t numImages);
-
-	std::vector<sk::Semaphore> imageAvailable{};
-	std::vector<sk::Semaphore> renderFinished{};
-	std::vector<sk::Fence>     inFlight{};
-	size_t                     currentFrame{};
+  VkResult init(const sk::VulkanApi& vk,
+                const sk::Device&    device,
+                uint32_t             numImages);
+
+  std::vector<sk::Semaphore> imageAvailable{};
+  std::vector<sk::Semaphore> renderFinished{};
+  std::vector<sk::Fence>     inFlight{};
+  size_t                     currentFrame{};
 };
 
 /// Renderer that owns the above and everything required to draw
 struct Renderer {
-	VkResult init(const sk::VulkanApi&  vk,
-	              const GraphicsDevice& gpu,
-	              const RectData&       rectData,
-	              const RectShaders&    rectShaders,
-	              VkExtent2D            extent,
-	              bool                  resizing);
-
-	VkResult recreate(const sk::VulkanApi&  vk,
-	                  const sk::SurfaceKHR& surface,
-	                  const GraphicsDevice& gpu,
-	                  const RectData&       rectData,
-	                  const RectShaders&    rectShaders,
-	                  VkExtent2D            extent,
-	                  bool                  resizing);
-
-	Swapchain    swapchain;
-	RenderPass   renderPass;
-	RectPipeline rectPipeline;
-	RenderSync   sync;
+  VkResult init(const sk::VulkanApi&  vk,
+                const GraphicsDevice& gpu,
+                const RectData&       rectData,
+                const RectShaders&    rectShaders,
+                VkExtent2D            extent,
+                bool                  resizing);
+
+  VkResult recreate(const sk::VulkanApi&  vk,
+                    const sk::SurfaceKHR& surface,
+                    const GraphicsDevice& gpu,
+                    const RectData&       rectData,
+                    const RectShaders&    rectShaders,
+                    VkExtent2D            extent,
+                    bool                  resizing);
+
+  Swapchain    swapchain;
+  RenderPass   renderPass;
+  RectPipeline rectPipeline;
+  RenderSync   sync;
 };
 
 VkResult
@@ -215,22 +216,21 @@ selectSurfaceFormat(const sk::VulkanApi&      vk,
                     const sk::SurfaceKHR&     surface,
                     VkSurfaceFormatKHR&       surfaceFormat)
 {
-	std::vector<VkSurfaceFormatKHR> formats;
-	if (VkResult r = vk.getPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
-	                                                       surface,
-	                                                       formats)) {
-		return r;
-	}
-
-	for (const auto& format : formats) {
-		if (format.format == VK_FORMAT_B8G8R8A8_UNORM &&
-		    format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
-			surfaceFormat = format;
-			return VK_SUCCESS;
-		}
-	}
-
-	return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  std::vector<VkSurfaceFormatKHR> formats;
+  if (VkResult r = vk.getPhysicalDeviceSurfaceFormatsKHR(
+        physicalDevice, surface, formats)) {
+    return r;
+  }
+
+  for (const auto& format : formats) {
+    if (format.format == VK_FORMAT_B8G8R8A8_UNORM &&
+        format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+      surfaceFormat = format;
+      return VK_SUCCESS;
+    }
+  }
+
+  return VK_ERROR_FORMAT_NOT_SUPPORTED;
 }
 
 VkResult
@@ -241,54 +241,53 @@ selectPresentMode(const sk::VulkanApi&      vk,
                   const bool                sync,
                   VkPresentModeKHR&         presentMode)
 {
-	// Map command line options to mode priorities
-	static constexpr VkPresentModeKHR priorities[][2][4] = {
-	    {
-	        // No double buffer, no sync
-	        {VK_PRESENT_MODE_IMMEDIATE_KHR,
-	         VK_PRESENT_MODE_MAILBOX_KHR,
-	         VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-	         VK_PRESENT_MODE_FIFO_KHR},
-
-	        // No double buffer, sync (nonsense, map to FIFO relaxed)
-	        {VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-	         VK_PRESENT_MODE_FIFO_KHR,
-	         VK_PRESENT_MODE_MAILBOX_KHR,
-	         VK_PRESENT_MODE_IMMEDIATE_KHR},
-	    },
-	    {
-	        // Double buffer, no sync
-	        {
-	            VK_PRESENT_MODE_MAILBOX_KHR,
-	            VK_PRESENT_MODE_IMMEDIATE_KHR,
-	            VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-	            VK_PRESENT_MODE_FIFO_KHR,
-	        },
-
-	        // Double buffer, sync
-	        {VK_PRESENT_MODE_FIFO_KHR,
-	         VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-	         VK_PRESENT_MODE_MAILBOX_KHR,
-	         VK_PRESENT_MODE_IMMEDIATE_KHR},
-	    },
-	};
-
-	std::vector<VkPresentModeKHR> modes;
-	if (VkResult r = vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice,
-	                                                            surface,
-	                                                            modes)) {
-		return r;
-	}
-
-	const auto& tryModes = priorities[bool(multiBuffer)][bool(sync)];
-	for (const auto m : tryModes) {
-		if (std::find(modes.begin(), modes.end(), m) != modes.end()) {
-			presentMode = m;
-			return VK_SUCCESS;
-		}
-	}
-
-	return VK_ERROR_INCOMPATIBLE_DRIVER;
+  // Map command line options to mode priorities
+  static constexpr VkPresentModeKHR priorities[][2][4] = {
+    {
+      // No double buffer, no sync
+      {VK_PRESENT_MODE_IMMEDIATE_KHR,
+       VK_PRESENT_MODE_MAILBOX_KHR,
+       VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+       VK_PRESENT_MODE_FIFO_KHR},
+
+      // No double buffer, sync (nonsense, map to FIFO relaxed)
+      {VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+       VK_PRESENT_MODE_FIFO_KHR,
+       VK_PRESENT_MODE_MAILBOX_KHR,
+       VK_PRESENT_MODE_IMMEDIATE_KHR},
+    },
+    {
+      // Double buffer, no sync
+      {
+        VK_PRESENT_MODE_MAILBOX_KHR,
+        VK_PRESENT_MODE_IMMEDIATE_KHR,
+        VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+        VK_PRESENT_MODE_FIFO_KHR,
+      },
+
+      // Double buffer, sync
+      {VK_PRESENT_MODE_FIFO_KHR,
+       VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+       VK_PRESENT_MODE_MAILBOX_KHR,
+       VK_PRESENT_MODE_IMMEDIATE_KHR},
+    },
+  };
+
+  std::vector<VkPresentModeKHR> modes;
+  if (VkResult r = vk.getPhysicalDeviceSurfacePresentModesKHR(
+        physicalDevice, surface, modes)) {
+    return r;
+  }
+
+  const auto& tryModes = priorities[bool(multiBuffer)][bool(sync)];
+  for (const auto m : tryModes) {
+    if (std::find(modes.begin(), modes.end(), m) != modes.end()) {
+      presentMode = m;
+      return VK_SUCCESS;
+    }
+  }
+
+  return VK_ERROR_INCOMPATIBLE_DRIVER;
 }
 
 VkResult
@@ -297,26 +296,26 @@ openDevice(const sk::VulkanApi&      vk,
            const uint32_t            graphicsFamilyIndex,
            sk::Device&               device)
 {
-	const float       graphicsQueuePriority = 1.0f;
-	const char* const swapchainName         = "VK_KHR_swapchain";
-
-	const VkDeviceQueueCreateInfo queueCreateInfo{
-	    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-	    nullptr,
-	    0u,
-	    graphicsFamilyIndex,
-	    SK_COUNTED(1u, &graphicsQueuePriority),
-	};
-
-	const VkDeviceCreateInfo createInfo{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-	                                    nullptr,
-	                                    0u,
-	                                    SK_COUNTED(1u, &queueCreateInfo),
-	                                    SK_COUNTED(0u, nullptr), // Deprecated
-	                                    SK_COUNTED(1u, &swapchainName),
-	                                    nullptr};
-
-	return vk.createDevice(physicalDevice, createInfo, device);
+  const float       graphicsQueuePriority = 1.0f;
+  const char* const swapchainName         = "VK_KHR_swapchain";
+
+  const VkDeviceQueueCreateInfo queueCreateInfo{
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+    nullptr,
+    0u,
+    graphicsFamilyIndex,
+    SK_COUNTED(1u, &graphicsQueuePriority),
+  };
+
+  const VkDeviceCreateInfo createInfo{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+                                      nullptr,
+                                      0u,
+                                      SK_COUNTED(1u, &queueCreateInfo),
+                                      SK_COUNTED(0u, nullptr), // Deprecated
+                                      SK_COUNTED(1u, &swapchainName),
+                                      nullptr};
+
+  return vk.createDevice(physicalDevice, createInfo, device);
 }
 
 /// Return whether the physical device supports the extensions we require
@@ -325,21 +324,19 @@ deviceSupportsRequiredExtensions(const sk::VulkanApi&      vk,
                                  const sk::PhysicalDevice& device,
                                  bool&                     supported)
 {
-	VkResult r = VK_SUCCESS;
+  VkResult r = VK_SUCCESS;
 
-	std::vector<VkExtensionProperties> props;
-	if ((r = vk.enumerateDeviceExtensionProperties(device, props))) {
-		return r;
-	}
+  std::vector<VkExtensionProperties> props;
+  if ((r = vk.enumerateDeviceExtensionProperties(device, props))) {
+    return r;
+  }
 
-	supported = std::any_of(props.begin(),
-	                        props.end(),
-	                        [&](const VkExtensionProperties& e) {
-		                        return !strcmp(e.extensionName,
-		                                       "VK_KHR_swapchain");
-	                        });
+  supported = std::any_of(
+    props.begin(), props.end(), [&](const VkExtensionProperties& e) {
+      return !strcmp(e.extensionName, "VK_KHR_swapchain");
+    });
 
-	return VK_SUCCESS;
+  return VK_SUCCESS;
 }
 
 /// Return the index of the graphics queue, if there is one
@@ -349,29 +346,29 @@ findGraphicsQueue(const sk::VulkanApi&      vk,
                   const sk::PhysicalDevice& device,
                   uint32_t&                 queueIndex)
 {
-	VkResult r = VK_SUCCESS;
-
-	std::vector<VkQueueFamilyProperties> queueProps;
-	if ((r = vk.getPhysicalDeviceQueueFamilyProperties(device, queueProps))) {
-		return r;
-	}
-
-	for (uint32_t q = 0u; q < queueProps.size(); ++q) {
-		if (queueProps[q].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-			bool supported = false;
-			if ((r = vk.getPhysicalDeviceSurfaceSupportKHR(
-			         device, q, surface, supported))) {
-				return r;
-			}
-
-			if (supported) {
-				queueIndex = q;
-				return VK_SUCCESS;
-			}
-		}
-	}
-
-	return VK_ERROR_FEATURE_NOT_PRESENT;
+  VkResult r = VK_SUCCESS;
+
+  std::vector<VkQueueFamilyProperties> queueProps;
+  if ((r = vk.getPhysicalDeviceQueueFamilyProperties(device, queueProps))) {
+    return r;
+  }
+
+  for (uint32_t q = 0u; q < queueProps.size(); ++q) {
+    if (queueProps[q].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      bool supported = false;
+      if ((r = vk.getPhysicalDeviceSurfaceSupportKHR(
+             device, q, surface, supported))) {
+        return r;
+      }
+
+      if (supported) {
+        queueIndex = q;
+        return VK_SUCCESS;
+      }
+    }
+  }
+
+  return VK_ERROR_FEATURE_NOT_PRESENT;
 }
 
 /// Select a physical graphics device to use (simply the first found)
@@ -381,31 +378,31 @@ selectPhysicalDevice(const sk::VulkanApi&     vk,
                      const sk::SurfaceKHR&    surface,
                      PhysicalDeviceSelection& selection)
 {
-	VkResult r = VK_SUCCESS;
-
-	std::vector<sk::PhysicalDevice> devices;
-	if ((r = vk.enumeratePhysicalDevices(instance, devices))) {
-		return r;
-	}
-
-	for (const auto& device : devices) {
-		auto supported = false;
-		if ((r = deviceSupportsRequiredExtensions(vk, device, supported))) {
-			return r;
-		}
-
-		if (supported) {
-			auto queueIndex = 0u;
-			if ((r = findGraphicsQueue(vk, surface, device, queueIndex))) {
-				return r;
-			}
-
-			selection = PhysicalDeviceSelection{device, queueIndex};
-			return VK_SUCCESS;
-		}
-	}
-
-	return VK_ERROR_INCOMPATIBLE_DISPLAY_KHR;
+  VkResult r = VK_SUCCESS;
+
+  std::vector<sk::PhysicalDevice> devices;
+  if ((r = vk.enumeratePhysicalDevices(instance, devices))) {
+    return r;
+  }
+
+  for (const auto& device : devices) {
+    auto supported = false;
+    if ((r = deviceSupportsRequiredExtensions(vk, device, supported))) {
+      return r;
+    }
+
+    if (supported) {
+      auto queueIndex = 0u;
+      if ((r = findGraphicsQueue(vk, surface, device, queueIndex))) {
+        return r;
+      }
+
+      selection = PhysicalDeviceSelection{device, queueIndex};
+      return VK_SUCCESS;
+    }
+  }
+
+  return VK_ERROR_INCOMPATIBLE_DISPLAY_KHR;
 }
 
 VkResult
@@ -414,55 +411,55 @@ GraphicsDevice::init(const pugl::VulkanLoader& loader,
                      pugl::View&               view,
                      const PuglTestOptions&    opts)
 {
-	const auto& vk = context.vk;
-	VkResult    r  = VK_SUCCESS;
-
-	// Create a Vulkan surface for the window using the Pugl API
-	VkSurfaceKHR surfaceHandle = {};
-	if ((r = pugl::createSurface(loader.getInstanceProcAddrFunc(),
-	                             view,
-	                             context.instance,
-	                             nullptr,
-	                             &surfaceHandle))) {
-		return r;
-	}
-
-	// Wrap surface in a safe RAII handle
-	surface = sk::SurfaceKHR{surfaceHandle,
-	                         {context.instance, vk.vkDestroySurfaceKHR}};
-
-	PhysicalDeviceSelection physicalDeviceSelection = {};
-	// Select a physical device to use
-	if ((r = selectPhysicalDevice(
-	         vk, context.instance, surface, physicalDeviceSelection))) {
-		return r;
-	}
-
-	physicalDevice = physicalDeviceSelection.physicalDevice;
-	graphicsIndex  = physicalDeviceSelection.graphicsFamilyIndex;
-
-	if ((r = selectSurfaceFormat(vk, physicalDevice, surface, surfaceFormat)) ||
-	    (r = selectPresentMode(vk,
-	                           physicalDevice,
-	                           surface,
-	                           opts.doubleBuffer,
-	                           opts.sync,
-	                           presentMode)) ||
-	    (r = selectPresentMode(
-	         vk, physicalDevice, surface, true, false, resizePresentMode)) ||
-	    (r = openDevice(vk, physicalDevice, graphicsIndex, device))) {
-		return r;
-	}
-
-	const VkCommandPoolCreateInfo commandPoolInfo{
-	    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, nullptr, {}, graphicsIndex};
-
-	if ((r = vk.createCommandPool(device, commandPoolInfo, commandPool))) {
-		return r;
-	}
-
-	graphicsQueue = vk.getDeviceQueue(device, graphicsIndex, 0);
-	return VK_SUCCESS;
+  const auto& vk = context.vk;
+  VkResult    r  = VK_SUCCESS;
+
+  // Create a Vulkan surface for the window using the Pugl API
+  VkSurfaceKHR surfaceHandle = {};
+  if ((r = pugl::createSurface(loader.getInstanceProcAddrFunc(),
+                               view,
+                               context.instance,
+                               nullptr,
+                               &surfaceHandle))) {
+    return r;
+  }
+
+  // Wrap surface in a safe RAII handle
+  surface =
+    sk::SurfaceKHR{surfaceHandle, {context.instance, vk.vkDestroySurfaceKHR}};
+
+  PhysicalDeviceSelection physicalDeviceSelection = {};
+  // Select a physical device to use
+  if ((r = selectPhysicalDevice(
+         vk, context.instance, surface, physicalDeviceSelection))) {
+    return r;
+  }
+
+  physicalDevice = physicalDeviceSelection.physicalDevice;
+  graphicsIndex  = physicalDeviceSelection.graphicsFamilyIndex;
+
+  if ((r = selectSurfaceFormat(vk, physicalDevice, surface, surfaceFormat)) ||
+      (r = selectPresentMode(vk,
+                             physicalDevice,
+                             surface,
+                             opts.doubleBuffer,
+                             opts.sync,
+                             presentMode)) ||
+      (r = selectPresentMode(
+         vk, physicalDevice, surface, true, false, resizePresentMode)) ||
+      (r = openDevice(vk, physicalDevice, graphicsIndex, device))) {
+    return r;
+  }
+
+  const VkCommandPoolCreateInfo commandPoolInfo{
+    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, nullptr, {}, graphicsIndex};
+
+  if ((r = vk.createCommandPool(device, commandPoolInfo, commandPool))) {
+    return r;
+  }
+
+  graphicsQueue = vk.getDeviceQueue(device, graphicsIndex, 0);
+  return VK_SUCCESS;
 }
 
 uint32_t
@@ -471,18 +468,17 @@ findMemoryType(const sk::VulkanApi&         vk,
                const uint32_t               typeFilter,
                const VkMemoryPropertyFlags& properties)
 {
-	VkPhysicalDeviceMemoryProperties memProperties =
-	    vk.getPhysicalDeviceMemoryProperties(physicalDevice);
-
-	for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
-		if ((typeFilter & (1 << i)) &&
-		    (memProperties.memoryTypes[i].propertyFlags & properties) ==
-		        properties) {
-			return i;
-		}
-	}
-
-	return UINT32_MAX;
+  VkPhysicalDeviceMemoryProperties memProperties =
+    vk.getPhysicalDeviceMemoryProperties(physicalDevice);
+
+  for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) {
+    if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags &
+                                    properties) == properties) {
+      return i;
+    }
+  }
+
+  return UINT32_MAX;
 }
 
 VkResult
@@ -492,42 +488,40 @@ Buffer::init(const sk::VulkanApi&        vk,
              const VkBufferUsageFlags    usage,
              const VkMemoryPropertyFlags properties)
 {
-	const VkBufferCreateInfo bufferInfo{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-	                                    nullptr,
-	                                    {},
-	                                    size,
-	                                    usage,
-	                                    VK_SHARING_MODE_EXCLUSIVE,
-	                                    SK_COUNTED(0, nullptr)};
-
-	const auto& device = gpu.device;
-
-	VkResult r = VK_SUCCESS;
-	if ((r = vk.createBuffer(device, bufferInfo, buffer))) {
-		return r;
-	}
-
-	const auto requirements    = vk.getBufferMemoryRequirements(device, buffer);
-	const auto memoryTypeIndex = findMemoryType(vk,
-	                                            gpu.physicalDevice,
-	                                            requirements.memoryTypeBits,
-	                                            properties);
-
-	if (memoryTypeIndex == UINT32_MAX) {
-		return VK_ERROR_FEATURE_NOT_PRESENT;
-	}
-
-	const VkMemoryAllocateInfo allocInfo{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-	                                     nullptr,
-	                                     requirements.size,
-	                                     memoryTypeIndex};
-
-	if ((r = vk.allocateMemory(device, allocInfo, deviceMemory)) ||
-	    (r = vk.bindBufferMemory(device, buffer, deviceMemory, 0))) {
-		return r;
-	}
-
-	return VK_SUCCESS;
+  const VkBufferCreateInfo bufferInfo{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                                      nullptr,
+                                      {},
+                                      size,
+                                      usage,
+                                      VK_SHARING_MODE_EXCLUSIVE,
+                                      SK_COUNTED(0, nullptr)};
+
+  const auto& device = gpu.device;
+
+  VkResult r = VK_SUCCESS;
+  if ((r = vk.createBuffer(device, bufferInfo, buffer))) {
+    return r;
+  }
+
+  const auto requirements    = vk.getBufferMemoryRequirements(device, buffer);
+  const auto memoryTypeIndex = findMemoryType(
+    vk, gpu.physicalDevice, requirements.memoryTypeBits, properties);
+
+  if (memoryTypeIndex == UINT32_MAX) {
+    return VK_ERROR_FEATURE_NOT_PRESENT;
+  }
+
+  const VkMemoryAllocateInfo allocInfo{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                                       nullptr,
+                                       requirements.size,
+                                       memoryTypeIndex};
+
+  if ((r = vk.allocateMemory(device, allocInfo, deviceMemory)) ||
+      (r = vk.bindBufferMemory(device, buffer, deviceMemory, 0))) {
+    return r;
+  }
+
+  return VK_SUCCESS;
 }
 
 VkResult
@@ -538,62 +532,59 @@ Swapchain::init(const sk::VulkanApi&           vk,
                 VkSwapchainKHR                 oldSwapchain,
                 bool                           resizing)
 {
-	capabilities = surfaceCapabilities;
-	extent       = surfaceExtent;
-
-	const auto minNumImages = (!capabilities.maxImageCount ||
-	                           capabilities.maxImageCount >= 3u)
-	                              ? 3u
-	                              : capabilities.maxImageCount;
-
-	const VkSwapchainCreateInfoKHR swapchainCreateInfo{
-	    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
-	    nullptr,
-	    {},
-	    gpu.surface,
-	    minNumImages,
-	    gpu.surfaceFormat.format,
-	    gpu.surfaceFormat.colorSpace,
-	    surfaceExtent,
-	    1,
-	    (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
-	    VK_SHARING_MODE_EXCLUSIVE,
-	    SK_COUNTED(0, nullptr),
-	    capabilities.currentTransform,
-	    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
-	    resizing ? gpu.resizePresentMode : gpu.presentMode,
-	    VK_TRUE,
-	    oldSwapchain};
-
-	VkResult             r = VK_SUCCESS;
-	std::vector<VkImage> images;
-	if ((r = vk.createSwapchainKHR(gpu.device,
-	                               swapchainCreateInfo,
-	                               swapchain)) ||
-	    (r = vk.getSwapchainImagesKHR(gpu.device, swapchain, images))) {
-		return r;
-	}
-
-	imageViews = std::vector<sk::ImageView>(images.size());
-	for (size_t i = 0; i < images.size(); ++i) {
-		const VkImageViewCreateInfo imageViewCreateInfo{
-		    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-		    nullptr,
-		    {},
-		    images[i],
-		    VK_IMAGE_VIEW_TYPE_2D,
-		    gpu.surfaceFormat.format,
-		    {},
-		    {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
-
-		if ((r = vk.createImageView(gpu.device,
-		                            imageViewCreateInfo,
-		                            imageViews[i]))) {
-			return r;
-		}
-	}
-
-	return VK_SUCCESS;
+  capabilities = surfaceCapabilities;
+  extent       = surfaceExtent;
+
+  const auto minNumImages =
+    (!capabilities.maxImageCount || capabilities.maxImageCount >= 3u)
+      ? 3u
+      : capabilities.maxImageCount;
+
+  const VkSwapchainCreateInfoKHR swapchainCreateInfo{
+    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+    nullptr,
+    {},
+    gpu.surface,
+    minNumImages,
+    gpu.surfaceFormat.format,
+    gpu.surfaceFormat.colorSpace,
+    surfaceExtent,
+    1,
+    (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
+    VK_SHARING_MODE_EXCLUSIVE,
+    SK_COUNTED(0, nullptr),
+    capabilities.currentTransform,
+    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
+    resizing ? gpu.resizePresentMode : gpu.presentMode,
+    VK_TRUE,
+    oldSwapchain};
+
+  VkResult             r = VK_SUCCESS;
+  std::vector<VkImage> images;
+  if ((r = vk.createSwapchainKHR(gpu.device, swapchainCreateInfo, swapchain)) ||
+      (r = vk.getSwapchainImagesKHR(gpu.device, swapchain, images))) {
+    return r;
+  }
+
+  imageViews = std::vector<sk::ImageView>(images.size());
+  for (size_t i = 0; i < images.size(); ++i) {
+    const VkImageViewCreateInfo imageViewCreateInfo{
+      VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+      nullptr,
+      {},
+      images[i],
+      VK_IMAGE_VIEW_TYPE_2D,
+      gpu.surfaceFormat.format,
+      {},
+      {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
+
+    if ((r = vk.createImageView(
+           gpu.device, imageViewCreateInfo, imageViews[i]))) {
+      return r;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 VkResult
@@ -601,121 +592,116 @@ RenderPass::init(const sk::VulkanApi&  vk,
                  const GraphicsDevice& gpu,
                  const Swapchain&      swapchain)
 {
-	const auto numImages = static_cast<uint32_t>(swapchain.imageViews.size());
-
-	assert(numImages > 0);
-
-	// Create command buffers
-	const VkCommandBufferAllocateInfo commandBufferAllocateInfo{
-	    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
-	    nullptr,
-	    gpu.commandPool,
-	    VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-	    numImages};
-
-	VkResult r = VK_SUCCESS;
-	if ((r = vk.allocateCommandBuffers(gpu.device,
-	                                   commandBufferAllocateInfo,
-	                                   commandBuffers))) {
-		return r;
-	}
-
-	static constexpr VkAttachmentReference colorAttachmentRef{
-	    0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
-
-	static constexpr VkSubpassDescription subpass{
-	    {},
-	    VK_PIPELINE_BIND_POINT_GRAPHICS,
-	    SK_COUNTED(0, nullptr),
-	    SK_COUNTED(1, &colorAttachmentRef, nullptr, nullptr),
-	    SK_COUNTED(0u, nullptr)};
-
-	static constexpr VkSubpassDependency dependency{
-	    VK_SUBPASS_EXTERNAL,
-	    0,
-	    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-	    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-	    (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
-	     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),
-	    {},
-	    {}};
-
-	const VkAttachmentDescription colorAttachment{
-	    {},
-	    gpu.surfaceFormat.format,
-	    VK_SAMPLE_COUNT_1_BIT,
-	    VK_ATTACHMENT_LOAD_OP_CLEAR,
-	    VK_ATTACHMENT_STORE_OP_STORE,
-	    VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-	    VK_ATTACHMENT_STORE_OP_DONT_CARE,
-	    VK_IMAGE_LAYOUT_UNDEFINED,
-	    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-	};
-
-	const VkRenderPassCreateInfo renderPassCreateInfo{
-	    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-	    nullptr,
-	    {},
-	    SK_COUNTED(1, &colorAttachment),
-	    SK_COUNTED(1, &subpass),
-	    SK_COUNTED(1, &dependency)};
-
-	if ((r = vk.createRenderPass(gpu.device,
-	                             renderPassCreateInfo,
-	                             renderPass))) {
-		return r;
-	}
-
-	// Create framebuffers
-	framebuffers = std::vector<sk::Framebuffer>(numImages);
-	for (uint32_t i = 0; i < numImages; ++i) {
-		const VkFramebufferCreateInfo framebufferCreateInfo{
-		    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
-		    nullptr,
-		    {},
-		    renderPass,
-		    SK_COUNTED(1, &swapchain.imageViews[i].get()),
-		    swapchain.extent.width,
-		    swapchain.extent.height,
-		    1};
-
-		if ((r = vk.createFramebuffer(gpu.device,
-		                              framebufferCreateInfo,
-		                              framebuffers[i]))) {
-			return r;
-		}
-	}
-
-	return VK_SUCCESS;
+  const auto numImages = static_cast<uint32_t>(swapchain.imageViews.size());
+
+  assert(numImages > 0);
+
+  // Create command buffers
+  const VkCommandBufferAllocateInfo commandBufferAllocateInfo{
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+    nullptr,
+    gpu.commandPool,
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    numImages};
+
+  VkResult r = VK_SUCCESS;
+  if ((r = vk.allocateCommandBuffers(
+         gpu.device, commandBufferAllocateInfo, commandBuffers))) {
+    return r;
+  }
+
+  static constexpr VkAttachmentReference colorAttachmentRef{
+    0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
+
+  static constexpr VkSubpassDescription subpass{
+    {},
+    VK_PIPELINE_BIND_POINT_GRAPHICS,
+    SK_COUNTED(0, nullptr),
+    SK_COUNTED(1, &colorAttachmentRef, nullptr, nullptr),
+    SK_COUNTED(0u, nullptr)};
+
+  static constexpr VkSubpassDependency dependency{
+    VK_SUBPASS_EXTERNAL,
+    0,
+    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+    (VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
+     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT),
+    {},
+    {}};
+
+  const VkAttachmentDescription colorAttachment{
+    {},
+    gpu.surfaceFormat.format,
+    VK_SAMPLE_COUNT_1_BIT,
+    VK_ATTACHMENT_LOAD_OP_CLEAR,
+    VK_ATTACHMENT_STORE_OP_STORE,
+    VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+    VK_ATTACHMENT_STORE_OP_DONT_CARE,
+    VK_IMAGE_LAYOUT_UNDEFINED,
+    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+  };
+
+  const VkRenderPassCreateInfo renderPassCreateInfo{
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
+    nullptr,
+    {},
+    SK_COUNTED(1, &colorAttachment),
+    SK_COUNTED(1, &subpass),
+    SK_COUNTED(1, &dependency)};
+
+  if ((r = vk.createRenderPass(gpu.device, renderPassCreateInfo, renderPass))) {
+    return r;
+  }
+
+  // Create framebuffers
+  framebuffers = std::vector<sk::Framebuffer>(numImages);
+  for (uint32_t i = 0; i < numImages; ++i) {
+    const VkFramebufferCreateInfo framebufferCreateInfo{
+      VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+      nullptr,
+      {},
+      renderPass,
+      SK_COUNTED(1, &swapchain.imageViews[i].get()),
+      swapchain.extent.width,
+      swapchain.extent.height,
+      1};
+
+    if ((r = vk.createFramebuffer(
+           gpu.device, framebufferCreateInfo, framebuffers[i]))) {
+      return r;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 std::vector<uint32_t>
 readFile(const char* const programPath, const std::string& filename)
 {
-	std::unique_ptr<char, decltype(&free)> path{resourcePath(programPath,
-	                                                         filename.c_str()),
-	                                            &free};
+  std::unique_ptr<char, decltype(&free)> path{
+    resourcePath(programPath, filename.c_str()), &free};
 
-	std::cerr << "Loading shader:           " << path.get() << std::endl;
+  std::cerr << "Loading shader:           " << path.get() << std::endl;
 
-	std::unique_ptr<FILE, decltype(&fclose)> file{fopen(path.get(), "rb"),
-	                                              &fclose};
+  std::unique_ptr<FILE, decltype(&fclose)> file{fopen(path.get(), "rb"),
+                                                &fclose};
 
-	if (!file) {
-		std::cerr << "Failed to open file '" << filename << "'\n";
-		return {};
-	}
+  if (!file) {
+    std::cerr << "Failed to open file '" << filename << "'\n";
+    return {};
+  }
 
-	fseek(file.get(), 0, SEEK_END);
-	const auto fileSize = static_cast<size_t>(ftell(file.get()));
-	fseek(file.get(), 0, SEEK_SET);
+  fseek(file.get(), 0, SEEK_END);
+  const auto fileSize = static_cast<size_t>(ftell(file.get()));
+  fseek(file.get(), 0, SEEK_SET);
 
-	const auto            numWords = fileSize / sizeof(uint32_t);
-	std::vector<uint32_t> buffer(numWords);
+  const auto            numWords = fileSize / sizeof(uint32_t);
+  std::vector<uint32_t> buffer(numWords);
 
-	fread(buffer.data(), sizeof(uint32_t), numWords, file.get());
+  fread(buffer.data(), sizeof(uint32_t), numWords, file.get());
 
-	return buffer;
+  return buffer;
 }
 
 VkResult
@@ -724,14 +710,14 @@ createShaderModule(const sk::VulkanApi&         vk,
                    const std::vector<uint32_t>& code,
                    sk::ShaderModule&            shaderModule)
 {
-	const VkShaderModuleCreateInfo createInfo{
-	    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    code.size() * sizeof(uint32_t),
-	    code.data()};
-
-	return vk.createShaderModule(gpu.device, createInfo, shaderModule);
+  const VkShaderModuleCreateInfo createInfo{
+    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
+    nullptr,
+    {},
+    code.size() * sizeof(uint32_t),
+    code.data()};
+
+  return vk.createShaderModule(gpu.device, createInfo, shaderModule);
 }
 
 VkResult
@@ -739,23 +725,21 @@ RectShaders::init(const sk::VulkanApi&  vk,
                   const GraphicsDevice& gpu,
                   const std::string&    programPath)
 {
-	auto vertShaderCode = readFile(programPath.c_str(),
-	                               "shaders/rect.vert.spv");
+  auto vertShaderCode = readFile(programPath.c_str(), "shaders/rect.vert.spv");
 
-	auto fragShaderCode = readFile(programPath.c_str(),
-	                               "shaders/rect.frag.spv");
+  auto fragShaderCode = readFile(programPath.c_str(), "shaders/rect.frag.spv");
 
-	if (vertShaderCode.empty() || fragShaderCode.empty()) {
-		return VK_ERROR_INITIALIZATION_FAILED;
-	}
+  if (vertShaderCode.empty() || fragShaderCode.empty()) {
+    return VK_ERROR_INITIALIZATION_FAILED;
+  }
 
-	VkResult r = VK_SUCCESS;
-	if ((r = createShaderModule(vk, gpu, vertShaderCode, vert)) ||
-	    (r = createShaderModule(vk, gpu, fragShaderCode, frag))) {
-		return r;
-	}
+  VkResult r = VK_SUCCESS;
+  if ((r = createShaderModule(vk, gpu, vertShaderCode, vert)) ||
+      (r = createShaderModule(vk, gpu, fragShaderCode, frag))) {
+    return r;
+  }
 
-	return VK_SUCCESS;
+  return VK_SUCCESS;
 }
 
 VkResult
@@ -766,222 +750,214 @@ RectPipeline::init(const sk::VulkanApi&  vk,
                    const Swapchain&      swapchain,
                    const RenderPass&     renderPass)
 {
-	const auto oldNumImages = numImages;
-	VkResult   r            = VK_SUCCESS;
-
-	numImages      = static_cast<uint32_t>(swapchain.imageViews.size());
-	pipelines      = {};
-	pipelineLayout = {};
-	descriptorSets = {};
-
-	if (numImages != oldNumImages) {
-		// Create layout descriptor pool
-
-		const VkDescriptorPoolSize poolSize{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-		                                    numImages};
-
-		const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo{
-		    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-		    nullptr,
-		    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
-		    numImages,
-		    1u,
-		    &poolSize};
-		if ((r = vk.createDescriptorPool(gpu.device,
-		                                 descriptorPoolCreateInfo,
-		                                 descriptorPool))) {
-			return r;
-		}
-	}
-
-	const std::vector<VkDescriptorSetLayout> layouts(
-	    numImages, rectData.descriptorSetLayout.get());
-
-	const VkDescriptorSetAllocateInfo descriptorSetAllocateInfo{
-	    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
-	    nullptr,
-	    descriptorPool,
-	    numImages,
-	    layouts.data()};
-	if ((r = vk.allocateDescriptorSets(gpu.device,
-	                                   descriptorSetAllocateInfo,
-	                                   descriptorSets))) {
-		return r;
-	}
-
-	const VkDescriptorBufferInfo bufferInfo{rectData.uniformBuffer.buffer,
-	                                        0,
-	                                        sizeof(UniformBufferObject)};
-
-	const std::array<VkWriteDescriptorSet, 1> descriptorWrites{
-	    {{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-	      nullptr,
-	      descriptorSets[0],
-	      0,
-	      0,
-	      1,
-	      VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-	      nullptr,
-	      &bufferInfo,
-	      nullptr}}};
-
-	const std::array<VkCopyDescriptorSet, 0> descriptorCopies{};
-
-	vk.updateDescriptorSets(gpu.device, descriptorWrites, descriptorCopies);
-
-	static constexpr std::array<VkVertexInputAttributeDescription, 4>
-	    vertexAttributeDescriptions{
-	        {// Model
-	         {0u, 0u, VK_FORMAT_R32G32_SFLOAT, 0},
-
-	         // Rect instance attributes
-	         {1u, 1u, VK_FORMAT_R32G32_SFLOAT, offsetof(Rect, pos)},
-	         {2u, 1u, VK_FORMAT_R32G32_SFLOAT, offsetof(Rect, size)},
-	         {3u,
-	          1u,
-	          VK_FORMAT_R32G32B32A32_SFLOAT,
-	          offsetof(Rect, fillColor)}}};
-
-	static constexpr std::array<VkVertexInputBindingDescription, 2>
-	    vertexBindingDescriptions{
-	        VkVertexInputBindingDescription{0,
-	                                        sizeof(vec2),
-	                                        VK_VERTEX_INPUT_RATE_VERTEX},
-	        VkVertexInputBindingDescription{1u,
-	                                        sizeof(Rect),
-	                                        VK_VERTEX_INPUT_RATE_INSTANCE}};
-
-	static constexpr VkPipelineInputAssemblyStateCreateInfo inputAssembly{
-	    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
-	    false};
-
-	static constexpr VkPipelineRasterizationStateCreateInfo rasterizer{
-	    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    0,
-	    0,
-	    VK_POLYGON_MODE_FILL,
-	    VK_CULL_MODE_BACK_BIT,
-	    VK_FRONT_FACE_CLOCKWISE,
-	    0,
-	    0,
-	    0,
-	    0,
-	    1.0f};
-
-	static constexpr VkPipelineMultisampleStateCreateInfo multisampling{
-	    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    VK_SAMPLE_COUNT_1_BIT,
-	    false,
-	    0.0f,
-	    nullptr,
-	    false,
-	    false};
-
-	static constexpr VkPipelineColorBlendAttachmentState colorBlendAttachment{
-	    true,
-	    VK_BLEND_FACTOR_SRC_ALPHA,
-	    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-	    VK_BLEND_OP_ADD,
-	    VK_BLEND_FACTOR_ONE,
-	    VK_BLEND_FACTOR_ZERO,
-	    VK_BLEND_OP_ADD,
-	    (VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
-	     VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT)};
-
-	const VkPipelineShaderStageCreateInfo shaderStages[] = {
-	    {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-	     nullptr,
-	     {},
-	     VK_SHADER_STAGE_VERTEX_BIT,
-	     shaders.vert.get(),
-	     "main",
-	     nullptr},
-	    {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-	     nullptr,
-	     {},
-	     VK_SHADER_STAGE_FRAGMENT_BIT,
-	     shaders.frag.get(),
-	     "main",
-	     nullptr}};
-
-	const VkPipelineVertexInputStateCreateInfo vertexInputInfo{
-	    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    SK_COUNTED(static_cast<uint32_t>(vertexBindingDescriptions.size()),
-	               vertexBindingDescriptions.data()),
-	    SK_COUNTED(static_cast<uint32_t>(vertexAttributeDescriptions.size()),
-	               vertexAttributeDescriptions.data())};
-
-	const VkViewport viewport{0.0f,
-	                          0.0f,
-	                          float(swapchain.extent.width),
-	                          float(swapchain.extent.height),
-	                          0.0f,
-	                          1.0f};
-
-	const VkRect2D scissor{{0, 0}, swapchain.extent};
-
-	const VkPipelineViewportStateCreateInfo viewportState{
-	    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    SK_COUNTED(1, &viewport),
-	    SK_COUNTED(1, &scissor)};
-
-	const VkPipelineColorBlendStateCreateInfo colorBlending{
-	    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
-	    nullptr,
-	    {},
-	    false,
-	    VK_LOGIC_OP_COPY,
-	    SK_COUNTED(1, &colorBlendAttachment),
-	    {1.0f, 0.0f, 0.0f, 0.0f}};
-
-	const VkPipelineLayoutCreateInfo layoutInfo{
-	    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-	    nullptr,
-	    {},
-	    SK_COUNTED(1, &rectData.descriptorSetLayout.get()),
-	    SK_COUNTED(0, nullptr)};
-
-	if ((r = vk.createPipelineLayout(gpu.device, layoutInfo, pipelineLayout))) {
-		return r;
-	}
-
-	const std::array<VkGraphicsPipelineCreateInfo, 1> pipelineInfos{
-	    {{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-	      nullptr,
-	      {},
-	      SK_COUNTED(2, shaderStages),
-	      &vertexInputInfo,
-	      &inputAssembly,
-	      nullptr,
-	      &viewportState,
-	      &rasterizer,
-	      &multisampling,
-	      nullptr,
-	      &colorBlending,
-	      nullptr,
-	      pipelineLayout,
-	      renderPass.renderPass,
-	      0u,
-	      {},
-	      0}}};
-
-	if ((r = vk.createGraphicsPipelines(
-	         gpu.device, {}, pipelineInfos, pipelines))) {
-		return r;
-	}
-
-	return VK_SUCCESS;
+  const auto oldNumImages = numImages;
+  VkResult   r            = VK_SUCCESS;
+
+  numImages      = static_cast<uint32_t>(swapchain.imageViews.size());
+  pipelines      = {};
+  pipelineLayout = {};
+  descriptorSets = {};
+
+  if (numImages != oldNumImages) {
+    // Create layout descriptor pool
+
+    const VkDescriptorPoolSize poolSize{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+                                        numImages};
+
+    const VkDescriptorPoolCreateInfo descriptorPoolCreateInfo{
+      VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+      nullptr,
+      VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT,
+      numImages,
+      1u,
+      &poolSize};
+    if ((r = vk.createDescriptorPool(
+           gpu.device, descriptorPoolCreateInfo, descriptorPool))) {
+      return r;
+    }
+  }
+
+  const std::vector<VkDescriptorSetLayout> layouts(
+    numImages, rectData.descriptorSetLayout.get());
+
+  const VkDescriptorSetAllocateInfo descriptorSetAllocateInfo{
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+    nullptr,
+    descriptorPool,
+    numImages,
+    layouts.data()};
+  if ((r = vk.allocateDescriptorSets(
+         gpu.device, descriptorSetAllocateInfo, descriptorSets))) {
+    return r;
+  }
+
+  const VkDescriptorBufferInfo bufferInfo{
+    rectData.uniformBuffer.buffer, 0, sizeof(UniformBufferObject)};
+
+  const std::array<VkWriteDescriptorSet, 1> descriptorWrites{
+    {{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+      nullptr,
+      descriptorSets[0],
+      0,
+      0,
+      1,
+      VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+      nullptr,
+      &bufferInfo,
+      nullptr}}};
+
+  const std::array<VkCopyDescriptorSet, 0> descriptorCopies{};
+
+  vk.updateDescriptorSets(gpu.device, descriptorWrites, descriptorCopies);
+
+  static constexpr std::array<VkVertexInputAttributeDescription, 4>
+    vertexAttributeDescriptions{
+      {// Model
+       {0u, 0u, VK_FORMAT_R32G32_SFLOAT, 0},
+
+       // Rect instance attributes
+       {1u, 1u, VK_FORMAT_R32G32_SFLOAT, offsetof(Rect, pos)},
+       {2u, 1u, VK_FORMAT_R32G32_SFLOAT, offsetof(Rect, size)},
+       {3u, 1u, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(Rect, fillColor)}}};
+
+  static constexpr std::array<VkVertexInputBindingDescription, 2>
+    vertexBindingDescriptions{
+      VkVertexInputBindingDescription{
+        0, sizeof(vec2), VK_VERTEX_INPUT_RATE_VERTEX},
+      VkVertexInputBindingDescription{
+        1u, sizeof(Rect), VK_VERTEX_INPUT_RATE_INSTANCE}};
+
+  static constexpr VkPipelineInputAssemblyStateCreateInfo inputAssembly{
+    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+    nullptr,
+    {},
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
+    false};
+
+  static constexpr VkPipelineRasterizationStateCreateInfo rasterizer{
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+    nullptr,
+    {},
+    0,
+    0,
+    VK_POLYGON_MODE_FILL,
+    VK_CULL_MODE_BACK_BIT,
+    VK_FRONT_FACE_CLOCKWISE,
+    0,
+    0,
+    0,
+    0,
+    1.0f};
+
+  static constexpr VkPipelineMultisampleStateCreateInfo multisampling{
+    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
+    nullptr,
+    {},
+    VK_SAMPLE_COUNT_1_BIT,
+    false,
+    0.0f,
+    nullptr,
+    false,
+    false};
+
+  static constexpr VkPipelineColorBlendAttachmentState colorBlendAttachment{
+    true,
+    VK_BLEND_FACTOR_SRC_ALPHA,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
+    VK_BLEND_OP_ADD,
+    VK_BLEND_FACTOR_ONE,
+    VK_BLEND_FACTOR_ZERO,
+    VK_BLEND_OP_ADD,
+    (VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+     VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT)};
+
+  const VkPipelineShaderStageCreateInfo shaderStages[] = {
+    {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+     nullptr,
+     {},
+     VK_SHADER_STAGE_VERTEX_BIT,
+     shaders.vert.get(),
+     "main",
+     nullptr},
+    {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
+     nullptr,
+     {},
+     VK_SHADER_STAGE_FRAGMENT_BIT,
+     shaders.frag.get(),
+     "main",
+     nullptr}};
+
+  const VkPipelineVertexInputStateCreateInfo vertexInputInfo{
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+    nullptr,
+    {},
+    SK_COUNTED(static_cast<uint32_t>(vertexBindingDescriptions.size()),
+               vertexBindingDescriptions.data()),
+    SK_COUNTED(static_cast<uint32_t>(vertexAttributeDescriptions.size()),
+               vertexAttributeDescriptions.data())};
+
+  const VkViewport viewport{0.0f,
+                            0.0f,
+                            float(swapchain.extent.width),
+                            float(swapchain.extent.height),
+                            0.0f,
+                            1.0f};
+
+  const VkRect2D scissor{{0, 0}, swapchain.extent};
+
+  const VkPipelineViewportStateCreateInfo viewportState{
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+    nullptr,
+    {},
+    SK_COUNTED(1, &viewport),
+    SK_COUNTED(1, &scissor)};
+
+  const VkPipelineColorBlendStateCreateInfo colorBlending{
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
+    nullptr,
+    {},
+    false,
+    VK_LOGIC_OP_COPY,
+    SK_COUNTED(1, &colorBlendAttachment),
+    {1.0f, 0.0f, 0.0f, 0.0f}};
+
+  const VkPipelineLayoutCreateInfo layoutInfo{
+    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
+    nullptr,
+    {},
+    SK_COUNTED(1, &rectData.descriptorSetLayout.get()),
+    SK_COUNTED(0, nullptr)};
+
+  if ((r = vk.createPipelineLayout(gpu.device, layoutInfo, pipelineLayout))) {
+    return r;
+  }
+
+  const std::array<VkGraphicsPipelineCreateInfo, 1> pipelineInfos{
+    {{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
+      nullptr,
+      {},
+      SK_COUNTED(2, shaderStages),
+      &vertexInputInfo,
+      &inputAssembly,
+      nullptr,
+      &viewportState,
+      &rasterizer,
+      &multisampling,
+      nullptr,
+      &colorBlending,
+      nullptr,
+      pipelineLayout,
+      renderPass.renderPass,
+      0u,
+      {},
+      0}}};
+
+  if ((r = vk.createGraphicsPipelines(
+         gpu.device, {}, pipelineInfos, pipelines))) {
+    return r;
+  }
+
+  return VK_SUCCESS;
 }
 
 VkResult
@@ -989,86 +965,85 @@ RectData::init(const sk::VulkanApi&  vk,
                const GraphicsDevice& gpu,
                const size_t          nRects)
 {
-	numRects = nRects;
-
-	static constexpr VkDescriptorSetLayoutBinding uboLayoutBinding{
-	    0,
-	    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-	    1,
-	    VK_SHADER_STAGE_VERTEX_BIT,
-	    nullptr};
-
-	const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo{
-	    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-	    nullptr,
-	    {},
-	    1,
-	    &uboLayoutBinding};
-
-	VkResult r = VK_SUCCESS;
-	if ((r = vk.createDescriptorSetLayout(gpu.device,
-	                                      descriptorSetLayoutInfo,
-	                                      descriptorSetLayout)) ||
-	    (r = uniformBuffer.init(vk,
-	                            gpu,
-	                            sizeof(UniformBufferObject),
-	                            VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-	                            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-	                                VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ||
-	    (r = vk.mapMemory(gpu.device,
-	                      uniformBuffer.deviceMemory,
-	                      0,
-	                      sizeof(UniformBufferObject),
-	                      {},
-	                      uniformData))) {
-		return r;
-	}
-
-	const VkBufferUsageFlags usageFlags = (VK_BUFFER_USAGE_VERTEX_BUFFER_BIT |
-	                                       VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
-	                                       VK_BUFFER_USAGE_TRANSFER_DST_BIT);
-
-	const VkMemoryPropertyFlags propertyFlags =
-	    (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-	     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
-
-	if ((r = modelBuffer.init(
-	         vk, gpu, sizeof(rectVertices), usageFlags, propertyFlags))) {
-		return r;
-	}
-
-	{
-		// Copy model vertices (directly, we do this only once)
-		sk::MappedMemory modelData;
-		if ((r = vk.mapMemory(gpu.device,
-		                      modelBuffer.deviceMemory,
-		                      0,
-		                      static_cast<VkDeviceSize>(sizeof(rectVertices)),
-		                      {},
-		                      modelData))) {
-			return r;
-		}
-
-		memcpy(modelData.get(), rectVertices, sizeof(rectVertices));
-	}
-
-	if ((r = instanceBuffer.init(
-	         vk, gpu, sizeof(Rect) * numRects, usageFlags, propertyFlags))) {
-		return r;
-	}
-
-	// Map attribute vertices (we will update them every frame)
-	const auto rectsSize = static_cast<VkDeviceSize>(sizeof(Rect) * numRects);
-	if ((r = vk.mapMemory(gpu.device,
-	                      instanceBuffer.deviceMemory,
-	                      0,
-	                      rectsSize,
-	                      {},
-	                      vertexData))) {
-		return r;
-	}
-
-	return VK_SUCCESS;
+  numRects = nRects;
+
+  static constexpr VkDescriptorSetLayoutBinding uboLayoutBinding{
+    0,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+    1,
+    VK_SHADER_STAGE_VERTEX_BIT,
+    nullptr};
+
+  const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo{
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+    nullptr,
+    {},
+    1,
+    &uboLayoutBinding};
+
+  VkResult r = VK_SUCCESS;
+  if ((r = vk.createDescriptorSetLayout(
+         gpu.device, descriptorSetLayoutInfo, descriptorSetLayout)) ||
+      (r = uniformBuffer.init(vk,
+                              gpu,
+                              sizeof(UniformBufferObject),
+                              VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+                              VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)) ||
+      (r = vk.mapMemory(gpu.device,
+                        uniformBuffer.deviceMemory,
+                        0,
+                        sizeof(UniformBufferObject),
+                        {},
+                        uniformData))) {
+    return r;
+  }
+
+  const VkBufferUsageFlags usageFlags =
+    (VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT |
+     VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+
+  const VkMemoryPropertyFlags propertyFlags =
+    (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+     VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+
+  if ((r = modelBuffer.init(
+         vk, gpu, sizeof(rectVertices), usageFlags, propertyFlags))) {
+    return r;
+  }
+
+  {
+    // Copy model vertices (directly, we do this only once)
+    sk::MappedMemory modelData;
+    if ((r = vk.mapMemory(gpu.device,
+                          modelBuffer.deviceMemory,
+                          0,
+                          static_cast<VkDeviceSize>(sizeof(rectVertices)),
+                          {},
+                          modelData))) {
+      return r;
+    }
+
+    memcpy(modelData.get(), rectVertices, sizeof(rectVertices));
+  }
+
+  if ((r = instanceBuffer.init(
+         vk, gpu, sizeof(Rect) * numRects, usageFlags, propertyFlags))) {
+    return r;
+  }
+
+  // Map attribute vertices (we will update them every frame)
+  const auto rectsSize = static_cast<VkDeviceSize>(sizeof(Rect) * numRects);
+  if ((r = vk.mapMemory(gpu.device,
+                        instanceBuffer.deviceMemory,
+                        0,
+                        rectsSize,
+                        {},
+                        vertexData))) {
+    return r;
+  }
+
+  return VK_SUCCESS;
 }
 
 VkResult
@@ -1076,38 +1051,34 @@ RenderSync::init(const sk::VulkanApi& vk,
                  const sk::Device&    device,
                  const uint32_t       numImages)
 {
-	const auto maxInFlight = std::max(1u, numImages - 1u);
-	VkResult   r           = VK_SUCCESS;
-
-	imageAvailable = std::vector<sk::Semaphore>(numImages);
-	renderFinished = std::vector<sk::Semaphore>(numImages);
-	for (uint32_t i = 0; i < numImages; ++i) {
-		static constexpr VkSemaphoreCreateInfo semaphoreInfo{
-		    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, {}};
-
-		if ((r = vk.createSemaphore(device,
-		                            semaphoreInfo,
-		                            imageAvailable[i])) ||
-		    (r = vk.createSemaphore(device,
-		                            semaphoreInfo,
-		                            renderFinished[i]))) {
-			return r;
-		}
-	}
-
-	inFlight = std::vector<sk::Fence>(maxInFlight);
-	for (uint32_t i = 0; i < maxInFlight; ++i) {
-		static constexpr VkFenceCreateInfo fenceInfo{
-		    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-		    nullptr,
-		    VK_FENCE_CREATE_SIGNALED_BIT};
-
-		if ((r = vk.createFence(device, fenceInfo, inFlight[i]))) {
-			return r;
-		}
-	}
-
-	return VK_SUCCESS;
+  const auto maxInFlight = std::max(1u, numImages - 1u);
+  VkResult   r           = VK_SUCCESS;
+
+  imageAvailable = std::vector<sk::Semaphore>(numImages);
+  renderFinished = std::vector<sk::Semaphore>(numImages);
+  for (uint32_t i = 0; i < numImages; ++i) {
+    static constexpr VkSemaphoreCreateInfo semaphoreInfo{
+      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, {}};
+
+    if ((r = vk.createSemaphore(device, semaphoreInfo, imageAvailable[i])) ||
+        (r = vk.createSemaphore(device, semaphoreInfo, renderFinished[i]))) {
+      return r;
+    }
+  }
+
+  inFlight = std::vector<sk::Fence>(maxInFlight);
+  for (uint32_t i = 0; i < maxInFlight; ++i) {
+    static constexpr VkFenceCreateInfo fenceInfo{
+      VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+      nullptr,
+      VK_FENCE_CREATE_SIGNALED_BIT};
+
+    if ((r = vk.createFence(device, fenceInfo, inFlight[i]))) {
+      return r;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 VkResult
@@ -1118,21 +1089,20 @@ Renderer::init(const sk::VulkanApi&  vk,
                const VkExtent2D      extent,
                bool                  resizing)
 {
-	VkResult                 r            = VK_SUCCESS;
-	VkSurfaceCapabilitiesKHR capabilities = {};
-
-	if ((r = vk.getPhysicalDeviceSurfaceCapabilitiesKHR(gpu.physicalDevice,
-	                                                    gpu.surface,
-	                                                    capabilities)) ||
-	    (r = swapchain.init(vk, gpu, capabilities, extent, {}, resizing)) ||
-	    (r = renderPass.init(vk, gpu, swapchain)) ||
-	    (r = rectPipeline.init(
-	         vk, gpu, rectData, rectShaders, swapchain, renderPass))) {
-		return r;
-	}
-
-	const auto numFrames = static_cast<uint32_t>(swapchain.imageViews.size());
-	return sync.init(vk, gpu.device, numFrames);
+  VkResult                 r            = VK_SUCCESS;
+  VkSurfaceCapabilitiesKHR capabilities = {};
+
+  if ((r = vk.getPhysicalDeviceSurfaceCapabilitiesKHR(
+         gpu.physicalDevice, gpu.surface, capabilities)) ||
+      (r = swapchain.init(vk, gpu, capabilities, extent, {}, resizing)) ||
+      (r = renderPass.init(vk, gpu, swapchain)) ||
+      (r = rectPipeline.init(
+         vk, gpu, rectData, rectShaders, swapchain, renderPass))) {
+    return r;
+  }
+
+  const auto numFrames = static_cast<uint32_t>(swapchain.imageViews.size());
+  return sync.init(vk, gpu.device, numFrames);
 }
 
 VkResult
@@ -1144,27 +1114,26 @@ Renderer::recreate(const sk::VulkanApi&  vk,
                    const VkExtent2D      extent,
                    bool                  resizing)
 {
-	VkResult   r            = VK_SUCCESS;
-	const auto oldNumImages = swapchain.imageViews.size();
-
-	VkSurfaceCapabilitiesKHR capabilities = {};
-	if ((r = vk.getPhysicalDeviceSurfaceCapabilitiesKHR(gpu.physicalDevice,
-	                                                    surface,
-	                                                    capabilities)) ||
-	    (r = swapchain.init(
-	         vk, gpu, capabilities, extent, swapchain.swapchain, resizing)) ||
-	    (r = renderPass.init(vk, gpu, swapchain)) ||
-	    (r = rectPipeline.init(
-	         vk, gpu, rectData, rectShaders, swapchain, renderPass))) {
-		return r;
-	}
-
-	const auto numFrames = static_cast<uint32_t>(swapchain.imageViews.size());
-	if (swapchain.imageViews.size() != oldNumImages) {
-		return sync.init(vk, gpu.device, numFrames);
-	}
-
-	return VK_SUCCESS;
+  VkResult   r            = VK_SUCCESS;
+  const auto oldNumImages = swapchain.imageViews.size();
+
+  VkSurfaceCapabilitiesKHR capabilities = {};
+  if ((r = vk.getPhysicalDeviceSurfaceCapabilitiesKHR(
+         gpu.physicalDevice, surface, capabilities)) ||
+      (r = swapchain.init(
+         vk, gpu, capabilities, extent, swapchain.swapchain, resizing)) ||
+      (r = renderPass.init(vk, gpu, swapchain)) ||
+      (r = rectPipeline.init(
+         vk, gpu, rectData, rectShaders, swapchain, renderPass))) {
+    return r;
+  }
+
+  const auto numFrames = static_cast<uint32_t>(swapchain.imageViews.size());
+  if (swapchain.imageViews.size() != oldNumImages) {
+    return sync.init(vk, gpu.device, numFrames);
+  }
+
+  return VK_SUCCESS;
 }
 
 VKAPI_ATTR
@@ -1178,43 +1147,43 @@ debugCallback(VkDebugReportFlagsEXT flags,
               const char* msg,
               void*)
 {
-	std::cerr << sk::string(static_cast<VkDebugReportFlagBitsEXT>(flags))
-	          << ": " << layerPrefix << ": " << msg << std::endl;
+  std::cerr << sk::string(static_cast<VkDebugReportFlagBitsEXT>(flags)) << ": "
+            << layerPrefix << ": " << msg << std::endl;
 
-	return VK_FALSE;
+  return VK_FALSE;
 }
 
 bool
 hasExtension(const char*                               name,
              const std::vector<VkExtensionProperties>& properties)
 {
-	for (const auto& p : properties) {
-		if (!strcmp(p.extensionName, name)) {
-			return true;
-		}
-	}
+  for (const auto& p : properties) {
+    if (!strcmp(p.extensionName, name)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 bool
 hasLayer(const char* name, const std::vector<VkLayerProperties>& properties)
 {
-	for (const auto& p : properties) {
-		if (!strcmp(p.layerName, name)) {
-			return true;
-		}
-	}
+  for (const auto& p : properties) {
+    if (!strcmp(p.layerName, name)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 template<class Value>
 void
 logInfo(const char* heading, const Value& value)
 {
-	std::cout << std::setw(26) << std::left << (std::string(heading) + ":")
-	          << value << std::endl;
+  std::cout << std::setw(26) << std::left << (std::string(heading) + ":")
+            << value << std::endl;
 }
 
 VkResult
@@ -1222,62 +1191,62 @@ createInstance(sk::VulkanInitApi&     initApi,
                const PuglTestOptions& opts,
                sk::Instance&          instance)
 {
-	VkResult r = VK_SUCCESS;
-
-	std::vector<VkLayerProperties>     layerProps;
-	std::vector<VkExtensionProperties> extProps;
-	if ((r = initApi.enumerateInstanceLayerProperties(layerProps)) ||
-	    (r = initApi.enumerateInstanceExtensionProperties(extProps))) {
-		return r;
-	}
-
-	const auto puglExtensions = pugl::getInstanceExtensions();
-	auto       extensions     = std::vector<const char*>(puglExtensions.begin(),
-                                               puglExtensions.end());
-
-	// Add extra extensions we want to use if they are supported
-	if (hasExtension("VK_EXT_debug_report", extProps)) {
-		extensions.push_back("VK_EXT_debug_report");
-	}
-
-	// Add validation layers if error checking is enabled
-	std::vector<const char*> layers;
-	if (opts.errorChecking) {
-		for (const char* l : {"VK_LAYER_KHRONOS_validation",
-		                      "VK_LAYER_LUNARG_standard_validation"}) {
-			if (hasLayer(l, layerProps)) {
-				layers.push_back(l);
-			}
-		}
-	}
-
-	for (const auto& e : extensions) {
-		logInfo("Using instance extension", e);
-	}
-
-	for (const auto& l : layers) {
-		logInfo("Using instance layer", l);
-	}
-
-	static constexpr VkApplicationInfo appInfo{
-	    VK_STRUCTURE_TYPE_APPLICATION_INFO,
-	    nullptr,
-	    "Pugl Vulkan Demo",
-	    0,
-	    nullptr,
-	    0,
-	    VK_MAKE_VERSION(1, 0, 0),
-	};
-
-	const VkInstanceCreateInfo createInfo{
-	    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-	    nullptr,
-	    VkInstanceCreateFlags{},
-	    &appInfo,
-	    SK_COUNTED(uint32_t(layers.size()), layers.data()),
-	    SK_COUNTED(uint32_t(extensions.size()), extensions.data())};
-
-	return initApi.createInstance(createInfo, instance);
+  VkResult r = VK_SUCCESS;
+
+  std::vector<VkLayerProperties>     layerProps;
+  std::vector<VkExtensionProperties> extProps;
+  if ((r = initApi.enumerateInstanceLayerProperties(layerProps)) ||
+      (r = initApi.enumerateInstanceExtensionProperties(extProps))) {
+    return r;
+  }
+
+  const auto puglExtensions = pugl::getInstanceExtensions();
+  auto       extensions =
+    std::vector<const char*>(puglExtensions.begin(), puglExtensions.end());
+
+  // Add extra extensions we want to use if they are supported
+  if (hasExtension("VK_EXT_debug_report", extProps)) {
+    extensions.push_back("VK_EXT_debug_report");
+  }
+
+  // Add validation layers if error checking is enabled
+  std::vector<const char*> layers;
+  if (opts.errorChecking) {
+    for (const char* l : {"VK_LAYER_KHRONOS_validation",
+                          "VK_LAYER_LUNARG_standard_validation"}) {
+      if (hasLayer(l, layerProps)) {
+        layers.push_back(l);
+      }
+    }
+  }
+
+  for (const auto& e : extensions) {
+    logInfo("Using instance extension", e);
+  }
+
+  for (const auto& l : layers) {
+    logInfo("Using instance layer", l);
+  }
+
+  static constexpr VkApplicationInfo appInfo{
+    VK_STRUCTURE_TYPE_APPLICATION_INFO,
+    nullptr,
+    "Pugl Vulkan Demo",
+    0,
+    nullptr,
+    0,
+    VK_MAKE_VERSION(1, 0, 0),
+  };
+
+  const VkInstanceCreateInfo createInfo{
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    nullptr,
+    VkInstanceCreateFlags{},
+    &appInfo,
+    SK_COUNTED(uint32_t(layers.size()), layers.data()),
+    SK_COUNTED(uint32_t(extensions.size()), extensions.data())};
+
+  return initApi.createInstance(createInfo, instance);
 }
 
 VkResult
@@ -1286,28 +1255,27 @@ getDebugReportCallback(sk::VulkanApi&              api,
                        const bool                  verbose,
                        sk::DebugReportCallbackEXT& callback)
 {
-	if (api.vkCreateDebugReportCallbackEXT) {
-		VkDebugReportFlagsEXT flags =
-		    (VK_DEBUG_REPORT_WARNING_BIT_EXT |
-		     VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT |
-		     VK_DEBUG_REPORT_ERROR_BIT_EXT);
-
-		if (verbose) {
-			flags |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
-			flags |= VK_DEBUG_REPORT_DEBUG_BIT_EXT;
-		}
-
-		const VkDebugReportCallbackCreateInfoEXT createInfo{
-		    VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
-		    nullptr,
-		    flags,
-		    debugCallback,
-		    nullptr};
-
-		return api.createDebugReportCallbackEXT(instance, createInfo, callback);
-	}
-
-	return VK_ERROR_FEATURE_NOT_PRESENT;
+  if (api.vkCreateDebugReportCallbackEXT) {
+    VkDebugReportFlagsEXT flags = (VK_DEBUG_REPORT_WARNING_BIT_EXT |
+                                   VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT |
+                                   VK_DEBUG_REPORT_ERROR_BIT_EXT);
+
+    if (verbose) {
+      flags |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
+      flags |= VK_DEBUG_REPORT_DEBUG_BIT_EXT;
+    }
+
+    const VkDebugReportCallbackCreateInfoEXT createInfo{
+      VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
+      nullptr,
+      flags,
+      debugCallback,
+      nullptr};
+
+    return api.createDebugReportCallbackEXT(instance, createInfo, callback);
+  }
+
+  return VK_ERROR_FEATURE_NOT_PRESENT;
 }
 
 void
@@ -1318,40 +1286,36 @@ recordCommandBuffer(sk::CommandScope&   cmd,
                     const RectData&     rectData,
                     const size_t        imageIndex)
 {
-	const VkClearColorValue clearColorValue{{0.0f, 0.0f, 0.0f, 1.0f}};
-	const VkClearValue      clearValue{clearColorValue};
-
-	const VkRenderPassBeginInfo renderPassBegin{
-	    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-	    nullptr,
-	    renderPass.renderPass,
-	    renderPass.framebuffers[imageIndex],
-	    VkRect2D{{0, 0}, swapchain.extent},
-	    SK_COUNTED(1, &clearValue)};
-
-	auto pass = cmd.beginRenderPass(renderPassBegin,
-	                                VK_SUBPASS_CONTENTS_INLINE);
-
-	pass.bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS,
-	                  rectPipeline.pipelines[0]);
-
-	const std::array<VkDeviceSize, 1> offsets{0};
-	pass.bindVertexBuffers(
-	    0u, SK_COUNTED(1u, &rectData.modelBuffer.buffer.get(), offsets.data()));
-
-	pass.bindVertexBuffers(1u,
-	                       SK_COUNTED(1u,
-	                                  &rectData.instanceBuffer.buffer.get(),
-	                                  offsets.data()));
-
-	pass.bindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS,
-	                        rectPipeline.pipelineLayout,
-	                        0u,
-	                        SK_COUNTED(1u, rectPipeline.descriptorSets.get()),
-	                        0u,
-	                        nullptr);
-
-	pass.draw(4u, static_cast<uint32_t>(rectData.numRects), 0u, 0u);
+  const VkClearColorValue clearColorValue{{0.0f, 0.0f, 0.0f, 1.0f}};
+  const VkClearValue      clearValue{clearColorValue};
+
+  const VkRenderPassBeginInfo renderPassBegin{
+    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+    nullptr,
+    renderPass.renderPass,
+    renderPass.framebuffers[imageIndex],
+    VkRect2D{{0, 0}, swapchain.extent},
+    SK_COUNTED(1, &clearValue)};
+
+  auto pass = cmd.beginRenderPass(renderPassBegin, VK_SUBPASS_CONTENTS_INLINE);
+
+  pass.bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, rectPipeline.pipelines[0]);
+
+  const std::array<VkDeviceSize, 1> offsets{0};
+  pass.bindVertexBuffers(
+    0u, SK_COUNTED(1u, &rectData.modelBuffer.buffer.get(), offsets.data()));
+
+  pass.bindVertexBuffers(
+    1u, SK_COUNTED(1u, &rectData.instanceBuffer.buffer.get(), offsets.data()));
+
+  pass.bindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS,
+                          rectPipeline.pipelineLayout,
+                          0u,
+                          SK_COUNTED(1u, rectPipeline.descriptorSets.get()),
+                          0u,
+                          nullptr);
+
+  pass.draw(4u, static_cast<uint32_t>(rectData.numRects), 0u, 0u);
 }
 
 VkResult
@@ -1361,30 +1325,29 @@ recordCommandBuffers(const sk::VulkanApi& vk,
                      const RectPipeline&  rectPipeline,
                      const RectData&      rectData)
 {
-	VkResult r = VK_SUCCESS;
-
-	for (size_t i = 0; i < swapchain.imageViews.size(); ++i) {
-		const VkCommandBufferBeginInfo beginInfo{
-		    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-		    nullptr,
-		    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
-		    nullptr};
-
-		auto* const commandBuffer = renderPass.commandBuffers[i];
-		auto        cmd = vk.beginCommandBuffer(commandBuffer, beginInfo);
-		if (!cmd) {
-			return cmd.error();
-		}
-
-		recordCommandBuffer(
-		    cmd, swapchain, renderPass, rectPipeline, rectData, i);
-
-		if ((r = cmd.end())) {
-			return r;
-		}
-	}
-
-	return VK_SUCCESS;
+  VkResult r = VK_SUCCESS;
+
+  for (size_t i = 0; i < swapchain.imageViews.size(); ++i) {
+    const VkCommandBufferBeginInfo beginInfo{
+      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+      nullptr,
+      VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+      nullptr};
+
+    auto* const commandBuffer = renderPass.commandBuffers[i];
+    auto        cmd           = vk.beginCommandBuffer(commandBuffer, beginInfo);
+    if (!cmd) {
+      return cmd.error();
+    }
+
+    recordCommandBuffer(cmd, swapchain, renderPass, rectPipeline, rectData, i);
+
+    if ((r = cmd.end())) {
+      return r;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 class PuglVulkanDemo;
@@ -1392,76 +1355,76 @@ class PuglVulkanDemo;
 class View : public pugl::View
 {
 public:
-	View(pugl::World& world, PuglVulkanDemo& app)
-	    : pugl::View{world}
-	    , _app{app}
-	{
-		setEventHandler(*this);
-	}
-
-	template<PuglEventType t, class Base>
-	pugl::Status onEvent(const pugl::Event<t, Base>&) noexcept
-	{
-		return pugl::Status::success;
-	}
-
-	pugl::Status onEvent(const pugl::ConfigureEvent& event);
-	pugl::Status onEvent(const pugl::UpdateEvent& event);
-	pugl::Status onEvent(const pugl::ExposeEvent& event);
-	pugl::Status onEvent(const pugl::LoopEnterEvent& event);
-	pugl::Status onEvent(const pugl::TimerEvent& event);
-	pugl::Status onEvent(const pugl::LoopLeaveEvent& event);
-	pugl::Status onEvent(const pugl::KeyPressEvent& event);
-	pugl::Status onEvent(const pugl::CloseEvent& event);
+  View(pugl::World& world, PuglVulkanDemo& app)
+    : pugl::View{world}
+    , _app{app}
+  {
+    setEventHandler(*this);
+  }
+
+  template<PuglEventType t, class Base>
+  pugl::Status onEvent(const pugl::Event<t, Base>&) noexcept
+  {
+    return pugl::Status::success;
+  }
+
+  pugl::Status onEvent(const pugl::ConfigureEvent& event);
+  pugl::Status onEvent(const pugl::UpdateEvent& event);
+  pugl::Status onEvent(const pugl::ExposeEvent& event);
+  pugl::Status onEvent(const pugl::LoopEnterEvent& event);
+  pugl::Status onEvent(const pugl::TimerEvent& event);
+  pugl::Status onEvent(const pugl::LoopLeaveEvent& event);
+  pugl::Status onEvent(const pugl::KeyPressEvent& event);
+  pugl::Status onEvent(const pugl::CloseEvent& event);
 
 private:
-	PuglVulkanDemo& _app;
+  PuglVulkanDemo& _app;
 };
 
 class PuglVulkanDemo
 {
 public:
-	PuglVulkanDemo(const char*            executablePath,
-	               const PuglTestOptions& o,
-	               size_t                 numRects);
-
-	const char*        programPath;
-	PuglTestOptions    opts;
-	pugl::World        world;
-	pugl::VulkanLoader loader;
-	View               view;
-	VulkanContext      vulkan;
-	GraphicsDevice     gpu;
-	Renderer           renderer;
-	RectData           rectData;
-	RectShaders        rectShaders;
-	uint32_t           framesDrawn{0};
-	VkExtent2D         extent{512u, 512u};
-	std::vector<Rect>  rects;
-	bool               resizing{false};
-	bool               quit{false};
+  PuglVulkanDemo(const char*            executablePath,
+                 const PuglTestOptions& o,
+                 size_t                 numRects);
+
+  const char*        programPath;
+  PuglTestOptions    opts;
+  pugl::World        world;
+  pugl::VulkanLoader loader;
+  View               view;
+  VulkanContext      vulkan;
+  GraphicsDevice     gpu;
+  Renderer           renderer;
+  RectData           rectData;
+  RectShaders        rectShaders;
+  uint32_t           framesDrawn{0};
+  VkExtent2D         extent{512u, 512u};
+  std::vector<Rect>  rects;
+  bool               resizing{false};
+  bool               quit{false};
 };
 
 std::vector<Rect>
 makeRects(const size_t numRects, const uint32_t windowWidth)
 {
-	std::vector<Rect> rects(numRects);
-	for (size_t i = 0; i < numRects; ++i) {
-		rects[i] = makeRect(i, static_cast<float>(windowWidth));
-	}
+  std::vector<Rect> rects(numRects);
+  for (size_t i = 0; i < numRects; ++i) {
+    rects[i] = makeRect(i, static_cast<float>(windowWidth));
+  }
 
-	return rects;
+  return rects;
 }
 
 PuglVulkanDemo::PuglVulkanDemo(const char* const      executablePath,
                                const PuglTestOptions& o,
                                const size_t           numRects)
-    : programPath{executablePath}
-    , opts{o}
-    , world{pugl::WorldType::program, pugl::WorldFlag::threads}
-    , loader{world}
-    , view{world, *this}
-    , rects{makeRects(numRects, extent.width)}
+  : programPath{executablePath}
+  , opts{o}
+  , world{pugl::WorldType::program, pugl::WorldFlag::threads}
+  , loader{world}
+  , view{world, *this}
+  , rects{makeRects(numRects, extent.width)}
 {}
 
 VkResult
@@ -1472,148 +1435,140 @@ recreateRenderer(PuglVulkanDemo&       app,
                  const RectData&       rectData,
                  const RectShaders&    rectShaders)
 {
-	VkResult                 r            = VK_SUCCESS;
-	VkSurfaceCapabilitiesKHR capabilities = {};
-	if ((r = vk.getPhysicalDeviceSurfaceCapabilitiesKHR(gpu.physicalDevice,
-	                                                    gpu.surface,
-	                                                    capabilities))) {
-		return r;
-	}
-
-	// There is a known race issue here, so we clamp and hope for the best
-	const VkExtent2D clampedExtent{
-	    std::min(capabilities.maxImageExtent.width,
-	             std::max(capabilities.minImageExtent.width, extent.width)),
-	    std::min(capabilities.maxImageExtent.height,
-	             std::max(capabilities.minImageExtent.height, extent.height))};
-
-	if ((r = vk.deviceWaitIdle(gpu.device)) ||
-	    (r = app.renderer.recreate(vk,
-	                               gpu.surface,
-	                               gpu,
-	                               rectData,
-	                               rectShaders,
-	                               clampedExtent,
-	                               app.resizing))) {
-		return r;
-	}
-
-	// Reset current (initially signaled) fence because we already waited
-	vk.resetFence(gpu.device,
-	              app.renderer.sync.inFlight[app.renderer.sync.currentFrame]);
-
-	// Record new command buffers
-	return recordCommandBuffers(vk,
-	                            app.renderer.swapchain,
-	                            app.renderer.renderPass,
-	                            app.renderer.rectPipeline,
-	                            rectData);
+  VkResult                 r            = VK_SUCCESS;
+  VkSurfaceCapabilitiesKHR capabilities = {};
+  if ((r = vk.getPhysicalDeviceSurfaceCapabilitiesKHR(
+         gpu.physicalDevice, gpu.surface, capabilities))) {
+    return r;
+  }
+
+  // There is a known race issue here, so we clamp and hope for the best
+  const VkExtent2D clampedExtent{
+    std::min(capabilities.maxImageExtent.width,
+             std::max(capabilities.minImageExtent.width, extent.width)),
+    std::min(capabilities.maxImageExtent.height,
+             std::max(capabilities.minImageExtent.height, extent.height))};
+
+  if ((r = vk.deviceWaitIdle(gpu.device)) ||
+      (r = app.renderer.recreate(vk,
+                                 gpu.surface,
+                                 gpu,
+                                 rectData,
+                                 rectShaders,
+                                 clampedExtent,
+                                 app.resizing))) {
+    return r;
+  }
+
+  // Reset current (initially signaled) fence because we already waited
+  vk.resetFence(gpu.device,
+                app.renderer.sync.inFlight[app.renderer.sync.currentFrame]);
+
+  // Record new command buffers
+  return recordCommandBuffers(vk,
+                              app.renderer.swapchain,
+                              app.renderer.renderPass,
+                              app.renderer.rectPipeline,
+                              rectData);
 }
 
 pugl::Status
 View::onEvent(const pugl::ConfigureEvent& event)
 {
-	// We just record the size here and lazily resize the surface when exposed
-	_app.extent = {static_cast<uint32_t>(event.width),
-	               static_cast<uint32_t>(event.height)};
+  // We just record the size here and lazily resize the surface when exposed
+  _app.extent = {static_cast<uint32_t>(event.width),
+                 static_cast<uint32_t>(event.height)};
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 View::onEvent(const pugl::UpdateEvent&)
 {
-	return postRedisplay();
+  return postRedisplay();
 }
 
 VkResult
 beginFrame(PuglVulkanDemo& app, const sk::Device& device, uint32_t& imageIndex)
 {
-	const auto& vk = app.vulkan.vk;
-
-	VkResult r = VK_SUCCESS;
-
-	// Wait until we can start rendering the next frame
-	if ((r = vk.waitForFence(
-	         device,
-	         app.renderer.sync.inFlight[app.renderer.sync.currentFrame])) ||
-	    (r = vk.resetFence(
-	         device,
-	         app.renderer.sync.inFlight[app.renderer.sync.currentFrame]))) {
-		return r;
-	}
-
-	// Rebuild the renderer first if the window size has changed
-	if (app.extent.width != app.renderer.swapchain.extent.width ||
-	    app.extent.height != app.renderer.swapchain.extent.height) {
-		if ((r = recreateRenderer(app,
-		                          vk,
-		                          app.gpu,
-		                          app.extent,
-		                          app.rectData,
-		                          app.rectShaders))) {
-			return r;
-		}
-	}
-
-	// Acquire the next image to render, rebuilding if necessary
-	while (
-	    (r = vk.acquireNextImageKHR(
-	         device,
-	         app.renderer.swapchain.swapchain,
-	         UINT64_MAX,
-	         app.renderer.sync.imageAvailable[app.renderer.sync.currentFrame],
-	         {},
-	         &imageIndex))) {
-		switch (r) {
-		case VK_SUBOPTIMAL_KHR:
-		case VK_ERROR_OUT_OF_DATE_KHR:
-			if ((r = recreateRenderer(app,
-			                          vk,
-			                          app.gpu,
-			                          app.renderer.swapchain.extent,
-			                          app.rectData,
-			                          app.rectShaders))) {
-				return r;
-			}
-			continue;
-		default:
-			return r;
-		}
-	}
-
-	return VK_SUCCESS;
+  const auto& vk = app.vulkan.vk;
+
+  VkResult r = VK_SUCCESS;
+
+  // Wait until we can start rendering the next frame
+  if ((r = vk.waitForFence(
+         device, app.renderer.sync.inFlight[app.renderer.sync.currentFrame])) ||
+      (r = vk.resetFence(
+         device, app.renderer.sync.inFlight[app.renderer.sync.currentFrame]))) {
+    return r;
+  }
+
+  // Rebuild the renderer first if the window size has changed
+  if (app.extent.width != app.renderer.swapchain.extent.width ||
+      app.extent.height != app.renderer.swapchain.extent.height) {
+    if ((r = recreateRenderer(
+           app, vk, app.gpu, app.extent, app.rectData, app.rectShaders))) {
+      return r;
+    }
+  }
+
+  // Acquire the next image to render, rebuilding if necessary
+  while ((r = vk.acquireNextImageKHR(
+            device,
+            app.renderer.swapchain.swapchain,
+            UINT64_MAX,
+            app.renderer.sync.imageAvailable[app.renderer.sync.currentFrame],
+            {},
+            &imageIndex))) {
+    switch (r) {
+    case VK_SUBOPTIMAL_KHR:
+    case VK_ERROR_OUT_OF_DATE_KHR:
+      if ((r = recreateRenderer(app,
+                                vk,
+                                app.gpu,
+                                app.renderer.swapchain.extent,
+                                app.rectData,
+                                app.rectShaders))) {
+        return r;
+      }
+      continue;
+    default:
+      return r;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 void
 update(PuglVulkanDemo& app, const double time)
 {
-	// Animate rectangles
-	for (size_t i = 0; i < app.rects.size(); ++i) {
-		moveRect(&app.rects[i],
-		         i,
-		         app.rects.size(),
-		         static_cast<float>(app.extent.width),
-		         static_cast<float>(app.extent.height),
-		         time);
-	}
-
-	// Update vertex buffer
-	memcpy(app.rectData.vertexData.get(),
-	       app.rects.data(),
-	       sizeof(Rect) * app.rects.size());
-
-	// Update uniform buffer
-	UniformBufferObject ubo = {{}};
-	mat4Ortho(ubo.projection,
-	          0.0f,
-	          float(app.renderer.swapchain.extent.width),
-	          0.0f,
-	          float(app.renderer.swapchain.extent.height),
-	          -1.0f,
-	          1.0f);
-
-	memcpy(app.rectData.uniformData.get(), &ubo, sizeof(ubo));
+  // Animate rectangles
+  for (size_t i = 0; i < app.rects.size(); ++i) {
+    moveRect(&app.rects[i],
+             i,
+             app.rects.size(),
+             static_cast<float>(app.extent.width),
+             static_cast<float>(app.extent.height),
+             time);
+  }
+
+  // Update vertex buffer
+  memcpy(app.rectData.vertexData.get(),
+         app.rects.data(),
+         sizeof(Rect) * app.rects.size());
+
+  // Update uniform buffer
+  UniformBufferObject ubo = {{}};
+  mat4Ortho(ubo.projection,
+            0.0f,
+            float(app.renderer.swapchain.extent.width),
+            0.0f,
+            float(app.renderer.swapchain.extent.height),
+            -1.0f,
+            1.0f);
+
+  memcpy(app.rectData.uniformData.get(), &ubo, sizeof(ubo));
 }
 
 VkResult
@@ -1622,133 +1577,132 @@ endFrame(const sk::VulkanApi&  vk,
          const Renderer&       renderer,
          const uint32_t        imageIndex)
 {
-	const auto currentFrame = renderer.sync.currentFrame;
-	VkResult   r            = VK_SUCCESS;
-
-	static constexpr VkPipelineStageFlags waitStage =
-	    VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-	const VkSubmitInfo submitInfo{
-	    VK_STRUCTURE_TYPE_SUBMIT_INFO,
-	    nullptr,
-	    SK_COUNTED(1, &renderer.sync.imageAvailable[currentFrame].get()),
-	    &waitStage,
-	    SK_COUNTED(1, &renderer.renderPass.commandBuffers[imageIndex]),
-	    SK_COUNTED(1, &renderer.sync.renderFinished[imageIndex].get())};
-
-	if ((r = vk.queueSubmit(gpu.graphicsQueue,
-	                        submitInfo,
-	                        renderer.sync.inFlight[currentFrame]))) {
-		return r;
-	}
-
-	const VkPresentInfoKHR presentInfo{
-	    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-	    nullptr,
-	    SK_COUNTED(1, &renderer.sync.renderFinished[imageIndex].get()),
-	    SK_COUNTED(1, &renderer.swapchain.swapchain.get(), &imageIndex),
-	    nullptr};
-
-	switch ((r = vk.queuePresentKHR(gpu.graphicsQueue, presentInfo))) {
-	case VK_SUCCESS:               // Sucessfully presented
-	case VK_SUBOPTIMAL_KHR:        // Probably a resize race, ignore
-	case VK_ERROR_OUT_OF_DATE_KHR: // Probably a resize race, ignore
-		break;
-	default:
-		return r;
-	}
-
-	return VK_SUCCESS;
+  const auto currentFrame = renderer.sync.currentFrame;
+  VkResult   r            = VK_SUCCESS;
+
+  static constexpr VkPipelineStageFlags waitStage =
+    VK_PIPELINE_STAGE_TRANSFER_BIT;
+
+  const VkSubmitInfo submitInfo{
+    VK_STRUCTURE_TYPE_SUBMIT_INFO,
+    nullptr,
+    SK_COUNTED(1, &renderer.sync.imageAvailable[currentFrame].get()),
+    &waitStage,
+    SK_COUNTED(1, &renderer.renderPass.commandBuffers[imageIndex]),
+    SK_COUNTED(1, &renderer.sync.renderFinished[imageIndex].get())};
+
+  if ((r = vk.queueSubmit(gpu.graphicsQueue,
+                          submitInfo,
+                          renderer.sync.inFlight[currentFrame]))) {
+    return r;
+  }
+
+  const VkPresentInfoKHR presentInfo{
+    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+    nullptr,
+    SK_COUNTED(1, &renderer.sync.renderFinished[imageIndex].get()),
+    SK_COUNTED(1, &renderer.swapchain.swapchain.get(), &imageIndex),
+    nullptr};
+
+  switch ((r = vk.queuePresentKHR(gpu.graphicsQueue, presentInfo))) {
+  case VK_SUCCESS:               // Sucessfully presented
+  case VK_SUBOPTIMAL_KHR:        // Probably a resize race, ignore
+  case VK_ERROR_OUT_OF_DATE_KHR: // Probably a resize race, ignore
+    break;
+  default:
+    return r;
+  }
+
+  return VK_SUCCESS;
 }
 
 pugl::Status
 View::onEvent(const pugl::ExposeEvent&)
 {
-	const auto& vk  = _app.vulkan.vk;
-	const auto& gpu = _app.gpu;
+  const auto& vk  = _app.vulkan.vk;
+  const auto& gpu = _app.gpu;
 
-	// Acquire the next image, waiting and/or rebuilding if necessary
-	auto nextImageIndex = 0u;
-	if (beginFrame(_app, gpu.device, nextImageIndex)) {
-		return pugl::Status::unknownError;
-	}
+  // Acquire the next image, waiting and/or rebuilding if necessary
+  auto nextImageIndex = 0u;
+  if (beginFrame(_app, gpu.device, nextImageIndex)) {
+    return pugl::Status::unknownError;
+  }
 
-	// Ready to go, update the data to the current time
-	update(_app, world().time());
+  // Ready to go, update the data to the current time
+  update(_app, world().time());
 
-	// Submit the frame to the queue and present it
-	endFrame(vk, gpu, _app.renderer, nextImageIndex);
+  // Submit the frame to the queue and present it
+  endFrame(vk, gpu, _app.renderer, nextImageIndex);
 
-	++_app.framesDrawn;
-	++_app.renderer.sync.currentFrame;
-	_app.renderer.sync.currentFrame %= _app.renderer.sync.inFlight.size();
+  ++_app.framesDrawn;
+  ++_app.renderer.sync.currentFrame;
+  _app.renderer.sync.currentFrame %= _app.renderer.sync.inFlight.size();
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 View::onEvent(const pugl::LoopEnterEvent&)
 {
-	_app.resizing = true;
-	startTimer(resizeTimerId,
-	           1.0 / static_cast<double>(getHint(pugl::ViewHint::refreshRate)));
+  _app.resizing = true;
+  startTimer(resizeTimerId,
+             1.0 / static_cast<double>(getHint(pugl::ViewHint::refreshRate)));
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 View::onEvent(const pugl::TimerEvent&)
 {
-	return postRedisplay();
+  return postRedisplay();
 }
 
 pugl::Status
 View::onEvent(const pugl::LoopLeaveEvent&)
 {
-	stopTimer(resizeTimerId);
+  stopTimer(resizeTimerId);
 
-	// Trigger a swapchain recreation with the normal present mode
-	_app.renderer.swapchain.extent = {};
-	_app.resizing                  = false;
+  // Trigger a swapchain recreation with the normal present mode
+  _app.renderer.swapchain.extent = {};
+  _app.resizing                  = false;
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 View::onEvent(const pugl::KeyPressEvent& event)
 {
-	if (event.key == PUGL_KEY_ESCAPE || event.key == 'q') {
-		_app.quit = true;
-	}
+  if (event.key == PUGL_KEY_ESCAPE || event.key == 'q') {
+    _app.quit = true;
+  }
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 pugl::Status
 View::onEvent(const pugl::CloseEvent&)
 {
-	_app.quit = true;
+  _app.quit = true;
 
-	return pugl::Status::success;
+  return pugl::Status::success;
 }
 
 VkResult
 VulkanContext::init(pugl::VulkanLoader& loader, const PuglTestOptions& opts)
 {
-	VkResult r = VK_SUCCESS;
+  VkResult r = VK_SUCCESS;
 
-	sk::VulkanInitApi initApi{};
+  sk::VulkanInitApi initApi{};
 
-	// Load Vulkan API and set up the fundamentals
-	if ((r = initApi.init(loader.getInstanceProcAddrFunc())) ||
-	    (r = createInstance(initApi, opts, instance)) ||
-	    (r = vk.init(initApi, instance)) ||
-	    (r = getDebugReportCallback(
-	         vk, instance, opts.verbose, debugCallback))) {
-		return r;
-	}
+  // Load Vulkan API and set up the fundamentals
+  if ((r = initApi.init(loader.getInstanceProcAddrFunc())) ||
+      (r = createInstance(initApi, opts, instance)) ||
+      (r = vk.init(initApi, instance)) ||
+      (r = getDebugReportCallback(vk, instance, opts.verbose, debugCallback))) {
+    return r;
+  }
 
-	return VK_SUCCESS;
+  return VK_SUCCESS;
 }
 
 int
@@ -1756,90 +1710,90 @@ run(const char* const     programPath,
     const PuglTestOptions opts,
     const size_t          numRects)
 {
-	PuglVulkanDemo app{programPath, opts, numRects};
-
-	VkResult   r      = VK_SUCCESS;
-	const auto width  = static_cast<int>(app.extent.width);
-	const auto height = static_cast<int>(app.extent.height);
-
-	// Realize window so we can set up Vulkan
-	app.world.setClassName("PuglVulkanDemo");
-	app.view.setWindowTitle("Pugl Vulkan Demo");
-	app.view.setAspectRatio(1, 1, 16, 9);
-	app.view.setDefaultSize(width, height);
-	app.view.setMinSize(width / 4, height / 4);
-	app.view.setBackend(pugl::vulkanBackend());
-	app.view.setHint(pugl::ViewHint::resizable, opts.resizable);
-	const pugl::Status st = app.view.realize();
-	if (st != pugl::Status::success) {
-		return logError("Failed to create window (%s)\n", pugl::strerror(st));
-	}
-
-	if (!app.loader) {
-		return logError("Failed to load Vulkan library\n");
-	}
-
-	// Load Vulkan for the view
-	if ((r = app.vulkan.init(app.loader, opts))) {
-		return logError("Failed to set up Vulkan API (%s)\n", sk::string(r));
-	}
-
-	const auto& vk = app.vulkan.vk;
-
-	// Set up the graphics device
-	if ((r = app.gpu.init(app.loader, app.vulkan, app.view, opts))) {
-		return logError("Failed to set up device (%s)\n", sk::string(r));
-	}
-
-	logInfo("Present mode", sk::string(app.gpu.presentMode));
-	logInfo("Resize present mode", sk::string(app.gpu.resizePresentMode));
-
-	// Set up the rectangle data we will render every frame
-	if ((r = app.rectData.init(vk, app.gpu, app.rects.size()))) {
-		return logError("Failed to allocate render data (%s)\n", sk::string(r));
-	}
-
-	// Load shader modules
-	if ((r = app.rectShaders.init(vk, app.gpu, app.programPath))) {
-		return logError("Failed to load shaders (%s)\n", sk::string(r));
-	}
-
-	if ((r = app.renderer.init(app.vulkan.vk,
-	                           app.gpu,
-	                           app.rectData,
-	                           app.rectShaders,
-	                           app.extent,
-	                           false))) {
-		return logError("Failed to create renderer (%s)\n", sk::string(r));
-	}
-
-	logInfo("Swapchain frames",
-	        std::to_string(app.renderer.swapchain.imageViews.size()));
-	logInfo("Frames in flight",
-	        std::to_string(app.renderer.sync.inFlight.size()));
-
-	recordCommandBuffers(app.vulkan.vk,
-	                     app.renderer.swapchain,
-	                     app.renderer.renderPass,
-	                     app.renderer.rectPipeline,
-	                     app.rectData);
-
-	const int    refreshRate   = app.view.getHint(pugl::ViewHint::refreshRate);
-	const double frameDuration = 1.0 / static_cast<double>(refreshRate);
-	const double timeout       = app.opts.sync ? frameDuration : 0.0;
-
-	PuglFpsPrinter fpsPrinter = {app.world.time()};
-	app.view.show();
-	while (!app.quit) {
-		app.world.update(timeout);
-		puglPrintFps(app.world.cobj(), &fpsPrinter, &app.framesDrawn);
-	}
-
-	if ((r = app.vulkan.vk.deviceWaitIdle(app.gpu.device))) {
-		return logError("Failed to wait for device idle (%s)\n", sk::string(r));
-	}
-
-	return 0;
+  PuglVulkanDemo app{programPath, opts, numRects};
+
+  VkResult   r      = VK_SUCCESS;
+  const auto width  = static_cast<int>(app.extent.width);
+  const auto height = static_cast<int>(app.extent.height);
+
+  // Realize window so we can set up Vulkan
+  app.world.setClassName("PuglVulkanDemo");
+  app.view.setWindowTitle("Pugl Vulkan Demo");
+  app.view.setAspectRatio(1, 1, 16, 9);
+  app.view.setDefaultSize(width, height);
+  app.view.setMinSize(width / 4, height / 4);
+  app.view.setBackend(pugl::vulkanBackend());
+  app.view.setHint(pugl::ViewHint::resizable, opts.resizable);
+  const pugl::Status st = app.view.realize();
+  if (st != pugl::Status::success) {
+    return logError("Failed to create window (%s)\n", pugl::strerror(st));
+  }
+
+  if (!app.loader) {
+    return logError("Failed to load Vulkan library\n");
+  }
+
+  // Load Vulkan for the view
+  if ((r = app.vulkan.init(app.loader, opts))) {
+    return logError("Failed to set up Vulkan API (%s)\n", sk::string(r));
+  }
+
+  const auto& vk = app.vulkan.vk;
+
+  // Set up the graphics device
+  if ((r = app.gpu.init(app.loader, app.vulkan, app.view, opts))) {
+    return logError("Failed to set up device (%s)\n", sk::string(r));
+  }
+
+  logInfo("Present mode", sk::string(app.gpu.presentMode));
+  logInfo("Resize present mode", sk::string(app.gpu.resizePresentMode));
+
+  // Set up the rectangle data we will render every frame
+  if ((r = app.rectData.init(vk, app.gpu, app.rects.size()))) {
+    return logError("Failed to allocate render data (%s)\n", sk::string(r));
+  }
+
+  // Load shader modules
+  if ((r = app.rectShaders.init(vk, app.gpu, app.programPath))) {
+    return logError("Failed to load shaders (%s)\n", sk::string(r));
+  }
+
+  if ((r = app.renderer.init(app.vulkan.vk,
+                             app.gpu,
+                             app.rectData,
+                             app.rectShaders,
+                             app.extent,
+                             false))) {
+    return logError("Failed to create renderer (%s)\n", sk::string(r));
+  }
+
+  logInfo("Swapchain frames",
+          std::to_string(app.renderer.swapchain.imageViews.size()));
+  logInfo("Frames in flight",
+          std::to_string(app.renderer.sync.inFlight.size()));
+
+  recordCommandBuffers(app.vulkan.vk,
+                       app.renderer.swapchain,
+                       app.renderer.renderPass,
+                       app.renderer.rectPipeline,
+                       app.rectData);
+
+  const int    refreshRate   = app.view.getHint(pugl::ViewHint::refreshRate);
+  const double frameDuration = 1.0 / static_cast<double>(refreshRate);
+  const double timeout       = app.opts.sync ? frameDuration : 0.0;
+
+  PuglFpsPrinter fpsPrinter = {app.world.time()};
+  app.view.show();
+  while (!app.quit) {
+    app.world.update(timeout);
+    puglPrintFps(app.world.cobj(), &fpsPrinter, &app.framesDrawn);
+  }
+
+  if ((r = app.vulkan.vk.deviceWaitIdle(app.gpu.device))) {
+    return logError("Failed to wait for device idle (%s)\n", sk::string(r));
+  }
+
+  return 0;
 }
 
 } // namespace
@@ -1847,25 +1801,25 @@ run(const char* const     programPath,
 int
 main(int argc, char** argv)
 {
-	// Parse command line options
-	const char* const     programPath = argv[0];
-	const PuglTestOptions opts        = puglParseTestOptions(&argc, &argv);
-	if (opts.help) {
-		puglPrintTestUsage(programPath, "");
-		return 0;
-	}
-
-	// Parse number of rectangles argument, if given
-	int64_t numRects = 1000;
-	if (argc >= 1) {
-		char* endptr = nullptr;
-		numRects     = strtol(argv[0], &endptr, 10);
-		if (endptr != argv[0] + strlen(argv[0]) || numRects < 1) {
-			logError("Invalid number of rectangles: %s\n", argv[0]);
-			return 1;
-		}
-	}
-
-	// Run application
-	return run(programPath, opts, static_cast<size_t>(numRects));
+  // Parse command line options
+  const char* const     programPath = argv[0];
+  const PuglTestOptions opts        = puglParseTestOptions(&argc, &argv);
+  if (opts.help) {
+    puglPrintTestUsage(programPath, "");
+    return 0;
+  }
+
+  // Parse number of rectangles argument, if given
+  int64_t numRects = 1000;
+  if (argc >= 1) {
+    char* endptr = nullptr;
+    numRects     = strtol(argv[0], &endptr, 10);
+    if (endptr != argv[0] + strlen(argv[0]) || numRects < 1) {
+      logError("Invalid number of rectangles: %s\n", argv[0]);
+      return 1;
+    }
+  }
+
+  // Run application
+  return run(programPath, opts, static_cast<size_t>(numRects));
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_vulkan_demo.c b/subprojects/nk_pugl/pugl/examples/pugl_vulkan_demo.c
index ec96ec3..0dfbadd 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_vulkan_demo.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_vulkan_demo.c
@@ -1,5 +1,5 @@
 /*
-  Copyright 2019-2020 David Robillard <http://drobilla.net>
+  Copyright 2019-2020 David Robillard <d@drobilla.net>
   Copyright 2019 Jordan Halase <jordan@halase.me>
 
   Permission to use, copy, modify, and/or distribute this software for any
@@ -50,55 +50,55 @@
 
 /// Dynamically loaded Vulkan API functions
 typedef struct {
-	PFN_vkCreateDebugReportCallbackEXT  vkCreateDebugReportCallbackEXT;
-	PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
+  PFN_vkCreateDebugReportCallbackEXT  vkCreateDebugReportCallbackEXT;
+  PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT;
 } InstanceAPI;
 
 /// Vulkan swapchain and everything that depends on it
 typedef struct {
-	VkSwapchainKHR   rawSwapchain;
-	uint32_t         nImages;
-	VkExtent2D       extent;
-	VkImage*         images;
-	VkImageView*     imageViews;
-	VkFence*         fences;
-	VkCommandBuffer* commandBuffers;
+  VkSwapchainKHR   rawSwapchain;
+  uint32_t         nImages;
+  VkExtent2D       extent;
+  VkImage*         images;
+  VkImageView*     imageViews;
+  VkFence*         fences;
+  VkCommandBuffer* commandBuffers;
 } Swapchain;
 
 /// Synchronization semaphores
 typedef struct {
-	VkSemaphore presentComplete;
-	VkSemaphore renderFinished;
+  VkSemaphore presentComplete;
+  VkSemaphore renderFinished;
 } Sync;
 
 /// Vulkan state, purely Vulkan functions can depend on only this
 typedef struct {
-	InstanceAPI                api;
-	VkInstance                 instance;
-	VkDebugReportCallbackEXT   debugCallback;
-	VkSurfaceKHR               surface;
-	VkSurfaceFormatKHR         surfaceFormat;
-	VkPresentModeKHR           presentMode;
-	VkPhysicalDeviceProperties deviceProperties;
-	VkPhysicalDevice           physicalDevice;
-	uint32_t                   graphicsIndex;
-	VkDevice                   device;
-	VkQueue                    graphicsQueue;
-	VkCommandPool              commandPool;
-	Swapchain*                 swapchain;
-	Sync                       sync;
+  InstanceAPI                api;
+  VkInstance                 instance;
+  VkDebugReportCallbackEXT   debugCallback;
+  VkSurfaceKHR               surface;
+  VkSurfaceFormatKHR         surfaceFormat;
+  VkPresentModeKHR           presentMode;
+  VkPhysicalDeviceProperties deviceProperties;
+  VkPhysicalDevice           physicalDevice;
+  uint32_t                   graphicsIndex;
+  VkDevice                   device;
+  VkQueue                    graphicsQueue;
+  VkCommandPool              commandPool;
+  Swapchain*                 swapchain;
+  Sync                       sync;
 } VulkanState;
 
 /// Complete application
 typedef struct {
-	PuglTestOptions opts;
-	PuglWorld*      world;
-	PuglView*       view;
-	VulkanState     vk;
-	uint32_t        framesDrawn;
-	uint32_t        width;
-	uint32_t        height;
-	bool            quit;
+  PuglTestOptions opts;
+  PuglWorld*      world;
+  PuglView*       view;
+  VulkanState     vk;
+  uint32_t        framesDrawn;
+  uint32_t        width;
+  uint32_t        height;
+  bool            quit;
 } VulkanApp;
 
 static VKAPI_ATTR VkBool32 VKAPI_CALL
@@ -111,27 +111,27 @@ debugCallback(VkDebugReportFlagsEXT      flags,
               const char*                msg,
               void*                      userData)
 {
-	(void)userData;
-	(void)objType;
-	(void)obj;
-	(void)location;
-	(void)code;
-
-	if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
-		fprintf(stderr, "note: ");
-	} else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
-		fprintf(stderr, "warning: ");
-	} else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
-		fprintf(stderr, "performance warning: ");
-	} else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
-		fprintf(stderr, "error: ");
-	} else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
-		fprintf(stderr, "debug: ");
-	}
-
-	fprintf(stderr, "%s: ", layerPrefix);
-	fprintf(stderr, "%s\n", msg);
-	return VK_FALSE;
+  (void)userData;
+  (void)objType;
+  (void)obj;
+  (void)location;
+  (void)code;
+
+  if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
+    fprintf(stderr, "note: ");
+  } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
+    fprintf(stderr, "warning: ");
+  } else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
+    fprintf(stderr, "performance warning: ");
+  } else if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
+    fprintf(stderr, "error: ");
+  } else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
+    fprintf(stderr, "debug: ");
+  }
+
+  fprintf(stderr, "%s: ", layerPrefix);
+  fprintf(stderr, "%s\n", msg);
+  return VK_FALSE;
 }
 
 static bool
@@ -139,13 +139,13 @@ hasExtension(const char* const                  name,
              const VkExtensionProperties* const properties,
              const uint32_t                     count)
 {
-	for (uint32_t i = 0; i < count; ++i) {
-		if (!strcmp(properties[i].extensionName, name)) {
-			return true;
-		}
-	}
+  for (uint32_t i = 0; i < count; ++i) {
+    if (!strcmp(properties[i].extensionName, name)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static bool
@@ -153,13 +153,13 @@ hasLayer(const char* const              name,
          const VkLayerProperties* const properties,
          const uint32_t                 count)
 {
-	for (uint32_t i = 0; i < count; ++i) {
-		if (!strcmp(properties[i].layerName, name)) {
-			return true;
-		}
-	}
+  for (uint32_t i = 0; i < count; ++i) {
+    if (!strcmp(properties[i].layerName, name)) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 static void
@@ -167,129 +167,129 @@ pushString(const char*** const array,
            uint32_t* const     count,
            const char* const   string)
 {
-	*array = (const char**)realloc(*array, (*count + 1) * sizeof(const char*));
-	(*array)[*count] = string;
-	++*count;
+  *array = (const char**)realloc(*array, (*count + 1) * sizeof(const char*));
+  (*array)[*count] = string;
+  ++*count;
 }
 
 static VkResult
 createInstance(VulkanApp* const app)
 {
-	const VkApplicationInfo appInfo = {
-	    VK_STRUCTURE_TYPE_APPLICATION_INFO,
-	    NULL,
-	    "Pugl Vulkan Test",
-	    VK_MAKE_VERSION(0, 1, 0),
-	    "Pugl Vulkan Test Engine",
-	    VK_MAKE_VERSION(0, 1, 0),
-	    VK_MAKE_VERSION(1, 0, 0),
-	};
-
-	// Get the number of supported extensions and layers
-	VkResult vr          = VK_SUCCESS;
-	uint32_t nExtProps   = 0;
-	uint32_t nLayerProps = 0;
-	if ((vr = vkEnumerateInstanceLayerProperties(&nLayerProps, NULL)) ||
-	    (vr = vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, NULL))) {
-		return vr;
-	}
-
-	// Get properties of supported extensions
-	VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
-	vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, extProps);
-
-	uint32_t     nExtensions = 0;
-	const char** extensions  = NULL;
-
-	// Add extensions required by pugl
-	uint32_t           nPuglExts = 0;
-	const char* const* puglExts  = puglGetInstanceExtensions(&nPuglExts);
-	for (uint32_t i = 0; i < nPuglExts; ++i) {
-		pushString(&extensions, &nExtensions, puglExts[i]);
-	}
-
-	// Add extra extensions we want to use if they are supported
-	if (hasExtension("VK_EXT_debug_report", extProps, nExtProps)) {
-		pushString(&extensions, &nExtensions, "VK_EXT_debug_report");
-	}
-
-	// Get properties of supported layers
-	VkLayerProperties* layerProps = AALLOC(nLayerProps, VkLayerProperties);
-	vkEnumerateInstanceLayerProperties(&nLayerProps, layerProps);
-
-	// Add validation layers if error checking is enabled
-	uint32_t     nLayers = 0;
-	const char** layers  = NULL;
-	if (app->opts.errorChecking) {
-		const char* debugLayers[] = {"VK_LAYER_KHRONOS_validation",
-		                             "VK_LAYER_LUNARG_standard_validation",
-		                             NULL};
-
-		for (const char** l = debugLayers; *l; ++l) {
-			if (hasLayer(*l, layerProps, nLayerProps)) {
-				pushString(&layers, &nLayers, *l);
-			}
-		}
-	}
-
-	for (uint32_t i = 0; i < nExtensions; ++i) {
-		printf("Using instance extension:    %s\n", extensions[i]);
-	}
-
-	for (uint32_t i = 0; i < nLayers; ++i) {
-		printf("Using instance layer:        %s\n", layers[i]);
-	}
-
-	const VkInstanceCreateInfo createInfo = {
-	    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-	    NULL,
-	    0,
-	    &appInfo,
-	    COUNTED(nLayers, layers),
-	    COUNTED(nExtensions, extensions),
-	};
-
-	if ((vr = vkCreateInstance(&createInfo, ALLOC_VK, &app->vk.instance))) {
-		logError("Could not create Vulkan Instance: %d\n", vr);
-	}
-
-	free(layers);
-	free(extensions);
-	free(layerProps);
-	free(extProps);
-
-	return vr;
+  const VkApplicationInfo appInfo = {
+    VK_STRUCTURE_TYPE_APPLICATION_INFO,
+    NULL,
+    "Pugl Vulkan Test",
+    VK_MAKE_VERSION(0, 1, 0),
+    "Pugl Vulkan Test Engine",
+    VK_MAKE_VERSION(0, 1, 0),
+    VK_MAKE_VERSION(1, 0, 0),
+  };
+
+  // Get the number of supported extensions and layers
+  VkResult vr          = VK_SUCCESS;
+  uint32_t nExtProps   = 0;
+  uint32_t nLayerProps = 0;
+  if ((vr = vkEnumerateInstanceLayerProperties(&nLayerProps, NULL)) ||
+      (vr = vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, NULL))) {
+    return vr;
+  }
+
+  // Get properties of supported extensions
+  VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
+  vkEnumerateInstanceExtensionProperties(NULL, &nExtProps, extProps);
+
+  uint32_t     nExtensions = 0;
+  const char** extensions  = NULL;
+
+  // Add extensions required by pugl
+  uint32_t           nPuglExts = 0;
+  const char* const* puglExts  = puglGetInstanceExtensions(&nPuglExts);
+  for (uint32_t i = 0; i < nPuglExts; ++i) {
+    pushString(&extensions, &nExtensions, puglExts[i]);
+  }
+
+  // Add extra extensions we want to use if they are supported
+  if (hasExtension("VK_EXT_debug_report", extProps, nExtProps)) {
+    pushString(&extensions, &nExtensions, "VK_EXT_debug_report");
+  }
+
+  // Get properties of supported layers
+  VkLayerProperties* layerProps = AALLOC(nLayerProps, VkLayerProperties);
+  vkEnumerateInstanceLayerProperties(&nLayerProps, layerProps);
+
+  // Add validation layers if error checking is enabled
+  uint32_t     nLayers = 0;
+  const char** layers  = NULL;
+  if (app->opts.errorChecking) {
+    const char* debugLayers[] = {"VK_LAYER_KHRONOS_validation",
+                                 "VK_LAYER_LUNARG_standard_validation",
+                                 NULL};
+
+    for (const char** l = debugLayers; *l; ++l) {
+      if (hasLayer(*l, layerProps, nLayerProps)) {
+        pushString(&layers, &nLayers, *l);
+      }
+    }
+  }
+
+  for (uint32_t i = 0; i < nExtensions; ++i) {
+    printf("Using instance extension:    %s\n", extensions[i]);
+  }
+
+  for (uint32_t i = 0; i < nLayers; ++i) {
+    printf("Using instance layer:        %s\n", layers[i]);
+  }
+
+  const VkInstanceCreateInfo createInfo = {
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    NULL,
+    0,
+    &appInfo,
+    COUNTED(nLayers, layers),
+    COUNTED(nExtensions, extensions),
+  };
+
+  if ((vr = vkCreateInstance(&createInfo, ALLOC_VK, &app->vk.instance))) {
+    logError("Could not create Vulkan Instance: %d\n", vr);
+  }
+
+  free(layers);
+  free(extensions);
+  free(layerProps);
+  free(extProps);
+
+  return vr;
 }
 
 static VkResult
 enableDebugging(VulkanState* const vk)
 {
-	vk->api.vkCreateDebugReportCallbackEXT =
-	    (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(
-	        vk->instance, "vkCreateDebugReportCallbackEXT");
-
-	vk->api.vkDestroyDebugReportCallbackEXT =
-	    (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(
-	        vk->instance, "vkDestroyDebugReportCallbackEXT");
-
-	if (vk->api.vkCreateDebugReportCallbackEXT) {
-		const VkDebugReportCallbackCreateInfoEXT info = {
-		    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
-		    NULL,
-		    VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
-		    debugCallback,
-		    NULL,
-		};
-
-		VkResult vr = VK_SUCCESS;
-		if ((vr = vk->api.vkCreateDebugReportCallbackEXT(
-		         vk->instance, &info, ALLOC_VK, &vk->debugCallback))) {
-			logError("Could not create debug reporter: %d\n", vr);
-			return vr;
-		}
-	}
-
-	return VK_SUCCESS;
+  vk->api.vkCreateDebugReportCallbackEXT =
+    (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(
+      vk->instance, "vkCreateDebugReportCallbackEXT");
+
+  vk->api.vkDestroyDebugReportCallbackEXT =
+    (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(
+      vk->instance, "vkDestroyDebugReportCallbackEXT");
+
+  if (vk->api.vkCreateDebugReportCallbackEXT) {
+    const VkDebugReportCallbackCreateInfoEXT info = {
+      VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+      NULL,
+      VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT,
+      debugCallback,
+      NULL,
+    };
+
+    VkResult vr = VK_SUCCESS;
+    if ((vr = vk->api.vkCreateDebugReportCallbackEXT(
+           vk->instance, &info, ALLOC_VK, &vk->debugCallback))) {
+      logError("Could not create debug reporter: %d\n", vr);
+      return vr;
+    }
+  }
+
+  return VK_SUCCESS;
 }
 
 static VkResult
@@ -297,52 +297,53 @@ getGraphicsQueueIndex(VkSurfaceKHR     surface,
                       VkPhysicalDevice device,
                       uint32_t*        graphicsIndex)
 {
-	VkResult r = VK_SUCCESS;
-
-	uint32_t nProps = 0;
-	vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, NULL);
-
-	VkQueueFamilyProperties* props = AALLOC(nProps, VkQueueFamilyProperties);
-	vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, props);
-
-	for (uint32_t q = 0; q < nProps; ++q) {
-		if (props[q].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-			VkBool32 supported = false;
-			if ((r = vkGetPhysicalDeviceSurfaceSupportKHR(
-			         device, q, surface, &supported))) {
-				free(props);
-				return r;
-			} else if (supported) {
-				*graphicsIndex = q;
-				free(props);
-				return VK_SUCCESS;
-			}
-		}
-	}
-
-	free(props);
-	return VK_ERROR_FEATURE_NOT_PRESENT;
+  VkResult r = VK_SUCCESS;
+
+  uint32_t nProps = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, NULL);
+
+  VkQueueFamilyProperties* props = AALLOC(nProps, VkQueueFamilyProperties);
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &nProps, props);
+
+  for (uint32_t q = 0; q < nProps; ++q) {
+    if (props[q].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      VkBool32 supported = false;
+      if ((r = vkGetPhysicalDeviceSurfaceSupportKHR(
+             device, q, surface, &supported))) {
+        free(props);
+        return r;
+      }
+
+      if (supported) {
+        *graphicsIndex = q;
+        free(props);
+        return VK_SUCCESS;
+      }
+    }
+  }
+
+  free(props);
+  return VK_ERROR_FEATURE_NOT_PRESENT;
 }
 
 static bool
 supportsRequiredExtensions(const VkPhysicalDevice device)
 {
-	uint32_t nExtProps = 0;
-	vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, NULL);
-
-	VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
-	vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, extProps);
-
-	for (uint32_t i = 0; i < nExtProps; ++i) {
-		if (!strcmp(extProps[i].extensionName,
-		            VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
-			free(extProps);
-			return true;
-		}
-	}
-
-	free(extProps);
-	return false;
+  uint32_t nExtProps = 0;
+  vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, NULL);
+
+  VkExtensionProperties* extProps = AALLOC(nExtProps, VkExtensionProperties);
+  vkEnumerateDeviceExtensionProperties(device, NULL, &nExtProps, extProps);
+
+  for (uint32_t i = 0; i < nExtProps; ++i) {
+    if (!strcmp(extProps[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME)) {
+      free(extProps);
+      return true;
+    }
+  }
+
+  free(extProps);
+  return false;
 }
 
 static bool
@@ -350,12 +351,12 @@ isDeviceSuitable(const VulkanState* const vk,
                  const VkPhysicalDevice   device,
                  uint32_t* const          graphicsIndex)
 {
-	if (!supportsRequiredExtensions(device) ||
-	    getGraphicsQueueIndex(vk->surface, device, graphicsIndex)) {
-		return false;
-	}
+  if (!supportsRequiredExtensions(device) ||
+      getGraphicsQueueIndex(vk->surface, device, graphicsIndex)) {
+    return false;
+  }
 
-	return true;
+  return true;
 }
 
 /**
@@ -366,134 +367,134 @@ isDeviceSuitable(const VulkanState* const vk,
 static VkResult
 selectPhysicalDevice(VulkanState* const vk)
 {
-	VkResult vr = VK_SUCCESS;
-	if (!vk->surface) {
-		logError("Cannot select a physical device without a surface\n");
-		return VK_ERROR_SURFACE_LOST_KHR;
-	}
-
-	uint32_t nDevices = 0;
-	if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, NULL))) {
-		logError("Failed to get count of physical devices: %d\n", vr);
-		return vr;
-	}
-
-	if (!nDevices) {
-		logError("No physical devices found\n");
-		return VK_ERROR_DEVICE_LOST;
-	}
-
-	VkPhysicalDevice* devices = AALLOC(nDevices, VkPhysicalDevice);
-	if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, devices))) {
-		logError("Failed to enumerate physical devices: %d\n", vr);
-		free(devices);
-		return vr;
-	}
-
-	uint32_t i = 0;
-	for (i = 0; i < nDevices; ++i) {
-		VkPhysicalDeviceProperties deviceProps = {0};
-		vkGetPhysicalDeviceProperties(devices[i], &deviceProps);
-
-		uint32_t graphicsIndex = 0;
-		if (isDeviceSuitable(vk, devices[i], &graphicsIndex)) {
-			printf("Using device %u/%u:            \"%s\"\n",
-			       i + 1,
-			       nDevices,
-			       deviceProps.deviceName);
-			vk->deviceProperties = deviceProps;
-			vk->physicalDevice   = devices[i];
-			vk->graphicsIndex    = graphicsIndex;
-			printf("Using graphics queue family: %u\n", vk->graphicsIndex);
-			break;
-		}
-
-		printf("Device \"%s\" not suitable\n", deviceProps.deviceName);
-	}
-
-	if (i >= nDevices) {
-		logError("No suitable devices found\n");
-		vr = VK_ERROR_DEVICE_LOST;
-	}
-
-	free(devices);
-	return vr;
+  VkResult vr = VK_SUCCESS;
+  if (!vk->surface) {
+    logError("Cannot select a physical device without a surface\n");
+    return VK_ERROR_SURFACE_LOST_KHR;
+  }
+
+  uint32_t nDevices = 0;
+  if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, NULL))) {
+    logError("Failed to get count of physical devices: %d\n", vr);
+    return vr;
+  }
+
+  if (!nDevices) {
+    logError("No physical devices found\n");
+    return VK_ERROR_DEVICE_LOST;
+  }
+
+  VkPhysicalDevice* devices = AALLOC(nDevices, VkPhysicalDevice);
+  if ((vr = vkEnumeratePhysicalDevices(vk->instance, &nDevices, devices))) {
+    logError("Failed to enumerate physical devices: %d\n", vr);
+    free(devices);
+    return vr;
+  }
+
+  uint32_t i = 0;
+  for (i = 0; i < nDevices; ++i) {
+    VkPhysicalDeviceProperties deviceProps = {0};
+    vkGetPhysicalDeviceProperties(devices[i], &deviceProps);
+
+    uint32_t graphicsIndex = 0;
+    if (isDeviceSuitable(vk, devices[i], &graphicsIndex)) {
+      printf("Using device %u/%u:            \"%s\"\n",
+             i + 1,
+             nDevices,
+             deviceProps.deviceName);
+      vk->deviceProperties = deviceProps;
+      vk->physicalDevice   = devices[i];
+      vk->graphicsIndex    = graphicsIndex;
+      printf("Using graphics queue family: %u\n", vk->graphicsIndex);
+      break;
+    }
+
+    printf("Device \"%s\" not suitable\n", deviceProps.deviceName);
+  }
+
+  if (i >= nDevices) {
+    logError("No suitable devices found\n");
+    vr = VK_ERROR_DEVICE_LOST;
+  }
+
+  free(devices);
+  return vr;
 }
 
 /// Opens the logical device and sets up the queue and command pool
 static VkResult
 openDevice(VulkanState* const vk)
 {
-	if (vk->device) {
-		logError("Renderer already has an opened device\n");
-		return VK_NOT_READY;
-	}
-
-	const float       graphicsQueuePriority = 1.0f;
-	const char* const swapchainName         = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
-
-	const VkDeviceQueueCreateInfo queueCreateInfo = {
-	    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-	    NULL,
-	    0,
-	    vk->graphicsIndex,
-	    COUNTED(1, &graphicsQueuePriority),
-	};
-
-	const VkDeviceCreateInfo createInfo = {
-	    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-	    NULL,
-	    0,
-	    COUNTED(1, &queueCreateInfo),
-	    COUNTED(0, NULL),
-	    COUNTED(1, &swapchainName),
-	    NULL,
-	};
-
-	VkDevice device = NULL;
-	VkResult vr     = VK_SUCCESS;
-	if ((vr = vkCreateDevice(
-	         vk->physicalDevice, &createInfo, ALLOC_VK, &device))) {
-		logError("Could not open device \"%s\": %d\n",
-		         vk->deviceProperties.deviceName,
-		         vr);
-		return vr;
-	}
-
-	vk->device = device;
-	vkGetDeviceQueue(vk->device, vk->graphicsIndex, 0, &vk->graphicsQueue);
-
-	const VkCommandPoolCreateInfo commandInfo = {
-	    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
-	    NULL,
-	    0,
-	    vk->graphicsIndex,
-	};
-
-	if ((vr = vkCreateCommandPool(
-	         vk->device, &commandInfo, ALLOC_VK, &vk->commandPool))) {
-		logError("Could not create command pool: %d\n", vr);
-		return vr;
-	}
-
-	return VK_SUCCESS;
+  if (vk->device) {
+    logError("Renderer already has an opened device\n");
+    return VK_NOT_READY;
+  }
+
+  const float       graphicsQueuePriority = 1.0f;
+  const char* const swapchainName         = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+
+  const VkDeviceQueueCreateInfo queueCreateInfo = {
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+    NULL,
+    0,
+    vk->graphicsIndex,
+    COUNTED(1, &graphicsQueuePriority),
+  };
+
+  const VkDeviceCreateInfo createInfo = {
+    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+    NULL,
+    0,
+    COUNTED(1, &queueCreateInfo),
+    COUNTED(0, NULL),
+    COUNTED(1, &swapchainName),
+    NULL,
+  };
+
+  VkDevice device = NULL;
+  VkResult vr     = VK_SUCCESS;
+  if ((vr =
+         vkCreateDevice(vk->physicalDevice, &createInfo, ALLOC_VK, &device))) {
+    logError("Could not open device \"%s\": %d\n",
+             vk->deviceProperties.deviceName,
+             vr);
+    return vr;
+  }
+
+  vk->device = device;
+  vkGetDeviceQueue(vk->device, vk->graphicsIndex, 0, &vk->graphicsQueue);
+
+  const VkCommandPoolCreateInfo commandInfo = {
+    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
+    NULL,
+    0,
+    vk->graphicsIndex,
+  };
+
+  if ((vr = vkCreateCommandPool(
+         vk->device, &commandInfo, ALLOC_VK, &vk->commandPool))) {
+    logError("Could not create command pool: %d\n", vr);
+    return vr;
+  }
+
+  return VK_SUCCESS;
 }
 
 static const char*
 presentModeString(const VkPresentModeKHR presentMode)
 {
-	switch (presentMode) {
-	case VK_PRESENT_MODE_IMMEDIATE_KHR:
-		return "Immediate";
-	case VK_PRESENT_MODE_MAILBOX_KHR:
-		return "Mailbox";
-	case VK_PRESENT_MODE_FIFO_KHR:
-		return "FIFO";
-	case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
-		return "FIFO relaxed";
-	default:
-		return "Other";
-	}
+  switch (presentMode) {
+  case VK_PRESENT_MODE_IMMEDIATE_KHR:
+    return "Immediate";
+  case VK_PRESENT_MODE_MAILBOX_KHR:
+    return "Mailbox";
+  case VK_PRESENT_MODE_FIFO_KHR:
+    return "FIFO";
+  case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
+    return "FIFO relaxed";
+  default:
+    return "Other";
+  }
 }
 
 static bool
@@ -501,90 +502,82 @@ hasPresentMode(const VkPresentModeKHR        mode,
                const VkPresentModeKHR* const presentModes,
                const uint32_t                nPresentModes)
 {
-	for (uint32_t i = 0; i < nPresentModes; ++i) {
-		if (presentModes[i] == mode) {
-			return true;
-		}
-	}
+  for (uint32_t i = 0; i < nPresentModes; ++i) {
+    if (presentModes[i] == mode) {
+      return true;
+    }
+  }
 
-	return false;
+  return false;
 }
 
 /// Configure the surface for the currently opened device
 static VkResult
 configureSurface(VulkanState* const vk)
 {
-	uint32_t nFormats = 0;
-	vkGetPhysicalDeviceSurfaceFormatsKHR(vk->physicalDevice,
-	                                     vk->surface,
-	                                     &nFormats,
-	                                     NULL);
-	if (!nFormats) {
-		logError("No surface formats available\n");
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	VkSurfaceFormatKHR* surfaceFormats = AALLOC(nFormats, VkSurfaceFormatKHR);
-	vkGetPhysicalDeviceSurfaceFormatsKHR(vk->physicalDevice,
-	                                     vk->surface,
-	                                     &nFormats,
-	                                     surfaceFormats);
-
-	const VkSurfaceFormatKHR want = {VK_FORMAT_B8G8R8A8_UNORM,
-	                                 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR};
-
-	uint32_t formatIndex = 0;
-	for (formatIndex = 0; formatIndex < nFormats; ++formatIndex) {
-		if (surfaceFormats[formatIndex].format == want.format &&
-		    surfaceFormats[formatIndex].colorSpace == want.colorSpace) {
-			vk->surfaceFormat = want;
-			break;
-		}
-	}
-	free(surfaceFormats);
-	if (formatIndex >= nFormats) {
-		logError("Could not find a suitable surface format\n");
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	uint32_t nPresentModes = 0;
-	vkGetPhysicalDeviceSurfacePresentModesKHR(vk->physicalDevice,
-	                                          vk->surface,
-	                                          &nPresentModes,
-	                                          NULL);
-	if (!nPresentModes) {
-		logError("No present modes available\n");
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	VkPresentModeKHR* presentModes = AALLOC(nPresentModes, VkPresentModeKHR);
-	vkGetPhysicalDeviceSurfacePresentModesKHR(vk->physicalDevice,
-	                                          vk->surface,
-	                                          &nPresentModes,
-	                                          presentModes);
-
-	const VkPresentModeKHR tryModes[] = {
-	    VK_PRESENT_MODE_MAILBOX_KHR,
-	    VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-	    VK_PRESENT_MODE_FIFO_KHR,
-	    VK_PRESENT_MODE_IMMEDIATE_KHR,
-	};
-
-	VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
-	for (uint32_t i = 0; i < sizeof(tryModes) / sizeof(VkPresentModeKHR); ++i) {
-		if (hasPresentMode(tryModes[i], presentModes, nPresentModes)) {
-			presentMode = tryModes[i];
-			break;
-		}
-	}
-
-	free(presentModes);
-	vk->presentMode = presentMode;
-	printf("Using present mode:          \"%s\" (%u)\n",
-	       presentModeString(presentMode),
-	       presentMode);
-
-	return VK_SUCCESS;
+  uint32_t nFormats = 0;
+  vkGetPhysicalDeviceSurfaceFormatsKHR(
+    vk->physicalDevice, vk->surface, &nFormats, NULL);
+  if (!nFormats) {
+    logError("No surface formats available\n");
+    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  }
+
+  VkSurfaceFormatKHR* surfaceFormats = AALLOC(nFormats, VkSurfaceFormatKHR);
+  vkGetPhysicalDeviceSurfaceFormatsKHR(
+    vk->physicalDevice, vk->surface, &nFormats, surfaceFormats);
+
+  const VkSurfaceFormatKHR want = {VK_FORMAT_B8G8R8A8_UNORM,
+                                   VK_COLOR_SPACE_SRGB_NONLINEAR_KHR};
+
+  uint32_t formatIndex = 0;
+  for (formatIndex = 0; formatIndex < nFormats; ++formatIndex) {
+    if (surfaceFormats[formatIndex].format == want.format &&
+        surfaceFormats[formatIndex].colorSpace == want.colorSpace) {
+      vk->surfaceFormat = want;
+      break;
+    }
+  }
+  free(surfaceFormats);
+  if (formatIndex >= nFormats) {
+    logError("Could not find a suitable surface format\n");
+    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  }
+
+  uint32_t nPresentModes = 0;
+  vkGetPhysicalDeviceSurfacePresentModesKHR(
+    vk->physicalDevice, vk->surface, &nPresentModes, NULL);
+  if (!nPresentModes) {
+    logError("No present modes available\n");
+    return VK_ERROR_FORMAT_NOT_SUPPORTED;
+  }
+
+  VkPresentModeKHR* presentModes = AALLOC(nPresentModes, VkPresentModeKHR);
+  vkGetPhysicalDeviceSurfacePresentModesKHR(
+    vk->physicalDevice, vk->surface, &nPresentModes, presentModes);
+
+  const VkPresentModeKHR tryModes[] = {
+    VK_PRESENT_MODE_MAILBOX_KHR,
+    VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+    VK_PRESENT_MODE_FIFO_KHR,
+    VK_PRESENT_MODE_IMMEDIATE_KHR,
+  };
+
+  VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
+  for (uint32_t i = 0; i < sizeof(tryModes) / sizeof(VkPresentModeKHR); ++i) {
+    if (hasPresentMode(tryModes[i], presentModes, nPresentModes)) {
+      presentMode = tryModes[i];
+      break;
+    }
+  }
+
+  free(presentModes);
+  vk->presentMode = presentMode;
+  printf("Using present mode:          \"%s\" (%u)\n",
+         presentModeString(presentMode),
+         presentMode);
+
+  return VK_SUCCESS;
 }
 
 static VkResult
@@ -592,140 +585,137 @@ createRawSwapchain(VulkanState* const vk,
                    const uint32_t     width,
                    const uint32_t     height)
 {
-	VkSurfaceCapabilitiesKHR surfaceCapabilities;
-	VkResult                 vr = VK_SUCCESS;
-	if ((vr = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-	         vk->physicalDevice, vk->surface, &surfaceCapabilities))) {
-		logError("Could not get surface capabilities: %d\n", vr);
-		return vr;
-	}
-
-	/* There is a known race condition with window/surface sizes, so we clamp
-	   to what Vulkan reports and hope for the best. */
-
-	vk->swapchain->extent.width =
-	    CLAMP(width,
-	          surfaceCapabilities.minImageExtent.width,
-	          surfaceCapabilities.maxImageExtent.width);
-
-	vk->swapchain->extent.height =
-	    CLAMP(height,
-	          surfaceCapabilities.minImageExtent.height,
-	          surfaceCapabilities.maxImageExtent.height);
-
-	vk->swapchain->nImages = surfaceCapabilities.minImageCount;
-
-	const VkSwapchainCreateInfoKHR createInfo = {
-	    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
-	    NULL,
-	    0,
-	    vk->surface,
-	    vk->swapchain->nImages,
-	    vk->surfaceFormat.format,
-	    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-	    vk->swapchain->extent,
-	    1,
-	    (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
-	    VK_SHARING_MODE_EXCLUSIVE,
-	    COUNTED(0, NULL),
-	    surfaceCapabilities.currentTransform,
-	    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-	    vk->presentMode,
-	    VK_TRUE,
-	    0,
-	};
-
-	if ((vr = vkCreateSwapchainKHR(vk->device,
-	                               &createInfo,
-	                               ALLOC_VK,
-	                               &vk->swapchain->rawSwapchain))) {
-		logError("Could not create swapchain: %d\n", vr);
-		return vr;
-	}
-
-	return VK_SUCCESS;
+  VkSurfaceCapabilitiesKHR surfaceCapabilities;
+  VkResult                 vr = VK_SUCCESS;
+  if ((vr = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+         vk->physicalDevice, vk->surface, &surfaceCapabilities))) {
+    logError("Could not get surface capabilities: %d\n", vr);
+    return vr;
+  }
+
+  /* There is a known race condition with window/surface sizes, so we clamp
+     to what Vulkan reports and hope for the best. */
+
+  vk->swapchain->extent.width = CLAMP(width,
+                                      surfaceCapabilities.minImageExtent.width,
+                                      surfaceCapabilities.maxImageExtent.width);
+
+  vk->swapchain->extent.height =
+    CLAMP(height,
+          surfaceCapabilities.minImageExtent.height,
+          surfaceCapabilities.maxImageExtent.height);
+
+  vk->swapchain->nImages = surfaceCapabilities.minImageCount;
+
+  const VkSwapchainCreateInfoKHR createInfo = {
+    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+    NULL,
+    0,
+    vk->surface,
+    vk->swapchain->nImages,
+    vk->surfaceFormat.format,
+    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    vk->swapchain->extent,
+    1,
+    (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
+    VK_SHARING_MODE_EXCLUSIVE,
+    COUNTED(0, NULL),
+    surfaceCapabilities.currentTransform,
+    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+    vk->presentMode,
+    VK_TRUE,
+    0,
+  };
+
+  if ((vr = vkCreateSwapchainKHR(
+         vk->device, &createInfo, ALLOC_VK, &vk->swapchain->rawSwapchain))) {
+    logError("Could not create swapchain: %d\n", vr);
+    return vr;
+  }
+
+  return VK_SUCCESS;
 }
 
 static VkResult
 recordCommandBuffers(VulkanState* const vk)
 {
-	const VkClearColorValue clearValue = {{
-	    0xA4 / (float)0x100, // R
-	    0x1E / (float)0x100, // G
-	    0x22 / (float)0x100, // B
-	    0xFF / (float)0x100, // A
-	}};
-
-	const VkImageSubresourceRange range = {
-	    VK_IMAGE_ASPECT_COLOR_BIT,
-	    0,
-	    1,
-	    0,
-	    1,
-	};
-
-	const VkCommandBufferBeginInfo beginInfo = {
-	    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-	    NULL,
-	    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
-	    NULL,
-	};
-
-	for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
-		const VkImageMemoryBarrier toClearBarrier = {
-		    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-		    NULL,
-		    VK_ACCESS_MEMORY_READ_BIT,
-		    VK_ACCESS_TRANSFER_WRITE_BIT,
-		    VK_IMAGE_LAYOUT_UNDEFINED,
-		    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-		    vk->graphicsIndex,
-		    vk->graphicsIndex,
-		    vk->swapchain->images[i],
-		    range,
-		};
-
-		const VkImageMemoryBarrier toPresentBarrier = {
-		    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-		    NULL,
-		    VK_ACCESS_TRANSFER_WRITE_BIT,
-		    VK_ACCESS_MEMORY_READ_BIT,
-		    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-		    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-		    vk->graphicsIndex,
-		    vk->graphicsIndex,
-		    vk->swapchain->images[i],
-		    range,
-		};
-
-		vkBeginCommandBuffer(vk->swapchain->commandBuffers[i], &beginInfo);
-
-		vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
-		                     VK_PIPELINE_STAGE_TRANSFER_BIT,
-		                     VK_PIPELINE_STAGE_TRANSFER_BIT,
-		                     0,
-		                     COUNTED(0, NULL),
-		                     COUNTED(0, NULL),
-		                     COUNTED(1, &toClearBarrier));
-
-		vkCmdClearColorImage(vk->swapchain->commandBuffers[i],
-		                     vk->swapchain->images[i],
-		                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-		                     &clearValue,
-		                     COUNTED(1, &range));
-
-		vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
-		                     VK_PIPELINE_STAGE_TRANSFER_BIT,
-		                     VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-		                     0,
-		                     COUNTED(0, NULL),
-		                     COUNTED(0, NULL),
-		                     COUNTED(1, &toPresentBarrier));
-
-		vkEndCommandBuffer(vk->swapchain->commandBuffers[i]);
-	}
-
-	return VK_SUCCESS;
+  const VkClearColorValue clearValue = {{
+    0xA4 / (float)0x100, // R
+    0x1E / (float)0x100, // G
+    0x22 / (float)0x100, // B
+    0xFF / (float)0x100, // A
+  }};
+
+  const VkImageSubresourceRange range = {
+    VK_IMAGE_ASPECT_COLOR_BIT,
+    0,
+    1,
+    0,
+    1,
+  };
+
+  const VkCommandBufferBeginInfo beginInfo = {
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+    NULL,
+    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
+    NULL,
+  };
+
+  for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
+    const VkImageMemoryBarrier toClearBarrier = {
+      VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+      NULL,
+      VK_ACCESS_MEMORY_READ_BIT,
+      VK_ACCESS_TRANSFER_WRITE_BIT,
+      VK_IMAGE_LAYOUT_UNDEFINED,
+      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+      vk->graphicsIndex,
+      vk->graphicsIndex,
+      vk->swapchain->images[i],
+      range,
+    };
+
+    const VkImageMemoryBarrier toPresentBarrier = {
+      VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+      NULL,
+      VK_ACCESS_TRANSFER_WRITE_BIT,
+      VK_ACCESS_MEMORY_READ_BIT,
+      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+      VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+      vk->graphicsIndex,
+      vk->graphicsIndex,
+      vk->swapchain->images[i],
+      range,
+    };
+
+    vkBeginCommandBuffer(vk->swapchain->commandBuffers[i], &beginInfo);
+
+    vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         0,
+                         COUNTED(0, NULL),
+                         COUNTED(0, NULL),
+                         COUNTED(1, &toClearBarrier));
+
+    vkCmdClearColorImage(vk->swapchain->commandBuffers[i],
+                         vk->swapchain->images[i],
+                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                         &clearValue,
+                         COUNTED(1, &range));
+
+    vkCmdPipelineBarrier(vk->swapchain->commandBuffers[i],
+                         VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                         0,
+                         COUNTED(0, NULL),
+                         COUNTED(0, NULL),
+                         COUNTED(1, &toPresentBarrier));
+
+    vkEndCommandBuffer(vk->swapchain->commandBuffers[i]);
+  }
+
+  return VK_SUCCESS;
 }
 
 static VkResult
@@ -733,204 +723,200 @@ createSwapchain(VulkanState* const vk,
                 const uint32_t     width,
                 const uint32_t     height)
 {
-	VkResult vr = VK_SUCCESS;
-
-	vk->swapchain = AALLOC(1, Swapchain);
-	if ((vr = createRawSwapchain(vk, width, height))) {
-		return vr;
-	}
-
-	if ((vr = vkGetSwapchainImagesKHR(vk->device,
-	                                  vk->swapchain->rawSwapchain,
-	                                  &vk->swapchain->nImages,
-	                                  NULL))) {
-		logError("Failed to query swapchain images: %d\n", vr);
-		return vr;
-	}
-
-	vk->swapchain->images = AALLOC(vk->swapchain->nImages, VkImage);
-	if ((vr = vkGetSwapchainImagesKHR(vk->device,
-	                                  vk->swapchain->rawSwapchain,
-	                                  &vk->swapchain->nImages,
-	                                  vk->swapchain->images))) {
-		logError("Failed to get swapchain images: %d\n", vr);
-		return vr;
-	}
-
-	const VkCommandBufferAllocateInfo allocInfo = {
-	    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
-	    NULL,
-	    vk->commandPool,
-	    VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-	    vk->swapchain->nImages,
-	};
-
-	vk->swapchain->commandBuffers = AALLOC(vk->swapchain->nImages,
-	                                       VkCommandBuffer);
-
-	if ((vr = vkAllocateCommandBuffers(vk->device,
-	                                   &allocInfo,
-	                                   vk->swapchain->commandBuffers))) {
-		logError("Could not allocate command buffers: %d\n", vr);
-		return vr;
-	}
-
-	const VkFenceCreateInfo fenceInfo = {
-	    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-	    NULL,
-	    VK_FENCE_CREATE_SIGNALED_BIT,
-	};
-	vk->swapchain->fences = AALLOC(vk->swapchain->nImages, VkFence);
-
-	for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
-		if ((vr = vkCreateFence(vk->device,
-		                        &fenceInfo,
-		                        ALLOC_VK,
-		                        &vk->swapchain->fences[i]))) {
-			logError("Could not create render finished fence: %d\n", vr);
-			return vr;
-		}
-	}
-
-	if ((vr = recordCommandBuffers(vk))) {
-		logError("Failed to record command buffers\n");
-		return vr;
-	}
-
-	return VK_SUCCESS;
+  VkResult vr = VK_SUCCESS;
+
+  vk->swapchain = AALLOC(1, Swapchain);
+  if ((vr = createRawSwapchain(vk, width, height))) {
+    return vr;
+  }
+
+  if ((vr = vkGetSwapchainImagesKHR(vk->device,
+                                    vk->swapchain->rawSwapchain,
+                                    &vk->swapchain->nImages,
+                                    NULL))) {
+    logError("Failed to query swapchain images: %d\n", vr);
+    return vr;
+  }
+
+  vk->swapchain->images = AALLOC(vk->swapchain->nImages, VkImage);
+  if ((vr = vkGetSwapchainImagesKHR(vk->device,
+                                    vk->swapchain->rawSwapchain,
+                                    &vk->swapchain->nImages,
+                                    vk->swapchain->images))) {
+    logError("Failed to get swapchain images: %d\n", vr);
+    return vr;
+  }
+
+  const VkCommandBufferAllocateInfo allocInfo = {
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
+    NULL,
+    vk->commandPool,
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    vk->swapchain->nImages,
+  };
+
+  vk->swapchain->commandBuffers =
+    AALLOC(vk->swapchain->nImages, VkCommandBuffer);
+
+  if ((vr = vkAllocateCommandBuffers(
+         vk->device, &allocInfo, vk->swapchain->commandBuffers))) {
+    logError("Could not allocate command buffers: %d\n", vr);
+    return vr;
+  }
+
+  const VkFenceCreateInfo fenceInfo = {
+    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
+    NULL,
+    VK_FENCE_CREATE_SIGNALED_BIT,
+  };
+  vk->swapchain->fences = AALLOC(vk->swapchain->nImages, VkFence);
+
+  for (uint32_t i = 0; i < vk->swapchain->nImages; ++i) {
+    if ((vr = vkCreateFence(
+           vk->device, &fenceInfo, ALLOC_VK, &vk->swapchain->fences[i]))) {
+      logError("Could not create render finished fence: %d\n", vr);
+      return vr;
+    }
+  }
+
+  if ((vr = recordCommandBuffers(vk))) {
+    logError("Failed to record command buffers\n");
+    return vr;
+  }
+
+  return VK_SUCCESS;
 }
 
 static void
 destroySwapchain(VulkanState* const vk, Swapchain* const swapchain)
 {
-	if (!swapchain) {
-		return;
-	}
-
-	for (uint32_t i = 0; i < swapchain->nImages; ++i) {
-		if (swapchain->fences[i]) {
-			vkDestroyFence(vk->device, swapchain->fences[i], ALLOC_VK);
-		}
-
-		if (swapchain->imageViews && swapchain->imageViews[i]) {
-			vkDestroyImageView(vk->device, swapchain->imageViews[i], ALLOC_VK);
-		}
-	}
-
-	free(swapchain->fences);
-	swapchain->fences = NULL;
-	free(swapchain->imageViews);
-	swapchain->imageViews = NULL;
-
-	if (swapchain->images) {
-		free(swapchain->images);
-		swapchain->images = NULL;
-	}
-
-	if (swapchain->commandBuffers) {
-		vkFreeCommandBuffers(vk->device,
-		                     vk->commandPool,
-		                     swapchain->nImages,
-		                     swapchain->commandBuffers);
-		free(swapchain->commandBuffers);
-	}
-
-	if (swapchain->rawSwapchain) {
-		vkDestroySwapchainKHR(vk->device, swapchain->rawSwapchain, ALLOC_VK);
-	}
-
-	free(swapchain);
+  if (!swapchain) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < swapchain->nImages; ++i) {
+    if (swapchain->fences[i]) {
+      vkDestroyFence(vk->device, swapchain->fences[i], ALLOC_VK);
+    }
+
+    if (swapchain->imageViews && swapchain->imageViews[i]) {
+      vkDestroyImageView(vk->device, swapchain->imageViews[i], ALLOC_VK);
+    }
+  }
+
+  free(swapchain->fences);
+  swapchain->fences = NULL;
+  free(swapchain->imageViews);
+  swapchain->imageViews = NULL;
+
+  if (swapchain->images) {
+    free(swapchain->images);
+    swapchain->images = NULL;
+  }
+
+  if (swapchain->commandBuffers) {
+    vkFreeCommandBuffers(vk->device,
+                         vk->commandPool,
+                         swapchain->nImages,
+                         swapchain->commandBuffers);
+    free(swapchain->commandBuffers);
+  }
+
+  if (swapchain->rawSwapchain) {
+    vkDestroySwapchainKHR(vk->device, swapchain->rawSwapchain, ALLOC_VK);
+  }
+
+  free(swapchain);
 }
 
 static VkResult
 createSyncObjects(VulkanState* const vk)
 {
-	const VkSemaphoreCreateInfo info = {
-	    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-	    NULL,
-	    0,
-	};
-
-	vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.presentComplete);
-	vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.renderFinished);
-	return VK_SUCCESS;
+  const VkSemaphoreCreateInfo info = {
+    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
+    NULL,
+    0,
+  };
+
+  vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.presentComplete);
+  vkCreateSemaphore(vk->device, &info, ALLOC_VK, &vk->sync.renderFinished);
+  return VK_SUCCESS;
 }
 
 static void
 destroySyncObjects(VulkanState* const vk)
 {
-	if (vk->sync.renderFinished) {
-		vkDestroySemaphore(vk->device, vk->sync.renderFinished, ALLOC_VK);
-		vk->sync.renderFinished = VK_NULL_HANDLE;
-	}
-	if (vk->sync.presentComplete) {
-		vkDestroySemaphore(vk->device, vk->sync.presentComplete, ALLOC_VK);
-		vk->sync.presentComplete = VK_NULL_HANDLE;
-	}
+  if (vk->sync.renderFinished) {
+    vkDestroySemaphore(vk->device, vk->sync.renderFinished, ALLOC_VK);
+    vk->sync.renderFinished = VK_NULL_HANDLE;
+  }
+  if (vk->sync.presentComplete) {
+    vkDestroySemaphore(vk->device, vk->sync.presentComplete, ALLOC_VK);
+    vk->sync.presentComplete = VK_NULL_HANDLE;
+  }
 }
 
 static void
 closeDevice(VulkanState* const vk)
 {
-	if (vk->device) {
-		vkDeviceWaitIdle(vk->device);
-		destroySyncObjects(vk);
-		destroySwapchain(vk, vk->swapchain);
-		if (vk->commandPool) {
-			vkDestroyCommandPool(vk->device, vk->commandPool, ALLOC_VK);
-			vk->commandPool = VK_NULL_HANDLE;
-		}
-		vk->graphicsQueue = VK_NULL_HANDLE;
-		vkDestroyDevice(vk->device, ALLOC_VK);
-		vk->device = VK_NULL_HANDLE;
-	}
+  if (vk->device) {
+    vkDeviceWaitIdle(vk->device);
+    destroySyncObjects(vk);
+    destroySwapchain(vk, vk->swapchain);
+    if (vk->commandPool) {
+      vkDestroyCommandPool(vk->device, vk->commandPool, ALLOC_VK);
+      vk->commandPool = VK_NULL_HANDLE;
+    }
+    vk->graphicsQueue = VK_NULL_HANDLE;
+    vkDestroyDevice(vk->device, ALLOC_VK);
+    vk->device = VK_NULL_HANDLE;
+  }
 }
 
 static void
 destroyWorld(VulkanApp* const app)
 {
-	VulkanState* vk = &app->vk;
-
-	if (vk) {
-		closeDevice(vk);
-
-		if (app->view) {
-			puglHide(app->view);
-			puglFreeView(app->view);
-			app->view = NULL;
-		}
-		if (vk->debugCallback && vk->api.vkDestroyDebugReportCallbackEXT) {
-			vk->api.vkDestroyDebugReportCallbackEXT(vk->instance,
-			                                        vk->debugCallback,
-			                                        ALLOC_VK);
-			vk->debugCallback = VK_NULL_HANDLE;
-		}
-		if (vk->surface) {
-			vkDestroySurfaceKHR(vk->instance, vk->surface, ALLOC_VK);
-			vk->surface = VK_NULL_HANDLE;
-		}
-		if (vk->instance) {
-			fflush(stderr);
-			vkDestroyInstance(vk->instance, ALLOC_VK);
-			vk->instance = VK_NULL_HANDLE;
-		}
-		if (app->world) {
-			puglFreeWorld(app->world);
-			app->world = NULL;
-		}
-	}
+  VulkanState* vk = &app->vk;
+
+  if (vk) {
+    closeDevice(vk);
+
+    if (app->view) {
+      puglHide(app->view);
+      puglFreeView(app->view);
+      app->view = NULL;
+    }
+    if (vk->debugCallback && vk->api.vkDestroyDebugReportCallbackEXT) {
+      vk->api.vkDestroyDebugReportCallbackEXT(
+        vk->instance, vk->debugCallback, ALLOC_VK);
+      vk->debugCallback = VK_NULL_HANDLE;
+    }
+    if (vk->surface) {
+      vkDestroySurfaceKHR(vk->instance, vk->surface, ALLOC_VK);
+      vk->surface = VK_NULL_HANDLE;
+    }
+    if (vk->instance) {
+      fflush(stderr);
+      vkDestroyInstance(vk->instance, ALLOC_VK);
+      vk->instance = VK_NULL_HANDLE;
+    }
+    if (app->world) {
+      puglFreeWorld(app->world);
+      app->world = NULL;
+    }
+  }
 }
 
 static PuglStatus
 onConfigure(PuglView* const view, const double width, const double height)
 {
-	VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
+  VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
 
-	// We just record the size here and lazily resize the surface when exposed
-	app->width  = (uint32_t)width;
-	app->height = (uint32_t)height;
+  // We just record the size here and lazily resize the surface when exposed
+  app->width  = (uint32_t)width;
+  app->height = (uint32_t)height;
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
@@ -938,202 +924,204 @@ recreateSwapchain(VulkanState* const vk,
                   const uint32_t     width,
                   const uint32_t     height)
 {
-	vkDeviceWaitIdle(vk->device);
-	destroySwapchain(vk, vk->swapchain);
+  vkDeviceWaitIdle(vk->device);
+  destroySwapchain(vk, vk->swapchain);
 
-	if (createSwapchain(vk, width, height)) {
-		logError("Failed to recreate swapchain\n");
-		return PUGL_UNKNOWN_ERROR;
-	}
+  if (createSwapchain(vk, width, height)) {
+    logError("Failed to recreate swapchain\n");
+    return PUGL_UNKNOWN_ERROR;
+  }
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
 onExpose(PuglView* const view)
 {
-	VulkanApp*   app        = (VulkanApp*)puglGetHandle(view);
-	VulkanState* vk         = &app->vk;
-	uint32_t     imageIndex = 0;
-	VkResult     result     = VK_SUCCESS;
-
-	// Recreate swapchain if the window size has changed
-	const Swapchain* swapchain = vk->swapchain;
-	if (swapchain->extent.width != app->width ||
-	    swapchain->extent.height != app->height) {
-		recreateSwapchain(vk, app->width, app->height);
-	}
-
-	// Acquire the next image to render, rebuilding if necessary
-	while ((result = vkAcquireNextImageKHR(vk->device,
-	                                       vk->swapchain->rawSwapchain,
-	                                       UINT64_MAX,
-	                                       vk->sync.presentComplete,
-	                                       VK_NULL_HANDLE,
-	                                       &imageIndex))) {
-		switch (result) {
-		case VK_SUCCESS:
-			break;
-		case VK_SUBOPTIMAL_KHR:
-		case VK_ERROR_OUT_OF_DATE_KHR:
-			recreateSwapchain(vk, app->width, app->height);
-			continue;
-		default:
-			logError("Could not acquire swapchain image: %d\n", result);
-			return PUGL_UNKNOWN_ERROR;
-		}
-	}
-
-	// Wait until we can start rendering this frame
-	vkWaitForFences(vk->device,
-	                COUNTED(1, &vk->swapchain->fences[imageIndex]),
-	                VK_TRUE,
-	                UINT64_MAX);
-	vkResetFences(vk->device, 1, &vk->swapchain->fences[imageIndex]);
-
-	const VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-
-	// Submit command buffer to render this frame
-	const VkSubmitInfo submitInfo = {
-	    VK_STRUCTURE_TYPE_SUBMIT_INFO,
-	    NULL,
-	    COUNTED(1, &vk->sync.presentComplete),
-	    &waitStage,
-	    COUNTED(1, &vk->swapchain->commandBuffers[imageIndex]),
-	    COUNTED(1, &vk->sync.renderFinished)};
-	if ((result = vkQueueSubmit(vk->graphicsQueue,
-	                            1,
-	                            &submitInfo,
-	                            vk->swapchain->fences[imageIndex]))) {
-		logError("Could not submit to queue: %d\n", result);
-		return PUGL_FAILURE;
-	}
-
-	// Present this frame
-	const VkPresentInfoKHR presentInfo = {
-	    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-	    NULL,
-	    COUNTED(1, &vk->sync.renderFinished),
-	    COUNTED(1, &vk->swapchain->rawSwapchain, &imageIndex, NULL),
-	};
-	if ((result = vkQueuePresentKHR(vk->graphicsQueue, &presentInfo))) {
-		logError("Could not present image: %d\n", result);
-	}
-
-	if (app->opts.continuous) {
-		++app->framesDrawn;
-	}
-
-	return PUGL_SUCCESS;
+  VulkanApp*   app        = (VulkanApp*)puglGetHandle(view);
+  VulkanState* vk         = &app->vk;
+  uint32_t     imageIndex = 0;
+  VkResult     result     = VK_SUCCESS;
+
+  // Recreate swapchain if the window size has changed
+  const Swapchain* swapchain = vk->swapchain;
+  if (swapchain->extent.width != app->width ||
+      swapchain->extent.height != app->height) {
+    recreateSwapchain(vk, app->width, app->height);
+  }
+
+  // Acquire the next image to render, rebuilding if necessary
+  while ((result = vkAcquireNextImageKHR(vk->device,
+                                         vk->swapchain->rawSwapchain,
+                                         UINT64_MAX,
+                                         vk->sync.presentComplete,
+                                         VK_NULL_HANDLE,
+                                         &imageIndex))) {
+    switch (result) {
+    case VK_SUCCESS:
+      break;
+    case VK_SUBOPTIMAL_KHR:
+    case VK_ERROR_OUT_OF_DATE_KHR:
+      recreateSwapchain(vk, app->width, app->height);
+      continue;
+    default:
+      logError("Could not acquire swapchain image: %d\n", result);
+      return PUGL_UNKNOWN_ERROR;
+    }
+  }
+
+  // Wait until we can start rendering this frame
+  vkWaitForFences(vk->device,
+                  COUNTED(1, &vk->swapchain->fences[imageIndex]),
+                  VK_TRUE,
+                  UINT64_MAX);
+  vkResetFences(vk->device, 1, &vk->swapchain->fences[imageIndex]);
+
+  const VkPipelineStageFlags waitStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
+
+  // Submit command buffer to render this frame
+  const VkSubmitInfo submitInfo = {
+    VK_STRUCTURE_TYPE_SUBMIT_INFO,
+    NULL,
+    COUNTED(1, &vk->sync.presentComplete),
+    &waitStage,
+    COUNTED(1, &vk->swapchain->commandBuffers[imageIndex]),
+    COUNTED(1, &vk->sync.renderFinished)};
+  if ((result = vkQueueSubmit(vk->graphicsQueue,
+                              1,
+                              &submitInfo,
+                              vk->swapchain->fences[imageIndex]))) {
+    logError("Could not submit to queue: %d\n", result);
+    return PUGL_FAILURE;
+  }
+
+  // Present this frame
+  const VkPresentInfoKHR presentInfo = {
+    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
+    NULL,
+    COUNTED(1, &vk->sync.renderFinished),
+    COUNTED(1, &vk->swapchain->rawSwapchain, &imageIndex, NULL),
+  };
+  if ((result = vkQueuePresentKHR(vk->graphicsQueue, &presentInfo))) {
+    logError("Could not present image: %d\n", result);
+  }
+
+  if (app->opts.continuous) {
+    ++app->framesDrawn;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 static PuglStatus
 onEvent(PuglView* const view, const PuglEvent* const e)
 {
-	VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
-
-	printEvent(e, "Event: ", app->opts.verbose);
-
-	switch (e->type) {
-	case PUGL_EXPOSE:
-		return onExpose(view);
-	case PUGL_CONFIGURE:
-		return onConfigure(view, e->configure.width, e->configure.height);
-	case PUGL_CLOSE:
-		app->quit = 1;
-		break;
-	case PUGL_KEY_PRESS:
-		switch (e->key.key) {
-		case PUGL_KEY_ESCAPE:
-		case 'q':
-			app->quit = 1;
-			break;
-		}
-		break;
-	default:
-		break;
-	}
-	return PUGL_SUCCESS;
+  VulkanApp* const app = (VulkanApp*)puglGetHandle(view);
+
+  printEvent(e, "Event: ", app->opts.verbose);
+
+  switch (e->type) {
+  case PUGL_EXPOSE:
+    return onExpose(view);
+  case PUGL_CONFIGURE:
+    return onConfigure(view, e->configure.width, e->configure.height);
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  case PUGL_KEY_PRESS:
+    switch (e->key.key) {
+    case PUGL_KEY_ESCAPE:
+    case 'q':
+      app->quit = 1;
+      break;
+    }
+    break;
+  default:
+    break;
+  }
+  return PUGL_SUCCESS;
 }
 
 int
 main(int argc, char** argv)
 {
-	VulkanApp      app           = {0};
-	VulkanState*   vk            = &app.vk;
-	const uint32_t defaultWidth  = 640;
-	const uint32_t defaultHeight = 360;
-	const PuglRect frame         = {0, 0, defaultWidth, defaultHeight};
-
-	// Parse command line options
-	app.opts = puglParseTestOptions(&argc, &argv);
-	if (app.opts.help) {
-		puglPrintTestUsage(argv[0], "");
-		return 0;
-	}
-
-	// Create world and view
-	if (!(app.world = puglNewWorld(PUGL_PROGRAM, PUGL_WORLD_THREADS))) {
-		return logError("Failed to create world\n");
-	} else if (!(app.view = puglNewView(app.world))) {
-		puglFreeWorld(app.world);
-		return logError("Failed to create Pugl World and View\n");
-	}
-
-	// Create Vulkan instance
-	if (createInstance(&app)) {
-		puglFreeWorld(app.world);
-		return logError("Failed to create instance\n");
-	}
-
-	// Create window
-	puglSetWindowTitle(app.view, "Pugl Vulkan");
-	puglSetFrame(app.view, frame);
-	puglSetHandle(app.view, &app);
-	puglSetBackend(app.view, puglVulkanBackend());
-	puglSetViewHint(app.view, PUGL_RESIZABLE, app.opts.resizable);
-	puglSetEventFunc(app.view, onEvent);
-	const PuglStatus st = puglRealize(app.view);
-	if (st) {
-		puglFreeWorld(app.world);
-		puglFreeView(app.view);
-		return logError("Failed to create window (%s)\n", puglStrerror(st));
-	}
-
-	// Create Vulkan surface for Window
-	PuglVulkanLoader* loader = puglNewVulkanLoader(app.world);
-	if (puglCreateSurface(puglGetInstanceProcAddrFunc(loader),
-	                      app.view,
-	                      vk->instance,
-	                      ALLOC_VK,
-	                      &vk->surface)) {
-		return logError("Failed to create surface\n");
-	}
-
-	// Set up Vulkan
-	VkResult vr = VK_SUCCESS;
-	if ((vr = enableDebugging(vk)) ||                              //
-	    (vr = selectPhysicalDevice(vk)) ||                         //
-	    (vr = openDevice(vk)) ||                                   //
-	    (vr = configureSurface(vk)) ||                             //
-	    (vr = createSwapchain(vk, defaultWidth, defaultHeight)) || //
-	    (vr = createSyncObjects(vk))) {
-		destroyWorld(&app);
-		return logError("Failed to set up graphics (%d)\n", vr);
-	}
-
-	printf("Swapchain images:            %u\n", app.vk.swapchain->nImages);
-
-	PuglFpsPrinter fpsPrinter = {puglGetTime(app.world)};
-	puglShow(app.view);
-	while (!app.quit) {
-		puglUpdate(app.world, -1.0);
-
-		if (app.opts.continuous) {
-			puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
-		}
-	}
-
-	destroyWorld(&app);
-	return 0;
+  VulkanApp      app           = {0};
+  VulkanState*   vk            = &app.vk;
+  const uint32_t defaultWidth  = 640;
+  const uint32_t defaultHeight = 360;
+  const PuglRect frame         = {0, 0, defaultWidth, defaultHeight};
+
+  // Parse command line options
+  app.opts = puglParseTestOptions(&argc, &argv);
+  if (app.opts.help) {
+    puglPrintTestUsage(argv[0], "");
+    return 0;
+  }
+
+  // Create world and view
+  if (!(app.world = puglNewWorld(PUGL_PROGRAM, PUGL_WORLD_THREADS))) {
+    return logError("Failed to create world\n");
+  }
+
+  if (!(app.view = puglNewView(app.world))) {
+    puglFreeWorld(app.world);
+    return logError("Failed to create Pugl World and View\n");
+  }
+
+  // Create Vulkan instance
+  if (createInstance(&app)) {
+    puglFreeWorld(app.world);
+    return logError("Failed to create instance\n");
+  }
+
+  // Create window
+  puglSetWindowTitle(app.view, "Pugl Vulkan");
+  puglSetFrame(app.view, frame);
+  puglSetHandle(app.view, &app);
+  puglSetBackend(app.view, puglVulkanBackend());
+  puglSetViewHint(app.view, PUGL_RESIZABLE, app.opts.resizable);
+  puglSetEventFunc(app.view, onEvent);
+  const PuglStatus st = puglRealize(app.view);
+  if (st) {
+    puglFreeWorld(app.world);
+    puglFreeView(app.view);
+    return logError("Failed to create window (%s)\n", puglStrerror(st));
+  }
+
+  // Create Vulkan surface for Window
+  PuglVulkanLoader* loader = puglNewVulkanLoader(app.world);
+  if (puglCreateSurface(puglGetInstanceProcAddrFunc(loader),
+                        app.view,
+                        vk->instance,
+                        ALLOC_VK,
+                        &vk->surface)) {
+    return logError("Failed to create surface\n");
+  }
+
+  // Set up Vulkan
+  VkResult vr = VK_SUCCESS;
+  if ((vr = enableDebugging(vk)) ||                              //
+      (vr = selectPhysicalDevice(vk)) ||                         //
+      (vr = openDevice(vk)) ||                                   //
+      (vr = configureSurface(vk)) ||                             //
+      (vr = createSwapchain(vk, defaultWidth, defaultHeight)) || //
+      (vr = createSyncObjects(vk))) {
+    destroyWorld(&app);
+    return logError("Failed to set up graphics (%d)\n", vr);
+  }
+
+  printf("Swapchain images:            %u\n", app.vk.swapchain->nImages);
+
+  PuglFpsPrinter fpsPrinter = {puglGetTime(app.world)};
+  puglShow(app.view);
+  while (!app.quit) {
+    puglUpdate(app.world, -1.0);
+
+    if (app.opts.continuous) {
+      puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
+    }
+  }
+
+  destroyWorld(&app);
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/pugl_window_demo.c b/subprojects/nk_pugl/pugl/examples/pugl_window_demo.c
index 3dfc39a..be320dd 100644
--- a/subprojects/nk_pugl/pugl/examples/pugl_window_demo.c
+++ b/subprojects/nk_pugl/pugl/examples/pugl_window_demo.c
@@ -30,22 +30,22 @@
 #include <string.h>
 
 typedef struct {
-	PuglView* view;
-	double    xAngle;
-	double    yAngle;
-	double    lastMouseX;
-	double    lastMouseY;
-	double    lastDrawTime;
-	float     dist;
-	bool      entered;
+  PuglView* view;
+  double    xAngle;
+  double    yAngle;
+  double    lastMouseX;
+  double    lastMouseY;
+  double    lastDrawTime;
+  float     dist;
+  bool      entered;
 } CubeView;
 
 typedef struct {
-	PuglWorld* world;
-	CubeView   cubes[2];
-	int        quit;
-	bool       continuous;
-	bool       verbose;
+  PuglWorld* world;
+  CubeView   cubes[2];
+  int        quit;
+  bool       continuous;
+  bool       verbose;
 } PuglTestApp;
 
 static const double pad = 64.0;
@@ -53,207 +53,201 @@ static const double pad = 64.0;
 static void
 onDisplay(PuglView* view)
 {
-	PuglWorld*   world = puglGetWorld(view);
-	PuglTestApp* app   = (PuglTestApp*)puglGetWorldHandle(world);
-	CubeView*    cube  = (CubeView*)puglGetHandle(view);
+  PuglWorld*   world = puglGetWorld(view);
+  PuglTestApp* app   = (PuglTestApp*)puglGetWorldHandle(world);
+  CubeView*    cube  = (CubeView*)puglGetHandle(view);
 
-	const double thisTime = puglGetTime(app->world);
-	if (app->continuous) {
-		const double dTime = thisTime - cube->lastDrawTime;
+  const double thisTime = puglGetTime(app->world);
+  if (app->continuous) {
+    const double dTime = thisTime - cube->lastDrawTime;
 
-		cube->xAngle = fmod(cube->xAngle + dTime * 100.0, 360.0);
-		cube->yAngle = fmod(cube->yAngle + dTime * 100.0, 360.0);
-	}
+    cube->xAngle = fmod(cube->xAngle + dTime * 100.0, 360.0);
+    cube->yAngle = fmod(cube->yAngle + dTime * 100.0, 360.0);
+  }
 
-	displayCube(view,
-	            cube->dist,
-	            (float)cube->xAngle,
-	            (float)cube->yAngle,
-	            cube->entered);
+  displayCube(
+    view, cube->dist, (float)cube->xAngle, (float)cube->yAngle, cube->entered);
 
-	cube->lastDrawTime = thisTime;
+  cube->lastDrawTime = thisTime;
 }
 
 static void
 onKeyPress(PuglView* view, const PuglEventKey* event)
 {
-	PuglWorld*   world = puglGetWorld(view);
-	PuglTestApp* app   = (PuglTestApp*)puglGetWorldHandle(world);
-	PuglRect     frame = puglGetFrame(view);
-
-	if (event->key == 'q' || event->key == PUGL_KEY_ESCAPE) {
-		app->quit = 1;
-	} else if (event->state & PUGL_MOD_SHIFT) {
-		if (event->key == PUGL_KEY_UP) {
-			frame.height += 10;
-		} else if (event->key == PUGL_KEY_DOWN) {
-			frame.height -= 10;
-		} else if (event->key == PUGL_KEY_LEFT) {
-			frame.width -= 10;
-		} else if (event->key == PUGL_KEY_RIGHT) {
-			frame.width += 10;
-		} else {
-			return;
-		}
-		puglSetFrame(view, frame);
-	} else {
-		if (event->key == PUGL_KEY_UP) {
-			frame.y -= 10;
-		} else if (event->key == PUGL_KEY_DOWN) {
-			frame.y += 10;
-		} else if (event->key == PUGL_KEY_LEFT) {
-			frame.x -= 10;
-		} else if (event->key == PUGL_KEY_RIGHT) {
-			frame.x += 10;
-		} else {
-			return;
-		}
-		puglSetFrame(view, frame);
-	}
+  PuglWorld*   world = puglGetWorld(view);
+  PuglTestApp* app   = (PuglTestApp*)puglGetWorldHandle(world);
+  PuglRect     frame = puglGetFrame(view);
+
+  if (event->key == 'q' || event->key == PUGL_KEY_ESCAPE) {
+    app->quit = 1;
+  } else if (event->state & PUGL_MOD_SHIFT) {
+    if (event->key == PUGL_KEY_UP) {
+      frame.height += 10;
+    } else if (event->key == PUGL_KEY_DOWN) {
+      frame.height -= 10;
+    } else if (event->key == PUGL_KEY_LEFT) {
+      frame.width -= 10;
+    } else if (event->key == PUGL_KEY_RIGHT) {
+      frame.width += 10;
+    } else {
+      return;
+    }
+    puglSetFrame(view, frame);
+  } else {
+    if (event->key == PUGL_KEY_UP) {
+      frame.y -= 10;
+    } else if (event->key == PUGL_KEY_DOWN) {
+      frame.y += 10;
+    } else if (event->key == PUGL_KEY_LEFT) {
+      frame.x -= 10;
+    } else if (event->key == PUGL_KEY_RIGHT) {
+      frame.x += 10;
+    } else {
+      return;
+    }
+    puglSetFrame(view, frame);
+  }
 }
 
 static void
 redisplayView(PuglTestApp* app, PuglView* view)
 {
-	if (!app->continuous) {
-		puglPostRedisplay(view);
-	}
+  if (!app->continuous) {
+    puglPostRedisplay(view);
+  }
 }
 
 static PuglStatus
 onEvent(PuglView* view, const PuglEvent* event)
 {
-	PuglWorld*   world = puglGetWorld(view);
-	PuglTestApp* app   = (PuglTestApp*)puglGetWorldHandle(world);
-	CubeView*    cube  = (CubeView*)puglGetHandle(view);
-
-	const char* const prefix = cube == &app->cubes[0] ? "View 1: " : "View 2: ";
-	printEvent(event, prefix, app->verbose);
-
-	switch (event->type) {
-	case PUGL_CONFIGURE:
-		reshapeCube((float)event->configure.width,
-		            (float)event->configure.height);
-		break;
-	case PUGL_UPDATE:
-		if (app->continuous) {
-			puglPostRedisplay(view);
-		}
-		break;
-	case PUGL_EXPOSE:
-		onDisplay(view);
-		break;
-	case PUGL_CLOSE:
-		app->quit = 1;
-		break;
-	case PUGL_KEY_PRESS:
-		onKeyPress(view, &event->key);
-		break;
-	case PUGL_MOTION:
-		cube->xAngle -= event->motion.x - cube->lastMouseX;
-		cube->yAngle += event->motion.y - cube->lastMouseY;
-		cube->lastMouseX = event->motion.x;
-		cube->lastMouseY = event->motion.y;
-		redisplayView(app, view);
-		break;
-	case PUGL_SCROLL:
-		cube->dist = fmaxf(10.0f, cube->dist + (float)event->scroll.dy);
-		redisplayView(app, view);
-		break;
-	case PUGL_POINTER_IN:
-		cube->entered = true;
-		redisplayView(app, view);
-		break;
-	case PUGL_POINTER_OUT:
-		cube->entered = false;
-		redisplayView(app, view);
-		break;
-	case PUGL_FOCUS_IN:
-	case PUGL_FOCUS_OUT:
-		redisplayView(app, view);
-		break;
-	default:
-		break;
-	}
-
-	return PUGL_SUCCESS;
+  PuglWorld*   world = puglGetWorld(view);
+  PuglTestApp* app   = (PuglTestApp*)puglGetWorldHandle(world);
+  CubeView*    cube  = (CubeView*)puglGetHandle(view);
+
+  const char* const prefix = cube == &app->cubes[0] ? "View 1: " : "View 2: ";
+  printEvent(event, prefix, app->verbose);
+
+  switch (event->type) {
+  case PUGL_CONFIGURE:
+    reshapeCube((float)event->configure.width, (float)event->configure.height);
+    break;
+  case PUGL_UPDATE:
+    if (app->continuous) {
+      puglPostRedisplay(view);
+    }
+    break;
+  case PUGL_EXPOSE:
+    onDisplay(view);
+    break;
+  case PUGL_CLOSE:
+    app->quit = 1;
+    break;
+  case PUGL_KEY_PRESS:
+    onKeyPress(view, &event->key);
+    break;
+  case PUGL_MOTION:
+    cube->xAngle -= event->motion.x - cube->lastMouseX;
+    cube->yAngle += event->motion.y - cube->lastMouseY;
+    cube->lastMouseX = event->motion.x;
+    cube->lastMouseY = event->motion.y;
+    redisplayView(app, view);
+    break;
+  case PUGL_SCROLL:
+    cube->dist = fmaxf(10.0f, cube->dist + (float)event->scroll.dy);
+    redisplayView(app, view);
+    break;
+  case PUGL_POINTER_IN:
+    cube->entered = true;
+    redisplayView(app, view);
+    break;
+  case PUGL_POINTER_OUT:
+    cube->entered = false;
+    redisplayView(app, view);
+    break;
+  case PUGL_FOCUS_IN:
+  case PUGL_FOCUS_OUT:
+    redisplayView(app, view);
+    break;
+  default:
+    break;
+  }
+
+  return PUGL_SUCCESS;
 }
 
 int
 main(int argc, char** argv)
 {
-	PuglTestApp app = {0};
-
-	const PuglTestOptions opts = puglParseTestOptions(&argc, &argv);
-	if (opts.help) {
-		puglPrintTestUsage(argv[0], "");
-		return 1;
-	}
-
-	app.continuous = opts.continuous;
-	app.verbose    = opts.verbose;
-
-	app.world         = puglNewWorld(PUGL_PROGRAM, 0);
-	app.cubes[0].view = puglNewView(app.world);
-	app.cubes[1].view = puglNewView(app.world);
-
-	puglSetWorldHandle(app.world, &app);
-	puglSetClassName(app.world, "Pugl Test");
-
-	PuglStatus st = PUGL_SUCCESS;
-	for (unsigned i = 0; i < 2; ++i) {
-		CubeView*      cube  = &app.cubes[i];
-		PuglView*      view  = cube->view;
-		const PuglRect frame = {pad + (128.0 + pad) * i,
-		                        pad + (128.0 + pad) * i,
-		                        512.0,
-		                        512.0};
-
-		cube->dist = 10;
-
-		puglSetWindowTitle(view, "Pugl Window Demo");
-		puglSetFrame(view, frame);
-		puglSetDefaultSize(view, 512, 512);
-		puglSetMinSize(view, 128, 128);
-		puglSetBackend(view, puglGlBackend());
-
-		puglSetViewHint(view, PUGL_USE_DEBUG_CONTEXT, opts.errorChecking);
-		puglSetViewHint(view, PUGL_RESIZABLE, opts.resizable);
-		puglSetViewHint(view, PUGL_SAMPLES, opts.samples);
-		puglSetViewHint(view, PUGL_DOUBLE_BUFFER, opts.doubleBuffer);
-		puglSetViewHint(view, PUGL_SWAP_INTERVAL, opts.sync);
-		puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, opts.ignoreKeyRepeat);
-		puglSetHandle(view, cube);
-		puglSetEventFunc(view, onEvent);
-
-		if (i == 1) {
-			puglSetTransientFor(app.cubes[1].view,
-			                    puglGetNativeWindow(app.cubes[0].view));
-		}
-
-		if ((st = puglRealize(view))) {
-			return logError("Failed to create window (%s)\n", puglStrerror(st));
-		}
-
-		puglShow(view);
-	}
-
-	PuglFpsPrinter fpsPrinter  = {puglGetTime(app.world)};
-	unsigned       framesDrawn = 0;
-	while (!app.quit) {
-		puglUpdate(app.world, app.continuous ? 0.0 : -1.0);
-		++framesDrawn;
-
-		if (app.continuous) {
-			puglPrintFps(app.world, &fpsPrinter, &framesDrawn);
-		}
-	}
-
-	for (size_t i = 0; i < 2; ++i) {
-		puglFreeView(app.cubes[i].view);
-	}
-
-	puglFreeWorld(app.world);
-
-	return 0;
+  PuglTestApp app = {0};
+
+  const PuglTestOptions opts = puglParseTestOptions(&argc, &argv);
+  if (opts.help) {
+    puglPrintTestUsage(argv[0], "");
+    return 1;
+  }
+
+  app.continuous = opts.continuous;
+  app.verbose    = opts.verbose;
+
+  app.world         = puglNewWorld(PUGL_PROGRAM, 0);
+  app.cubes[0].view = puglNewView(app.world);
+  app.cubes[1].view = puglNewView(app.world);
+
+  puglSetWorldHandle(app.world, &app);
+  puglSetClassName(app.world, "Pugl Test");
+
+  PuglStatus st = PUGL_SUCCESS;
+  for (unsigned i = 0; i < 2; ++i) {
+    CubeView*      cube  = &app.cubes[i];
+    PuglView*      view  = cube->view;
+    const PuglRect frame = {
+      pad + (128.0 + pad) * i, pad + (128.0 + pad) * i, 512.0, 512.0};
+
+    cube->dist = 10;
+
+    puglSetWindowTitle(view, "Pugl Window Demo");
+    puglSetFrame(view, frame);
+    puglSetDefaultSize(view, 512, 512);
+    puglSetMinSize(view, 128, 128);
+    puglSetBackend(view, puglGlBackend());
+
+    puglSetViewHint(view, PUGL_USE_DEBUG_CONTEXT, opts.errorChecking);
+    puglSetViewHint(view, PUGL_RESIZABLE, opts.resizable);
+    puglSetViewHint(view, PUGL_SAMPLES, opts.samples);
+    puglSetViewHint(view, PUGL_DOUBLE_BUFFER, opts.doubleBuffer);
+    puglSetViewHint(view, PUGL_SWAP_INTERVAL, opts.sync);
+    puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, opts.ignoreKeyRepeat);
+    puglSetHandle(view, cube);
+    puglSetEventFunc(view, onEvent);
+
+    if (i == 1) {
+      puglSetTransientFor(app.cubes[1].view,
+                          puglGetNativeWindow(app.cubes[0].view));
+    }
+
+    if ((st = puglRealize(view))) {
+      return logError("Failed to create window (%s)\n", puglStrerror(st));
+    }
+
+    puglShow(view);
+  }
+
+  PuglFpsPrinter fpsPrinter  = {puglGetTime(app.world)};
+  unsigned       framesDrawn = 0;
+  while (!app.quit) {
+    puglUpdate(app.world, app.continuous ? 0.0 : -1.0);
+    ++framesDrawn;
+
+    if (app.continuous) {
+      puglPrintFps(app.world, &fpsPrinter, &framesDrawn);
+    }
+  }
+
+  for (size_t i = 0; i < 2; ++i) {
+    puglFreeView(app.cubes[i].view);
+  }
+
+  puglFreeWorld(app.world);
+
+  return 0;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/rects.h b/subprojects/nk_pugl/pugl/examples/rects.h
index 3537a5b..b99d9f0 100644
--- a/subprojects/nk_pugl/pugl/examples/rects.h
+++ b/subprojects/nk_pugl/pugl/examples/rects.h
@@ -23,16 +23,16 @@
 typedef float vec2[2];
 
 typedef struct {
-	float pos[2];
-	float size[2];
-	float fillColor[4];
+  float pos[2];
+  float size[2];
+  float fillColor[4];
 } Rect;
 
 static const vec2 rectVertices[] = {
-    {0.0f, 0.0f}, // TL
-    {1.0f, 0.0f}, // TR
-    {0.0f, 1.0f}, // BL
-    {1.0f, 1.0f}  // BR
+  {0.0f, 0.0f}, // TL
+  {1.0f, 0.0f}, // TR
+  {0.0f, 1.0f}, // BL
+  {1.0f, 1.0f}  // BR
 };
 
 static const unsigned rectIndices[4] = {0, 1, 2, 3};
@@ -41,19 +41,19 @@ static const unsigned rectIndices[4] = {0, 1, 2, 3};
 static inline Rect
 makeRect(const size_t index, const float frameWidth)
 {
-	static const float alpha   = 0.3f;
-	const float        minSize = frameWidth / 64.0f;
-	const float        maxSize = frameWidth / 6.0f;
-	const float        s       = (sinf((float)index) / 2.0f + 0.5f);
-	const float        c       = (cosf((float)index) / 2.0f + 0.5f);
+  static const float alpha   = 0.3f;
+  const float        minSize = frameWidth / 64.0f;
+  const float        maxSize = frameWidth / 6.0f;
+  const float        s       = (sinf((float)index) / 2.0f + 0.5f);
+  const float        c       = (cosf((float)index) / 2.0f + 0.5f);
 
-	const Rect rect = {
-	    {0.0f, 0.0f}, // Position is set later during expose
-	    {minSize + s * maxSize, minSize + c * maxSize},
-	    {0.0f, s / 2.0f + 0.25f, c / 2.0f + 0.25f, alpha},
-	};
+  const Rect rect = {
+    {0.0f, 0.0f}, // Position is set later during expose
+    {minSize + s * maxSize, minSize + c * maxSize},
+    {0.0f, s / 2.0f + 0.25f, c / 2.0f + 0.25f, alpha},
+  };
 
-	return rect;
+  return rect;
 }
 
 /// Move `rect` with the given index around in an arbitrary way that looks cool
@@ -65,15 +65,15 @@ moveRect(Rect* const  rect,
          const float  frameHeight,
          const double time)
 {
-	const float normal    = (float)index / (float)numRects;
-	const float offset[2] = {normal * 128.0f, normal * 128.0f};
+  const float normal    = (float)index / (float)numRects;
+  const float offset[2] = {normal * 128.0f, normal * 128.0f};
 
-	rect->pos[0] = (frameWidth - rect->size[0] + offset[0]) *
-	               (sinf((float)time * rect->size[0] / 64.0f + normal) + 1.0f) /
-	               2.0f;
-	rect->pos[1] = (frameHeight - rect->size[1] + offset[1]) *
-	               (cosf((float)time * rect->size[1] / 64.0f + normal) + 1.0f) /
-	               2.0f;
+  rect->pos[0] = (frameWidth - rect->size[0] + offset[0]) *
+                 (sinf((float)time * rect->size[0] / 64.0f + normal) + 1.0f) /
+                 2.0f;
+  rect->pos[1] = (frameHeight - rect->size[1] + offset[1]) *
+                 (cosf((float)time * rect->size[1] / 64.0f + normal) + 1.0f) /
+                 2.0f;
 }
 
 #endif // EXAMPLES_RECTS_H
diff --git a/subprojects/nk_pugl/pugl/examples/shader_utils.h b/subprojects/nk_pugl/pugl/examples/shader_utils.h
index 217ba47..2575f47 100644
--- a/subprojects/nk_pugl/pugl/examples/shader_utils.h
+++ b/subprojects/nk_pugl/pugl/examples/shader_utils.h
@@ -23,45 +23,44 @@
 #include <stdlib.h>
 #include <string.h>
 
-typedef struct
-{
-	GLuint vertexShader;
-	GLuint fragmentShader;
-	GLuint program;
+typedef struct {
+  GLuint vertexShader;
+  GLuint fragmentShader;
+  GLuint program;
 } Program;
 
 static GLuint
 compileShader(const char* header, const char* source, const GLenum type)
 {
-	const GLchar* sources[] = {header, source};
-	const GLint   lengths[] = {(GLint)strlen(header), (GLint)strlen(source)};
-	GLuint        shader    = glCreateShader(type);
-	glShaderSource(shader, 2, sources, lengths);
-	glCompileShader(shader);
-
-	int status = 0;
-	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
-	if (status == GL_FALSE) {
-		GLint length = 0;
-		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
-
-		char* log = (char*)calloc(1, (size_t)length);
-		glGetShaderInfoLog(shader, length, &length, log);
-		fprintf(stderr, "error: Failed to compile shader (%s)\n", log);
-		free(log);
-
-		return 0;
-	}
-
-	return shader;
+  const GLchar* sources[] = {header, source};
+  const GLint   lengths[] = {(GLint)strlen(header), (GLint)strlen(source)};
+  GLuint        shader    = glCreateShader(type);
+  glShaderSource(shader, 2, sources, lengths);
+  glCompileShader(shader);
+
+  int status = 0;
+  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+  if (status == GL_FALSE) {
+    GLint length = 0;
+    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
+
+    char* log = (char*)calloc(1, (size_t)length);
+    glGetShaderInfoLog(shader, length, &length, log);
+    fprintf(stderr, "error: Failed to compile shader (%s)\n", log);
+    free(log);
+
+    return 0;
+  }
+
+  return shader;
 }
 
 static void
 deleteProgram(Program program)
 {
-	glDeleteShader(program.vertexShader);
-	glDeleteShader(program.fragmentShader);
-	glDeleteProgram(program.program);
+  glDeleteShader(program.vertexShader);
+  glDeleteShader(program.fragmentShader);
+  glDeleteProgram(program.program);
 }
 
 static Program
@@ -69,39 +68,39 @@ compileProgram(const char* headerSource,
                const char* vertexSource,
                const char* fragmentSource)
 {
-	static const Program nullProgram = {0, 0, 0};
-
-	Program program = {
-	    compileShader(headerSource, vertexSource, GL_VERTEX_SHADER),
-	    compileShader(headerSource, fragmentSource, GL_FRAGMENT_SHADER),
-	    glCreateProgram(),
-	};
-
-	if (!program.vertexShader || !program.fragmentShader || !program.program) {
-		deleteProgram(program);
-		return nullProgram;
-	}
-
-	glAttachShader(program.program, program.vertexShader);
-	glAttachShader(program.program, program.fragmentShader);
-	glLinkProgram(program.program);
-
-	GLint status = 0;
-	glGetProgramiv(program.program, GL_LINK_STATUS, &status);
-	if (status == GL_FALSE) {
-		GLint length = 0;
-		glGetProgramiv(program.program, GL_INFO_LOG_LENGTH, &length);
-
-		char* log = (char*)calloc(1, (size_t)length);
-		glGetProgramInfoLog(program.program, length, &length, &log[0]);
-		fprintf(stderr, "error: Failed to link program (%s)\n", log);
-		free(log);
-
-		deleteProgram(program);
-		return nullProgram;
-	}
-
-	return program;
+  static const Program nullProgram = {0, 0, 0};
+
+  Program program = {
+    compileShader(headerSource, vertexSource, GL_VERTEX_SHADER),
+    compileShader(headerSource, fragmentSource, GL_FRAGMENT_SHADER),
+    glCreateProgram(),
+  };
+
+  if (!program.vertexShader || !program.fragmentShader || !program.program) {
+    deleteProgram(program);
+    return nullProgram;
+  }
+
+  glAttachShader(program.program, program.vertexShader);
+  glAttachShader(program.program, program.fragmentShader);
+  glLinkProgram(program.program);
+
+  GLint status = 0;
+  glGetProgramiv(program.program, GL_LINK_STATUS, &status);
+  if (status == GL_FALSE) {
+    GLint length = 0;
+    glGetProgramiv(program.program, GL_INFO_LOG_LENGTH, &length);
+
+    char* log = (char*)calloc(1, (size_t)length);
+    glGetProgramInfoLog(program.program, length, &length, &log[0]);
+    fprintf(stderr, "error: Failed to link program (%s)\n", log);
+    free(log);
+
+    deleteProgram(program);
+    return nullProgram;
+  }
+
+  return program;
 }
 
 #endif // EXAMPLES_SHADER_UTILS_H
diff --git a/subprojects/nk_pugl/pugl/examples/shaders/header_330.glsl b/subprojects/nk_pugl/pugl/examples/shaders/header_330.glsl
index bfe7a00..59d5f6f 100644
--- a/subprojects/nk_pugl/pugl/examples/shaders/header_330.glsl
+++ b/subprojects/nk_pugl/pugl/examples/shaders/header_330.glsl
@@ -2,4 +2,3 @@
 
 #define INTER(qualifiers)
 #define UBO(qualifiers) layout(std140)
-
diff --git a/subprojects/nk_pugl/pugl/examples/shaders/header_420.glsl b/subprojects/nk_pugl/pugl/examples/shaders/header_420.glsl
index 55fbe8a..2beaad0 100644
--- a/subprojects/nk_pugl/pugl/examples/shaders/header_420.glsl
+++ b/subprojects/nk_pugl/pugl/examples/shaders/header_420.glsl
@@ -2,4 +2,3 @@
 
 #define INTER(qualifiers) layout(qualifiers)
 #define UBO(qualifiers) layout(std140, qualifiers)
-
diff --git a/subprojects/nk_pugl/pugl/examples/shaders/rect.frag b/subprojects/nk_pugl/pugl/examples/shaders/rect.frag
index ecec50d..33bfbb2 100644
--- a/subprojects/nk_pugl/pugl/examples/shaders/rect.frag
+++ b/subprojects/nk_pugl/pugl/examples/shaders/rect.frag
@@ -17,17 +17,17 @@ layout(location = 0) out vec4 FragColor;
 void
 main()
 {
-	const float borderWidth = 2.0;
+  const float borderWidth = 2.0;
 
-	vec4  borderColor = f_fillColor + vec4(0.0, 0.4, 0.4, 0.0);
-	float t           = step(borderWidth, f_uv[1]);
-	float r           = step(borderWidth, f_size.x - f_uv[0]);
-	float b           = step(borderWidth, f_size.y - f_uv[1]);
-	float l           = step(borderWidth, f_uv[0]);
-	float fillMix     = t * r * b * l;
-	float borderMix   = 1.0 - fillMix;
-	vec4  fill        = fillMix * f_fillColor;
-	vec4  border      = borderMix * borderColor;
+  vec4  borderColor = f_fillColor + vec4(0.0, 0.4, 0.4, 0.0);
+  float t           = step(borderWidth, f_uv[1]);
+  float r           = step(borderWidth, f_size.x - f_uv[0]);
+  float b           = step(borderWidth, f_size.y - f_uv[1]);
+  float l           = step(borderWidth, f_uv[0]);
+  float fillMix     = t * r * b * l;
+  float borderMix   = 1.0 - fillMix;
+  vec4  fill        = fillMix * f_fillColor;
+  vec4  border      = borderMix * borderColor;
 
-	FragColor = fill + border;
+  FragColor = fill + border;
 }
diff --git a/subprojects/nk_pugl/pugl/examples/shaders/rect.vert b/subprojects/nk_pugl/pugl/examples/shaders/rect.vert
index 09f1917..2c7b5f1 100644
--- a/subprojects/nk_pugl/pugl/examples/shaders/rect.vert
+++ b/subprojects/nk_pugl/pugl/examples/shaders/rect.vert
@@ -3,8 +3,9 @@
 
 UBO(binding = 0) uniform UniformBufferObject
 {
-	mat4 projection;
-} ubo;
+  mat4 projection;
+}
+ubo;
 
 layout(location = 0) in vec2 v_position;
 layout(location = 1) in vec2 v_origin;
@@ -18,18 +19,18 @@ INTER(location = 2) noperspective out vec4 f_fillColor;
 void
 main()
 {
-	// clang-format off
-	mat4 m = mat4(v_size[0],   0.0,         0.0, 0.0,
-	              0.0,         v_size[1],   0.0, 0.0,
-	              0.0,         0.0,         1.0, 0.0,
-	              v_origin[0], v_origin[1], 0.0, 1.0);
-	// clang-format on
+  // clang-format off
+  mat4 m = mat4(v_size[0],   0.0,         0.0, 0.0,
+                0.0,         v_size[1],   0.0, 0.0,
+                0.0,         0.0,         1.0, 0.0,
+                v_origin[0], v_origin[1], 0.0, 1.0);
+  // clang-format on
 
-	mat4 MVP = ubo.projection * m;
+  mat4 MVP = ubo.projection * m;
 
-	f_uv        = v_position * v_size;
-	f_size      = v_size;
-	f_fillColor = v_fillColor;
+  f_uv        = v_position * v_size;
+  f_size      = v_size;
+  f_fillColor = v_fillColor;
 
-	gl_Position = MVP * vec4(v_position, 0.0, 1.0);
+  gl_Position = MVP * vec4(v_position, 0.0, 1.0);
 }
diff --git a/subprojects/nk_pugl/pugl/examples/sybok.hpp b/subprojects/nk_pugl/pugl/examples/sybok.hpp
index 8985547..7740824 100644
--- a/subprojects/nk_pugl/pugl/examples/sybok.hpp
+++ b/subprojects/nk_pugl/pugl/examples/sybok.hpp
@@ -1,5 +1,5 @@
 /*
-  Copyright 2020 David Robillard <http://drobilla.net>
+  Copyright 2020 David Robillard <d@drobilla.net>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
@@ -63,16 +63,25 @@
 #ifndef SYBOK_HPP
 #define SYBOK_HPP
 
+#ifdef VULKAN_CORE_H_
+#  error "sybok.hpp must be included before or instead of vulkan headers"
+#endif
+
+#ifdef __GNUC__
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+
 #define VK_NO_PROTOTYPES
 
 // On 64-bit platforms, all handles are "dispatchable" pointers
-#if defined(__LP64__) || defined(_WIN64) ||                            \
-    (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \
-    defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) ||     \
-    defined(__powerpc64__)
+#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;
+#  define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \
+    typedef struct object##_T* object; // NOLINT(bugprone-macro-parentheses)
 
 // On 32-bit platforms, some "non-dispatchable" handles are 64 bit integers
 #else
@@ -80,18 +89,18 @@
 /// Trivial wrapper class for a 64-bit integer handle for type safety
 template<class Tag>
 struct NonDispatchableHandle {
-	explicit operator uint64_t() const noexcept { return handle; }
-	explicit operator bool() const noexcept { return handle; }
+  explicit operator uint64_t() const noexcept { return handle; }
+  explicit operator bool() const noexcept { return handle; }
 
-	uint64_t handle;
+  uint64_t handle;
 };
 
-#	define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \
-		using object = NonDispatchableHandle<struct Sk##object##Tag>;
+#  define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) \
+    using object = NonDispatchableHandle<struct Sk##object##Tag>;
 
 #endif
 
-#include <vulkan/vulkan_core.h>
+#include <vulkan/vulkan_core.h> // IWYU pragma: export
 
 #include <array>
 #include <cassert>
@@ -101,11 +110,11 @@ struct NonDispatchableHandle {
 #include <utility>
 
 #if __cplusplus >= 201703L
-#	define SYBOK_NODISCARD [[nodiscard]]
+#  define SYBOK_NODISCARD [[nodiscard]]
 #elif defined(__GNUC__)
-#	define SYBOK_NODISCARD [[gnu::warn_unused_result]]
+#  define SYBOK_NODISCARD [[gnu::warn_unused_result]]
 #else
-#	define SYBOK_NODISCARD
+#  define SYBOK_NODISCARD
 #endif
 
 /// Helper macro to make array arguments format nicely
@@ -116,298 +125,299 @@ namespace sk {
 class CommandScope;
 class RenderCommandScope;
 
-static inline const char*
+inline const char*
 string(const VkResult result)
 {
-	switch (result) {
-	case VK_SUCCESS:
-		return "Success";
-	case VK_NOT_READY:
-		return "Not Ready";
-	case VK_TIMEOUT:
-		return "Timeout";
-	case VK_EVENT_SET:
-		return "Event set";
-	case VK_EVENT_RESET:
-		return "Event reset";
-	case VK_INCOMPLETE:
-		return "Incomplete";
-	case VK_ERROR_OUT_OF_HOST_MEMORY:
-		return "Out of host memory";
-	case VK_ERROR_OUT_OF_DEVICE_MEMORY:
-		return "Out of device memory";
-	case VK_ERROR_INITIALIZATION_FAILED:
-		return "Initialization failed";
-	case VK_ERROR_DEVICE_LOST:
-		return "Device lost";
-	case VK_ERROR_MEMORY_MAP_FAILED:
-		return "Memory map failed";
-	case VK_ERROR_LAYER_NOT_PRESENT:
-		return "Layer not present";
-	case VK_ERROR_EXTENSION_NOT_PRESENT:
-		return "Extension not present";
-	case VK_ERROR_FEATURE_NOT_PRESENT:
-		return "Feature not present";
-	case VK_ERROR_INCOMPATIBLE_DRIVER:
-		return "Incompatible driver";
-	case VK_ERROR_TOO_MANY_OBJECTS:
-		return "Too many objects";
-	case VK_ERROR_FORMAT_NOT_SUPPORTED:
-		return "Format not supported";
-	case VK_ERROR_FRAGMENTED_POOL:
-		return "Fragmented pool";
-	case VK_ERROR_OUT_OF_POOL_MEMORY: // Vulkan 1.1
-		return "Out of pool memory";
-	case VK_ERROR_INVALID_EXTERNAL_HANDLE: // Vulkan 1.1
-		return "Invalid external handle";
-	case VK_ERROR_SURFACE_LOST_KHR: // VK_KHR_surface
-		return "Surface lost";
-	case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: // VK_KHR_surface
-		return "Native window in use";
-	case VK_SUBOPTIMAL_KHR: // VK_KHR_swapchain
-		return "Suboptimal";
-	case VK_ERROR_OUT_OF_DATE_KHR: // VK_KHR_swapchain
-		return "Out of date";
-	case VK_ERROR_VALIDATION_FAILED_EXT: // VK_EXT_debug_report
-		return "Validation failed";
-	default:
-		break;
-	}
-
-	return "Unknown error";
+  switch (result) {
+  case VK_SUCCESS:
+    return "Success";
+  case VK_NOT_READY:
+    return "Not Ready";
+  case VK_TIMEOUT:
+    return "Timeout";
+  case VK_EVENT_SET:
+    return "Event set";
+  case VK_EVENT_RESET:
+    return "Event reset";
+  case VK_INCOMPLETE:
+    return "Incomplete";
+  case VK_ERROR_OUT_OF_HOST_MEMORY:
+    return "Out of host memory";
+  case VK_ERROR_OUT_OF_DEVICE_MEMORY:
+    return "Out of device memory";
+  case VK_ERROR_INITIALIZATION_FAILED:
+    return "Initialization failed";
+  case VK_ERROR_DEVICE_LOST:
+    return "Device lost";
+  case VK_ERROR_MEMORY_MAP_FAILED:
+    return "Memory map failed";
+  case VK_ERROR_LAYER_NOT_PRESENT:
+    return "Layer not present";
+  case VK_ERROR_EXTENSION_NOT_PRESENT:
+    return "Extension not present";
+  case VK_ERROR_FEATURE_NOT_PRESENT:
+    return "Feature not present";
+  case VK_ERROR_INCOMPATIBLE_DRIVER:
+    return "Incompatible driver";
+  case VK_ERROR_TOO_MANY_OBJECTS:
+    return "Too many objects";
+  case VK_ERROR_FORMAT_NOT_SUPPORTED:
+    return "Format not supported";
+  case VK_ERROR_FRAGMENTED_POOL:
+    return "Fragmented pool";
+  case VK_ERROR_OUT_OF_POOL_MEMORY: // Vulkan 1.1
+    return "Out of pool memory";
+  case VK_ERROR_INVALID_EXTERNAL_HANDLE: // Vulkan 1.1
+    return "Invalid external handle";
+  case VK_ERROR_SURFACE_LOST_KHR: // VK_KHR_surface
+    return "Surface lost";
+  case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: // VK_KHR_surface
+    return "Native window in use";
+  case VK_SUBOPTIMAL_KHR: // VK_KHR_swapchain
+    return "Suboptimal";
+  case VK_ERROR_OUT_OF_DATE_KHR: // VK_KHR_swapchain
+    return "Out of date";
+  case VK_ERROR_VALIDATION_FAILED_EXT: // VK_EXT_debug_report
+    return "Validation failed";
+  default:
+    break;
+  }
+
+  return "Unknown error";
 }
 
-static inline const char*
+inline const char*
 string(const VkPresentModeKHR presentMode)
 {
-	switch (presentMode) {
-	case VK_PRESENT_MODE_IMMEDIATE_KHR:
-		return "Immediate";
-	case VK_PRESENT_MODE_MAILBOX_KHR:
-		return "Mailbox";
-	case VK_PRESENT_MODE_FIFO_KHR:
-		return "FIFO";
-	case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
-		return "Relaxed FIFO";
-	default:
-		break;
-	}
-
-	return "Unknown present mode";
+  switch (presentMode) {
+  case VK_PRESENT_MODE_IMMEDIATE_KHR:
+    return "Immediate";
+  case VK_PRESENT_MODE_MAILBOX_KHR:
+    return "Mailbox";
+  case VK_PRESENT_MODE_FIFO_KHR:
+    return "FIFO";
+  case VK_PRESENT_MODE_FIFO_RELAXED_KHR:
+    return "Relaxed FIFO";
+  default:
+    break;
+  }
+
+  return "Unknown present mode";
 }
 
-static inline const char*
+inline const char*
 string(const VkDebugReportFlagBitsEXT flag)
 {
-	switch (flag) {
-	case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
-		return "Information";
-	case VK_DEBUG_REPORT_WARNING_BIT_EXT:
-		return "Warning";
-	case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
-		return "Performance Warning";
-	case VK_DEBUG_REPORT_ERROR_BIT_EXT:
-		return "Error";
-	case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
-		return "Debug";
-	default:
-		break;
-	}
-
-	return "Unknown report";
+  switch (flag) {
+  case VK_DEBUG_REPORT_INFORMATION_BIT_EXT:
+    return "Information";
+  case VK_DEBUG_REPORT_WARNING_BIT_EXT:
+    return "Warning";
+  case VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT:
+    return "Performance Warning";
+  case VK_DEBUG_REPORT_ERROR_BIT_EXT:
+    return "Error";
+  case VK_DEBUG_REPORT_DEBUG_BIT_EXT:
+    return "Debug";
+  default:
+    break;
+  }
+
+  return "Unknown report";
 }
 
 template<class T>
 class GlobalDeleter
 {
 public:
-	using DestroyFunc = void (*)(T, const VkAllocationCallbacks*);
+  using DestroyFunc = void (*)(T, const VkAllocationCallbacks*);
 
-	GlobalDeleter()  = default;
-	~GlobalDeleter() = default;
+  GlobalDeleter()  = default;
+  ~GlobalDeleter() = default;
 
-	GlobalDeleter(DestroyFunc destroyFunc) noexcept
-	    : _destroyFunc{destroyFunc}
-	{}
+  // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+  GlobalDeleter(DestroyFunc destroyFunc) noexcept
+    : _destroyFunc{destroyFunc}
+  {}
 
-	GlobalDeleter(const GlobalDeleter&) = delete;
-	GlobalDeleter& operator=(const GlobalDeleter&) = delete;
+  GlobalDeleter(const GlobalDeleter&) = delete;
+  GlobalDeleter& operator=(const GlobalDeleter&) = delete;
 
-	GlobalDeleter(GlobalDeleter&& other) noexcept
-	{
-		std::swap(_destroyFunc, other._destroyFunc);
-	}
+  GlobalDeleter(GlobalDeleter&& other) noexcept
+  {
+    std::swap(_destroyFunc, other._destroyFunc);
+  }
 
-	GlobalDeleter& operator=(GlobalDeleter&& other) noexcept
-	{
-		std::swap(_destroyFunc, other._destroyFunc);
-		return *this;
-	}
+  GlobalDeleter& operator=(GlobalDeleter&& other) noexcept
+  {
+    std::swap(_destroyFunc, other._destroyFunc);
+    return *this;
+  }
 
-	void operator()(T handle) noexcept
-	{
-		if (_destroyFunc && handle) {
-			_destroyFunc(handle, nullptr);
-		}
-	}
+  void operator()(T handle) noexcept
+  {
+    if (_destroyFunc && handle) {
+      _destroyFunc(handle, nullptr);
+    }
+  }
 
 private:
-	DestroyFunc _destroyFunc{};
+  DestroyFunc _destroyFunc{};
 };
 
 template<class T, class Parent>
 class DependantDeleter
 {
 public:
-	using DestroyFunc = void (*)(Parent, T, const VkAllocationCallbacks*);
+  using DestroyFunc = void (*)(Parent, T, const VkAllocationCallbacks*);
 
-	DependantDeleter()  = default;
-	~DependantDeleter() = default;
+  DependantDeleter()  = default;
+  ~DependantDeleter() = default;
 
-	DependantDeleter(Parent parent, DestroyFunc destroyFunc) noexcept
-	    : _parent{parent}
-	    , _destroyFunc{destroyFunc}
-	{}
+  DependantDeleter(Parent parent, DestroyFunc destroyFunc) noexcept
+    : _parent{parent}
+    , _destroyFunc{destroyFunc}
+  {}
 
-	DependantDeleter(const DependantDeleter&) = delete;
-	DependantDeleter& operator=(const DependantDeleter&) = delete;
+  DependantDeleter(const DependantDeleter&) = delete;
+  DependantDeleter& operator=(const DependantDeleter&) = delete;
 
-	DependantDeleter(DependantDeleter&& other) noexcept { swap(other); }
+  DependantDeleter(DependantDeleter&& other) noexcept { swap(other); }
 
-	DependantDeleter& operator=(DependantDeleter&& other) noexcept
-	{
-		swap(other);
-		return *this;
-	}
+  DependantDeleter& operator=(DependantDeleter&& other) noexcept
+  {
+    swap(other);
+    return *this;
+  }
 
-	void operator()(T handle) noexcept
-	{
-		if (_parent && _destroyFunc && handle) {
-			_destroyFunc(_parent, handle, nullptr);
-		}
-	}
+  void operator()(T handle) noexcept
+  {
+    if (_parent && _destroyFunc && handle) {
+      _destroyFunc(_parent, handle, nullptr);
+    }
+  }
 
 private:
-	void swap(DependantDeleter& other) noexcept
-	{
-		std::swap(_parent, other._parent);
-		std::swap(_destroyFunc, other._destroyFunc);
-	}
-
-	Parent      _parent{};
-	DestroyFunc _destroyFunc{};
+  void swap(DependantDeleter& other) noexcept
+  {
+    std::swap(_parent, other._parent);
+    std::swap(_destroyFunc, other._destroyFunc);
+  }
+
+  Parent      _parent{};
+  DestroyFunc _destroyFunc{};
 };
 
 template<class T, class Pool, class FreeFuncResult>
 class PoolDeleter
 {
 public:
-	using FreeFunc = FreeFuncResult (*)(VkDevice, Pool, uint32_t, const T*);
-
-	PoolDeleter() noexcept  = default;
-	~PoolDeleter() noexcept = default;
-
-	PoolDeleter(VkDevice device,
-	            Pool     pool,
-	            uint32_t count,
-	            FreeFunc freeFunc) noexcept
-	    : _device{device}
-	    , _pool{pool}
-	    , _count{count}
-	    , _freeFunc{freeFunc}
-	{}
-
-	PoolDeleter(const PoolDeleter&) = delete;
-	PoolDeleter& operator=(const PoolDeleter&) = delete;
-
-	PoolDeleter(PoolDeleter&& other) noexcept { swap(other); }
-
-	PoolDeleter& operator=(PoolDeleter&& other) noexcept
-	{
-		swap(other);
-		return *this;
-	}
-
-	void operator()(T* handle) noexcept
-	{
-		if (_device && _pool && handle) {
-			_freeFunc(_device, _pool, _count, handle);
-		}
-	}
+  using FreeFunc = FreeFuncResult (*)(VkDevice, Pool, uint32_t, const T*);
+
+  PoolDeleter() noexcept  = default;
+  ~PoolDeleter() noexcept = default;
+
+  PoolDeleter(VkDevice device,
+              Pool     pool,
+              uint32_t count,
+              FreeFunc freeFunc) noexcept
+    : _device{device}
+    , _pool{pool}
+    , _count{count}
+    , _freeFunc{freeFunc}
+  {}
+
+  PoolDeleter(const PoolDeleter&) = delete;
+  PoolDeleter& operator=(const PoolDeleter&) = delete;
+
+  PoolDeleter(PoolDeleter&& other) noexcept { swap(other); }
+
+  PoolDeleter& operator=(PoolDeleter&& other) noexcept
+  {
+    swap(other);
+    return *this;
+  }
+
+  void operator()(T* handle) noexcept
+  {
+    if (_device && _pool && handle) {
+      _freeFunc(_device, _pool, _count, handle);
+    }
+  }
 
 private:
-	void swap(PoolDeleter& other) noexcept
-	{
-		std::swap(_device, other._device);
-		std::swap(_pool, other._pool);
-		std::swap(_count, other._count);
-		std::swap(_freeFunc, other._freeFunc);
-	}
-
-	VkDevice _device{};
-	Pool     _pool{};
-	uint32_t _count{};
-	FreeFunc _freeFunc{};
+  void swap(PoolDeleter& other) noexcept
+  {
+    std::swap(_device, other._device);
+    std::swap(_pool, other._pool);
+    std::swap(_count, other._count);
+    std::swap(_freeFunc, other._freeFunc);
+  }
+
+  VkDevice _device{};
+  Pool     _pool{};
+  uint32_t _count{};
+  FreeFunc _freeFunc{};
 };
 
 template<class T, class TDeleter>
 class UniqueDispatchableHandle
 {
 public:
-	using Deleter = TDeleter;
-	using Handle  = T;
+  using Deleter = TDeleter;
+  using Handle  = T;
 
-	static_assert(std::is_pointer<T>::value, "");
+  static_assert(std::is_pointer<T>::value, "");
 
-	UniqueDispatchableHandle() = default;
+  UniqueDispatchableHandle() = default;
 
-	UniqueDispatchableHandle(Handle handle, Deleter deleter) noexcept
-	    : _handle{handle}
-	    , _deleter{std::move(deleter)}
-	{}
+  UniqueDispatchableHandle(Handle handle, Deleter deleter) noexcept
+    : _handle{handle}
+    , _deleter{std::move(deleter)}
+  {}
 
-	~UniqueDispatchableHandle() noexcept
-	{
-		if (_handle) {
-			_deleter(_handle);
-		}
-	}
+  ~UniqueDispatchableHandle() noexcept
+  {
+    if (_handle) {
+      _deleter(_handle);
+    }
+  }
 
-	UniqueDispatchableHandle(const UniqueDispatchableHandle&) noexcept = delete;
-	UniqueDispatchableHandle&
-	operator=(const UniqueDispatchableHandle&) noexcept = delete;
+  UniqueDispatchableHandle(const UniqueDispatchableHandle&) noexcept = delete;
+  UniqueDispatchableHandle& operator                                 =(
+    const UniqueDispatchableHandle&) noexcept = delete;
 
-	UniqueDispatchableHandle(UniqueDispatchableHandle&& other) noexcept
-	{
-		swap(other);
-	}
+  UniqueDispatchableHandle(UniqueDispatchableHandle&& other) noexcept
+  {
+    swap(other);
+  }
 
-	UniqueDispatchableHandle&
-	operator=(UniqueDispatchableHandle&& other) noexcept
-	{
-		swap(other);
-		return *this;
-	}
+  UniqueDispatchableHandle& operator=(UniqueDispatchableHandle&& other) noexcept
+  {
+    swap(other);
+    return *this;
+  }
 
-	const Handle& get() const noexcept { return _handle; }
+  const Handle& get() const noexcept { return _handle; }
 
-	operator Handle() const noexcept { return _handle; }
+  // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
+  operator Handle() const noexcept { return _handle; }
 
 private:
-	void swap(UniqueDispatchableHandle& other) noexcept
-	{
-		std::swap(_handle, other._handle);
-		std::swap(_deleter, other._deleter);
-	}
-
-	Handle  _handle{};
-	Deleter _deleter{};
+  void swap(UniqueDispatchableHandle& other) noexcept
+  {
+    std::swap(_handle, other._handle);
+    std::swap(_deleter, other._deleter);
+  }
+
+  Handle  _handle{};
+  Deleter _deleter{};
 };
 
-#if defined(__LP64__) || defined(_WIN64) ||                            \
-    (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \
-    defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) ||     \
-    defined(__powerpc64__)
+#if defined(__LP64__) || defined(_WIN64) ||                          \
+  (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || \
+  defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) ||     \
+  defined(__powerpc64__)
 
 template<class T, class TDeleter>
 using UniqueNonDispatchableHandle = UniqueDispatchableHandle<T, TDeleter>;
@@ -418,55 +428,55 @@ template<class T, class TDeleter>
 class UniqueNonDispatchableHandle
 {
 public:
-	using Deleter = TDeleter;
-	using Handle  = T;
-
-	UniqueNonDispatchableHandle() = default;
-
-	UniqueNonDispatchableHandle(T handle, Deleter deleter) noexcept
-	    : _handle{handle}
-	    , _deleter{std::move(deleter)}
-	{
-		assert(handle);
-	}
-
-	~UniqueNonDispatchableHandle() noexcept
-	{
-		if (_handle) {
-			_deleter(_handle);
-		}
-	}
-
-	UniqueNonDispatchableHandle(const UniqueNonDispatchableHandle&) noexcept =
-	    delete;
-	UniqueNonDispatchableHandle&
-	operator=(const UniqueNonDispatchableHandle&) noexcept = delete;
-
-	UniqueNonDispatchableHandle(UniqueNonDispatchableHandle&& other) noexcept
-	{
-		swap(other);
-	}
-
-	UniqueNonDispatchableHandle&
-	operator=(UniqueNonDispatchableHandle&& other) noexcept
-	{
-		swap(other);
-		return *this;
-	}
-
-	const Handle& get() const noexcept { return _handle; }
-
-	operator Handle() const noexcept { return _handle; }
+  using Deleter = TDeleter;
+  using Handle  = T;
+
+  UniqueNonDispatchableHandle() = default;
+
+  UniqueNonDispatchableHandle(T handle, Deleter deleter) noexcept
+    : _handle{handle}
+    , _deleter{std::move(deleter)}
+  {
+    assert(handle);
+  }
+
+  ~UniqueNonDispatchableHandle() noexcept
+  {
+    if (_handle) {
+      _deleter(_handle);
+    }
+  }
+
+  UniqueNonDispatchableHandle(const UniqueNonDispatchableHandle&) noexcept =
+    delete;
+  UniqueNonDispatchableHandle& operator          =(
+    const UniqueNonDispatchableHandle&) noexcept = delete;
+
+  UniqueNonDispatchableHandle(UniqueNonDispatchableHandle&& other) noexcept
+  {
+    swap(other);
+  }
+
+  UniqueNonDispatchableHandle& operator=(
+    UniqueNonDispatchableHandle&& other) noexcept
+  {
+    swap(other);
+    return *this;
+  }
+
+  const Handle& get() const noexcept { return _handle; }
+
+  operator Handle() const noexcept { return _handle; }
 
 private:
-	void swap(UniqueNonDispatchableHandle& other) noexcept
-	{
-		std::swap(_handle, other._handle);
-		std::swap(_deleter, other._deleter);
-	}
-
-	T       _handle{};
-	Deleter _deleter{};
+  void swap(UniqueNonDispatchableHandle& other) noexcept
+  {
+    std::swap(_handle, other._handle);
+    std::swap(_deleter, other._deleter);
+  }
+
+  T       _handle{};
+  Deleter _deleter{};
 };
 
 #endif
@@ -475,83 +485,83 @@ template<class Vector, class Deleter>
 class UniqueArrayHandle
 {
 public:
-	using T = typename Vector::value_type;
+  using T = typename Vector::value_type;
 
-	UniqueArrayHandle() = default;
+  UniqueArrayHandle() = default;
 
-	UniqueArrayHandle(uint32_t size, Vector&& array, Deleter deleter) noexcept
-	    : _array{std::move(array)}
-	    , _deleter{std::move(deleter)}
-	    , _size{size}
-	{
-		assert(!_array.empty());
-	}
+  UniqueArrayHandle(uint32_t size, Vector&& array, Deleter deleter) noexcept
+    : _array{std::move(array)}
+    , _deleter{std::move(deleter)}
+    , _size{size}
+  {
+    assert(!_array.empty());
+  }
 
-	~UniqueArrayHandle() noexcept
-	{
-		if (!_array.empty()) {
-			_deleter(_array.data());
-		}
-	}
+  ~UniqueArrayHandle() noexcept
+  {
+    if (!_array.empty()) {
+      _deleter(_array.data());
+    }
+  }
 
-	UniqueArrayHandle(const UniqueArrayHandle&) noexcept = delete;
-	UniqueArrayHandle& operator=(const UniqueArrayHandle&) noexcept = delete;
+  UniqueArrayHandle(const UniqueArrayHandle&) noexcept = delete;
+  UniqueArrayHandle& operator=(const UniqueArrayHandle&) noexcept = delete;
 
-	UniqueArrayHandle(UniqueArrayHandle&& other) noexcept { swap(other); }
+  UniqueArrayHandle(UniqueArrayHandle&& other) noexcept { swap(other); }
 
-	UniqueArrayHandle& operator=(UniqueArrayHandle&& other) noexcept
-	{
-		swap(other);
-		return *this;
-	}
+  UniqueArrayHandle& operator=(UniqueArrayHandle&& other) noexcept
+  {
+    swap(other);
+    return *this;
+  }
 
-	const T& operator[](const size_t index) const noexcept
-	{
-		return _array[index];
-	}
+  const T& operator[](const size_t index) const noexcept
+  {
+    return _array[index];
+  }
 
-	T& operator[](const size_t index) noexcept { return _array[index]; }
+  T& operator[](const size_t index) noexcept { return _array[index]; }
 
-	const T* get() const noexcept { return _array.data(); }
-	T*       get() noexcept { return _array.data(); }
+  const T* get() const noexcept { return _array.data(); }
+  T*       get() noexcept { return _array.data(); }
 
 private:
-	void swap(UniqueArrayHandle& other) noexcept
-	{
-		std::swap(_array, other._array);
-		std::swap(_deleter, other._deleter);
-		std::swap(_size, other._size);
-	}
-
-	Vector   _array{};
-	Deleter  _deleter{};
-	uint32_t _size{};
+  void swap(UniqueArrayHandle& other) noexcept
+  {
+    std::swap(_array, other._array);
+    std::swap(_deleter, other._deleter);
+    std::swap(_size, other._size);
+  }
+
+  Vector   _array{};
+  Deleter  _deleter{};
+  uint32_t _size{};
 };
 
 template<typename T>
 class OptionalParameter
 {
 public:
-	using Handle = typename T::Handle;
+  using Handle = typename T::Handle;
 
-	OptionalParameter(const T& value) noexcept
-	    : _handle{value.get()}
-	{}
+  // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
+  OptionalParameter(const T& value) noexcept
+    : _handle{value.get()}
+  {}
 
-	OptionalParameter() noexcept
-	    : _handle{}
-	{}
+  OptionalParameter() noexcept  = default;
+  ~OptionalParameter() noexcept = default;
 
-	OptionalParameter(const OptionalParameter&) = delete;
-	OptionalParameter& operator=(const OptionalParameter&) = delete;
+  OptionalParameter(const OptionalParameter&) = delete;
+  OptionalParameter& operator=(const OptionalParameter&) = delete;
 
-	OptionalParameter(OptionalParameter&&) = delete;
-	OptionalParameter& operator=(OptionalParameter&&) = delete;
+  OptionalParameter(OptionalParameter&&) = delete;
+  OptionalParameter& operator=(OptionalParameter&&) = delete;
 
-	const Handle get() const noexcept { return _handle; }
+  Handle get() const noexcept { return _handle; }
 
 private:
-	Handle _handle{};
+  Handle _handle{};
 };
 
 template<typename T>
@@ -559,20 +569,20 @@ using GlobalObject = UniqueDispatchableHandle<T, GlobalDeleter<T>>;
 
 template<typename T>
 using InstanceChild =
-    UniqueNonDispatchableHandle<T, DependantDeleter<T, VkInstance>>;
+  UniqueNonDispatchableHandle<T, DependantDeleter<T, VkInstance>>;
 
 template<typename T>
 using DispatchableDeviceChild =
-    UniqueDispatchableHandle<T, DependantDeleter<T, VkDevice>>;
+  UniqueDispatchableHandle<T, DependantDeleter<T, VkDevice>>;
 
 template<typename T>
 using NonDispatchableDeviceChild =
-    UniqueNonDispatchableHandle<T, DependantDeleter<T, VkDevice>>;
+  UniqueNonDispatchableHandle<T, DependantDeleter<T, VkDevice>>;
 
 template<typename Vector, typename Pool, typename FreeFuncResult>
 using PoolChild = UniqueArrayHandle<
-    Vector,
-    PoolDeleter<typename Vector::value_type, Pool, FreeFuncResult>>;
+  Vector,
+  PoolDeleter<typename Vector::value_type, Pool, FreeFuncResult>>;
 
 using Device   = GlobalObject<VkDevice>;
 using Instance = GlobalObject<VkInstance>;
@@ -606,7 +616,7 @@ using CommandBuffers = PoolChild<VkCommandBufferVector, VkCommandPool, void>;
 
 template<class VkDescriptorSetVector>
 using DescriptorSets =
-    PoolChild<VkDescriptorSetVector, VkDescriptorPool, VkResult>;
+  PoolChild<VkDescriptorSetVector, VkDescriptorPool, VkResult>;
 
 // VK_KHR_swapchain
 using SwapchainKHR = NonDispatchableDeviceChild<VkSwapchainKHR>;
@@ -622,11 +632,11 @@ struct IndexSequence {};
 
 template<size_t N, size_t... Next>
 struct IndexSequenceHelper
-    : public IndexSequenceHelper<N - 1U, N - 1U, Next...> {};
+  : public IndexSequenceHelper<N - 1U, N - 1U, Next...> {};
 
 template<size_t... Next>
 struct IndexSequenceHelper<0U, Next...> {
-	using type = IndexSequence<Next...>;
+  using type = IndexSequence<Next...>;
 };
 
 template<size_t N>
@@ -639,7 +649,7 @@ make_handle_array_h(Parent                                parent,
                     std::array<typename T::Handle, count> handles,
                     IndexSequence<Is...>) noexcept
 {
-	return {T{handles[Is], {parent, destroyFunc}}...};
+  return {T{handles[Is], {parent, destroyFunc}}...};
 }
 
 template<class T, class Parent, class DestroyFunc, size_t count>
@@ -648,8 +658,8 @@ make_handle_array(Parent                                parent,
                   DestroyFunc                           destroyFunc,
                   std::array<typename T::Handle, count> handles) noexcept
 {
-	return make_handle_array_h<T, Parent, DestroyFunc, count>(
-	    parent, destroyFunc, handles, makeIndexSequence<count>());
+  return make_handle_array_h<T, Parent, DestroyFunc, count>(
+    parent, destroyFunc, handles, makeIndexSequence<count>());
 }
 
 namespace detail {
@@ -658,20 +668,20 @@ template<class Value, class Vector, class Func, class... Args>
 inline VkResult
 wrapVectorAccessor(Vector& vector, Func func, Args... args) noexcept
 {
-	uint32_t count = 0u;
-	VkResult r     = func(args..., &count, nullptr);
-	if (r > VK_INCOMPLETE) {
-		vector.clear();
-		return r;
-	}
-
-	vector = Vector(count);
-	if ((r = func(args..., &count, vector.data()))) {
-		vector.clear();
-		return r;
-	}
-
-	return VK_SUCCESS;
+  uint32_t count = 0u;
+  VkResult r     = func(args..., &count, nullptr);
+  if (r > VK_INCOMPLETE) {
+    vector.clear();
+    return r;
+  }
+
+  vector = Vector(count);
+  if ((r = func(args..., &count, vector.data()))) {
+    vector.clear();
+    return r;
+  }
+
+  return VK_SUCCESS;
 }
 
 } // namespace detail
@@ -679,148 +689,149 @@ wrapVectorAccessor(Vector& vector, Func func, Args... args) noexcept
 class VulkanApi;
 
 struct MappedMemory {
-	MappedMemory() noexcept = default;
-
-	MappedMemory(const VulkanApi& api,
-	             VkDevice         device,
-	             VkDeviceMemory   memory,
-	             void*            data) noexcept
-	    : _api{&api}
-	    , _device{device}
-	    , _memory{memory}
-	    , _data{data}
-	{}
-
-	MappedMemory(const MappedMemory&) = delete;
-	MappedMemory& operator=(const MappedMemory&) = delete;
-
-	MappedMemory(MappedMemory&& mappedMemory) noexcept
-	    : _api{mappedMemory._api}
-	    , _device{mappedMemory._device}
-	    , _memory{mappedMemory._memory}
-	    , _data{mappedMemory._data}
-	{
-		mappedMemory._device = {};
-		mappedMemory._memory = {};
-		mappedMemory._data   = {};
-	}
-
-	MappedMemory& operator=(MappedMemory&& mappedMemory) noexcept
-	{
-		std::swap(_api, mappedMemory._api);
-		std::swap(_device, mappedMemory._device);
-		std::swap(_memory, mappedMemory._memory);
-		std::swap(_data, mappedMemory._data);
-		return *this;
-	}
-
-	~MappedMemory() noexcept;
-
-	const void* get() const noexcept { return _data; }
-	void*       get() noexcept { return _data; }
+  MappedMemory() noexcept = default;
+
+  MappedMemory(const VulkanApi& api,
+               VkDevice         device,
+               VkDeviceMemory   memory,
+               void*            data) noexcept
+    : _api{&api}
+    , _device{device}
+    , _memory{memory}
+    , _data{data}
+  {}
+
+  MappedMemory(const MappedMemory&) = delete;
+  MappedMemory& operator=(const MappedMemory&) = delete;
+
+  MappedMemory(MappedMemory&& mappedMemory) noexcept
+    : _api{mappedMemory._api}
+    , _device{mappedMemory._device}
+    , _memory{mappedMemory._memory}
+    , _data{mappedMemory._data}
+  {
+    mappedMemory._device = {};
+    mappedMemory._memory = {};
+    mappedMemory._data   = {};
+  }
+
+  MappedMemory& operator=(MappedMemory&& mappedMemory) noexcept
+  {
+    std::swap(_api, mappedMemory._api);
+    std::swap(_device, mappedMemory._device);
+    std::swap(_memory, mappedMemory._memory);
+    std::swap(_data, mappedMemory._data);
+    return *this;
+  }
+
+  ~MappedMemory() noexcept;
+
+  const void* get() const noexcept { return _data; }
+  void*       get() noexcept { return _data; }
 
 private:
-	const VulkanApi* _api{};
-	VkDevice         _device{};
-	VkDeviceMemory   _memory{};
-	void*            _data{};
+  const VulkanApi* _api{};
+  VkDevice         _device{};
+  VkDeviceMemory   _memory{};
+  void*            _data{};
 };
 
 class VulkanInitApi
 {
 public:
-	template<typename NotFoundFunc>
-	VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr,
-	              NotFoundFunc              notFound) noexcept
-	{
-#define SK_INIT(name)                                                 \
-	do {                                                              \
-		if (!(name = PFN_##name(getInstanceProcAddr(NULL, #name)))) { \
-			notFound(#name);                                          \
-		}                                                             \
-	} while (0)
-
-		vkGetInstanceProcAddr = pGetInstanceProcAddr;
-		SK_INIT(vkCreateInstance);
-		vkDestroyInstance = {}; // Loaded after we create an instance
-		SK_INIT(vkEnumerateInstanceExtensionProperties);
-		SK_INIT(vkEnumerateInstanceLayerProperties);
-
-		if (!vkCreateInstance || !vkEnumerateInstanceExtensionProperties ||
-		    !vkEnumerateInstanceLayerProperties) {
-			return VK_ERROR_INITIALIZATION_FAILED;
-		}
-
-		return VK_SUCCESS;
+  template<typename NotFoundFunc>
+  VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr,
+                NotFoundFunc              notFound) noexcept
+  {
+#define SK_INIT(name)                                             \
+  do {                                                            \
+    if (!(name = PFN_##name(getInstanceProcAddr(NULL, #name)))) { \
+      notFound(#name);                                            \
+    }                                                             \
+  } while (0)
+
+    vkGetInstanceProcAddr = pGetInstanceProcAddr;
+    SK_INIT(vkCreateInstance);
+    vkDestroyInstance = {}; // Loaded after we create an instance
+    SK_INIT(vkEnumerateInstanceExtensionProperties);
+    SK_INIT(vkEnumerateInstanceLayerProperties);
+
+    if (!vkCreateInstance || !vkEnumerateInstanceExtensionProperties ||
+        !vkEnumerateInstanceLayerProperties) {
+      return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    return VK_SUCCESS;
 #undef SK_INIT
-	}
-
-	VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr) noexcept
-	{
-		return init(pGetInstanceProcAddr, [](const char*) {});
-	}
-
-	PFN_vkVoidFunction
-	getInstanceProcAddr(VkInstance        instance,
-	                    const char* const name) const noexcept
-	{
-		return vkGetInstanceProcAddr(instance, name);
-	}
-
-	VkResult createInstance(const VkInstanceCreateInfo& createInfo,
-	                        Instance&                   instance) noexcept
-	{
-		VkInstance h = {};
-		if (const VkResult r = vkCreateInstance(&createInfo, nullptr, &h)) {
-			return r;
-		} else if (!h) {
-			// Shouldn't actually happen, but this lets the compiler know that
-			return VK_ERROR_INITIALIZATION_FAILED;
-		}
-
-		if (!vkDestroyInstance) {
-			vkDestroyInstance = PFN_vkDestroyInstance(
-			    getInstanceProcAddr(instance, "vkDestroyInstance"));
-		}
-
-		instance = {h, {vkDestroyInstance}};
-		return VK_SUCCESS;
-	}
-
-	template<class Vector>
-	VkResult
-	enumerateInstanceExtensionProperties(Vector& properties) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkExtensionProperties>(
-		    properties, vkEnumerateInstanceExtensionProperties, nullptr);
-	}
-
-	template<class Vector>
-	VkResult
-	enumerateInstanceExtensionProperties(const char* const layerName,
-	                                     Vector& properties) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkExtensionProperties>(
-		    properties, vkEnumerateInstanceExtensionProperties, layerName);
-	}
-
-	template<class Vector>
-	VkResult enumerateInstanceLayerProperties(Vector& properties) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkLayerProperties>(
-		    properties, vkEnumerateInstanceLayerProperties);
-	}
+  }
+
+  VkResult init(PFN_vkGetInstanceProcAddr pGetInstanceProcAddr) noexcept
+  {
+    return init(pGetInstanceProcAddr, [](const char*) {});
+  }
+
+  PFN_vkVoidFunction getInstanceProcAddr(VkInstance        instance,
+                                         const char* const name) const noexcept
+  {
+    return vkGetInstanceProcAddr(instance, name);
+  }
+
+  VkResult createInstance(const VkInstanceCreateInfo& createInfo,
+                          Instance&                   instance) noexcept
+  {
+    VkInstance h = {};
+    if (const VkResult r = vkCreateInstance(&createInfo, nullptr, &h)) {
+      return r;
+    }
+
+    if (!h) {
+      // Shouldn't actually happen, but this lets the compiler know that
+      return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    if (!vkDestroyInstance) {
+      vkDestroyInstance = PFN_vkDestroyInstance(
+        getInstanceProcAddr(instance, "vkDestroyInstance"));
+    }
+
+    instance = {h, {vkDestroyInstance}};
+    return VK_SUCCESS;
+  }
+
+  template<class Vector>
+  VkResult enumerateInstanceExtensionProperties(
+    Vector& properties) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkExtensionProperties>(
+      properties, vkEnumerateInstanceExtensionProperties, nullptr);
+  }
+
+  template<class Vector>
+  VkResult enumerateInstanceExtensionProperties(
+    const char* const layerName,
+    Vector&           properties) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkExtensionProperties>(
+      properties, vkEnumerateInstanceExtensionProperties, layerName);
+  }
+
+  template<class Vector>
+  VkResult enumerateInstanceLayerProperties(Vector& properties) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkLayerProperties>(
+      properties, vkEnumerateInstanceLayerProperties);
+  }
 
 private:
-	PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
+  PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{};
 
 #define SK_FUNC(name) \
-	PFN_##name name {}
+  PFN_##name name {}
 
-	SK_FUNC(vkCreateInstance);
-	SK_FUNC(vkDestroyInstance);
-	SK_FUNC(vkEnumerateInstanceExtensionProperties);
-	SK_FUNC(vkEnumerateInstanceLayerProperties);
+  SK_FUNC(vkCreateInstance);
+  SK_FUNC(vkDestroyInstance);
+  SK_FUNC(vkEnumerateInstanceExtensionProperties);
+  SK_FUNC(vkEnumerateInstanceLayerProperties);
 
 #undef SK_FUNC
 };
@@ -828,1531 +839,1487 @@ private:
 class VulkanApi
 {
 public:
-	template<typename NotFoundFunc>
-	VkResult init(const VulkanInitApi& initApi,
-	              const Instance&      instance,
-	              NotFoundFunc         notFound) noexcept
-	{
-		VkResult r = VK_SUCCESS;
-
-		const auto notFoundWrapper = [&r, notFound](const char* name) {
-			r = VK_INCOMPLETE;
-			notFound(name);
-		};
-
-#define SK_INIT(name)                                               \
-	do {                                                            \
-		if (!(name = PFN_##name(                                    \
-		          initApi.getInstanceProcAddr(instance, #name)))) { \
-			notFoundWrapper(#name);                                 \
-		}                                                           \
-	} while (0)
-
-		SK_INIT(vkAllocateCommandBuffers);
-		SK_INIT(vkAllocateDescriptorSets);
-		SK_INIT(vkAllocateMemory);
-		SK_INIT(vkBeginCommandBuffer);
-		SK_INIT(vkBindBufferMemory);
-		SK_INIT(vkBindImageMemory);
-		SK_INIT(vkCmdBeginQuery);
-		SK_INIT(vkCmdBeginRenderPass);
-		SK_INIT(vkCmdBindDescriptorSets);
-		SK_INIT(vkCmdBindIndexBuffer);
-		SK_INIT(vkCmdBindPipeline);
-		SK_INIT(vkCmdBindVertexBuffers);
-		SK_INIT(vkCmdBlitImage);
-		SK_INIT(vkCmdClearAttachments);
-		SK_INIT(vkCmdClearColorImage);
-		SK_INIT(vkCmdClearDepthStencilImage);
-		SK_INIT(vkCmdCopyBuffer);
-		SK_INIT(vkCmdCopyBufferToImage);
-		SK_INIT(vkCmdCopyImage);
-		SK_INIT(vkCmdCopyImageToBuffer);
-		SK_INIT(vkCmdCopyQueryPoolResults);
-		SK_INIT(vkCmdDispatch);
-		SK_INIT(vkCmdDispatchIndirect);
-		SK_INIT(vkCmdDraw);
-		SK_INIT(vkCmdDrawIndexed);
-		SK_INIT(vkCmdDrawIndexedIndirect);
-		SK_INIT(vkCmdDrawIndirect);
-		SK_INIT(vkCmdEndQuery);
-		SK_INIT(vkCmdEndRenderPass);
-		SK_INIT(vkCmdExecuteCommands);
-		SK_INIT(vkCmdFillBuffer);
-		SK_INIT(vkCmdNextSubpass);
-		SK_INIT(vkCmdPipelineBarrier);
-		SK_INIT(vkCmdPushConstants);
-		SK_INIT(vkCmdResetEvent);
-		SK_INIT(vkCmdResetQueryPool);
-		SK_INIT(vkCmdResolveImage);
-		SK_INIT(vkCmdSetBlendConstants);
-		SK_INIT(vkCmdSetDepthBias);
-		SK_INIT(vkCmdSetDepthBounds);
-		SK_INIT(vkCmdSetEvent);
-		SK_INIT(vkCmdSetLineWidth);
-		SK_INIT(vkCmdSetScissor);
-		SK_INIT(vkCmdSetStencilCompareMask);
-		SK_INIT(vkCmdSetStencilReference);
-		SK_INIT(vkCmdSetStencilWriteMask);
-		SK_INIT(vkCmdSetViewport);
-		SK_INIT(vkCmdUpdateBuffer);
-		SK_INIT(vkCmdWaitEvents);
-		SK_INIT(vkCmdWriteTimestamp);
-		SK_INIT(vkCreateBuffer);
-		SK_INIT(vkCreateBufferView);
-		SK_INIT(vkCreateCommandPool);
-		SK_INIT(vkCreateComputePipelines);
-		SK_INIT(vkCreateDescriptorPool);
-		SK_INIT(vkCreateDescriptorSetLayout);
-		SK_INIT(vkCreateDevice);
-		SK_INIT(vkCreateEvent);
-		SK_INIT(vkCreateFence);
-		SK_INIT(vkCreateFramebuffer);
-		SK_INIT(vkCreateGraphicsPipelines);
-		SK_INIT(vkCreateImage);
-		SK_INIT(vkCreateImageView);
-		SK_INIT(vkCreateInstance);
-		SK_INIT(vkCreatePipelineCache);
-		SK_INIT(vkCreatePipelineLayout);
-		SK_INIT(vkCreateQueryPool);
-		SK_INIT(vkCreateRenderPass);
-		SK_INIT(vkCreateSampler);
-		SK_INIT(vkCreateSemaphore);
-		SK_INIT(vkCreateShaderModule);
-		SK_INIT(vkDestroyBuffer);
-		SK_INIT(vkDestroyBufferView);
-		SK_INIT(vkDestroyCommandPool);
-		SK_INIT(vkDestroyDescriptorPool);
-		SK_INIT(vkDestroyDescriptorSetLayout);
-		SK_INIT(vkDestroyDevice);
-		SK_INIT(vkDestroyEvent);
-		SK_INIT(vkDestroyFence);
-		SK_INIT(vkDestroyFramebuffer);
-		SK_INIT(vkDestroyImage);
-		SK_INIT(vkDestroyImageView);
-		SK_INIT(vkDestroyPipeline);
-		SK_INIT(vkDestroyPipelineCache);
-		SK_INIT(vkDestroyPipelineLayout);
-		SK_INIT(vkDestroyQueryPool);
-		SK_INIT(vkDestroyRenderPass);
-		SK_INIT(vkDestroySampler);
-		SK_INIT(vkDestroySemaphore);
-		SK_INIT(vkDestroyShaderModule);
-		SK_INIT(vkDeviceWaitIdle);
-		SK_INIT(vkEndCommandBuffer);
-		SK_INIT(vkEnumerateDeviceExtensionProperties);
-		SK_INIT(vkEnumerateDeviceLayerProperties);
-		SK_INIT(vkEnumeratePhysicalDevices);
-		SK_INIT(vkFlushMappedMemoryRanges);
-		SK_INIT(vkFreeCommandBuffers);
-		SK_INIT(vkFreeDescriptorSets);
-		SK_INIT(vkFreeMemory);
-		SK_INIT(vkGetBufferMemoryRequirements);
-		SK_INIT(vkGetDeviceMemoryCommitment);
-		SK_INIT(vkGetDeviceProcAddr);
-		SK_INIT(vkGetDeviceQueue);
-		SK_INIT(vkGetEventStatus);
-		SK_INIT(vkGetFenceStatus);
-		SK_INIT(vkGetImageMemoryRequirements);
-		SK_INIT(vkGetImageSparseMemoryRequirements);
-		SK_INIT(vkGetImageSubresourceLayout);
-		SK_INIT(vkGetInstanceProcAddr);
-		SK_INIT(vkGetPhysicalDeviceFeatures);
-		SK_INIT(vkGetPhysicalDeviceFormatProperties);
-		SK_INIT(vkGetPhysicalDeviceImageFormatProperties);
-		SK_INIT(vkGetPhysicalDeviceMemoryProperties);
-		SK_INIT(vkGetPhysicalDeviceProperties);
-		SK_INIT(vkGetPhysicalDeviceQueueFamilyProperties);
-		SK_INIT(vkGetPhysicalDeviceSparseImageFormatProperties);
-		SK_INIT(vkGetPipelineCacheData);
-		SK_INIT(vkGetQueryPoolResults);
-		SK_INIT(vkGetRenderAreaGranularity);
-		SK_INIT(vkInvalidateMappedMemoryRanges);
-		SK_INIT(vkMapMemory);
-		SK_INIT(vkMergePipelineCaches);
-		SK_INIT(vkQueueBindSparse);
-		SK_INIT(vkQueueSubmit);
-		SK_INIT(vkQueueWaitIdle);
-		SK_INIT(vkResetCommandBuffer);
-		SK_INIT(vkResetCommandPool);
-		SK_INIT(vkResetDescriptorPool);
-		SK_INIT(vkResetEvent);
-		SK_INIT(vkResetFences);
-		SK_INIT(vkSetEvent);
-		SK_INIT(vkUnmapMemory);
-		SK_INIT(vkUpdateDescriptorSets);
-		SK_INIT(vkWaitForFences);
-
-		// VK_EXT_debug_report
-		SK_INIT(vkCreateDebugReportCallbackEXT);
-		SK_INIT(vkDebugReportMessageEXT);
-		SK_INIT(vkDestroyDebugReportCallbackEXT);
-
-		// VK_KHR_surface
-		SK_INIT(vkDestroySurfaceKHR);
-		SK_INIT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
-		SK_INIT(vkGetPhysicalDeviceSurfaceFormatsKHR);
-		SK_INIT(vkGetPhysicalDeviceSurfacePresentModesKHR);
-		SK_INIT(vkGetPhysicalDeviceSurfaceSupportKHR);
-
-		// VK_KHR_swapchain
-		SK_INIT(vkAcquireNextImageKHR);
-		SK_INIT(vkCreateSwapchainKHR);
-		SK_INIT(vkDestroySwapchainKHR);
-		SK_INIT(vkGetDeviceGroupPresentCapabilitiesKHR);
-		SK_INIT(vkGetDeviceGroupSurfacePresentModesKHR);
-		SK_INIT(vkGetPhysicalDevicePresentRectanglesKHR);
-		SK_INIT(vkGetSwapchainImagesKHR);
-		SK_INIT(vkQueuePresentKHR);
+  template<typename NotFoundFunc>
+  VkResult init(const VulkanInitApi& initApi,
+                const Instance&      instance,
+                NotFoundFunc         notFound) noexcept
+  {
+    VkResult r = VK_SUCCESS;
+
+    const auto notFoundWrapper = [&r, notFound](const char* name) {
+      r = VK_INCOMPLETE;
+      notFound(name);
+    };
+
+#define SK_INIT(name)                                                         \
+  do {                                                                        \
+    if (!(name = PFN_##name(initApi.getInstanceProcAddr(instance, #name)))) { \
+      notFoundWrapper(#name);                                                 \
+    }                                                                         \
+  } while (0)
+
+    SK_INIT(vkAllocateCommandBuffers);
+    SK_INIT(vkAllocateDescriptorSets);
+    SK_INIT(vkAllocateMemory);
+    SK_INIT(vkBeginCommandBuffer);
+    SK_INIT(vkBindBufferMemory);
+    SK_INIT(vkBindImageMemory);
+    SK_INIT(vkCmdBeginQuery);
+    SK_INIT(vkCmdBeginRenderPass);
+    SK_INIT(vkCmdBindDescriptorSets);
+    SK_INIT(vkCmdBindIndexBuffer);
+    SK_INIT(vkCmdBindPipeline);
+    SK_INIT(vkCmdBindVertexBuffers);
+    SK_INIT(vkCmdBlitImage);
+    SK_INIT(vkCmdClearAttachments);
+    SK_INIT(vkCmdClearColorImage);
+    SK_INIT(vkCmdClearDepthStencilImage);
+    SK_INIT(vkCmdCopyBuffer);
+    SK_INIT(vkCmdCopyBufferToImage);
+    SK_INIT(vkCmdCopyImage);
+    SK_INIT(vkCmdCopyImageToBuffer);
+    SK_INIT(vkCmdCopyQueryPoolResults);
+    SK_INIT(vkCmdDispatch);
+    SK_INIT(vkCmdDispatchIndirect);
+    SK_INIT(vkCmdDraw);
+    SK_INIT(vkCmdDrawIndexed);
+    SK_INIT(vkCmdDrawIndexedIndirect);
+    SK_INIT(vkCmdDrawIndirect);
+    SK_INIT(vkCmdEndQuery);
+    SK_INIT(vkCmdEndRenderPass);
+    SK_INIT(vkCmdExecuteCommands);
+    SK_INIT(vkCmdFillBuffer);
+    SK_INIT(vkCmdNextSubpass);
+    SK_INIT(vkCmdPipelineBarrier);
+    SK_INIT(vkCmdPushConstants);
+    SK_INIT(vkCmdResetEvent);
+    SK_INIT(vkCmdResetQueryPool);
+    SK_INIT(vkCmdResolveImage);
+    SK_INIT(vkCmdSetBlendConstants);
+    SK_INIT(vkCmdSetDepthBias);
+    SK_INIT(vkCmdSetDepthBounds);
+    SK_INIT(vkCmdSetEvent);
+    SK_INIT(vkCmdSetLineWidth);
+    SK_INIT(vkCmdSetScissor);
+    SK_INIT(vkCmdSetStencilCompareMask);
+    SK_INIT(vkCmdSetStencilReference);
+    SK_INIT(vkCmdSetStencilWriteMask);
+    SK_INIT(vkCmdSetViewport);
+    SK_INIT(vkCmdUpdateBuffer);
+    SK_INIT(vkCmdWaitEvents);
+    SK_INIT(vkCmdWriteTimestamp);
+    SK_INIT(vkCreateBuffer);
+    SK_INIT(vkCreateBufferView);
+    SK_INIT(vkCreateCommandPool);
+    SK_INIT(vkCreateComputePipelines);
+    SK_INIT(vkCreateDescriptorPool);
+    SK_INIT(vkCreateDescriptorSetLayout);
+    SK_INIT(vkCreateDevice);
+    SK_INIT(vkCreateEvent);
+    SK_INIT(vkCreateFence);
+    SK_INIT(vkCreateFramebuffer);
+    SK_INIT(vkCreateGraphicsPipelines);
+    SK_INIT(vkCreateImage);
+    SK_INIT(vkCreateImageView);
+    SK_INIT(vkCreateInstance);
+    SK_INIT(vkCreatePipelineCache);
+    SK_INIT(vkCreatePipelineLayout);
+    SK_INIT(vkCreateQueryPool);
+    SK_INIT(vkCreateRenderPass);
+    SK_INIT(vkCreateSampler);
+    SK_INIT(vkCreateSemaphore);
+    SK_INIT(vkCreateShaderModule);
+    SK_INIT(vkDestroyBuffer);
+    SK_INIT(vkDestroyBufferView);
+    SK_INIT(vkDestroyCommandPool);
+    SK_INIT(vkDestroyDescriptorPool);
+    SK_INIT(vkDestroyDescriptorSetLayout);
+    SK_INIT(vkDestroyDevice);
+    SK_INIT(vkDestroyEvent);
+    SK_INIT(vkDestroyFence);
+    SK_INIT(vkDestroyFramebuffer);
+    SK_INIT(vkDestroyImage);
+    SK_INIT(vkDestroyImageView);
+    SK_INIT(vkDestroyPipeline);
+    SK_INIT(vkDestroyPipelineCache);
+    SK_INIT(vkDestroyPipelineLayout);
+    SK_INIT(vkDestroyQueryPool);
+    SK_INIT(vkDestroyRenderPass);
+    SK_INIT(vkDestroySampler);
+    SK_INIT(vkDestroySemaphore);
+    SK_INIT(vkDestroyShaderModule);
+    SK_INIT(vkDeviceWaitIdle);
+    SK_INIT(vkEndCommandBuffer);
+    SK_INIT(vkEnumerateDeviceExtensionProperties);
+    SK_INIT(vkEnumerateDeviceLayerProperties);
+    SK_INIT(vkEnumeratePhysicalDevices);
+    SK_INIT(vkFlushMappedMemoryRanges);
+    SK_INIT(vkFreeCommandBuffers);
+    SK_INIT(vkFreeDescriptorSets);
+    SK_INIT(vkFreeMemory);
+    SK_INIT(vkGetBufferMemoryRequirements);
+    SK_INIT(vkGetDeviceMemoryCommitment);
+    SK_INIT(vkGetDeviceProcAddr);
+    SK_INIT(vkGetDeviceQueue);
+    SK_INIT(vkGetEventStatus);
+    SK_INIT(vkGetFenceStatus);
+    SK_INIT(vkGetImageMemoryRequirements);
+    SK_INIT(vkGetImageSparseMemoryRequirements);
+    SK_INIT(vkGetImageSubresourceLayout);
+    SK_INIT(vkGetInstanceProcAddr);
+    SK_INIT(vkGetPhysicalDeviceFeatures);
+    SK_INIT(vkGetPhysicalDeviceFormatProperties);
+    SK_INIT(vkGetPhysicalDeviceImageFormatProperties);
+    SK_INIT(vkGetPhysicalDeviceMemoryProperties);
+    SK_INIT(vkGetPhysicalDeviceProperties);
+    SK_INIT(vkGetPhysicalDeviceQueueFamilyProperties);
+    SK_INIT(vkGetPhysicalDeviceSparseImageFormatProperties);
+    SK_INIT(vkGetPipelineCacheData);
+    SK_INIT(vkGetQueryPoolResults);
+    SK_INIT(vkGetRenderAreaGranularity);
+    SK_INIT(vkInvalidateMappedMemoryRanges);
+    SK_INIT(vkMapMemory);
+    SK_INIT(vkMergePipelineCaches);
+    SK_INIT(vkQueueBindSparse);
+    SK_INIT(vkQueueSubmit);
+    SK_INIT(vkQueueWaitIdle);
+    SK_INIT(vkResetCommandBuffer);
+    SK_INIT(vkResetCommandPool);
+    SK_INIT(vkResetDescriptorPool);
+    SK_INIT(vkResetEvent);
+    SK_INIT(vkResetFences);
+    SK_INIT(vkSetEvent);
+    SK_INIT(vkUnmapMemory);
+    SK_INIT(vkUpdateDescriptorSets);
+    SK_INIT(vkWaitForFences);
+
+    // VK_EXT_debug_report
+    SK_INIT(vkCreateDebugReportCallbackEXT);
+    SK_INIT(vkDebugReportMessageEXT);
+    SK_INIT(vkDestroyDebugReportCallbackEXT);
+
+    // VK_KHR_surface
+    SK_INIT(vkDestroySurfaceKHR);
+    SK_INIT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+    SK_INIT(vkGetPhysicalDeviceSurfaceFormatsKHR);
+    SK_INIT(vkGetPhysicalDeviceSurfacePresentModesKHR);
+    SK_INIT(vkGetPhysicalDeviceSurfaceSupportKHR);
+
+    // VK_KHR_swapchain
+    SK_INIT(vkAcquireNextImageKHR);
+    SK_INIT(vkCreateSwapchainKHR);
+    SK_INIT(vkDestroySwapchainKHR);
+    SK_INIT(vkGetDeviceGroupPresentCapabilitiesKHR);
+    SK_INIT(vkGetDeviceGroupSurfacePresentModesKHR);
+    SK_INIT(vkGetPhysicalDevicePresentRectanglesKHR);
+    SK_INIT(vkGetSwapchainImagesKHR);
+    SK_INIT(vkQueuePresentKHR);
 
 #undef SK_INIT
 
-		return r;
-	}
-
-	VkResult
-	init(const VulkanInitApi& initApi, const Instance& instance) noexcept
-	{
-		return init(initApi, instance, [](const char*) {});
-	}
-
-	template<class VkCommandBufferVector>
-	VkResult allocateCommandBuffers(
-	    const Device&                          device,
-	    const VkCommandBufferAllocateInfo&     allocateInfo,
-	    CommandBuffers<VkCommandBufferVector>& commandBuffers) const noexcept
-	{
-		VkCommandBufferVector rawCommandBuffers = VkCommandBufferVector(
-		    allocateInfo.commandBufferCount);
-
-		if (const VkResult r = vkAllocateCommandBuffers(
-		        device, &allocateInfo, rawCommandBuffers.data())) {
-			return r;
-		}
-
-		commandBuffers = CommandBuffers<VkCommandBufferVector>{
-		    allocateInfo.commandBufferCount,
-		    std::move(rawCommandBuffers),
-		    PoolDeleter<VkCommandBuffer, VkCommandPool, void>{
-		        device,
-		        allocateInfo.commandPool,
-		        allocateInfo.commandBufferCount,
-		        vkFreeCommandBuffers}};
-		return VK_SUCCESS;
-	}
-
-	template<class VkDescriptorSetVector>
-	VkResult allocateDescriptorSets(
-	    const Device&                          device,
-	    const VkDescriptorSetAllocateInfo&     allocateInfo,
-	    DescriptorSets<VkDescriptorSetVector>& descriptorSets) const noexcept
-	{
-		auto descriptorSetVector = VkDescriptorSetVector(
-		    allocateInfo.descriptorSetCount);
-
-		if (const VkResult r = vkAllocateDescriptorSets(
-		        device, &allocateInfo, descriptorSetVector.data())) {
-			return r;
-		}
-
-		descriptorSets = DescriptorSets<VkDescriptorSetVector>{
-		    allocateInfo.descriptorSetCount,
-		    std::move(descriptorSetVector),
-		    PoolDeleter<VkDescriptorSet, VkDescriptorPool, VkResult>{
-		        device,
-		        allocateInfo.descriptorPool,
-		        allocateInfo.descriptorSetCount,
-		        vkFreeDescriptorSets}};
-		return VK_SUCCESS;
-	}
-
-	VkResult bindBufferMemory(const Device&       device,
-	                          const Buffer&       buffer,
-	                          const DeviceMemory& memory,
-	                          VkDeviceSize        memoryOffset) const noexcept
-	{
-		return vkBindBufferMemory
-		           ? vkBindBufferMemory(device, buffer, memory, memoryOffset)
-		           : VK_ERROR_FEATURE_NOT_PRESENT;
-	}
-
-	VkResult createBuffer(const Device&             device,
-	                      const VkBufferCreateInfo& createInfo,
-	                      Buffer&                   buffer) const noexcept
-	{
-		VkBuffer       h = {};
-		const VkResult r = vkCreateBuffer(device, &createInfo, nullptr, &h);
-		return wrapResult(r, h, {device, vkDestroyBuffer}, buffer);
-	}
-
-	VkResult createBufferView(const Device&                 device,
-	                          const VkBufferViewCreateInfo& createInfo,
-	                          BufferView& bufferView) const noexcept
-	{
-		VkBufferView   h = {};
-		const VkResult r = vkCreateBufferView(device, &createInfo, nullptr, &h);
-		return wrapResult(r, h, {device, vkDestroyBufferView}, bufferView);
-	}
-
-	VkResult createCommandPool(const Device&                  device,
-	                           const VkCommandPoolCreateInfo& createInfo,
-	                           CommandPool& commandPool) const noexcept
-	{
-		VkCommandPool  h = {};
-		const VkResult r =
-		    vkCreateCommandPool(device, &createInfo, nullptr, &h);
-		return wrapResult(r, h, {device, vkDestroyCommandPool}, commandPool);
-	}
-
-	VkResult createDescriptorPool(const Device&                     device,
-	                              const VkDescriptorPoolCreateInfo& createInfo,
-	                              DescriptorPool& descriptorPool) const noexcept
-	{
-		VkDescriptorPool h = {};
-		const VkResult   r =
-		    vkCreateDescriptorPool(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r,
-		                  h,
-		                  {device, vkDestroyDescriptorPool},
-		                  descriptorPool);
-	}
-
-	VkResult createDescriptorSetLayout(
-	    const Device&                          device,
-	    const VkDescriptorSetLayoutCreateInfo& createInfo,
-	    DescriptorSetLayout& descriptorSetLayout) const noexcept
-	{
-		VkDescriptorSetLayout h = {};
-		const VkResult        r =
-		    vkCreateDescriptorSetLayout(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r,
-		                  h,
-		                  {device, vkDestroyDescriptorSetLayout},
-		                  descriptorSetLayout);
-	}
-
-	VkResult createDevice(const PhysicalDevice&     physicalDevice,
-	                      const VkDeviceCreateInfo& createInfo,
-	                      Device&                   result) const noexcept
-	{
-		VkDevice       h = {};
-		const VkResult r =
-		    vkCreateDevice(physicalDevice, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {vkDestroyDevice}, result);
-	}
-
-	VkResult createEvent(const Device&            device,
-	                     const VkEventCreateInfo& createInfo,
-	                     Event&                   event) const noexcept
-	{
-		VkEvent        h = {};
-		const VkResult r = vkCreateEvent(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyEvent}, event);
-	}
-
-	VkResult createFence(const Device&            device,
-	                     const VkFenceCreateInfo& createInfo,
-	                     Fence&                   fence) const noexcept
-	{
-		VkFence        h = {};
-		const VkResult r = vkCreateFence(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyFence}, fence);
-	}
-
-	VkResult createFramebuffer(const Device&                  device,
-	                           const VkFramebufferCreateInfo& createInfo,
-	                           Framebuffer& framebuffer) const noexcept
-	{
-		VkFramebuffer  h = {};
-		const VkResult r =
-		    vkCreateFramebuffer(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyFramebuffer}, framebuffer);
-	}
-
-	VkResult createImage(const Device&            device,
-	                     const VkImageCreateInfo& createInfo,
-	                     Image&                   image) const noexcept
-	{
-		VkImage        h = {};
-		const VkResult r = vkCreateImage(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyImage}, image);
-	}
-
-	VkResult createImageView(const Device&                device,
-	                         const VkImageViewCreateInfo& createInfo,
-	                         ImageView& imageView) const noexcept
-	{
-		VkImageView    h = {};
-		const VkResult r = vkCreateImageView(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyImageView}, imageView);
-	}
-
-	template<size_t count>
-	VkResult createGraphicsPipelines(
-	    const Device&                                          device,
-	    const OptionalParameter<PipelineCache>&                pipelineCache,
-	    const std::array<VkGraphicsPipelineCreateInfo, count>& createInfos,
-	    std::array<Pipeline, count>& pipelines) const noexcept
-	{
-		std::array<VkPipeline, count> pipelineHandles{};
-
-		if (const VkResult r = vkCreateGraphicsPipelines(
-		        device,
-		        pipelineCache.get(),
-		        static_cast<uint32_t>(createInfos.size()),
-		        createInfos.data(),
-		        nullptr,
-		        pipelineHandles.data())) {
-			return r;
-		}
-
-		pipelines = make_handle_array<Pipeline>(device.get(),
-		                                        vkDestroyPipeline,
-		                                        pipelineHandles);
-		return VK_SUCCESS;
-	}
-
-	VkResult createPipelineCache(const Device&                    device,
-	                             const VkPipelineCacheCreateInfo& createInfo,
-	                             PipelineCache& pipelineCache) const noexcept
-	{
-		VkPipelineCache h = {};
-		const VkResult  r =
-		    vkCreatePipelineCache(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r,
-		                  h,
-		                  {device, vkDestroyPipelineCache},
-		                  pipelineCache);
-	}
-
-	VkResult createPipelineLayout(const Device&                     device,
-	                              const VkPipelineLayoutCreateInfo& createInfo,
-	                              PipelineLayout& pipelineLayout) const noexcept
-	{
-		VkPipelineLayout h = {};
-		const VkResult   r =
-		    vkCreatePipelineLayout(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r,
-		                  h,
-		                  {device, vkDestroyPipelineLayout},
-		                  pipelineLayout);
-	}
-
-	VkResult createQueryPool(const Device&                device,
-	                         const VkQueryPoolCreateInfo& createInfo,
-	                         QueryPool& queryPool) const noexcept
-	{
-		VkQueryPool    h = {};
-		const VkResult r = vkCreateQueryPool(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyQueryPool}, queryPool);
-	}
-
-	VkResult createRenderPass(const Device&                 device,
-	                          const VkRenderPassCreateInfo& createInfo,
-	                          RenderPass& renderPass) const noexcept
-	{
-		VkRenderPass   h = {};
-		const VkResult r = vkCreateRenderPass(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyRenderPass}, renderPass);
-	}
-
-	VkResult createSampler(const Device&              device,
-	                       const VkSamplerCreateInfo& createInfo,
-	                       Sampler&                   sampler) const noexcept
-	{
-		VkSampler      h = {};
-		const VkResult r = vkCreateSampler(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroySampler}, sampler);
-	}
-
-	VkResult createSemaphore(const Device&                device,
-	                         const VkSemaphoreCreateInfo& createInfo,
-	                         Semaphore& semaphore) const noexcept
-	{
-		VkSemaphore    h = {};
-		const VkResult r = vkCreateSemaphore(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroySemaphore}, semaphore);
-	}
-
-	VkResult createShaderModule(const Device&                   device,
-	                            const VkShaderModuleCreateInfo& createInfo,
-	                            ShaderModule& shaderModule) const noexcept
-	{
-		VkShaderModule h = {};
-		const VkResult r =
-		    vkCreateShaderModule(device, &createInfo, nullptr, &h);
-
-		return wrapResult(r, h, {device, vkDestroyShaderModule}, shaderModule);
-	}
-
-	VkResult deviceWaitIdle(const Device& device) const noexcept
-	{
-		return vkDeviceWaitIdle(device);
-	}
-
-	template<class Vector>
-	VkResult
-	enumerateDeviceExtensionProperties(const PhysicalDevice& physicalDevice,
-	                                   const char* const     layerName,
-	                                   Vector& properties) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkExtensionProperties>(
-		    properties,
-		    vkEnumerateDeviceExtensionProperties,
-		    physicalDevice,
-		    layerName);
-	}
-
-	template<class Vector>
-	VkResult
-	enumerateDeviceExtensionProperties(const PhysicalDevice& physicalDevice,
-	                                   Vector& properties) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkExtensionProperties>(
-		    properties,
-		    vkEnumerateDeviceExtensionProperties,
-		    physicalDevice,
-		    nullptr);
-	}
-
-	template<class Vector>
-	VkResult enumeratePhysicalDevices(const Instance& instance,
-	                                  Vector& physicalDevices) const noexcept
-	{
-		uint32_t count = 0u;
-		VkResult r     = vkEnumeratePhysicalDevices(instance, &count, nullptr);
-		if (r > VK_INCOMPLETE) {
-			return r;
-		}
-
-		physicalDevices = Vector(count);
-		if ((r = vkEnumeratePhysicalDevices(instance,
-		                                    &count,
-		                                    physicalDevices.data()))) {
-			return r;
-		}
-
-		return VK_SUCCESS;
-	}
-
-	sk::Queue getDeviceQueue(const Device&  device,
-	                         const uint32_t queueFamilyIndex,
-	                         const uint32_t queueIndex) const noexcept
-	{
-		VkQueue queue{};
-		vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, &queue);
-		return sk::Queue{queue};
-	}
-
-	VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties(
-	    VkPhysicalDevice physicalDevice) const noexcept
-	{
-		VkPhysicalDeviceMemoryProperties properties{};
-		vkGetPhysicalDeviceMemoryProperties(physicalDevice, &properties);
-		return properties;
-	}
-
-	VkPhysicalDeviceProperties getPhysicalDeviceProperties(
-	    const PhysicalDevice& physicalDevice) const noexcept
-	{
-		VkPhysicalDeviceProperties properties{};
-		vkGetPhysicalDeviceProperties(physicalDevice, &properties);
-		return properties;
-	}
-
-	template<class Vector>
-	VkResult getPhysicalDeviceQueueFamilyProperties(
-	    const PhysicalDevice& physicalDevice,
-	    Vector&               queueFamilyProperties) const noexcept
-	{
-		uint32_t count = 0u;
-		vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice,
-		                                         &count,
-		                                         nullptr);
-
-		queueFamilyProperties = Vector(count);
-		vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice,
-		                                         &count,
-		                                         queueFamilyProperties.data());
-
-		return VK_SUCCESS;
-	}
-
-	VkMemoryRequirements
-	getBufferMemoryRequirements(const Device& device,
-	                            const Buffer& buffer) const noexcept
-	{
-		VkMemoryRequirements requirements;
-		vkGetBufferMemoryRequirements(device, buffer, &requirements);
-		return requirements;
-	}
-
-	VkResult allocateMemory(const Device&               device,
-	                        const VkMemoryAllocateInfo& info,
-	                        DeviceMemory&               memory) const noexcept
-	{
-		VkDeviceMemory h = {};
-		if (const VkResult r = vkAllocateMemory(device, &info, nullptr, &h)) {
-			return r;
-		} else if (!h) {
-			return VK_ERROR_OUT_OF_DEVICE_MEMORY;
-		}
-
-		memory = DeviceMemory{h, {device, vkFreeMemory}};
-		return VK_SUCCESS;
-	}
-
-	VkResult mapMemory(const Device&       device,
-	                   const DeviceMemory& memory,
-	                   VkDeviceSize        offset,
-	                   VkDeviceSize        size,
-	                   VkMemoryMapFlags    flags,
-	                   MappedMemory&       mappedMemory) const noexcept
-	{
-		void* data = nullptr;
-		if (const VkResult r =
-		        vkMapMemory(device, memory, offset, size, flags, &data)) {
-			return r;
-		}
-
-		mappedMemory = MappedMemory{*this, device, memory, data};
-		return VK_SUCCESS;
-	}
-
-	VkResult queueSubmit(const Queue&        queue,
-	                     uint32_t            submitCount,
-	                     const VkSubmitInfo& submits,
-	                     const Fence&        fence) const noexcept
-	{
-		return vkQueueSubmit(queue, submitCount, &submits, fence);
-	}
-
-	VkResult queueSubmit(const Queue&        queue,
-	                     const VkSubmitInfo& submit,
-	                     const Fence&        fence) const noexcept
-	{
-		return vkQueueSubmit(queue, 1u, &submit, fence);
-	}
-
-	template<size_t descriptorWriteCount, size_t descriptorCopyCount>
-	void updateDescriptorSets(
-	    const Device&                                          device,
-	    std::array<VkWriteDescriptorSet, descriptorWriteCount> descriptorWrites,
-	    std::array<VkCopyDescriptorSet, descriptorCopyCount>   descriptorCopies)
-	    const noexcept
-	{
-		vkUpdateDescriptorSets(device,
-		                       static_cast<uint32_t>(descriptorWrites.size()),
-		                       descriptorWrites.data(),
-		                       static_cast<uint32_t>(descriptorCopies.size()),
-		                       descriptorCopies.data());
-	}
-
-	VkResult resetFence(const Device& device, const Fence& fence) const noexcept
-	{
-		VkFence h = fence;
-		return vkResetFences(device, 1u, &h);
-	}
-
-	VkResult waitForFence(const Device& device,
-	                      const Fence&  fence,
-	                      uint64_t      timeout) const noexcept
-	{
-		VkFence h = fence;
-		return vkWaitForFences(device, 1u, &h, VK_TRUE, timeout);
-	}
-
-	VkResult
-	waitForFence(const Device& device, const Fence& fence) const noexcept
-	{
-		VkFence h = fence;
-		return vkWaitForFences(device, 1u, &h, VK_TRUE, UINT64_MAX);
-	}
-
-	// Scoped command buffer interface
-	SYBOK_NODISCARD
-	CommandScope
-	beginCommandBuffer(VkCommandBuffer          commandBuffer,
-	                   VkCommandBufferBeginInfo beginInfo) const noexcept;
-
-	// VK_EXT_debug_report
-
-	VkResult createDebugReportCallbackEXT(
-	    const Instance&                           instance,
-	    const VkDebugReportCallbackCreateInfoEXT& createInfo,
-	    DebugReportCallbackEXT&                   callback) const noexcept
-	{
-		VkDebugReportCallbackEXT h = {};
-
-		if (const VkResult r = vkCreateDebugReportCallbackEXT(
-		        instance, &createInfo, nullptr, &h)) {
-			return r;
-		} else if (!h) {
-			return VK_ERROR_FEATURE_NOT_PRESENT;
-		}
-
-		callback = {h, {instance, vkDestroyDebugReportCallbackEXT}};
-		return VK_SUCCESS;
-	}
-
-	// VK_KHR_surface
-
-	VkResult getPhysicalDeviceSurfaceCapabilitiesKHR(
-	    const PhysicalDevice&     physicalDevice,
-	    const SurfaceKHR&         surface,
-	    VkSurfaceCapabilitiesKHR& capabilities) const noexcept
-	{
-		return vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice,
-		                                                 surface,
-		                                                 &capabilities);
-	}
-
-	template<typename Vector>
-	VkResult
-	getPhysicalDeviceSurfaceFormatsKHR(const PhysicalDevice& physicalDevice,
-	                                   const SurfaceKHR&     surface,
-	                                   Vector& surfaceFormats) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkSurfaceFormatKHR>(
-		    surfaceFormats,
-		    vkGetPhysicalDeviceSurfaceFormatsKHR,
-		    physicalDevice,
-		    surface.get());
-	}
-
-	template<typename Vector>
-	VkResult getPhysicalDeviceSurfacePresentModesKHR(
-	    const PhysicalDevice& physicalDevice,
-	    const SurfaceKHR&     surface,
-	    Vector&               presentModes) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkPresentModeKHR>(
-		    presentModes,
-		    vkGetPhysicalDeviceSurfacePresentModesKHR,
-		    physicalDevice,
-		    surface.get());
-	}
-
-	VkResult
-	getPhysicalDeviceSurfaceSupportKHR(const PhysicalDevice& physicalDevice,
-	                                   uint32_t              queueFamilyIndex,
-	                                   const SurfaceKHR&     surface,
-	                                   bool& supported) const noexcept
-	{
-		VkBool32 s = {};
-
-		if (VkResult r = vkGetPhysicalDeviceSurfaceSupportKHR(
-		        physicalDevice, queueFamilyIndex, surface, &s)) {
-			return r;
-		}
-
-		supported = s;
-		return VK_SUCCESS;
-	}
-
-	// VK_KHR_swapchain
-
-	VkResult acquireNextImageKHR(const Device&                   device,
-	                             const SwapchainKHR&             swapchain,
-	                             uint64_t                        timeout,
-	                             const Semaphore&                semaphore,
-	                             const OptionalParameter<Fence>& fence,
-	                             uint32_t* pImageIndex) const noexcept
-	{
-		return vkAcquireNextImageKHR(
-		    device, swapchain, timeout, semaphore, fence.get(), pImageIndex);
-	}
-
-	template<class Vector>
-	VkResult getSwapchainImagesKHR(const Device&       device,
-	                               const SwapchainKHR& swapchain,
-	                               Vector&             images) const noexcept
-	{
-		return detail::wrapVectorAccessor<VkImage>(images,
-		                                           vkGetSwapchainImagesKHR,
-		                                           device.get(),
-		                                           swapchain.get());
-	}
-
-	VkResult createSwapchainKHR(const Device&                   device,
-	                            const VkSwapchainCreateInfoKHR& createInfo,
-	                            SwapchainKHR& swapchain) const noexcept
-	{
-		VkSwapchainKHR h = {};
-		const VkResult r =
-		    vkCreateSwapchainKHR(device, &createInfo, nullptr, &h);
-
-		if (r) {
-			return r;
-		} else if (!h) {
-			return VK_ERROR_INCOMPATIBLE_DRIVER;
-		}
-
-		swapchain = {h, {device, vkDestroySwapchainKHR}};
-		return VK_SUCCESS;
-	}
-
-	VkResult queuePresentKHR(const Queue&            queue,
-	                         const VkPresentInfoKHR& presentInfo) const noexcept
-	{
-		return vkQueuePresentKHR(queue, &presentInfo);
-	}
+    return r;
+  }
+
+  VkResult init(const VulkanInitApi& initApi, const Instance& instance) noexcept
+  {
+    return init(initApi, instance, [](const char*) {});
+  }
+
+  template<class VkCommandBufferVector>
+  VkResult allocateCommandBuffers(
+    const Device&                          device,
+    const VkCommandBufferAllocateInfo&     allocateInfo,
+    CommandBuffers<VkCommandBufferVector>& commandBuffers) const noexcept
+  {
+    VkCommandBufferVector rawCommandBuffers =
+      VkCommandBufferVector(allocateInfo.commandBufferCount);
+
+    if (const VkResult r = vkAllocateCommandBuffers(
+          device, &allocateInfo, rawCommandBuffers.data())) {
+      return r;
+    }
+
+    commandBuffers = CommandBuffers<VkCommandBufferVector>{
+      allocateInfo.commandBufferCount,
+      std::move(rawCommandBuffers),
+      PoolDeleter<VkCommandBuffer, VkCommandPool, void>{
+        device,
+        allocateInfo.commandPool,
+        allocateInfo.commandBufferCount,
+        vkFreeCommandBuffers}};
+    return VK_SUCCESS;
+  }
+
+  template<class VkDescriptorSetVector>
+  VkResult allocateDescriptorSets(
+    const Device&                          device,
+    const VkDescriptorSetAllocateInfo&     allocateInfo,
+    DescriptorSets<VkDescriptorSetVector>& descriptorSets) const noexcept
+  {
+    auto descriptorSetVector =
+      VkDescriptorSetVector(allocateInfo.descriptorSetCount);
+
+    if (const VkResult r = vkAllocateDescriptorSets(
+          device, &allocateInfo, descriptorSetVector.data())) {
+      return r;
+    }
+
+    descriptorSets = DescriptorSets<VkDescriptorSetVector>{
+      allocateInfo.descriptorSetCount,
+      std::move(descriptorSetVector),
+      PoolDeleter<VkDescriptorSet, VkDescriptorPool, VkResult>{
+        device,
+        allocateInfo.descriptorPool,
+        allocateInfo.descriptorSetCount,
+        vkFreeDescriptorSets}};
+    return VK_SUCCESS;
+  }
+
+  VkResult bindBufferMemory(const Device&       device,
+                            const Buffer&       buffer,
+                            const DeviceMemory& memory,
+                            VkDeviceSize        memoryOffset) const noexcept
+  {
+    return vkBindBufferMemory
+             ? vkBindBufferMemory(device, buffer, memory, memoryOffset)
+             : VK_ERROR_FEATURE_NOT_PRESENT;
+  }
+
+  VkResult createBuffer(const Device&             device,
+                        const VkBufferCreateInfo& createInfo,
+                        Buffer&                   buffer) const noexcept
+  {
+    VkBuffer       h = {};
+    const VkResult r = vkCreateBuffer(device, &createInfo, nullptr, &h);
+    return wrapResult(r, h, {device, vkDestroyBuffer}, buffer);
+  }
+
+  VkResult createBufferView(const Device&                 device,
+                            const VkBufferViewCreateInfo& createInfo,
+                            BufferView& bufferView) const noexcept
+  {
+    VkBufferView   h = {};
+    const VkResult r = vkCreateBufferView(device, &createInfo, nullptr, &h);
+    return wrapResult(r, h, {device, vkDestroyBufferView}, bufferView);
+  }
+
+  VkResult createCommandPool(const Device&                  device,
+                             const VkCommandPoolCreateInfo& createInfo,
+                             CommandPool& commandPool) const noexcept
+  {
+    VkCommandPool  h = {};
+    const VkResult r = vkCreateCommandPool(device, &createInfo, nullptr, &h);
+    return wrapResult(r, h, {device, vkDestroyCommandPool}, commandPool);
+  }
+
+  VkResult createDescriptorPool(const Device&                     device,
+                                const VkDescriptorPoolCreateInfo& createInfo,
+                                DescriptorPool& descriptorPool) const noexcept
+  {
+    VkDescriptorPool h = {};
+    const VkResult r = vkCreateDescriptorPool(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyDescriptorPool}, descriptorPool);
+  }
+
+  VkResult createDescriptorSetLayout(
+    const Device&                          device,
+    const VkDescriptorSetLayoutCreateInfo& createInfo,
+    DescriptorSetLayout&                   descriptorSetLayout) const noexcept
+  {
+    VkDescriptorSetLayout h = {};
+    const VkResult        r =
+      vkCreateDescriptorSetLayout(device, &createInfo, nullptr, &h);
+
+    return wrapResult(
+      r, h, {device, vkDestroyDescriptorSetLayout}, descriptorSetLayout);
+  }
+
+  VkResult createDevice(const PhysicalDevice&     physicalDevice,
+                        const VkDeviceCreateInfo& createInfo,
+                        Device&                   result) const noexcept
+  {
+    VkDevice       h = {};
+    const VkResult r = vkCreateDevice(physicalDevice, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {vkDestroyDevice}, result);
+  }
+
+  VkResult createEvent(const Device&            device,
+                       const VkEventCreateInfo& createInfo,
+                       Event&                   event) const noexcept
+  {
+    VkEvent        h = {};
+    const VkResult r = vkCreateEvent(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyEvent}, event);
+  }
+
+  VkResult createFence(const Device&            device,
+                       const VkFenceCreateInfo& createInfo,
+                       Fence&                   fence) const noexcept
+  {
+    VkFence        h = {};
+    const VkResult r = vkCreateFence(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyFence}, fence);
+  }
+
+  VkResult createFramebuffer(const Device&                  device,
+                             const VkFramebufferCreateInfo& createInfo,
+                             Framebuffer& framebuffer) const noexcept
+  {
+    VkFramebuffer  h = {};
+    const VkResult r = vkCreateFramebuffer(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyFramebuffer}, framebuffer);
+  }
+
+  VkResult createImage(const Device&            device,
+                       const VkImageCreateInfo& createInfo,
+                       Image&                   image) const noexcept
+  {
+    VkImage        h = {};
+    const VkResult r = vkCreateImage(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyImage}, image);
+  }
+
+  VkResult createImageView(const Device&                device,
+                           const VkImageViewCreateInfo& createInfo,
+                           ImageView& imageView) const noexcept
+  {
+    VkImageView    h = {};
+    const VkResult r = vkCreateImageView(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyImageView}, imageView);
+  }
+
+  template<size_t count>
+  VkResult createGraphicsPipelines(
+    const Device&                                          device,
+    const OptionalParameter<PipelineCache>&                pipelineCache,
+    const std::array<VkGraphicsPipelineCreateInfo, count>& createInfos,
+    std::array<Pipeline, count>& pipelines) const noexcept
+  {
+    std::array<VkPipeline, count> pipelineHandles{};
+
+    if (const VkResult r =
+          vkCreateGraphicsPipelines(device,
+                                    pipelineCache.get(),
+                                    static_cast<uint32_t>(createInfos.size()),
+                                    createInfos.data(),
+                                    nullptr,
+                                    pipelineHandles.data())) {
+      return r;
+    }
+
+    pipelines = make_handle_array<Pipeline>(
+      device.get(), vkDestroyPipeline, pipelineHandles);
+    return VK_SUCCESS;
+  }
+
+  VkResult createPipelineCache(const Device&                    device,
+                               const VkPipelineCacheCreateInfo& createInfo,
+                               PipelineCache& pipelineCache) const noexcept
+  {
+    VkPipelineCache h = {};
+    const VkResult  r = vkCreatePipelineCache(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyPipelineCache}, pipelineCache);
+  }
+
+  VkResult createPipelineLayout(const Device&                     device,
+                                const VkPipelineLayoutCreateInfo& createInfo,
+                                PipelineLayout& pipelineLayout) const noexcept
+  {
+    VkPipelineLayout h = {};
+    const VkResult r = vkCreatePipelineLayout(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyPipelineLayout}, pipelineLayout);
+  }
+
+  VkResult createQueryPool(const Device&                device,
+                           const VkQueryPoolCreateInfo& createInfo,
+                           QueryPool& queryPool) const noexcept
+  {
+    VkQueryPool    h = {};
+    const VkResult r = vkCreateQueryPool(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyQueryPool}, queryPool);
+  }
+
+  VkResult createRenderPass(const Device&                 device,
+                            const VkRenderPassCreateInfo& createInfo,
+                            RenderPass& renderPass) const noexcept
+  {
+    VkRenderPass   h = {};
+    const VkResult r = vkCreateRenderPass(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyRenderPass}, renderPass);
+  }
+
+  VkResult createSampler(const Device&              device,
+                         const VkSamplerCreateInfo& createInfo,
+                         Sampler&                   sampler) const noexcept
+  {
+    VkSampler      h = {};
+    const VkResult r = vkCreateSampler(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroySampler}, sampler);
+  }
+
+  VkResult createSemaphore(const Device&                device,
+                           const VkSemaphoreCreateInfo& createInfo,
+                           Semaphore& semaphore) const noexcept
+  {
+    VkSemaphore    h = {};
+    const VkResult r = vkCreateSemaphore(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroySemaphore}, semaphore);
+  }
+
+  VkResult createShaderModule(const Device&                   device,
+                              const VkShaderModuleCreateInfo& createInfo,
+                              ShaderModule& shaderModule) const noexcept
+  {
+    VkShaderModule h = {};
+    const VkResult r = vkCreateShaderModule(device, &createInfo, nullptr, &h);
+
+    return wrapResult(r, h, {device, vkDestroyShaderModule}, shaderModule);
+  }
+
+  VkResult deviceWaitIdle(const Device& device) const noexcept
+  {
+    return vkDeviceWaitIdle(device);
+  }
+
+  template<class Vector>
+  VkResult enumerateDeviceExtensionProperties(
+    const PhysicalDevice& physicalDevice,
+    const char* const     layerName,
+    Vector&               properties) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkExtensionProperties>(
+      properties,
+      vkEnumerateDeviceExtensionProperties,
+      physicalDevice,
+      layerName);
+  }
+
+  template<class Vector>
+  VkResult enumerateDeviceExtensionProperties(
+    const PhysicalDevice& physicalDevice,
+    Vector&               properties) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkExtensionProperties>(
+      properties,
+      vkEnumerateDeviceExtensionProperties,
+      physicalDevice,
+      nullptr);
+  }
+
+  template<class Vector>
+  VkResult enumeratePhysicalDevices(const Instance& instance,
+                                    Vector& physicalDevices) const noexcept
+  {
+    uint32_t count = 0u;
+    VkResult r     = vkEnumeratePhysicalDevices(instance, &count, nullptr);
+    if (r > VK_INCOMPLETE) {
+      return r;
+    }
+
+    physicalDevices = Vector(count);
+    if ((r = vkEnumeratePhysicalDevices(
+           instance, &count, physicalDevices.data()))) {
+      return r;
+    }
+
+    return VK_SUCCESS;
+  }
+
+  sk::Queue getDeviceQueue(const Device&  device,
+                           const uint32_t queueFamilyIndex,
+                           const uint32_t queueIndex) const noexcept
+  {
+    VkQueue queue{};
+    vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, &queue);
+    return sk::Queue{queue};
+  }
+
+  VkPhysicalDeviceMemoryProperties getPhysicalDeviceMemoryProperties(
+    VkPhysicalDevice physicalDevice) const noexcept
+  {
+    VkPhysicalDeviceMemoryProperties properties{};
+    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &properties);
+    return properties;
+  }
+
+  VkPhysicalDeviceProperties getPhysicalDeviceProperties(
+    const PhysicalDevice& physicalDevice) const noexcept
+  {
+    VkPhysicalDeviceProperties properties{};
+    vkGetPhysicalDeviceProperties(physicalDevice, &properties);
+    return properties;
+  }
+
+  template<class Vector>
+  VkResult getPhysicalDeviceQueueFamilyProperties(
+    const PhysicalDevice& physicalDevice,
+    Vector&               queueFamilyProperties) const noexcept
+  {
+    uint32_t count = 0u;
+    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, nullptr);
+
+    queueFamilyProperties = Vector(count);
+    vkGetPhysicalDeviceQueueFamilyProperties(
+      physicalDevice, &count, queueFamilyProperties.data());
+
+    return VK_SUCCESS;
+  }
+
+  VkMemoryRequirements getBufferMemoryRequirements(
+    const Device& device,
+    const Buffer& buffer) const noexcept
+  {
+    VkMemoryRequirements requirements;
+    vkGetBufferMemoryRequirements(device, buffer, &requirements);
+    return requirements;
+  }
+
+  VkResult allocateMemory(const Device&               device,
+                          const VkMemoryAllocateInfo& info,
+                          DeviceMemory&               memory) const noexcept
+  {
+    VkDeviceMemory h = {};
+    if (const VkResult r = vkAllocateMemory(device, &info, nullptr, &h)) {
+      return r;
+    }
+
+    if (!h) {
+      return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+    }
+
+    memory = DeviceMemory{h, {device, vkFreeMemory}};
+    return VK_SUCCESS;
+  }
+
+  VkResult mapMemory(const Device&       device,
+                     const DeviceMemory& memory,
+                     VkDeviceSize        offset,
+                     VkDeviceSize        size,
+                     VkMemoryMapFlags    flags,
+                     MappedMemory&       mappedMemory) const noexcept
+  {
+    void* data = nullptr;
+    if (const VkResult r =
+          vkMapMemory(device, memory, offset, size, flags, &data)) {
+      return r;
+    }
+
+    mappedMemory = MappedMemory{*this, device, memory, data};
+    return VK_SUCCESS;
+  }
+
+  VkResult queueSubmit(const Queue&        queue,
+                       uint32_t            submitCount,
+                       const VkSubmitInfo& submits,
+                       const Fence&        fence) const noexcept
+  {
+    return vkQueueSubmit(queue, submitCount, &submits, fence);
+  }
+
+  VkResult queueSubmit(const Queue&        queue,
+                       const VkSubmitInfo& submit,
+                       const Fence&        fence) const noexcept
+  {
+    return vkQueueSubmit(queue, 1u, &submit, fence);
+  }
+
+  template<size_t descriptorWriteCount, size_t descriptorCopyCount>
+  void updateDescriptorSets(
+    const Device&                                          device,
+    std::array<VkWriteDescriptorSet, descriptorWriteCount> descriptorWrites,
+    std::array<VkCopyDescriptorSet, descriptorCopyCount>   descriptorCopies)
+    const noexcept
+  {
+    vkUpdateDescriptorSets(device,
+                           static_cast<uint32_t>(descriptorWrites.size()),
+                           descriptorWrites.data(),
+                           static_cast<uint32_t>(descriptorCopies.size()),
+                           descriptorCopies.data());
+  }
+
+  VkResult resetFence(const Device& device, const Fence& fence) const noexcept
+  {
+    VkFence h = fence;
+    return vkResetFences(device, 1u, &h);
+  }
+
+  VkResult waitForFence(const Device& device,
+                        const Fence&  fence,
+                        uint64_t      timeout) const noexcept
+  {
+    VkFence h = fence;
+    return vkWaitForFences(device, 1u, &h, VK_TRUE, timeout);
+  }
+
+  VkResult waitForFence(const Device& device, const Fence& fence) const noexcept
+  {
+    VkFence h = fence;
+    return vkWaitForFences(device, 1u, &h, VK_TRUE, UINT64_MAX);
+  }
+
+  // Scoped command buffer interface
+  SYBOK_NODISCARD
+  CommandScope beginCommandBuffer(
+    VkCommandBuffer          commandBuffer,
+    VkCommandBufferBeginInfo beginInfo) const noexcept;
+
+  // VK_EXT_debug_report
+
+  VkResult createDebugReportCallbackEXT(
+    const Instance&                           instance,
+    const VkDebugReportCallbackCreateInfoEXT& createInfo,
+    DebugReportCallbackEXT&                   callback) const noexcept
+  {
+    VkDebugReportCallbackEXT h = {};
+
+    if (const VkResult r =
+          vkCreateDebugReportCallbackEXT(instance, &createInfo, nullptr, &h)) {
+      return r;
+    }
+
+    if (!h) {
+      return VK_ERROR_FEATURE_NOT_PRESENT;
+    }
+
+    callback = {h, {instance, vkDestroyDebugReportCallbackEXT}};
+    return VK_SUCCESS;
+  }
+
+  // VK_KHR_surface
+
+  VkResult getPhysicalDeviceSurfaceCapabilitiesKHR(
+    const PhysicalDevice&     physicalDevice,
+    const SurfaceKHR&         surface,
+    VkSurfaceCapabilitiesKHR& capabilities) const noexcept
+  {
+    return vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+      physicalDevice, surface, &capabilities);
+  }
+
+  template<typename Vector>
+  VkResult getPhysicalDeviceSurfaceFormatsKHR(
+    const PhysicalDevice& physicalDevice,
+    const SurfaceKHR&     surface,
+    Vector&               surfaceFormats) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkSurfaceFormatKHR>(
+      surfaceFormats,
+      vkGetPhysicalDeviceSurfaceFormatsKHR,
+      physicalDevice,
+      surface.get());
+  }
+
+  template<typename Vector>
+  VkResult getPhysicalDeviceSurfacePresentModesKHR(
+    const PhysicalDevice& physicalDevice,
+    const SurfaceKHR&     surface,
+    Vector&               presentModes) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkPresentModeKHR>(
+      presentModes,
+      vkGetPhysicalDeviceSurfacePresentModesKHR,
+      physicalDevice,
+      surface.get());
+  }
+
+  VkResult getPhysicalDeviceSurfaceSupportKHR(
+    const PhysicalDevice& physicalDevice,
+    uint32_t              queueFamilyIndex,
+    const SurfaceKHR&     surface,
+    bool&                 supported) const noexcept
+  {
+    VkBool32 s = {};
+
+    if (VkResult r = vkGetPhysicalDeviceSurfaceSupportKHR(
+          physicalDevice, queueFamilyIndex, surface, &s)) {
+      return r;
+    }
+
+    supported = s;
+    return VK_SUCCESS;
+  }
+
+  // VK_KHR_swapchain
+
+  VkResult acquireNextImageKHR(const Device&                   device,
+                               const SwapchainKHR&             swapchain,
+                               uint64_t                        timeout,
+                               const Semaphore&                semaphore,
+                               const OptionalParameter<Fence>& fence,
+                               uint32_t* pImageIndex) const noexcept
+  {
+    return vkAcquireNextImageKHR(
+      device, swapchain, timeout, semaphore, fence.get(), pImageIndex);
+  }
+
+  template<class Vector>
+  VkResult getSwapchainImagesKHR(const Device&       device,
+                                 const SwapchainKHR& swapchain,
+                                 Vector&             images) const noexcept
+  {
+    return detail::wrapVectorAccessor<VkImage>(
+      images, vkGetSwapchainImagesKHR, device.get(), swapchain.get());
+  }
+
+  VkResult createSwapchainKHR(const Device&                   device,
+                              const VkSwapchainCreateInfoKHR& createInfo,
+                              SwapchainKHR& swapchain) const noexcept
+  {
+    VkSwapchainKHR h = {};
+    const VkResult r = vkCreateSwapchainKHR(device, &createInfo, nullptr, &h);
+
+    if (r) {
+      return r;
+    }
+
+    if (!h) {
+      return VK_ERROR_INCOMPATIBLE_DRIVER;
+    }
+
+    swapchain = {h, {device, vkDestroySwapchainKHR}};
+    return VK_SUCCESS;
+  }
+
+  VkResult queuePresentKHR(const Queue&            queue,
+                           const VkPresentInfoKHR& presentInfo) const noexcept
+  {
+    return vkQueuePresentKHR(queue, &presentInfo);
+  }
 
 #define SK_FUNC(name) \
-	PFN_##name name {} // NOLINT
-
-	// Vulkan 1.0 Core
-	SK_FUNC(vkAllocateCommandBuffers);
-	SK_FUNC(vkAllocateDescriptorSets);
-	SK_FUNC(vkAllocateMemory);
-	SK_FUNC(vkBeginCommandBuffer);
-	SK_FUNC(vkBindBufferMemory);
-	SK_FUNC(vkBindImageMemory);
-	SK_FUNC(vkCmdBeginQuery);
-	SK_FUNC(vkCmdBeginRenderPass);
-	SK_FUNC(vkCmdBindDescriptorSets);
-	SK_FUNC(vkCmdBindIndexBuffer);
-	SK_FUNC(vkCmdBindPipeline);
-	SK_FUNC(vkCmdBindVertexBuffers);
-	SK_FUNC(vkCmdBlitImage);
-	SK_FUNC(vkCmdClearAttachments);
-	SK_FUNC(vkCmdClearColorImage);
-	SK_FUNC(vkCmdClearDepthStencilImage);
-	SK_FUNC(vkCmdCopyBuffer);
-	SK_FUNC(vkCmdCopyBufferToImage);
-	SK_FUNC(vkCmdCopyImage);
-	SK_FUNC(vkCmdCopyImageToBuffer);
-	SK_FUNC(vkCmdCopyQueryPoolResults);
-	SK_FUNC(vkCmdDispatch);
-	SK_FUNC(vkCmdDispatchIndirect);
-	SK_FUNC(vkCmdDraw);
-	SK_FUNC(vkCmdDrawIndexed);
-	SK_FUNC(vkCmdDrawIndexedIndirect);
-	SK_FUNC(vkCmdDrawIndirect);
-	SK_FUNC(vkCmdEndQuery);
-	SK_FUNC(vkCmdEndRenderPass);
-	SK_FUNC(vkCmdExecuteCommands);
-	SK_FUNC(vkCmdFillBuffer);
-	SK_FUNC(vkCmdNextSubpass);
-	SK_FUNC(vkCmdPipelineBarrier);
-	SK_FUNC(vkCmdPushConstants);
-	SK_FUNC(vkCmdResetEvent);
-	SK_FUNC(vkCmdResetQueryPool);
-	SK_FUNC(vkCmdResolveImage);
-	SK_FUNC(vkCmdSetBlendConstants);
-	SK_FUNC(vkCmdSetDepthBias);
-	SK_FUNC(vkCmdSetDepthBounds);
-	SK_FUNC(vkCmdSetEvent);
-	SK_FUNC(vkCmdSetLineWidth);
-	SK_FUNC(vkCmdSetScissor);
-	SK_FUNC(vkCmdSetStencilCompareMask);
-	SK_FUNC(vkCmdSetStencilReference);
-	SK_FUNC(vkCmdSetStencilWriteMask);
-	SK_FUNC(vkCmdSetViewport);
-	SK_FUNC(vkCmdUpdateBuffer);
-	SK_FUNC(vkCmdWaitEvents);
-	SK_FUNC(vkCmdWriteTimestamp);
-	SK_FUNC(vkCreateBuffer);
-	SK_FUNC(vkCreateBufferView);
-	SK_FUNC(vkCreateCommandPool);
-	SK_FUNC(vkCreateComputePipelines);
-	SK_FUNC(vkCreateDescriptorPool);
-	SK_FUNC(vkCreateDescriptorSetLayout);
-	SK_FUNC(vkCreateDevice);
-	SK_FUNC(vkCreateEvent);
-	SK_FUNC(vkCreateFence);
-	SK_FUNC(vkCreateFramebuffer);
-	SK_FUNC(vkCreateGraphicsPipelines);
-	SK_FUNC(vkCreateImage);
-	SK_FUNC(vkCreateImageView);
-	SK_FUNC(vkCreateInstance);
-	SK_FUNC(vkCreatePipelineCache);
-	SK_FUNC(vkCreatePipelineLayout);
-	SK_FUNC(vkCreateQueryPool);
-	SK_FUNC(vkCreateRenderPass);
-	SK_FUNC(vkCreateSampler);
-	SK_FUNC(vkCreateSemaphore);
-	SK_FUNC(vkCreateShaderModule);
-	SK_FUNC(vkDestroyBuffer);
-	SK_FUNC(vkDestroyBufferView);
-	SK_FUNC(vkDestroyCommandPool);
-	SK_FUNC(vkDestroyDescriptorPool);
-	SK_FUNC(vkDestroyDescriptorSetLayout);
-	SK_FUNC(vkDestroyDevice);
-	SK_FUNC(vkDestroyEvent);
-	SK_FUNC(vkDestroyFence);
-	SK_FUNC(vkDestroyFramebuffer);
-	SK_FUNC(vkDestroyImage);
-	SK_FUNC(vkDestroyImageView);
-	SK_FUNC(vkDestroyPipeline);
-	SK_FUNC(vkDestroyPipelineCache);
-	SK_FUNC(vkDestroyPipelineLayout);
-	SK_FUNC(vkDestroyQueryPool);
-	SK_FUNC(vkDestroyRenderPass);
-	SK_FUNC(vkDestroySampler);
-	SK_FUNC(vkDestroySemaphore);
-	SK_FUNC(vkDestroyShaderModule);
-	SK_FUNC(vkDeviceWaitIdle);
-	SK_FUNC(vkEndCommandBuffer);
-	SK_FUNC(vkEnumerateDeviceExtensionProperties);
-	SK_FUNC(vkEnumerateDeviceLayerProperties);
-	SK_FUNC(vkEnumeratePhysicalDevices);
-	SK_FUNC(vkFlushMappedMemoryRanges);
-	SK_FUNC(vkFreeCommandBuffers);
-	SK_FUNC(vkFreeDescriptorSets);
-	SK_FUNC(vkFreeMemory);
-	SK_FUNC(vkGetBufferMemoryRequirements);
-	SK_FUNC(vkGetDeviceMemoryCommitment);
-	SK_FUNC(vkGetDeviceProcAddr);
-	SK_FUNC(vkGetDeviceQueue);
-	SK_FUNC(vkGetEventStatus);
-	SK_FUNC(vkGetFenceStatus);
-	SK_FUNC(vkGetImageMemoryRequirements);
-	SK_FUNC(vkGetImageSparseMemoryRequirements);
-	SK_FUNC(vkGetImageSubresourceLayout);
-	SK_FUNC(vkGetInstanceProcAddr);
-	SK_FUNC(vkGetPhysicalDeviceFeatures);
-	SK_FUNC(vkGetPhysicalDeviceFormatProperties);
-	SK_FUNC(vkGetPhysicalDeviceImageFormatProperties);
-	SK_FUNC(vkGetPhysicalDeviceMemoryProperties);
-	SK_FUNC(vkGetPhysicalDeviceProperties);
-	SK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties);
-	SK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties);
-	SK_FUNC(vkGetPipelineCacheData);
-	SK_FUNC(vkGetQueryPoolResults);
-	SK_FUNC(vkGetRenderAreaGranularity);
-	SK_FUNC(vkInvalidateMappedMemoryRanges);
-	SK_FUNC(vkMapMemory);
-	SK_FUNC(vkMergePipelineCaches);
-	SK_FUNC(vkQueueBindSparse);
-	SK_FUNC(vkQueueSubmit);
-	SK_FUNC(vkQueueWaitIdle);
-	SK_FUNC(vkResetCommandBuffer);
-	SK_FUNC(vkResetCommandPool);
-	SK_FUNC(vkResetDescriptorPool);
-	SK_FUNC(vkResetEvent);
-	SK_FUNC(vkResetFences);
-	SK_FUNC(vkSetEvent);
-	SK_FUNC(vkUnmapMemory);
-	SK_FUNC(vkUpdateDescriptorSets);
-	SK_FUNC(vkWaitForFences);
-
-	// VK_EXT_debug_report
-	SK_FUNC(vkCreateDebugReportCallbackEXT);
-	SK_FUNC(vkDebugReportMessageEXT);
-	SK_FUNC(vkDestroyDebugReportCallbackEXT);
-
-	// VK_KHR_surface
-	SK_FUNC(vkDestroySurfaceKHR);
-	SK_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
-	SK_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR);
-	SK_FUNC(vkGetPhysicalDeviceSurfacePresentModesKHR);
-	SK_FUNC(vkGetPhysicalDeviceSurfaceSupportKHR);
-
-	// VK_KHR_swapchain
-	SK_FUNC(vkAcquireNextImageKHR);
-	SK_FUNC(vkCreateSwapchainKHR);
-	SK_FUNC(vkDestroySwapchainKHR);
-	SK_FUNC(vkGetDeviceGroupPresentCapabilitiesKHR);
-	SK_FUNC(vkGetDeviceGroupSurfacePresentModesKHR);
-	SK_FUNC(vkGetPhysicalDevicePresentRectanglesKHR);
-	SK_FUNC(vkGetSwapchainImagesKHR);
-	SK_FUNC(vkQueuePresentKHR);
+  PFN_##name name {} // NOLINT
+
+  // Vulkan 1.0 Core
+  SK_FUNC(vkAllocateCommandBuffers);
+  SK_FUNC(vkAllocateDescriptorSets);
+  SK_FUNC(vkAllocateMemory);
+  SK_FUNC(vkBeginCommandBuffer);
+  SK_FUNC(vkBindBufferMemory);
+  SK_FUNC(vkBindImageMemory);
+  SK_FUNC(vkCmdBeginQuery);
+  SK_FUNC(vkCmdBeginRenderPass);
+  SK_FUNC(vkCmdBindDescriptorSets);
+  SK_FUNC(vkCmdBindIndexBuffer);
+  SK_FUNC(vkCmdBindPipeline);
+  SK_FUNC(vkCmdBindVertexBuffers);
+  SK_FUNC(vkCmdBlitImage);
+  SK_FUNC(vkCmdClearAttachments);
+  SK_FUNC(vkCmdClearColorImage);
+  SK_FUNC(vkCmdClearDepthStencilImage);
+  SK_FUNC(vkCmdCopyBuffer);
+  SK_FUNC(vkCmdCopyBufferToImage);
+  SK_FUNC(vkCmdCopyImage);
+  SK_FUNC(vkCmdCopyImageToBuffer);
+  SK_FUNC(vkCmdCopyQueryPoolResults);
+  SK_FUNC(vkCmdDispatch);
+  SK_FUNC(vkCmdDispatchIndirect);
+  SK_FUNC(vkCmdDraw);
+  SK_FUNC(vkCmdDrawIndexed);
+  SK_FUNC(vkCmdDrawIndexedIndirect);
+  SK_FUNC(vkCmdDrawIndirect);
+  SK_FUNC(vkCmdEndQuery);
+  SK_FUNC(vkCmdEndRenderPass);
+  SK_FUNC(vkCmdExecuteCommands);
+  SK_FUNC(vkCmdFillBuffer);
+  SK_FUNC(vkCmdNextSubpass);
+  SK_FUNC(vkCmdPipelineBarrier);
+  SK_FUNC(vkCmdPushConstants);
+  SK_FUNC(vkCmdResetEvent);
+  SK_FUNC(vkCmdResetQueryPool);
+  SK_FUNC(vkCmdResolveImage);
+  SK_FUNC(vkCmdSetBlendConstants);
+  SK_FUNC(vkCmdSetDepthBias);
+  SK_FUNC(vkCmdSetDepthBounds);
+  SK_FUNC(vkCmdSetEvent);
+  SK_FUNC(vkCmdSetLineWidth);
+  SK_FUNC(vkCmdSetScissor);
+  SK_FUNC(vkCmdSetStencilCompareMask);
+  SK_FUNC(vkCmdSetStencilReference);
+  SK_FUNC(vkCmdSetStencilWriteMask);
+  SK_FUNC(vkCmdSetViewport);
+  SK_FUNC(vkCmdUpdateBuffer);
+  SK_FUNC(vkCmdWaitEvents);
+  SK_FUNC(vkCmdWriteTimestamp);
+  SK_FUNC(vkCreateBuffer);
+  SK_FUNC(vkCreateBufferView);
+  SK_FUNC(vkCreateCommandPool);
+  SK_FUNC(vkCreateComputePipelines);
+  SK_FUNC(vkCreateDescriptorPool);
+  SK_FUNC(vkCreateDescriptorSetLayout);
+  SK_FUNC(vkCreateDevice);
+  SK_FUNC(vkCreateEvent);
+  SK_FUNC(vkCreateFence);
+  SK_FUNC(vkCreateFramebuffer);
+  SK_FUNC(vkCreateGraphicsPipelines);
+  SK_FUNC(vkCreateImage);
+  SK_FUNC(vkCreateImageView);
+  SK_FUNC(vkCreateInstance);
+  SK_FUNC(vkCreatePipelineCache);
+  SK_FUNC(vkCreatePipelineLayout);
+  SK_FUNC(vkCreateQueryPool);
+  SK_FUNC(vkCreateRenderPass);
+  SK_FUNC(vkCreateSampler);
+  SK_FUNC(vkCreateSemaphore);
+  SK_FUNC(vkCreateShaderModule);
+  SK_FUNC(vkDestroyBuffer);
+  SK_FUNC(vkDestroyBufferView);
+  SK_FUNC(vkDestroyCommandPool);
+  SK_FUNC(vkDestroyDescriptorPool);
+  SK_FUNC(vkDestroyDescriptorSetLayout);
+  SK_FUNC(vkDestroyDevice);
+  SK_FUNC(vkDestroyEvent);
+  SK_FUNC(vkDestroyFence);
+  SK_FUNC(vkDestroyFramebuffer);
+  SK_FUNC(vkDestroyImage);
+  SK_FUNC(vkDestroyImageView);
+  SK_FUNC(vkDestroyPipeline);
+  SK_FUNC(vkDestroyPipelineCache);
+  SK_FUNC(vkDestroyPipelineLayout);
+  SK_FUNC(vkDestroyQueryPool);
+  SK_FUNC(vkDestroyRenderPass);
+  SK_FUNC(vkDestroySampler);
+  SK_FUNC(vkDestroySemaphore);
+  SK_FUNC(vkDestroyShaderModule);
+  SK_FUNC(vkDeviceWaitIdle);
+  SK_FUNC(vkEndCommandBuffer);
+  SK_FUNC(vkEnumerateDeviceExtensionProperties);
+  SK_FUNC(vkEnumerateDeviceLayerProperties);
+  SK_FUNC(vkEnumeratePhysicalDevices);
+  SK_FUNC(vkFlushMappedMemoryRanges);
+  SK_FUNC(vkFreeCommandBuffers);
+  SK_FUNC(vkFreeDescriptorSets);
+  SK_FUNC(vkFreeMemory);
+  SK_FUNC(vkGetBufferMemoryRequirements);
+  SK_FUNC(vkGetDeviceMemoryCommitment);
+  SK_FUNC(vkGetDeviceProcAddr);
+  SK_FUNC(vkGetDeviceQueue);
+  SK_FUNC(vkGetEventStatus);
+  SK_FUNC(vkGetFenceStatus);
+  SK_FUNC(vkGetImageMemoryRequirements);
+  SK_FUNC(vkGetImageSparseMemoryRequirements);
+  SK_FUNC(vkGetImageSubresourceLayout);
+  SK_FUNC(vkGetInstanceProcAddr);
+  SK_FUNC(vkGetPhysicalDeviceFeatures);
+  SK_FUNC(vkGetPhysicalDeviceFormatProperties);
+  SK_FUNC(vkGetPhysicalDeviceImageFormatProperties);
+  SK_FUNC(vkGetPhysicalDeviceMemoryProperties);
+  SK_FUNC(vkGetPhysicalDeviceProperties);
+  SK_FUNC(vkGetPhysicalDeviceQueueFamilyProperties);
+  SK_FUNC(vkGetPhysicalDeviceSparseImageFormatProperties);
+  SK_FUNC(vkGetPipelineCacheData);
+  SK_FUNC(vkGetQueryPoolResults);
+  SK_FUNC(vkGetRenderAreaGranularity);
+  SK_FUNC(vkInvalidateMappedMemoryRanges);
+  SK_FUNC(vkMapMemory);
+  SK_FUNC(vkMergePipelineCaches);
+  SK_FUNC(vkQueueBindSparse);
+  SK_FUNC(vkQueueSubmit);
+  SK_FUNC(vkQueueWaitIdle);
+  SK_FUNC(vkResetCommandBuffer);
+  SK_FUNC(vkResetCommandPool);
+  SK_FUNC(vkResetDescriptorPool);
+  SK_FUNC(vkResetEvent);
+  SK_FUNC(vkResetFences);
+  SK_FUNC(vkSetEvent);
+  SK_FUNC(vkUnmapMemory);
+  SK_FUNC(vkUpdateDescriptorSets);
+  SK_FUNC(vkWaitForFences);
+
+  // VK_EXT_debug_report
+  SK_FUNC(vkCreateDebugReportCallbackEXT);
+  SK_FUNC(vkDebugReportMessageEXT);
+  SK_FUNC(vkDestroyDebugReportCallbackEXT);
+
+  // VK_KHR_surface
+  SK_FUNC(vkDestroySurfaceKHR);
+  SK_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+  SK_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR);
+  SK_FUNC(vkGetPhysicalDeviceSurfacePresentModesKHR);
+  SK_FUNC(vkGetPhysicalDeviceSurfaceSupportKHR);
+
+  // VK_KHR_swapchain
+  SK_FUNC(vkAcquireNextImageKHR);
+  SK_FUNC(vkCreateSwapchainKHR);
+  SK_FUNC(vkDestroySwapchainKHR);
+  SK_FUNC(vkGetDeviceGroupPresentCapabilitiesKHR);
+  SK_FUNC(vkGetDeviceGroupSurfacePresentModesKHR);
+  SK_FUNC(vkGetPhysicalDevicePresentRectanglesKHR);
+  SK_FUNC(vkGetSwapchainImagesKHR);
+  SK_FUNC(vkQueuePresentKHR);
 
 #undef SK_FUNC
 
 private:
-	template<class T>
-	static inline VkResult wrapResult(const VkResult           r,
-	                                  const typename T::Handle handle,
-	                                  typename T::Deleter&&    deleter,
-	                                  T&                       result) noexcept
-	{
-		if (r) {
-			return r;
-		} else if (!handle) {
-			return VK_ERROR_INITIALIZATION_FAILED;
-		}
-
-		result = T{handle, std::move(deleter)};
-		return VK_SUCCESS;
-	}
+  template<class T>
+  static inline VkResult wrapResult(const VkResult           r,
+                                    const typename T::Handle handle,
+                                    typename T::Deleter&&    deleter,
+                                    T&                       result) noexcept
+  {
+    if (r) {
+      return r;
+    }
+
+    if (!handle) {
+      return VK_ERROR_INITIALIZATION_FAILED;
+    }
+
+    result = T{handle, std::move(deleter)};
+    return VK_SUCCESS;
+  }
 };
 
 /// Scope for commands that work both inside and outside a render pass
 class CommonCommandScope
 {
 public:
-	CommonCommandScope(const VulkanApi& api,
-	                   VkCommandBuffer  commandBuffer,
-	                   VkResult         result) noexcept
-	    : _api{api}
-	    , _commandBuffer{commandBuffer}
-	    , _result{result}
-	{}
-
-	CommonCommandScope(const CommonCommandScope&) noexcept = delete;
-	CommonCommandScope& operator=(const CommonCommandScope&) noexcept = delete;
-
-	CommonCommandScope(CommonCommandScope&& scope) noexcept
-	    : _api{scope._api}
-	    , _commandBuffer{scope._commandBuffer}
-	{
-		scope._commandBuffer = {};
-	}
-
-	CommonCommandScope& operator=(CommonCommandScope&&) = delete;
-
-	~CommonCommandScope() noexcept = default;
-
-	explicit operator bool() const noexcept { return _result == VK_SUCCESS; }
-
-	VkResult error() const noexcept { return _result; }
-
-	void bindPipeline(VkPipelineBindPoint pipelineBindPoint,
-	                  VkPipeline          pipeline) const noexcept
-	{
-		_api.vkCmdBindPipeline(_commandBuffer, pipelineBindPoint, pipeline);
-	}
-
-	void setViewport(uint32_t          firstViewport,
-	                 uint32_t          viewportCount,
-	                 const VkViewport* pViewports) const noexcept
-	{
-		_api.vkCmdSetViewport(_commandBuffer,
-		                      firstViewport,
-		                      viewportCount,
-		                      pViewports);
-	}
-
-	void setScissor(uint32_t        firstScissor,
-	                uint32_t        scissorCount,
-	                const VkRect2D* pScissors) const noexcept
-	{
-		_api.vkCmdSetScissor(_commandBuffer,
-		                     firstScissor,
-		                     scissorCount,
-		                     pScissors);
-	}
-
-	void setLineWidth(float lineWidth) const noexcept
-	{
-		_api.vkCmdSetLineWidth(_commandBuffer, lineWidth);
-	}
-
-	void setDepthBias(float depthBiasConstantFactor,
-	                  float depthBiasClamp,
-	                  float depthBiasSlopeFactor) const noexcept
-	{
-		_api.vkCmdSetDepthBias(_commandBuffer,
-		                       depthBiasConstantFactor,
-		                       depthBiasClamp,
-		                       depthBiasSlopeFactor);
-	}
-
-	void setBlendConstants(const float blendConstants[4]) const noexcept
-	{
-		_api.vkCmdSetBlendConstants(_commandBuffer, blendConstants);
-	}
-
-	void
-	setDepthBounds(float minDepthBounds, float maxDepthBounds) const noexcept
-	{
-		_api.vkCmdSetDepthBounds(_commandBuffer,
-		                         minDepthBounds,
-		                         maxDepthBounds);
-	}
-
-	void setStencilCompareMask(VkStencilFaceFlags faceMask,
-	                           uint32_t           compareMask) const noexcept
-	{
-		_api.vkCmdSetStencilCompareMask(_commandBuffer, faceMask, compareMask);
-	}
-
-	void setStencilWriteMask(VkStencilFaceFlags faceMask,
-	                         uint32_t           writeMask) const noexcept
-	{
-		_api.vkCmdSetStencilWriteMask(_commandBuffer, faceMask, writeMask);
-	}
-
-	void setStencilReference(VkStencilFaceFlags faceMask,
-	                         uint32_t           reference) const noexcept
-	{
-		_api.vkCmdSetStencilReference(_commandBuffer, faceMask, reference);
-	}
-
-	void bindDescriptorSets(VkPipelineBindPoint    pipelineBindPoint,
-	                        VkPipelineLayout       layout,
-	                        uint32_t               firstSet,
-	                        uint32_t               descriptorSetCount,
-	                        const VkDescriptorSet* pDescriptorSets,
-	                        uint32_t               dynamicOffsetCount,
-	                        const uint32_t* pDynamicOffsets) const noexcept
-	{
-		_api.vkCmdBindDescriptorSets(_commandBuffer,
-		                             pipelineBindPoint,
-		                             layout,
-		                             firstSet,
-		                             descriptorSetCount,
-		                             pDescriptorSets,
-		                             dynamicOffsetCount,
-		                             pDynamicOffsets);
-	}
-
-	void bindIndexBuffer(VkBuffer     buffer,
-	                     VkDeviceSize offset,
-	                     VkIndexType  indexType) const noexcept
-	{
-		_api.vkCmdBindIndexBuffer(_commandBuffer, buffer, offset, indexType);
-	}
-
-	void bindVertexBuffers(uint32_t            firstBinding,
-	                       uint32_t            bindingCount,
-	                       const VkBuffer*     pBuffers,
-	                       const VkDeviceSize* pOffsets) const noexcept
-	{
-		_api.vkCmdBindVertexBuffers(
-		    _commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-	}
-
-	void
-	waitEvents(uint32_t                     eventCount,
-	           const VkEvent*               pEvents,
-	           VkPipelineStageFlags         srcStageMask,
-	           VkPipelineStageFlags         dstStageMask,
-	           uint32_t                     memoryBarrierCount,
-	           const VkMemoryBarrier*       pMemoryBarriers,
-	           uint32_t                     bufferMemoryBarrierCount,
-	           const VkBufferMemoryBarrier* pBufferMemoryBarriers,
-	           uint32_t                     imageMemoryBarrierCount,
-	           const VkImageMemoryBarrier*  pImageMemoryBarriers) const noexcept
-	{
-		_api.vkCmdWaitEvents(_commandBuffer,
-		                     eventCount,
-		                     pEvents,
-		                     srcStageMask,
-		                     dstStageMask,
-		                     memoryBarrierCount,
-		                     pMemoryBarriers,
-		                     bufferMemoryBarrierCount,
-		                     pBufferMemoryBarriers,
-		                     imageMemoryBarrierCount,
-		                     pImageMemoryBarriers);
-	}
-
-	void pipelineBarrier(
-	    VkPipelineStageFlags         srcStageMask,
-	    VkPipelineStageFlags         dstStageMask,
-	    VkDependencyFlags            dependencyFlags,
-	    uint32_t                     memoryBarrierCount,
-	    const VkMemoryBarrier*       pMemoryBarriers,
-	    uint32_t                     bufferMemoryBarrierCount,
-	    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
-	    uint32_t                     imageMemoryBarrierCount,
-	    const VkImageMemoryBarrier*  pImageMemoryBarriers) const noexcept
-	{
-		_api.vkCmdPipelineBarrier(_commandBuffer,
-		                          srcStageMask,
-		                          dstStageMask,
-		                          dependencyFlags,
-		                          memoryBarrierCount,
-		                          pMemoryBarriers,
-		                          bufferMemoryBarrierCount,
-		                          pBufferMemoryBarriers,
-		                          imageMemoryBarrierCount,
-		                          pImageMemoryBarriers);
-	}
-
-	void beginQuery(VkQueryPool         queryPool,
-	                uint32_t            query,
-	                VkQueryControlFlags flags) const noexcept
-	{
-		_api.vkCmdBeginQuery(_commandBuffer, queryPool, query, flags);
-	}
-
-	void endQuery(VkQueryPool queryPool, uint32_t query) const noexcept
-	{
-		_api.vkCmdEndQuery(_commandBuffer, queryPool, query);
-	}
-
-	void writeTimestamp(VkPipelineStageFlagBits pipelineStage,
-	                    VkQueryPool             queryPool,
-	                    uint32_t                query) const noexcept
-	{
-		_api.vkCmdWriteTimestamp(_commandBuffer,
-		                         pipelineStage,
-		                         queryPool,
-		                         query);
-	}
-
-	void pushConstants(VkPipelineLayout   layout,
-	                   VkShaderStageFlags stageFlags,
-	                   uint32_t           offset,
-	                   uint32_t           size,
-	                   const void*        pValues) const noexcept
-	{
-		_api.vkCmdPushConstants(
-		    _commandBuffer, layout, stageFlags, offset, size, pValues);
-	}
-
-	void executeCommands(uint32_t               commandBufferCount,
-	                     const VkCommandBuffer* pCommandBuffers) const noexcept
-	{
-		_api.vkCmdExecuteCommands(_commandBuffer,
-		                          commandBufferCount,
-		                          pCommandBuffers);
-	}
+  CommonCommandScope(const VulkanApi& api,
+                     VkCommandBuffer  commandBuffer,
+                     VkResult         result) noexcept
+    : _api{api}
+    , _commandBuffer{commandBuffer}
+    , _result{result}
+  {}
+
+  CommonCommandScope(const CommonCommandScope&) noexcept = delete;
+  CommonCommandScope& operator=(const CommonCommandScope&) noexcept = delete;
+
+  CommonCommandScope(CommonCommandScope&& scope) noexcept
+    : _api{scope._api}
+    , _commandBuffer{scope._commandBuffer}
+    , _result{scope._result}
+  {
+    scope._commandBuffer = {};
+  }
+
+  CommonCommandScope& operator=(CommonCommandScope&&) = delete;
+
+  ~CommonCommandScope() noexcept = default;
+
+  explicit operator bool() const noexcept { return _result == VK_SUCCESS; }
+
+  VkResult error() const noexcept { return _result; }
+
+  void bindPipeline(VkPipelineBindPoint pipelineBindPoint,
+                    VkPipeline          pipeline) const noexcept
+  {
+    _api.vkCmdBindPipeline(_commandBuffer, pipelineBindPoint, pipeline);
+  }
+
+  void setViewport(uint32_t          firstViewport,
+                   uint32_t          viewportCount,
+                   const VkViewport* pViewports) const noexcept
+  {
+    _api.vkCmdSetViewport(
+      _commandBuffer, firstViewport, viewportCount, pViewports);
+  }
+
+  void setScissor(uint32_t        firstScissor,
+                  uint32_t        scissorCount,
+                  const VkRect2D* pScissors) const noexcept
+  {
+    _api.vkCmdSetScissor(_commandBuffer, firstScissor, scissorCount, pScissors);
+  }
+
+  void setLineWidth(float lineWidth) const noexcept
+  {
+    _api.vkCmdSetLineWidth(_commandBuffer, lineWidth);
+  }
+
+  void setDepthBias(float depthBiasConstantFactor,
+                    float depthBiasClamp,
+                    float depthBiasSlopeFactor) const noexcept
+  {
+    _api.vkCmdSetDepthBias(_commandBuffer,
+                           depthBiasConstantFactor,
+                           depthBiasClamp,
+                           depthBiasSlopeFactor);
+  }
+
+  void setBlendConstants(const float blendConstants[4]) const noexcept
+  {
+    _api.vkCmdSetBlendConstants(_commandBuffer, blendConstants);
+  }
+
+  void setDepthBounds(float minDepthBounds, float maxDepthBounds) const noexcept
+  {
+    _api.vkCmdSetDepthBounds(_commandBuffer, minDepthBounds, maxDepthBounds);
+  }
+
+  void setStencilCompareMask(VkStencilFaceFlags faceMask,
+                             uint32_t           compareMask) const noexcept
+  {
+    _api.vkCmdSetStencilCompareMask(_commandBuffer, faceMask, compareMask);
+  }
+
+  void setStencilWriteMask(VkStencilFaceFlags faceMask,
+                           uint32_t           writeMask) const noexcept
+  {
+    _api.vkCmdSetStencilWriteMask(_commandBuffer, faceMask, writeMask);
+  }
+
+  void setStencilReference(VkStencilFaceFlags faceMask,
+                           uint32_t           reference) const noexcept
+  {
+    _api.vkCmdSetStencilReference(_commandBuffer, faceMask, reference);
+  }
+
+  void bindDescriptorSets(VkPipelineBindPoint    pipelineBindPoint,
+                          VkPipelineLayout       layout,
+                          uint32_t               firstSet,
+                          uint32_t               descriptorSetCount,
+                          const VkDescriptorSet* pDescriptorSets,
+                          uint32_t               dynamicOffsetCount,
+                          const uint32_t*        pDynamicOffsets) const noexcept
+  {
+    _api.vkCmdBindDescriptorSets(_commandBuffer,
+                                 pipelineBindPoint,
+                                 layout,
+                                 firstSet,
+                                 descriptorSetCount,
+                                 pDescriptorSets,
+                                 dynamicOffsetCount,
+                                 pDynamicOffsets);
+  }
+
+  void bindIndexBuffer(VkBuffer     buffer,
+                       VkDeviceSize offset,
+                       VkIndexType  indexType) const noexcept
+  {
+    _api.vkCmdBindIndexBuffer(_commandBuffer, buffer, offset, indexType);
+  }
+
+  void bindVertexBuffers(uint32_t            firstBinding,
+                         uint32_t            bindingCount,
+                         const VkBuffer*     pBuffers,
+                         const VkDeviceSize* pOffsets) const noexcept
+  {
+    _api.vkCmdBindVertexBuffers(
+      _commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
+  }
+
+  void waitEvents(
+    uint32_t                     eventCount,
+    const VkEvent*               pEvents,
+    VkPipelineStageFlags         srcStageMask,
+    VkPipelineStageFlags         dstStageMask,
+    uint32_t                     memoryBarrierCount,
+    const VkMemoryBarrier*       pMemoryBarriers,
+    uint32_t                     bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+    uint32_t                     imageMemoryBarrierCount,
+    const VkImageMemoryBarrier*  pImageMemoryBarriers) const noexcept
+  {
+    _api.vkCmdWaitEvents(_commandBuffer,
+                         eventCount,
+                         pEvents,
+                         srcStageMask,
+                         dstStageMask,
+                         memoryBarrierCount,
+                         pMemoryBarriers,
+                         bufferMemoryBarrierCount,
+                         pBufferMemoryBarriers,
+                         imageMemoryBarrierCount,
+                         pImageMemoryBarriers);
+  }
+
+  void pipelineBarrier(
+    VkPipelineStageFlags         srcStageMask,
+    VkPipelineStageFlags         dstStageMask,
+    VkDependencyFlags            dependencyFlags,
+    uint32_t                     memoryBarrierCount,
+    const VkMemoryBarrier*       pMemoryBarriers,
+    uint32_t                     bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+    uint32_t                     imageMemoryBarrierCount,
+    const VkImageMemoryBarrier*  pImageMemoryBarriers) const noexcept
+  {
+    _api.vkCmdPipelineBarrier(_commandBuffer,
+                              srcStageMask,
+                              dstStageMask,
+                              dependencyFlags,
+                              memoryBarrierCount,
+                              pMemoryBarriers,
+                              bufferMemoryBarrierCount,
+                              pBufferMemoryBarriers,
+                              imageMemoryBarrierCount,
+                              pImageMemoryBarriers);
+  }
+
+  void beginQuery(VkQueryPool         queryPool,
+                  uint32_t            query,
+                  VkQueryControlFlags flags) const noexcept
+  {
+    _api.vkCmdBeginQuery(_commandBuffer, queryPool, query, flags);
+  }
+
+  void endQuery(VkQueryPool queryPool, uint32_t query) const noexcept
+  {
+    _api.vkCmdEndQuery(_commandBuffer, queryPool, query);
+  }
+
+  void writeTimestamp(VkPipelineStageFlagBits pipelineStage,
+                      VkQueryPool             queryPool,
+                      uint32_t                query) const noexcept
+  {
+    _api.vkCmdWriteTimestamp(_commandBuffer, pipelineStage, queryPool, query);
+  }
+
+  void pushConstants(VkPipelineLayout   layout,
+                     VkShaderStageFlags stageFlags,
+                     uint32_t           offset,
+                     uint32_t           size,
+                     const void*        pValues) const noexcept
+  {
+    _api.vkCmdPushConstants(
+      _commandBuffer, layout, stageFlags, offset, size, pValues);
+  }
+
+  void executeCommands(uint32_t               commandBufferCount,
+                       const VkCommandBuffer* pCommandBuffers) const noexcept
+  {
+    _api.vkCmdExecuteCommands(
+      _commandBuffer, commandBufferCount, pCommandBuffers);
+  }
 
 protected:
-	const VulkanApi& _api;
-	VkCommandBuffer  _commandBuffer;
-	VkResult         _result;
+  const VulkanApi& _api;
+  VkCommandBuffer  _commandBuffer;
+  VkResult         _result;
 };
 
 // Top level command scope outside a render pass
 class CommandScope : public CommonCommandScope
 {
 public:
-	CommandScope(const VulkanApi& api,
-	             VkCommandBuffer  commandBuffer,
-	             VkResult         result) noexcept
-	    : CommonCommandScope{api, commandBuffer, result}
-	{}
-
-	CommandScope(const CommandScope&) = delete;
-	CommandScope& operator=(const CommandScope&) = delete;
-
-	CommandScope(CommandScope&& scope) noexcept
-	    : CommonCommandScope{std::forward<CommandScope>(scope)}
-	{}
-
-	CommandScope& operator=(CommandScope&&) = delete;
-
-	~CommandScope() noexcept
-	{
-		assert(!_commandBuffer); // Buffer must be finished with end()
-	}
-
-	VkResult end() noexcept
-	{
-		if (_commandBuffer) {
-			VkResult r     = _api.vkEndCommandBuffer(_commandBuffer);
-			_commandBuffer = {};
-			return r;
-		}
-
-		return VK_NOT_READY;
-	}
-
-	void dispatch(uint32_t groupCountX,
-	              uint32_t groupCountY,
-	              uint32_t groupCountZ) const noexcept
-	{
-		_api.vkCmdDispatch(_commandBuffer,
-		                   groupCountX,
-		                   groupCountY,
-		                   groupCountZ);
-	}
-
-	void dispatchIndirect(VkBuffer buffer, VkDeviceSize offset) const noexcept
-	{
-		_api.vkCmdDispatchIndirect(_commandBuffer, buffer, offset);
-	}
-
-	void copyBuffer(VkBuffer            srcBuffer,
-	                VkBuffer            dstBuffer,
-	                uint32_t            regionCount,
-	                const VkBufferCopy* pRegions) const noexcept
-	{
-		_api.vkCmdCopyBuffer(
-		    _commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-	}
-
-	void copyImage(VkImage            srcImage,
-	               VkImageLayout      srcImageLayout,
-	               VkImage            dstImage,
-	               VkImageLayout      dstImageLayout,
-	               uint32_t           regionCount,
-	               const VkImageCopy* pRegions) const noexcept
-	{
-		_api.vkCmdCopyImage(_commandBuffer,
-		                    srcImage,
-		                    srcImageLayout,
-		                    dstImage,
-		                    dstImageLayout,
-		                    regionCount,
-		                    pRegions);
-	}
-
-	void blitImage(VkImage            srcImage,
-	               VkImageLayout      srcImageLayout,
-	               VkImage            dstImage,
-	               VkImageLayout      dstImageLayout,
-	               uint32_t           regionCount,
-	               const VkImageBlit* pRegions,
-	               VkFilter           filter) const noexcept
-	{
-		_api.vkCmdBlitImage(_commandBuffer,
-		                    srcImage,
-		                    srcImageLayout,
-		                    dstImage,
-		                    dstImageLayout,
-		                    regionCount,
-		                    pRegions,
-		                    filter);
-	}
-
-	void copyBufferToImage(VkBuffer                 srcBuffer,
-	                       VkImage                  dstImage,
-	                       VkImageLayout            dstImageLayout,
-	                       uint32_t                 regionCount,
-	                       const VkBufferImageCopy* pRegions) const noexcept
-	{
-		_api.vkCmdCopyBufferToImage(_commandBuffer,
-		                            srcBuffer,
-		                            dstImage,
-		                            dstImageLayout,
-		                            regionCount,
-		                            pRegions);
-	}
-
-	void copyImageToBuffer(VkImage                  srcImage,
-	                       VkImageLayout            srcImageLayout,
-	                       VkBuffer                 dstBuffer,
-	                       uint32_t                 regionCount,
-	                       const VkBufferImageCopy* pRegions) const noexcept
-	{
-		_api.vkCmdCopyImageToBuffer(_commandBuffer,
-		                            srcImage,
-		                            srcImageLayout,
-		                            dstBuffer,
-		                            regionCount,
-		                            pRegions);
-	}
-
-	void updateBuffer(VkBuffer     dstBuffer,
-	                  VkDeviceSize dstOffset,
-	                  VkDeviceSize dataSize,
-	                  const void*  pData) const noexcept
-	{
-		_api.vkCmdUpdateBuffer(
-		    _commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-	}
-
-	void fillBuffer(VkBuffer     dstBuffer,
-	                VkDeviceSize dstOffset,
-	                VkDeviceSize size,
-	                uint32_t     data) const noexcept
-	{
-		_api.vkCmdFillBuffer(_commandBuffer, dstBuffer, dstOffset, size, data);
-	}
-
-	void clearColorImage(VkImage                        image,
-	                     VkImageLayout                  imageLayout,
-	                     const VkClearColorValue&       color,
-	                     uint32_t                       rangeCount,
-	                     const VkImageSubresourceRange* pRanges) const noexcept
-	{
-		_api.vkCmdClearColorImage(
-		    _commandBuffer, image, imageLayout, &color, rangeCount, pRanges);
-	}
-
-	void clearDepthStencilImage(
-	    VkImage                         image,
-	    VkImageLayout                   imageLayout,
-	    const VkClearDepthStencilValue& depthStencil,
-	    uint32_t                        rangeCount,
-	    const VkImageSubresourceRange*  pRanges) const noexcept
-	{
-		_api.vkCmdClearDepthStencilImage(_commandBuffer,
-		                                 image,
-		                                 imageLayout,
-		                                 &depthStencil,
-		                                 rangeCount,
-		                                 pRanges);
-	}
-
-	void resolveImage(VkImage               srcImage,
-	                  VkImageLayout         srcImageLayout,
-	                  VkImage               dstImage,
-	                  VkImageLayout         dstImageLayout,
-	                  uint32_t              regionCount,
-	                  const VkImageResolve* pRegions) const noexcept
-	{
-		_api.vkCmdResolveImage(_commandBuffer,
-		                       srcImage,
-		                       srcImageLayout,
-		                       dstImage,
-		                       dstImageLayout,
-		                       regionCount,
-		                       pRegions);
-	}
-
-	void setEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept
-	{
-		_api.vkCmdSetEvent(_commandBuffer, event, stageMask);
-	}
-
-	void
-	resetEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept
-	{
-		_api.vkCmdResetEvent(_commandBuffer, event, stageMask);
-	}
-
-	void resetQueryPool(VkQueryPool queryPool,
-	                    uint32_t    firstQuery,
-	                    uint32_t    queryCount) const noexcept
-	{
-		_api.vkCmdResetQueryPool(_commandBuffer,
-		                         queryPool,
-		                         firstQuery,
-		                         queryCount);
-	}
-
-	void copyQueryPoolResults(VkQueryPool        queryPool,
-	                          uint32_t           firstQuery,
-	                          uint32_t           queryCount,
-	                          VkBuffer           dstBuffer,
-	                          VkDeviceSize       dstOffset,
-	                          VkDeviceSize       stride,
-	                          VkQueryResultFlags flags) const noexcept
-	{
-		_api.vkCmdCopyQueryPoolResults(_commandBuffer,
-		                               queryPool,
-		                               firstQuery,
-		                               queryCount,
-		                               dstBuffer,
-		                               dstOffset,
-		                               stride,
-		                               flags);
-	}
-
-	SYBOK_NODISCARD
-	RenderCommandScope
-	beginRenderPass(const VkRenderPassBeginInfo& renderPassBegin,
-	                VkSubpassContents            contents) const noexcept;
+  CommandScope(const VulkanApi& api,
+               VkCommandBuffer  commandBuffer,
+               VkResult         result) noexcept
+    : CommonCommandScope{api, commandBuffer, result}
+  {}
+
+  CommandScope(const CommandScope&) = delete;
+  CommandScope& operator=(const CommandScope&) = delete;
+
+  CommandScope(CommandScope&& scope) noexcept
+    : CommonCommandScope{std::forward<CommandScope>(scope)}
+  {}
+
+  CommandScope& operator=(CommandScope&&) = delete;
+
+  ~CommandScope() noexcept
+  {
+    assert(!_commandBuffer); // Buffer must be finished with end()
+  }
+
+  VkResult end() noexcept
+  {
+    if (_commandBuffer) {
+      VkResult r     = _api.vkEndCommandBuffer(_commandBuffer);
+      _commandBuffer = {};
+      return r;
+    }
+
+    return VK_NOT_READY;
+  }
+
+  void dispatch(uint32_t groupCountX,
+                uint32_t groupCountY,
+                uint32_t groupCountZ) const noexcept
+  {
+    _api.vkCmdDispatch(_commandBuffer, groupCountX, groupCountY, groupCountZ);
+  }
+
+  void dispatchIndirect(VkBuffer buffer, VkDeviceSize offset) const noexcept
+  {
+    _api.vkCmdDispatchIndirect(_commandBuffer, buffer, offset);
+  }
+
+  void copyBuffer(VkBuffer            srcBuffer,
+                  VkBuffer            dstBuffer,
+                  uint32_t            regionCount,
+                  const VkBufferCopy* pRegions) const noexcept
+  {
+    _api.vkCmdCopyBuffer(
+      _commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
+  }
+
+  void copyImage(VkImage            srcImage,
+                 VkImageLayout      srcImageLayout,
+                 VkImage            dstImage,
+                 VkImageLayout      dstImageLayout,
+                 uint32_t           regionCount,
+                 const VkImageCopy* pRegions) const noexcept
+  {
+    _api.vkCmdCopyImage(_commandBuffer,
+                        srcImage,
+                        srcImageLayout,
+                        dstImage,
+                        dstImageLayout,
+                        regionCount,
+                        pRegions);
+  }
+
+  void blitImage(VkImage            srcImage,
+                 VkImageLayout      srcImageLayout,
+                 VkImage            dstImage,
+                 VkImageLayout      dstImageLayout,
+                 uint32_t           regionCount,
+                 const VkImageBlit* pRegions,
+                 VkFilter           filter) const noexcept
+  {
+    _api.vkCmdBlitImage(_commandBuffer,
+                        srcImage,
+                        srcImageLayout,
+                        dstImage,
+                        dstImageLayout,
+                        regionCount,
+                        pRegions,
+                        filter);
+  }
+
+  void copyBufferToImage(VkBuffer                 srcBuffer,
+                         VkImage                  dstImage,
+                         VkImageLayout            dstImageLayout,
+                         uint32_t                 regionCount,
+                         const VkBufferImageCopy* pRegions) const noexcept
+  {
+    _api.vkCmdCopyBufferToImage(_commandBuffer,
+                                srcBuffer,
+                                dstImage,
+                                dstImageLayout,
+                                regionCount,
+                                pRegions);
+  }
+
+  void copyImageToBuffer(VkImage                  srcImage,
+                         VkImageLayout            srcImageLayout,
+                         VkBuffer                 dstBuffer,
+                         uint32_t                 regionCount,
+                         const VkBufferImageCopy* pRegions) const noexcept
+  {
+    _api.vkCmdCopyImageToBuffer(_commandBuffer,
+                                srcImage,
+                                srcImageLayout,
+                                dstBuffer,
+                                regionCount,
+                                pRegions);
+  }
+
+  void updateBuffer(VkBuffer     dstBuffer,
+                    VkDeviceSize dstOffset,
+                    VkDeviceSize dataSize,
+                    const void*  pData) const noexcept
+  {
+    _api.vkCmdUpdateBuffer(
+      _commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+  }
+
+  void fillBuffer(VkBuffer     dstBuffer,
+                  VkDeviceSize dstOffset,
+                  VkDeviceSize size,
+                  uint32_t     data) const noexcept
+  {
+    _api.vkCmdFillBuffer(_commandBuffer, dstBuffer, dstOffset, size, data);
+  }
+
+  void clearColorImage(VkImage                        image,
+                       VkImageLayout                  imageLayout,
+                       const VkClearColorValue&       color,
+                       uint32_t                       rangeCount,
+                       const VkImageSubresourceRange* pRanges) const noexcept
+  {
+    _api.vkCmdClearColorImage(
+      _commandBuffer, image, imageLayout, &color, rangeCount, pRanges);
+  }
+
+  void clearDepthStencilImage(
+    VkImage                         image,
+    VkImageLayout                   imageLayout,
+    const VkClearDepthStencilValue& depthStencil,
+    uint32_t                        rangeCount,
+    const VkImageSubresourceRange*  pRanges) const noexcept
+  {
+    _api.vkCmdClearDepthStencilImage(
+      _commandBuffer, image, imageLayout, &depthStencil, rangeCount, pRanges);
+  }
+
+  void resolveImage(VkImage               srcImage,
+                    VkImageLayout         srcImageLayout,
+                    VkImage               dstImage,
+                    VkImageLayout         dstImageLayout,
+                    uint32_t              regionCount,
+                    const VkImageResolve* pRegions) const noexcept
+  {
+    _api.vkCmdResolveImage(_commandBuffer,
+                           srcImage,
+                           srcImageLayout,
+                           dstImage,
+                           dstImageLayout,
+                           regionCount,
+                           pRegions);
+  }
+
+  void setEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept
+  {
+    _api.vkCmdSetEvent(_commandBuffer, event, stageMask);
+  }
+
+  void resetEvent(VkEvent event, VkPipelineStageFlags stageMask) const noexcept
+  {
+    _api.vkCmdResetEvent(_commandBuffer, event, stageMask);
+  }
+
+  void resetQueryPool(VkQueryPool queryPool,
+                      uint32_t    firstQuery,
+                      uint32_t    queryCount) const noexcept
+  {
+    _api.vkCmdResetQueryPool(_commandBuffer, queryPool, firstQuery, queryCount);
+  }
+
+  void copyQueryPoolResults(VkQueryPool        queryPool,
+                            uint32_t           firstQuery,
+                            uint32_t           queryCount,
+                            VkBuffer           dstBuffer,
+                            VkDeviceSize       dstOffset,
+                            VkDeviceSize       stride,
+                            VkQueryResultFlags flags) const noexcept
+  {
+    _api.vkCmdCopyQueryPoolResults(_commandBuffer,
+                                   queryPool,
+                                   firstQuery,
+                                   queryCount,
+                                   dstBuffer,
+                                   dstOffset,
+                                   stride,
+                                   flags);
+  }
+
+  SYBOK_NODISCARD
+  RenderCommandScope beginRenderPass(
+    const VkRenderPassBeginInfo& renderPassBegin,
+    VkSubpassContents            contents) const noexcept;
 };
 
 class RenderCommandScope : public CommonCommandScope
 {
 public:
-	RenderCommandScope(const VulkanApi& api,
-	                   VkCommandBuffer  commandBuffer) noexcept
-	    : CommonCommandScope{api, commandBuffer, VK_SUCCESS}
-	{}
-
-	RenderCommandScope(const RenderCommandScope&) = delete;
-	RenderCommandScope& operator=(const RenderCommandScope&) = delete;
-
-	RenderCommandScope(RenderCommandScope&& scope) noexcept
-	    : CommonCommandScope{std::forward<RenderCommandScope>(scope)}
-	{}
-
-	RenderCommandScope& operator=(RenderCommandScope&&) = delete;
-
-	~RenderCommandScope() noexcept { _api.vkCmdEndRenderPass(_commandBuffer); }
-
-	void draw(uint32_t vertexCount,
-	          uint32_t instanceCount,
-	          uint32_t firstVertex,
-	          uint32_t firstInstance) const noexcept
-	{
-		_api.vkCmdDraw(_commandBuffer,
-		               vertexCount,
-		               instanceCount,
-		               firstVertex,
-		               firstInstance);
-	}
-
-	void drawIndexed(uint32_t indexCount,
-	                 uint32_t instanceCount,
-	                 uint32_t firstIndex,
-	                 int32_t  vertexOffset,
-	                 uint32_t firstInstance) const noexcept
-	{
-		_api.vkCmdDrawIndexed(_commandBuffer,
-		                      indexCount,
-		                      instanceCount,
-		                      firstIndex,
-		                      vertexOffset,
-		                      firstInstance);
-	}
-
-	void drawIndirect(VkBuffer     buffer,
-	                  VkDeviceSize offset,
-	                  uint32_t     drawCount,
-	                  uint32_t     stride) const noexcept
-	{
-		_api.vkCmdDrawIndirect(
-		    _commandBuffer, buffer, offset, drawCount, stride);
-	}
-
-	void drawIndexedIndirect(VkBuffer     buffer,
-	                         VkDeviceSize offset,
-	                         uint32_t     drawCount,
-	                         uint32_t     stride) const noexcept
-	{
-		_api.vkCmdDrawIndexedIndirect(
-		    _commandBuffer, buffer, offset, drawCount, stride);
-	}
-
-	void clearAttachments(uint32_t                 attachmentCount,
-	                      const VkClearAttachment& attachments,
-	                      uint32_t                 rectCount,
-	                      const VkClearRect*       pRects) const noexcept
-	{
-		_api.vkCmdClearAttachments(
-		    _commandBuffer, attachmentCount, &attachments, rectCount, pRects);
-	}
-
-	void nextSubpass(VkSubpassContents contents) const noexcept
-	{
-		_api.vkCmdNextSubpass(_commandBuffer, contents);
-	}
+  RenderCommandScope(const VulkanApi& api,
+                     VkCommandBuffer  commandBuffer) noexcept
+    : CommonCommandScope{api, commandBuffer, VK_SUCCESS}
+  {}
+
+  RenderCommandScope(const RenderCommandScope&) = delete;
+  RenderCommandScope& operator=(const RenderCommandScope&) = delete;
+
+  RenderCommandScope(RenderCommandScope&& scope) noexcept
+    : CommonCommandScope{std::forward<RenderCommandScope>(scope)}
+  {}
+
+  RenderCommandScope& operator=(RenderCommandScope&&) = delete;
+
+  ~RenderCommandScope() noexcept { _api.vkCmdEndRenderPass(_commandBuffer); }
+
+  void draw(uint32_t vertexCount,
+            uint32_t instanceCount,
+            uint32_t firstVertex,
+            uint32_t firstInstance) const noexcept
+  {
+    _api.vkCmdDraw(
+      _commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+  }
+
+  void drawIndexed(uint32_t indexCount,
+                   uint32_t instanceCount,
+                   uint32_t firstIndex,
+                   int32_t  vertexOffset,
+                   uint32_t firstInstance) const noexcept
+  {
+    _api.vkCmdDrawIndexed(_commandBuffer,
+                          indexCount,
+                          instanceCount,
+                          firstIndex,
+                          vertexOffset,
+                          firstInstance);
+  }
+
+  void drawIndirect(VkBuffer     buffer,
+                    VkDeviceSize offset,
+                    uint32_t     drawCount,
+                    uint32_t     stride) const noexcept
+  {
+    _api.vkCmdDrawIndirect(_commandBuffer, buffer, offset, drawCount, stride);
+  }
+
+  void drawIndexedIndirect(VkBuffer     buffer,
+                           VkDeviceSize offset,
+                           uint32_t     drawCount,
+                           uint32_t     stride) const noexcept
+  {
+    _api.vkCmdDrawIndexedIndirect(
+      _commandBuffer, buffer, offset, drawCount, stride);
+  }
+
+  void clearAttachments(uint32_t                 attachmentCount,
+                        const VkClearAttachment& attachments,
+                        uint32_t                 rectCount,
+                        const VkClearRect*       pRects) const noexcept
+  {
+    _api.vkCmdClearAttachments(
+      _commandBuffer, attachmentCount, &attachments, rectCount, pRects);
+  }
+
+  void nextSubpass(VkSubpassContents contents) const noexcept
+  {
+    _api.vkCmdNextSubpass(_commandBuffer, contents);
+  }
 };
 
-CommandScope
+inline CommandScope
 VulkanApi::beginCommandBuffer(
-    VkCommandBuffer                commandBuffer,
-    const VkCommandBufferBeginInfo beginInfo) const noexcept
+  VkCommandBuffer                commandBuffer,
+  const VkCommandBufferBeginInfo beginInfo) const noexcept
 {
-	if (const VkResult r = vkBeginCommandBuffer(commandBuffer, &beginInfo)) {
-		return {*this, nullptr, r};
-	}
+  if (const VkResult r = vkBeginCommandBuffer(commandBuffer, &beginInfo)) {
+    return {*this, nullptr, r};
+  }
 
-	return {*this, commandBuffer, VK_SUCCESS};
+  return {*this, commandBuffer, VK_SUCCESS};
 }
 
 inline RenderCommandScope
 CommandScope::beginRenderPass(const VkRenderPassBeginInfo& renderPassBegin,
                               VkSubpassContents contents) const noexcept
 {
-	_api.vkCmdBeginRenderPass(_commandBuffer, &renderPassBegin, contents);
+  _api.vkCmdBeginRenderPass(_commandBuffer, &renderPassBegin, contents);
 
-	return {_api, _commandBuffer};
+  return {_api, _commandBuffer};
 }
 
 inline MappedMemory::~MappedMemory() noexcept
 {
-	if (_api && _memory) {
-		_api->vkUnmapMemory(_device, _memory);
-	}
+  if (_api && _memory) {
+    _api->vkUnmapMemory(_device, _memory);
+  }
 }
 
 } // namespace sk
 
+#ifdef __GNUC__
+#  pragma GCC diagnostic pop
+#endif
+
 #endif // SYBOK_HPP
diff --git a/subprojects/nk_pugl/pugl/include/pugl/cairo.h b/subprojects/nk_pugl/pugl/include/pugl/cairo.h
index d72580d..48e868e 100644
--- a/subprojects/nk_pugl/pugl/include/pugl/cairo.h
+++ b/subprojects/nk_pugl/pugl/include/pugl/cairo.h
@@ -33,7 +33,8 @@ PUGL_BEGIN_DECLS
 
    Pass the returned value to puglSetBackend() to draw to a view with Cairo.
 */
-PUGL_API PUGL_CONST_FUNC const PuglBackend*
+PUGL_CONST_API
+const PuglBackend*
 puglCairoBackend(void);
 
 /**
diff --git a/subprojects/nk_pugl/pugl/include/pugl/gl.h b/subprojects/nk_pugl/pugl/include/pugl/gl.h
index eb86c3d..51c4a7d 100644
--- a/subprojects/nk_pugl/pugl/include/pugl/gl.h
+++ b/subprojects/nk_pugl/pugl/include/pugl/gl.h
@@ -25,25 +25,25 @@
    enable pure portable programs. */
 
 #ifndef PUGL_NO_INCLUDE_GL_H
-#	ifdef __APPLE__
-#		include "OpenGL/gl.h"
-#	else
-#		ifdef _WIN32
-#			include <windows.h>
-#		endif
-#		include "GL/gl.h"
-#	endif
+#  ifdef __APPLE__
+#    include <OpenGL/gl.h>
+#  else
+#    ifdef _WIN32
+#      include <windows.h>
+#    endif
+#    include <GL/gl.h>
+#  endif
 #endif
 
 #ifndef PUGL_NO_INCLUDE_GLU_H
-#	ifdef __APPLE__
-#		include "OpenGL/glu.h"
-#	else
-#		ifdef _WIN32
-#			include <windows.h>
-#		endif
-#		include "GL/glu.h"
-#	endif
+#  ifdef __APPLE__
+#    include <OpenGL/glu.h>
+#  else
+#    ifdef _WIN32
+#      include <windows.h>
+#    endif
+#    include <GL/glu.h>
+#  endif
 #endif
 
 // IWYU pragma: end_exports
@@ -65,7 +65,8 @@ typedef void (*PuglGlFunc)(void);
 /**
    Return the address of an OpenGL extension function.
 */
-PUGL_API PuglGlFunc
+PUGL_API
+PuglGlFunc
 puglGetProcAddress(const char* name);
 
 /**
@@ -75,7 +76,8 @@ puglGetProcAddress(const char* name);
    doing things like loading textures.  Note that this must not be used for
    drawing, which may only be done while processing an expose event.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglEnterContext(PuglView* view);
 
 /**
@@ -83,7 +85,8 @@ puglEnterContext(PuglView* view);
 
    This must only be called after puglEnterContext().
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglLeaveContext(PuglView* view);
 
 /**
@@ -91,7 +94,8 @@ puglLeaveContext(PuglView* view);
 
    Pass the returned value to puglSetBackend() to draw to a view with OpenGL.
 */
-PUGL_API PUGL_CONST_FUNC const PuglBackend*
+PUGL_CONST_API
+const PuglBackend*
 puglGlBackend(void);
 
 PUGL_END_DECLS
diff --git a/subprojects/nk_pugl/pugl/include/pugl/pugl.h b/subprojects/nk_pugl/pugl/include/pugl/pugl.h
index 9ddc1ec..8a261c7 100644
--- a/subprojects/nk_pugl/pugl/include/pugl/pugl.h
+++ b/subprojects/nk_pugl/pugl/include/pugl/pugl.h
@@ -21,45 +21,42 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#ifdef PUGL_SHARED
-#    ifdef _WIN32
-#        define PUGL_LIB_IMPORT __declspec(dllimport)
-#        define PUGL_LIB_EXPORT __declspec(dllexport)
-#    else
-#        define PUGL_LIB_IMPORT __attribute__((visibility("default")))
-#        define PUGL_LIB_EXPORT __attribute__((visibility("default")))
-#    endif
-#    ifdef PUGL_INTERNAL
-#        define PUGL_API PUGL_LIB_EXPORT
-#    else
-#        define PUGL_API PUGL_LIB_IMPORT
-#    endif
+#if defined(_WIN32) && !defined(PUGL_STATIC) && defined(PUGL_INTERNAL)
+#  define PUGL_API __declspec(dllexport)
+#elif defined(_WIN32) && !defined(PUGL_STATIC)
+#  define PUGL_API __declspec(dllimport)
+#elif defined(__GNUC__) && !defined(PUGL_STATIC)
+#  define PUGL_API __attribute__((visibility("default")))
 #else
-#    define PUGL_API
+#  define PUGL_API
 #endif
 
 #ifndef PUGL_DISABLE_DEPRECATED
-#    if defined(__clang__)
-#        define PUGL_DEPRECATED_BY(rep) __attribute__((deprecated("", rep)))
-#    elif defined(__GNUC__)
-#        define PUGL_DEPRECATED_BY(rep) __attribute__((deprecated("Use " rep)))
-#    else
-#        define PUGL_DEPRECATED_BY(rep)
-#    endif
+#  if defined(__clang__)
+#    define PUGL_DEPRECATED_BY(rep) __attribute__((deprecated("", rep)))
+#  elif defined(__GNUC__)
+#    define PUGL_DEPRECATED_BY(rep) __attribute__((deprecated("Use " rep)))
+#  else
+#    define PUGL_DEPRECATED_BY(rep)
+#  endif
 #endif
 
 #if defined(__GNUC__)
-#    define PUGL_CONST_FUNC __attribute__((const))
+#  define PUGL_CONST_FUNC __attribute__((const))
 #else
-#    define PUGL_CONST_FUNC
+#  define PUGL_CONST_FUNC
 #endif
 
+#define PUGL_CONST_API \
+  PUGL_API             \
+  PUGL_CONST_FUNC
+
 #ifdef __cplusplus
-#	define PUGL_BEGIN_DECLS extern "C" {
-#	define PUGL_END_DECLS }
+#  define PUGL_BEGIN_DECLS extern "C" {
+#  define PUGL_END_DECLS }
 #else
-#	define PUGL_BEGIN_DECLS
-#	define PUGL_END_DECLS
+#  define PUGL_BEGIN_DECLS
+#  define PUGL_END_DECLS
 #endif
 
 PUGL_BEGIN_DECLS
@@ -77,10 +74,10 @@ PUGL_BEGIN_DECLS
    uses coordinates where the top left corner is 0,0.
 */
 typedef struct {
-	double x;
-	double y;
-	double width;
-	double height;
+  double x;
+  double y;
+  double width;
+  double height;
 } PuglRect;
 
 /**
@@ -96,10 +93,10 @@ typedef struct {
 
 /// Keyboard modifier flags
 typedef enum {
-	PUGL_MOD_SHIFT = 1u << 0u, ///< Shift key
-	PUGL_MOD_CTRL  = 1u << 1u, ///< Control key
-	PUGL_MOD_ALT   = 1u << 2u, ///< Alt/Option key
-	PUGL_MOD_SUPER = 1u << 3u  ///< Mod4/Command/Windows key
+  PUGL_MOD_SHIFT = 1u << 0u, ///< Shift key
+  PUGL_MOD_CTRL  = 1u << 1u, ///< Control key
+  PUGL_MOD_ALT   = 1u << 2u, ///< Alt/Option key
+  PUGL_MOD_SUPER = 1u << 3u  ///< Mod4/Command/Windows key
 } PuglMod;
 
 /// Bitwise OR of #PuglMod values
@@ -120,92 +117,92 @@ typedef uint32_t PuglMods;
    mapping used here is arbitrary and specific to Pugl.
 */
 typedef enum {
-	// ASCII control codes
-	PUGL_KEY_BACKSPACE = 0x08,
-	PUGL_KEY_ESCAPE    = 0x1B,
-	PUGL_KEY_DELETE    = 0x7F,
-
-	// Unicode Private Use Area
-	PUGL_KEY_F1 = 0xE000,
-	PUGL_KEY_F2,
-	PUGL_KEY_F3,
-	PUGL_KEY_F4,
-	PUGL_KEY_F5,
-	PUGL_KEY_F6,
-	PUGL_KEY_F7,
-	PUGL_KEY_F8,
-	PUGL_KEY_F9,
-	PUGL_KEY_F10,
-	PUGL_KEY_F11,
-	PUGL_KEY_F12,
-	PUGL_KEY_LEFT,
-	PUGL_KEY_UP,
-	PUGL_KEY_RIGHT,
-	PUGL_KEY_DOWN,
-	PUGL_KEY_PAGE_UP,
-	PUGL_KEY_PAGE_DOWN,
-	PUGL_KEY_HOME,
-	PUGL_KEY_END,
-	PUGL_KEY_INSERT,
-	PUGL_KEY_SHIFT,
-	PUGL_KEY_SHIFT_L = PUGL_KEY_SHIFT,
-	PUGL_KEY_SHIFT_R,
-	PUGL_KEY_CTRL,
-	PUGL_KEY_CTRL_L = PUGL_KEY_CTRL,
-	PUGL_KEY_CTRL_R,
-	PUGL_KEY_ALT,
-	PUGL_KEY_ALT_L = PUGL_KEY_ALT,
-	PUGL_KEY_ALT_R,
-	PUGL_KEY_SUPER,
-	PUGL_KEY_SUPER_L = PUGL_KEY_SUPER,
-	PUGL_KEY_SUPER_R,
-	PUGL_KEY_MENU,
-	PUGL_KEY_CAPS_LOCK,
-	PUGL_KEY_SCROLL_LOCK,
-	PUGL_KEY_NUM_LOCK,
-	PUGL_KEY_PRINT_SCREEN,
-	PUGL_KEY_PAUSE
+  // ASCII control codes
+  PUGL_KEY_BACKSPACE = 0x08,
+  PUGL_KEY_ESCAPE    = 0x1B,
+  PUGL_KEY_DELETE    = 0x7F,
+
+  // Unicode Private Use Area
+  PUGL_KEY_F1 = 0xE000,
+  PUGL_KEY_F2,
+  PUGL_KEY_F3,
+  PUGL_KEY_F4,
+  PUGL_KEY_F5,
+  PUGL_KEY_F6,
+  PUGL_KEY_F7,
+  PUGL_KEY_F8,
+  PUGL_KEY_F9,
+  PUGL_KEY_F10,
+  PUGL_KEY_F11,
+  PUGL_KEY_F12,
+  PUGL_KEY_LEFT,
+  PUGL_KEY_UP,
+  PUGL_KEY_RIGHT,
+  PUGL_KEY_DOWN,
+  PUGL_KEY_PAGE_UP,
+  PUGL_KEY_PAGE_DOWN,
+  PUGL_KEY_HOME,
+  PUGL_KEY_END,
+  PUGL_KEY_INSERT,
+  PUGL_KEY_SHIFT,
+  PUGL_KEY_SHIFT_L = PUGL_KEY_SHIFT,
+  PUGL_KEY_SHIFT_R,
+  PUGL_KEY_CTRL,
+  PUGL_KEY_CTRL_L = PUGL_KEY_CTRL,
+  PUGL_KEY_CTRL_R,
+  PUGL_KEY_ALT,
+  PUGL_KEY_ALT_L = PUGL_KEY_ALT,
+  PUGL_KEY_ALT_R,
+  PUGL_KEY_SUPER,
+  PUGL_KEY_SUPER_L = PUGL_KEY_SUPER,
+  PUGL_KEY_SUPER_R,
+  PUGL_KEY_MENU,
+  PUGL_KEY_CAPS_LOCK,
+  PUGL_KEY_SCROLL_LOCK,
+  PUGL_KEY_NUM_LOCK,
+  PUGL_KEY_PRINT_SCREEN,
+  PUGL_KEY_PAUSE
 } PuglKey;
 
 /// The type of a PuglEvent
 typedef enum {
-	PUGL_NOTHING,        ///< No event
-	PUGL_CREATE,         ///< View created, a #PuglEventCreate
-	PUGL_DESTROY,        ///< View destroyed, a #PuglEventDestroy
-	PUGL_CONFIGURE,      ///< View moved/resized, a #PuglEventConfigure
-	PUGL_MAP,            ///< View made visible, a #PuglEventMap
-	PUGL_UNMAP,          ///< View made invisible, a #PuglEventUnmap
-	PUGL_UPDATE,         ///< View ready to draw, a #PuglEventUpdate
-	PUGL_EXPOSE,         ///< View must be drawn, a #PuglEventExpose
-	PUGL_CLOSE,          ///< View will be closed, a #PuglEventClose
-	PUGL_FOCUS_IN,       ///< Keyboard focus entered view, a #PuglEventFocus
-	PUGL_FOCUS_OUT,      ///< Keyboard focus left view, a #PuglEventFocus
-	PUGL_KEY_PRESS,      ///< Key pressed, a #PuglEventKey
-	PUGL_KEY_RELEASE,    ///< Key released, a #PuglEventKey
-	PUGL_TEXT,           ///< Character entered, a #PuglEventText
-	PUGL_POINTER_IN,     ///< Pointer entered view, a #PuglEventCrossing
-	PUGL_POINTER_OUT,    ///< Pointer left view, a #PuglEventCrossing
-	PUGL_BUTTON_PRESS,   ///< Mouse button pressed, a #PuglEventButton
-	PUGL_BUTTON_RELEASE, ///< Mouse button released, a #PuglEventButton
-	PUGL_MOTION,         ///< Pointer moved, a #PuglEventMotion
-	PUGL_SCROLL,         ///< Scrolled, a #PuglEventScroll
-	PUGL_CLIENT,         ///< Custom client message, a #PuglEventClient
-	PUGL_TIMER,          ///< Timer triggered, a #PuglEventTimer
-	PUGL_LOOP_ENTER,     ///< Recursive loop entered, a #PuglEventLoopEnter
-	PUGL_LOOP_LEAVE,     ///< Recursive loop left, a #PuglEventLoopLeave
+  PUGL_NOTHING,        ///< No event
+  PUGL_CREATE,         ///< View created, a #PuglEventCreate
+  PUGL_DESTROY,        ///< View destroyed, a #PuglEventDestroy
+  PUGL_CONFIGURE,      ///< View moved/resized, a #PuglEventConfigure
+  PUGL_MAP,            ///< View made visible, a #PuglEventMap
+  PUGL_UNMAP,          ///< View made invisible, a #PuglEventUnmap
+  PUGL_UPDATE,         ///< View ready to draw, a #PuglEventUpdate
+  PUGL_EXPOSE,         ///< View must be drawn, a #PuglEventExpose
+  PUGL_CLOSE,          ///< View will be closed, a #PuglEventClose
+  PUGL_FOCUS_IN,       ///< Keyboard focus entered view, a #PuglEventFocus
+  PUGL_FOCUS_OUT,      ///< Keyboard focus left view, a #PuglEventFocus
+  PUGL_KEY_PRESS,      ///< Key pressed, a #PuglEventKey
+  PUGL_KEY_RELEASE,    ///< Key released, a #PuglEventKey
+  PUGL_TEXT,           ///< Character entered, a #PuglEventText
+  PUGL_POINTER_IN,     ///< Pointer entered view, a #PuglEventCrossing
+  PUGL_POINTER_OUT,    ///< Pointer left view, a #PuglEventCrossing
+  PUGL_BUTTON_PRESS,   ///< Mouse button pressed, a #PuglEventButton
+  PUGL_BUTTON_RELEASE, ///< Mouse button released, a #PuglEventButton
+  PUGL_MOTION,         ///< Pointer moved, a #PuglEventMotion
+  PUGL_SCROLL,         ///< Scrolled, a #PuglEventScroll
+  PUGL_CLIENT,         ///< Custom client message, a #PuglEventClient
+  PUGL_TIMER,          ///< Timer triggered, a #PuglEventTimer
+  PUGL_LOOP_ENTER,     ///< Recursive loop entered, a #PuglEventLoopEnter
+  PUGL_LOOP_LEAVE,     ///< Recursive loop left, a #PuglEventLoopLeave
 
 #ifndef PUGL_DISABLE_DEPRECATED
-	PUGL_ENTER_NOTIFY PUGL_DEPRECATED_BY("PUGL_POINTER_IN") = PUGL_POINTER_IN,
-	PUGL_LEAVE_NOTIFY PUGL_DEPRECATED_BY("PUGL_POINTER_OUT") = PUGL_POINTER_OUT,
-	PUGL_MOTION_NOTIFY PUGL_DEPRECATED_BY("PUGL_MOTION") = PUGL_MOTION,
+  PUGL_ENTER_NOTIFY  PUGL_DEPRECATED_BY("PUGL_POINTER_IN")  = PUGL_POINTER_IN,
+  PUGL_LEAVE_NOTIFY  PUGL_DEPRECATED_BY("PUGL_POINTER_OUT") = PUGL_POINTER_OUT,
+  PUGL_MOTION_NOTIFY PUGL_DEPRECATED_BY("PUGL_MOTION")      = PUGL_MOTION,
 #endif
 
 } PuglEventType;
 
 /// Common flags for all event types
 typedef enum {
-	PUGL_IS_SEND_EVENT = 1, ///< Event is synthetic
-	PUGL_IS_HINT       = 2  ///< Event is a hint (not direct user input)
+  PUGL_IS_SEND_EVENT = 1, ///< Event is synthetic
+  PUGL_IS_HINT       = 2  ///< Event is a hint (not direct user input)
 } PuglEventFlag;
 
 /// Bitwise OR of #PuglEventFlag values
@@ -213,9 +210,9 @@ typedef uint32_t PuglEventFlags;
 
 /// Reason for a PuglEventCrossing
 typedef enum {
-	PUGL_CROSSING_NORMAL, ///< Crossing due to pointer motion
-	PUGL_CROSSING_GRAB,   ///< Crossing due to a grab
-	PUGL_CROSSING_UNGRAB  ///< Crossing due to a grab release
+  PUGL_CROSSING_NORMAL, ///< Crossing due to pointer motion
+  PUGL_CROSSING_GRAB,   ///< Crossing due to a grab
+  PUGL_CROSSING_UNGRAB  ///< Crossing due to a grab release
 } PuglCrossingMode;
 
 /**
@@ -227,17 +224,17 @@ typedef enum {
    arbitrary scroll direction freedom, like some touchpads.
 */
 typedef enum {
-	PUGL_SCROLL_UP,    ///< Scroll up
-	PUGL_SCROLL_DOWN,  ///< Scroll down
-	PUGL_SCROLL_LEFT,  ///< Scroll left
-	PUGL_SCROLL_RIGHT, ///< Scroll right
-	PUGL_SCROLL_SMOOTH ///< Smooth scroll in any direction
+  PUGL_SCROLL_UP,    ///< Scroll up
+  PUGL_SCROLL_DOWN,  ///< Scroll down
+  PUGL_SCROLL_LEFT,  ///< Scroll left
+  PUGL_SCROLL_RIGHT, ///< Scroll right
+  PUGL_SCROLL_SMOOTH ///< Smooth scroll in any direction
 } PuglScrollDirection;
 
 /// Common header for all event structs
 typedef struct {
-	PuglEventType  type;  ///< Event type
-	PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
+  PuglEventType  type;  ///< Event type
+  PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
 } PuglEventAny;
 
 /**
@@ -275,12 +272,12 @@ typedef PuglEventAny PuglEventDestroy;
    otherwise configure the context, but not to draw anything.
 */
 typedef struct {
-	PuglEventType  type;   ///< #PUGL_CONFIGURE
-	PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
-	double         x;      ///< New parent-relative X coordinate
-	double         y;      ///< New parent-relative Y coordinate
-	double         width;  ///< New width
-	double         height; ///< New height
+  PuglEventType  type;   ///< #PUGL_CONFIGURE
+  PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
+  double         x;      ///< New parent-relative X coordinate
+  double         y;      ///< New parent-relative Y coordinate
+  double         width;  ///< New width
+  double         height; ///< New height
 } PuglEventConfigure;
 
 /**
@@ -321,12 +318,12 @@ typedef PuglEventAny PuglEventUpdate;
    undefined, there is no preservation of anything drawn previously.
 */
 typedef struct {
-	PuglEventType  type;   ///< #PUGL_EXPOSE
-	PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
-	double         x;      ///< View-relative X coordinate
-	double         y;      ///< View-relative Y coordinate
-	double         width;  ///< Width of exposed region
-	double         height; ///< Height of exposed region
+  PuglEventType  type;   ///< #PUGL_EXPOSE
+  PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
+  double         x;      ///< View-relative X coordinate
+  double         y;      ///< View-relative Y coordinate
+  double         width;  ///< Width of exposed region
+  double         height; ///< Height of exposed region
 } PuglEventExpose;
 
 /**
@@ -346,9 +343,9 @@ typedef PuglEventAny PuglEventClose;
    view with the keyboard focus will receive any key press or release events.
 */
 typedef struct {
-	PuglEventType    type;  ///< #PUGL_FOCUS_IN or #PUGL_FOCUS_OUT
-	PuglEventFlags   flags; ///< Bitwise OR of #PuglEventFlag values
-	PuglCrossingMode mode;  ///< Reason for focus change
+  PuglEventType    type;  ///< #PUGL_FOCUS_IN or #PUGL_FOCUS_OUT
+  PuglEventFlags   flags; ///< Bitwise OR of #PuglEventFlag values
+  PuglCrossingMode mode;  ///< Reason for focus change
 } PuglEventFocus;
 
 /**
@@ -369,16 +366,16 @@ typedef struct {
    and hardware.
 */
 typedef struct {
-	PuglEventType  type;    ///< #PUGL_KEY_PRESS or #PUGL_KEY_RELEASE
-	PuglEventFlags flags;   ///< Bitwise OR of #PuglEventFlag values
-	double         time;    ///< Time in seconds
-	double         x;       ///< View-relative X coordinate
-	double         y;       ///< View-relative Y coordinate
-	double         xRoot;   ///< Root-relative X coordinate
-	double         yRoot;   ///< Root-relative Y coordinate
-	PuglMods       state;   ///< Bitwise OR of #PuglMod flags
-	uint32_t       keycode; ///< Raw key code
-	uint32_t       key;     ///< Unshifted Unicode character code, or 0
+  PuglEventType  type;    ///< #PUGL_KEY_PRESS or #PUGL_KEY_RELEASE
+  PuglEventFlags flags;   ///< Bitwise OR of #PuglEventFlag values
+  double         time;    ///< Time in seconds
+  double         x;       ///< View-relative X coordinate
+  double         y;       ///< View-relative Y coordinate
+  double         xRoot;   ///< Root-relative X coordinate
+  double         yRoot;   ///< Root-relative Y coordinate
+  PuglMods       state;   ///< Bitwise OR of #PuglMod flags
+  uint32_t       keycode; ///< Raw key code
+  uint32_t       key;     ///< Unshifted Unicode character code, or 0
 } PuglEventKey;
 
 /**
@@ -393,17 +390,17 @@ typedef struct {
    presses will generate a single character.
 */
 typedef struct {
-	PuglEventType  type;      ///< #PUGL_TEXT
-	PuglEventFlags flags;     ///< Bitwise OR of #PuglEventFlag values
-	double         time;      ///< Time in seconds
-	double         x;         ///< View-relative X coordinate
-	double         y;         ///< View-relative Y coordinate
-	double         xRoot;     ///< Root-relative X coordinate
-	double         yRoot;     ///< Root-relative Y coordinate
-	PuglMods       state;     ///< Bitwise OR of #PuglMod flags
-	uint32_t       keycode;   ///< Raw key code
-	uint32_t       character; ///< Unicode character code
-	char           string[8]; ///< UTF-8 string
+  PuglEventType  type;      ///< #PUGL_TEXT
+  PuglEventFlags flags;     ///< Bitwise OR of #PuglEventFlag values
+  double         time;      ///< Time in seconds
+  double         x;         ///< View-relative X coordinate
+  double         y;         ///< View-relative Y coordinate
+  double         xRoot;     ///< Root-relative X coordinate
+  double         yRoot;     ///< Root-relative Y coordinate
+  PuglMods       state;     ///< Bitwise OR of #PuglMod flags
+  uint32_t       keycode;   ///< Raw key code
+  uint32_t       character; ///< Unicode character code
+  char           string[8]; ///< UTF-8 string
 } PuglEventText;
 
 /**
@@ -414,44 +411,44 @@ typedef struct {
    window edge), as described by the `mode` field.
 */
 typedef struct {
-	PuglEventType    type;  ///< #PUGL_POINTER_IN or #PUGL_POINTER_OUT
-	PuglEventFlags   flags; ///< Bitwise OR of #PuglEventFlag values
-	double           time;  ///< Time in seconds
-	double           x;     ///< View-relative X coordinate
-	double           y;     ///< View-relative Y coordinate
-	double           xRoot; ///< Root-relative X coordinate
-	double           yRoot; ///< Root-relative Y coordinate
-	PuglMods         state; ///< Bitwise OR of #PuglMod flags
-	PuglCrossingMode mode;  ///< Reason for crossing
+  PuglEventType    type;  ///< #PUGL_POINTER_IN or #PUGL_POINTER_OUT
+  PuglEventFlags   flags; ///< Bitwise OR of #PuglEventFlag values
+  double           time;  ///< Time in seconds
+  double           x;     ///< View-relative X coordinate
+  double           y;     ///< View-relative Y coordinate
+  double           xRoot; ///< Root-relative X coordinate
+  double           yRoot; ///< Root-relative Y coordinate
+  PuglMods         state; ///< Bitwise OR of #PuglMod flags
+  PuglCrossingMode mode;  ///< Reason for crossing
 } PuglEventCrossing;
 
 /**
    Button press or release event.
 */
 typedef struct {
-	PuglEventType  type;   ///< #PUGL_BUTTON_PRESS or #PUGL_BUTTON_RELEASE
-	PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
-	double         time;   ///< Time in seconds
-	double         x;      ///< View-relative X coordinate
-	double         y;      ///< View-relative Y coordinate
-	double         xRoot;  ///< Root-relative X coordinate
-	double         yRoot;  ///< Root-relative Y coordinate
-	PuglMods       state;  ///< Bitwise OR of #PuglMod flags
-	uint32_t       button; ///< Button number starting from 1
+  PuglEventType  type;   ///< #PUGL_BUTTON_PRESS or #PUGL_BUTTON_RELEASE
+  PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
+  double         time;   ///< Time in seconds
+  double         x;      ///< View-relative X coordinate
+  double         y;      ///< View-relative Y coordinate
+  double         xRoot;  ///< Root-relative X coordinate
+  double         yRoot;  ///< Root-relative Y coordinate
+  PuglMods       state;  ///< Bitwise OR of #PuglMod flags
+  uint32_t       button; ///< Button number starting from 1
 } PuglEventButton;
 
 /**
    Pointer motion event.
 */
 typedef struct {
-	PuglEventType  type;   ///< #PUGL_MOTION
-	PuglEventFlags flags;  ///< Bitwise OR of #PuglEventFlag values
-	double         time;   ///< Time in seconds
-	double         x;      ///< View-relative X coordinate
-	double         y;      ///< View-relative Y coordinate
-	double         xRoot;  ///< Root-relative X coordinate
-	double         yRoot;  ///< Root-relative Y coordinate
-	PuglMods       state;  ///< Bitwise OR of #PuglMod flags
+  PuglEventType  type;  ///< #PUGL_MOTION
+  PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
+  double         time;  ///< Time in seconds
+  double         x;     ///< View-relative X coordinate
+  double         y;     ///< View-relative Y coordinate
+  double         xRoot; ///< Root-relative X coordinate
+  double         yRoot; ///< Root-relative Y coordinate
+  PuglMods       state; ///< Bitwise OR of #PuglMod flags
 } PuglEventMotion;
 
 /**
@@ -464,17 +461,17 @@ typedef struct {
    gracefully.
 */
 typedef struct {
-	PuglEventType       type;      ///< #PUGL_SCROLL
-	PuglEventFlags      flags;     ///< Bitwise OR of #PuglEventFlag values
-	double              time;      ///< Time in seconds
-	double              x;         ///< View-relative X coordinate
-	double              y;         ///< View-relative Y coordinate
-	double              xRoot;     ///< Root-relative X coordinate
-	double              yRoot;     ///< Root-relative Y coordinate
-	PuglMods            state;     ///< Bitwise OR of #PuglMod flags
-	PuglScrollDirection direction; ///< Scroll direction
-	double              dx;        ///< Scroll X distance in lines
-	double              dy;        ///< Scroll Y distance in lines
+  PuglEventType       type;      ///< #PUGL_SCROLL
+  PuglEventFlags      flags;     ///< Bitwise OR of #PuglEventFlag values
+  double              time;      ///< Time in seconds
+  double              x;         ///< View-relative X coordinate
+  double              y;         ///< View-relative Y coordinate
+  double              xRoot;     ///< Root-relative X coordinate
+  double              yRoot;     ///< Root-relative Y coordinate
+  PuglMods            state;     ///< Bitwise OR of #PuglMod flags
+  PuglScrollDirection direction; ///< Scroll direction
+  double              dx;        ///< Scroll X distance in lines
+  double              dy;        ///< Scroll Y distance in lines
 } PuglEventScroll;
 
 /**
@@ -485,10 +482,10 @@ typedef struct {
    things, this makes it possible to wake up the event loop for any reason.
 */
 typedef struct {
-	PuglEventType  type;  ///< #PUGL_CLIENT
-	PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
-	uintptr_t      data1; ///< Client-specific data
-	uintptr_t      data2; ///< Client-specific data
+  PuglEventType  type;  ///< #PUGL_CLIENT
+  PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
+  uintptr_t      data1; ///< Client-specific data
+  uintptr_t      data2; ///< Client-specific data
 } PuglEventClient;
 
 /**
@@ -502,9 +499,9 @@ typedef struct {
    event handler, even in applications that register only one timer.
 */
 typedef struct {
-	PuglEventType  type;  ///< #PUGL_TIMER
-	PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
-	uintptr_t      id;    ///< Timer ID
+  PuglEventType  type;  ///< #PUGL_TIMER
+  PuglEventFlags flags; ///< Bitwise OR of #PuglEventFlag values
+  uintptr_t      id;    ///< Timer ID
 } PuglEventTimer;
 
 /**
@@ -551,19 +548,19 @@ typedef PuglEventAny PuglEventLoopLeave;
    and #PUGL_EXPOSE, but only enabled for drawing for #PUGL_EXPOSE.
 */
 typedef union {
-	PuglEventAny       any;       ///< Valid for all event types
-	PuglEventType      type;      ///< Event type
-	PuglEventButton    button;    ///< #PUGL_BUTTON_PRESS, #PUGL_BUTTON_RELEASE
-	PuglEventConfigure configure; ///< #PUGL_CONFIGURE
-	PuglEventExpose    expose;    ///< #PUGL_EXPOSE
-	PuglEventKey       key;       ///< #PUGL_KEY_PRESS, #PUGL_KEY_RELEASE
-	PuglEventText      text;      ///< #PUGL_TEXT
-	PuglEventCrossing  crossing;  ///< #PUGL_POINTER_IN, #PUGL_POINTER_OUT
-	PuglEventMotion    motion;    ///< #PUGL_MOTION
-	PuglEventScroll    scroll;    ///< #PUGL_SCROLL
-	PuglEventFocus     focus;     ///< #PUGL_FOCUS_IN, #PUGL_FOCUS_OUT
-	PuglEventClient    client;    ///< #PUGL_CLIENT
-	PuglEventTimer     timer;     ///< #PUGL_TIMER
+  PuglEventAny       any;       ///< Valid for all event types
+  PuglEventType      type;      ///< Event type
+  PuglEventButton    button;    ///< #PUGL_BUTTON_PRESS, #PUGL_BUTTON_RELEASE
+  PuglEventConfigure configure; ///< #PUGL_CONFIGURE
+  PuglEventExpose    expose;    ///< #PUGL_EXPOSE
+  PuglEventKey       key;       ///< #PUGL_KEY_PRESS, #PUGL_KEY_RELEASE
+  PuglEventText      text;      ///< #PUGL_TEXT
+  PuglEventCrossing  crossing;  ///< #PUGL_POINTER_IN, #PUGL_POINTER_OUT
+  PuglEventMotion    motion;    ///< #PUGL_MOTION
+  PuglEventScroll    scroll;    ///< #PUGL_SCROLL
+  PuglEventFocus     focus;     ///< #PUGL_FOCUS_IN, #PUGL_FOCUS_OUT
+  PuglEventClient    client;    ///< #PUGL_CLIENT
+  PuglEventTimer     timer;     ///< #PUGL_TIMER
 } PuglEvent;
 
 /**
@@ -577,22 +574,22 @@ typedef union {
 
 /// Return status code
 typedef enum {
-	PUGL_SUCCESS,               ///< Success
-	PUGL_FAILURE,               ///< Non-fatal failure
-	PUGL_UNKNOWN_ERROR,         ///< Unknown system error
-	PUGL_BAD_BACKEND,           ///< Invalid or missing backend
-	PUGL_BAD_CONFIGURATION,     ///< Invalid view configuration
-	PUGL_BAD_PARAMETER,         ///< Invalid parameter
-	PUGL_BACKEND_FAILED,        ///< Backend initialization failed
-	PUGL_REGISTRATION_FAILED,   ///< Class registration failed
-	PUGL_REALIZE_FAILED,        ///< System view realization failed
-	PUGL_SET_FORMAT_FAILED,     ///< Failed to set pixel format
-	PUGL_CREATE_CONTEXT_FAILED, ///< Failed to create drawing context
-	PUGL_UNSUPPORTED_TYPE,      ///< Unsupported data type
+  PUGL_SUCCESS,               ///< Success
+  PUGL_FAILURE,               ///< Non-fatal failure
+  PUGL_UNKNOWN_ERROR,         ///< Unknown system error
+  PUGL_BAD_BACKEND,           ///< Invalid or missing backend
+  PUGL_BAD_CONFIGURATION,     ///< Invalid view configuration
+  PUGL_BAD_PARAMETER,         ///< Invalid parameter
+  PUGL_BACKEND_FAILED,        ///< Backend initialization failed
+  PUGL_REGISTRATION_FAILED,   ///< Class registration failed
+  PUGL_REALIZE_FAILED,        ///< System view realization failed
+  PUGL_SET_FORMAT_FAILED,     ///< Failed to set pixel format
+  PUGL_CREATE_CONTEXT_FAILED, ///< Failed to create drawing context
+  PUGL_UNSUPPORTED_TYPE,      ///< Unsupported data type
 } PuglStatus;
 
 /// Return a string describing a status code
-PUGL_API PUGL_CONST_FUNC
+PUGL_CONST_API
 const char*
 puglStrerror(PuglStatus status);
 
@@ -625,18 +622,18 @@ typedef void* PuglWorldHandle;
 
 /// The type of a World
 typedef enum {
-	PUGL_PROGRAM, ///< Top-level application
-	PUGL_MODULE   ///< Plugin or module within a larger application
+  PUGL_PROGRAM, ///< Top-level application
+  PUGL_MODULE   ///< Plugin or module within a larger application
 } PuglWorldType;
 
 /// World flags
 typedef enum {
-	/**
-	   Set up support for threads if necessary.
+  /**
+     Set up support for threads if necessary.
 
-	   - X11: Calls XInitThreads() which is required for some drivers.
-	*/
-	PUGL_WORLD_THREADS = 1u << 0u
+     - X11: Calls XInitThreads() which is required for some drivers.
+  */
+  PUGL_WORLD_THREADS = 1u << 0u
 } PuglWorldFlag;
 
 /// Bitwise OR of #PuglWorldFlag values
@@ -649,11 +646,13 @@ typedef uint32_t PuglWorldFlags;
    @param flags Flags to control world features.
    @return A new world, which must be later freed with puglFreeWorld().
 */
-PUGL_API PuglWorld*
+PUGL_API
+PuglWorld*
 puglNewWorld(PuglWorldType type, PuglWorldFlags flags);
 
 /// Free a world allocated with puglNewWorld()
-PUGL_API void
+PUGL_API
+void
 puglFreeWorld(PuglWorld* world);
 
 /**
@@ -664,11 +663,13 @@ puglFreeWorld(PuglWorld* world);
 
    The handle is opaque to Pugl and is not interpreted in any way.
 */
-PUGL_API void
+PUGL_API
+void
 puglSetWorldHandle(PuglWorld* world, PuglWorldHandle handle);
 
 /// Get the user data for the world
-PUGL_API PuglWorldHandle
+PUGL_API
+PuglWorldHandle
 puglGetWorldHandle(PuglWorld* world);
 
 /**
@@ -680,7 +681,8 @@ puglGetWorldHandle(PuglWorld* world);
 
    Windows: Returns the `HMODULE` of the calling process.
 */
-PUGL_API void*
+PUGL_API
+void*
 puglGetNativeWorld(PuglWorld* world);
 
 /**
@@ -692,7 +694,8 @@ puglGetNativeWorld(PuglWorld* world);
    for every instance of the application, but different from other
    applications.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetClassName(PuglWorld* world, const char* name);
 
 /**
@@ -702,7 +705,8 @@ puglSetClassName(PuglWorld* world, const char* name);
    time is only useful to compare against other times returned by this
    function, its absolute value has no meaning.
 */
-PUGL_API double
+PUGL_API
+double
 puglGetTime(const PuglWorld* world);
 
 /**
@@ -726,7 +730,8 @@ puglGetTime(const PuglWorld* world);
 
    @return #PUGL_SUCCESS if events are read, #PUGL_FAILURE if not, or an error.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglUpdate(PuglWorld* world, double timeout);
 
 /**
@@ -775,31 +780,31 @@ typedef void* PuglHandle;
 
 /// A hint for configuring a view
 typedef enum {
-	PUGL_USE_COMPAT_PROFILE,    ///< Use compatible (not core) OpenGL profile
-	PUGL_USE_DEBUG_CONTEXT,     ///< True to use a debug OpenGL context
-	PUGL_CONTEXT_VERSION_MAJOR, ///< OpenGL context major version
-	PUGL_CONTEXT_VERSION_MINOR, ///< OpenGL context minor version
-	PUGL_RED_BITS,              ///< Number of bits for red channel
-	PUGL_GREEN_BITS,            ///< Number of bits for green channel
-	PUGL_BLUE_BITS,             ///< Number of bits for blue channel
-	PUGL_ALPHA_BITS,            ///< Number of bits for alpha channel
-	PUGL_DEPTH_BITS,            ///< Number of bits for depth buffer
-	PUGL_STENCIL_BITS,          ///< Number of bits for stencil buffer
-	PUGL_SAMPLES,               ///< Number of samples per pixel (AA)
-	PUGL_DOUBLE_BUFFER,         ///< True if double buffering should be used
-	PUGL_SWAP_INTERVAL,         ///< Number of frames between buffer swaps
-	PUGL_RESIZABLE,             ///< True if view should be resizable
-	PUGL_IGNORE_KEY_REPEAT,     ///< True if key repeat events are ignored
-	PUGL_REFRESH_RATE,          ///< Refresh rate in Hz
-
-	PUGL_NUM_VIEW_HINTS
+  PUGL_USE_COMPAT_PROFILE,    ///< Use compatible (not core) OpenGL profile
+  PUGL_USE_DEBUG_CONTEXT,     ///< True to use a debug OpenGL context
+  PUGL_CONTEXT_VERSION_MAJOR, ///< OpenGL context major version
+  PUGL_CONTEXT_VERSION_MINOR, ///< OpenGL context minor version
+  PUGL_RED_BITS,              ///< Number of bits for red channel
+  PUGL_GREEN_BITS,            ///< Number of bits for green channel
+  PUGL_BLUE_BITS,             ///< Number of bits for blue channel
+  PUGL_ALPHA_BITS,            ///< Number of bits for alpha channel
+  PUGL_DEPTH_BITS,            ///< Number of bits for depth buffer
+  PUGL_STENCIL_BITS,          ///< Number of bits for stencil buffer
+  PUGL_SAMPLES,               ///< Number of samples per pixel (AA)
+  PUGL_DOUBLE_BUFFER,         ///< True if double buffering should be used
+  PUGL_SWAP_INTERVAL,         ///< Number of frames between buffer swaps
+  PUGL_RESIZABLE,             ///< True if view should be resizable
+  PUGL_IGNORE_KEY_REPEAT,     ///< True if key repeat events are ignored
+  PUGL_REFRESH_RATE,          ///< Refresh rate in Hz
+
+  PUGL_NUM_VIEW_HINTS
 } PuglViewHint;
 
 /// A special view hint value
 typedef enum {
-	PUGL_DONT_CARE = -1, ///< Use best available value
-	PUGL_FALSE     = 0,  ///< Explicitly false
-	PUGL_TRUE      = 1   ///< Explicitly true
+  PUGL_DONT_CARE = -1, ///< Use best available value
+  PUGL_FALSE     = 0,  ///< Explicitly false
+  PUGL_TRUE      = 1   ///< Explicitly true
 } PuglViewHintValue;
 
 /// A function called when an event occurs
@@ -818,15 +823,18 @@ typedef PuglStatus (*PuglEventFunc)(PuglView* view, const PuglEvent* event);
    It must first be configured, then the system view can be created with
    puglRealize().
 */
-PUGL_API PuglView*
+PUGL_API
+PuglView*
 puglNewView(PuglWorld* world);
 
 /// Free a view created with puglNewView()
-PUGL_API void
+PUGL_API
+void
 puglFreeView(PuglView* view);
 
 /// Return the world that `view` is a part of
-PUGL_API PuglWorld*
+PUGL_API
+PuglWorld*
 puglGetWorld(PuglView* view);
 
 /**
@@ -838,11 +846,13 @@ puglGetWorld(PuglView* view);
 
    The handle is opaque to Pugl and is not interpreted in any way.
 */
-PUGL_API void
+PUGL_API
+void
 puglSetHandle(PuglView* view, PuglHandle handle);
 
 /// Get the user data for a view
-PUGL_API PuglHandle
+PUGL_API
+PuglHandle
 puglGetHandle(PuglView* view);
 
 /**
@@ -862,11 +872,13 @@ puglGetHandle(PuglView* view);
    applications must link against the appropriate backend library, or be sure
    to compile in the appropriate code if using a local copy of Pugl.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetBackend(PuglView* view, const PuglBackend* backend);
 
 /// Set the function to call when an event occurs
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetEventFunc(PuglView* view, PuglEventFunc eventFunc);
 
 /**
@@ -874,7 +886,8 @@ puglSetEventFunc(PuglView* view, PuglEventFunc eventFunc);
 
    This only has an effect when called before puglRealize().
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetViewHint(PuglView* view, PuglViewHint hint, int value);
 
 /**
@@ -884,7 +897,8 @@ puglSetViewHint(PuglView* view, PuglViewHint hint, int value);
    hint which was initially set to PUGL_DONT_CARE, or has been adjusted from
    the suggested value.
 */
-PUGL_API int
+PUGL_API
+int
 puglGetViewHint(const PuglView* view, PuglViewHint hint);
 
 /**
@@ -899,7 +913,8 @@ puglGetViewHint(const PuglView* view, PuglViewHint hint);
 
    The position is in screen coordinates with an upper left origin.
 */
-PUGL_API PuglRect
+PUGL_API
+PuglRect
 puglGetFrame(const PuglView* view);
 
 /**
@@ -910,7 +925,8 @@ puglGetFrame(const PuglView* view);
    @return #PUGL_UNKNOWN_ERROR on failure, in which case the view frame is
    unchanged.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetFrame(PuglView* view, PuglRect frame);
 
 /**
@@ -923,7 +939,8 @@ puglSetFrame(PuglView* view, PuglRect frame);
    @return #PUGL_UNKNOWN_ERROR on failure, but always succeeds if the view is
    not yet realized.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetDefaultSize(PuglView* view, int width, int height);
 
 /**
@@ -935,7 +952,8 @@ puglSetDefaultSize(PuglView* view, int width, int height);
    @return #PUGL_UNKNOWN_ERROR on failure, but always succeeds if the view is
    not yet realized.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetMinSize(PuglView* view, int width, int height);
 
 /**
@@ -947,7 +965,8 @@ puglSetMinSize(PuglView* view, int width, int height);
    @return #PUGL_UNKNOWN_ERROR on failure, but always succeeds if the view is
    not yet realized.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetMaxSize(PuglView* view, int width, int height);
 
 /**
@@ -966,7 +985,8 @@ puglSetMaxSize(PuglView* view, int width, int height);
    @return #PUGL_UNKNOWN_ERROR on failure, but always succeeds if the view is
    not yet realized.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetAspectRatio(PuglView* view, int minX, int minY, int maxX, int maxY);
 
 /**
@@ -983,7 +1003,8 @@ puglSetAspectRatio(PuglView* view, int minX, int minY, int maxX, int maxY);
    top-level window, and sets the title, typically displayed in the title bar
    or in window switchers.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetWindowTitle(PuglView* view, const char* title);
 
 /**
@@ -991,7 +1012,8 @@ puglSetWindowTitle(PuglView* view, const char* title);
 
    This must be called before puglRealize(), reparenting is not supported.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetParentWindow(PuglView* view, PuglNativeView parent);
 
 /**
@@ -1004,7 +1026,8 @@ puglSetParentWindow(PuglView* view, PuglNativeView parent);
    A view can either have a parent (for embedding) or a transient parent (for
    top-level windows like dialogs), but not both.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetTransientFor(PuglView* view, PuglNativeView parent);
 
 /**
@@ -1018,7 +1041,8 @@ puglSetTransientFor(PuglView* view, PuglNativeView parent);
    The view should be fully configured using the above functions before this is
    called.  This function may only be called once per view.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglRealize(PuglView* view);
 
 /**
@@ -1030,19 +1054,23 @@ puglRealize(PuglView* view);
    If the view is currently hidden, it will be shown and possibly raised to the
    top depending on the platform.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglShow(PuglView* view);
 
 /// Hide the current window
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglHide(PuglView* view);
 
 /// Return true iff the view is currently visible
-PUGL_API bool
+PUGL_API
+bool
 puglGetVisible(const PuglView* view);
 
 /// Return the native window handle
-PUGL_API PuglNativeView
+PUGL_API
+PuglNativeView
 puglGetNativeWindow(PuglView* view);
 
 /**
@@ -1063,7 +1091,8 @@ puglGetNativeWindow(PuglView* view);
 
    All other backends: returns null.
 */
-PUGL_API void*
+PUGL_API
+void*
 puglGetContext(PuglView* view);
 
 /**
@@ -1075,7 +1104,8 @@ puglGetContext(PuglView* view);
    platforms.  If called elsewhere, an expose will be enqueued to be processed
    in the next event loop iteration.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglPostRedisplay(PuglView* view);
 
 /**
@@ -1084,7 +1114,8 @@ puglPostRedisplay(PuglView* view);
    This has the same semantics as puglPostRedisplay(), but allows giving a
    precise region for redrawing only a portion of the view.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglPostRedisplayRect(PuglView* view, PuglRect rect);
 
 /**
@@ -1101,21 +1132,23 @@ puglPostRedisplayRect(PuglView* view, PuglRect rect);
    Windows.
 */
 typedef enum {
-	PUGL_CURSOR_ARROW,      ///< Default pointing arrow
-	PUGL_CURSOR_CARET,      ///< Caret (I-Beam) for text entry
-	PUGL_CURSOR_CROSSHAIR,  ///< Cross-hair
-	PUGL_CURSOR_HAND,       ///< Hand with a pointing finger
-	PUGL_CURSOR_NO,         ///< Operation not allowed
-	PUGL_CURSOR_LEFT_RIGHT, ///< Left/right arrow for horizontal resize
-	PUGL_CURSOR_UP_DOWN,    ///< Up/down arrow for vertical resize
+  PUGL_CURSOR_ARROW,      ///< Default pointing arrow
+  PUGL_CURSOR_CARET,      ///< Caret (I-Beam) for text entry
+  PUGL_CURSOR_CROSSHAIR,  ///< Cross-hair
+  PUGL_CURSOR_HAND,       ///< Hand with a pointing finger
+  PUGL_CURSOR_NO,         ///< Operation not allowed
+  PUGL_CURSOR_LEFT_RIGHT, ///< Left/right arrow for horizontal resize
+  PUGL_CURSOR_UP_DOWN,    ///< Up/down arrow for vertical resize
 } PuglCursor;
 
 /// Grab the keyboard input focus
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglGrabFocus(PuglView* view);
 
 /// Return whether `view` has the keyboard input focus
-PUGL_API bool
+PUGL_API
+bool
 puglHasFocus(const PuglView* view);
 
 /**
@@ -1129,7 +1162,8 @@ puglHasFocus(const PuglView* view);
    @param data The data to copy to the clipboard.
    @param len The length of data in bytes (including terminator if necessary).
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetClipboard(PuglView*   view,
                  const char* type,
                  const void* data,
@@ -1146,7 +1180,8 @@ puglSetClipboard(PuglView*   view,
    @param[out] len Set to the length of the data in bytes.
    @return The clipboard contents, or `NULL`.
 */
-PUGL_API const void*
+PUGL_API
+const void*
 puglGetClipboard(PuglView* view, const char** type, size_t* len);
 
 /**
@@ -1160,7 +1195,8 @@ puglGetClipboard(PuglView* view, const char** type, size_t* len);
    - #PUGL_BAD_PARAMETER if the given cursor is invalid.
    - #PUGL_FAILURE if the cursor isknown but loading it from the system fails.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSetCursor(PuglView* view, PuglCursor cursor);
 
 /**
@@ -1170,7 +1206,8 @@ puglSetCursor(PuglView* view, PuglCursor cursor);
    from the user.  The exact effect depends on the platform, but is usually
    something like a flashing task bar entry or bouncing application icon.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglRequestAttention(PuglView* view);
 
 /**
@@ -1200,7 +1237,8 @@ puglRequestAttention(PuglView* view);
    - #PUGL_FAILURE if timers are not supported by this system or build.
    - #PUGL_UNKNOWN_ERROR if setting the timer failed.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglStartTimer(PuglView* view, uintptr_t id, double timeout);
 
 /**
@@ -1213,7 +1251,8 @@ puglStartTimer(PuglView* view, uintptr_t id, double timeout);
    - #PUGL_FAILURE if timers are not supported by this system or build.
    - #PUGL_UNKNOWN_ERROR if stopping the timer failed.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglStopTimer(PuglView* view, uintptr_t id);
 
 /**
@@ -1233,7 +1272,8 @@ puglStopTimer(PuglView* view, uintptr_t id);
    - #PUGL_UNSUPPORTED_TYPE if sending events of this type is not supported.
    - #PUGL_UNKNOWN_ERROR if sending the event failed.
 */
-PUGL_API PuglStatus
+PUGL_API
+PuglStatus
 puglSendEvent(PuglView* view, const PuglEvent* event);
 
 /**
@@ -1271,13 +1311,14 @@ typedef uintptr_t PuglNativeWindow;
    @param argv  Arguments (currently unused).
    @return A newly created view.
 */
-static inline PUGL_DEPRECATED_BY("puglNewView") PuglView*
+static inline PUGL_DEPRECATED_BY("puglNewView")
+PuglView*
 puglInit(const int* pargc, char** argv)
 {
-	(void)pargc;
-	(void)argv;
+  (void)pargc;
+  (void)argv;
 
-	return puglNewView(puglNewWorld(PUGL_MODULE, 0));
+  return puglNewView(puglNewWorld(PUGL_MODULE, 0));
 }
 
 /**
@@ -1285,22 +1326,24 @@ puglInit(const int* pargc, char** argv)
 
    @deprecated Use puglFreeApp() and puglFreeView().
 */
-static inline PUGL_DEPRECATED_BY("puglFreeView") void
+static inline PUGL_DEPRECATED_BY("puglFreeView")
+void
 puglDestroy(PuglView* view)
 {
-	PuglWorld* const world = puglGetWorld(view);
+  PuglWorld* const world = puglGetWorld(view);
 
-	puglFreeView(view);
-	puglFreeWorld(world);
+  puglFreeView(view);
+  puglFreeWorld(world);
 }
 
 /**
    Set the window class name before creating a window.
 */
-static inline PUGL_DEPRECATED_BY("puglSetClassName") void
+static inline PUGL_DEPRECATED_BY("puglSetClassName")
+void
 puglInitWindowClass(PuglView* view, const char* name)
 {
-	puglSetClassName(puglGetWorld(view), name);
+  puglSetClassName(puglGetWorld(view), name);
 }
 
 /**
@@ -1308,24 +1351,26 @@ puglInitWindowClass(PuglView* view, const char* name)
 
    @deprecated Use puglSetFrame().
 */
-static inline PUGL_DEPRECATED_BY("puglSetFrame") void
+static inline PUGL_DEPRECATED_BY("puglSetFrame")
+void
 puglInitWindowSize(PuglView* view, int width, int height)
 {
-	PuglRect frame = puglGetFrame(view);
+  PuglRect frame = puglGetFrame(view);
 
-	frame.width = width;
-	frame.height = height;
+  frame.width  = width;
+  frame.height = height;
 
-	puglSetFrame(view, frame);
+  puglSetFrame(view, frame);
 }
 
 /**
    Set the minimum window size before creating a window.
 */
-static inline PUGL_DEPRECATED_BY("puglSetMinSize") void
+static inline PUGL_DEPRECATED_BY("puglSetMinSize")
+void
 puglInitWindowMinSize(PuglView* view, int width, int height)
 {
-	puglSetMinSize(view, width, height);
+  puglSetMinSize(view, width, height);
 }
 
 /**
@@ -1338,14 +1383,15 @@ puglInitWindowMinSize(PuglView* view, int width, int height)
    currenty work on MacOS (the minimum is used), so only setting a fixed aspect
    ratio works properly across all platforms.
 */
-static inline PUGL_DEPRECATED_BY("puglSetAspectRatio") void
+static inline PUGL_DEPRECATED_BY("puglSetAspectRatio")
+void
 puglInitWindowAspectRatio(PuglView* view,
                           int       minX,
                           int       minY,
                           int       maxX,
                           int       maxY)
 {
-	puglSetAspectRatio(view, minX, minY, maxX, maxY);
+  puglSetAspectRatio(view, minX, minY, maxX, maxY);
 }
 
 /**
@@ -1354,10 +1400,11 @@ puglInitWindowAspectRatio(PuglView* view,
    On X11, parent must be a Window.
    On OSX, parent must be an NSView*.
 */
-static inline PUGL_DEPRECATED_BY("puglSetTransientFor") void
+static inline PUGL_DEPRECATED_BY("puglSetTransientFor")
+void
 puglInitTransientFor(PuglView* view, uintptr_t parent)
 {
-	puglSetTransientFor(view, (PuglNativeWindow)parent);
+  puglSetTransientFor(view, (PuglNativeWindow)parent);
 }
 
 /**
@@ -1365,10 +1412,11 @@ puglInitTransientFor(PuglView* view, uintptr_t parent)
 
    @deprecated Use puglSetViewHint() with #PUGL_RESIZABLE.
 */
-static inline PUGL_DEPRECATED_BY("puglSetViewHint") void
+static inline PUGL_DEPRECATED_BY("puglSetViewHint")
+void
 puglInitResizable(PuglView* view, bool resizable)
 {
-	puglSetViewHint(view, PUGL_RESIZABLE, resizable);
+  puglSetViewHint(view, PUGL_RESIZABLE, resizable);
 }
 
 /**
@@ -1377,13 +1425,14 @@ puglInitResizable(PuglView* view, bool resizable)
    @deprecated Use puglGetFrame().
 
 */
-static inline PUGL_DEPRECATED_BY("puglGetFrame") void
+static inline PUGL_DEPRECATED_BY("puglGetFrame")
+void
 puglGetSize(PuglView* view, int* width, int* height)
 {
-	const PuglRect frame = puglGetFrame(view);
+  const PuglRect frame = puglGetFrame(view);
 
-	*width  = (int)frame.width;
-	*height = (int)frame.height;
+  *width  = (int)frame.width;
+  *height = (int)frame.height;
 }
 
 /**
@@ -1391,10 +1440,11 @@ puglGetSize(PuglView* view, int* width, int* height)
 
    @deprecated Use puglSetViewHint() with #PUGL_IGNORE_KEY_REPEAT.
 */
-static inline PUGL_DEPRECATED_BY("puglSetViewHint") void
+static inline PUGL_DEPRECATED_BY("puglSetViewHint")
+void
 puglIgnoreKeyRepeat(PuglView* view, bool ignore)
 {
-	puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, ignore);
+  puglSetViewHint(view, PUGL_IGNORE_KEY_REPEAT, ignore);
 }
 
 /**
@@ -1402,10 +1452,11 @@ puglIgnoreKeyRepeat(PuglView* view, bool ignore)
 
    @deprecated Use puglSetWindowHint().
 */
-static inline PUGL_DEPRECATED_BY("puglSetViewHint") void
+static inline PUGL_DEPRECATED_BY("puglSetViewHint")
+void
 puglInitWindowHint(PuglView* view, PuglViewHint hint, int value)
 {
-	puglSetViewHint(view, hint, value);
+  puglSetViewHint(view, hint, value);
 }
 
 /**
@@ -1413,10 +1464,11 @@ puglInitWindowHint(PuglView* view, PuglViewHint hint, int value)
 
    @deprecated Use puglSetWindowParent().
 */
-static inline PUGL_DEPRECATED_BY("puglSetParentWindow") void
+static inline PUGL_DEPRECATED_BY("puglSetParentWindow")
+void
 puglInitWindowParent(PuglView* view, PuglNativeWindow parent)
 {
-	puglSetParentWindow(view, parent);
+  puglSetParentWindow(view, parent);
 }
 
 /**
@@ -1424,10 +1476,11 @@ puglInitWindowParent(PuglView* view, PuglNativeWindow parent)
 
    @deprecated Use puglSetBackend().
 */
-static inline PUGL_DEPRECATED_BY("puglSetBackend") int
+static inline PUGL_DEPRECATED_BY("puglSetBackend")
+int
 puglInitBackend(PuglView* view, const PuglBackend* backend)
 {
-	return (int)puglSetBackend(view, backend);
+  return (int)puglSetBackend(view, backend);
 }
 
 /**
@@ -1438,11 +1491,12 @@ puglInitBackend(PuglView* view, const PuglBackend* backend)
 
    @deprecated Use puglRealize(), or just show the view.
 */
-static inline PUGL_DEPRECATED_BY("puglRealize") PuglStatus
+static inline PUGL_DEPRECATED_BY("puglRealize")
+PuglStatus
 puglCreateWindow(PuglView* view, const char* title)
 {
-	puglSetWindowTitle(view, title);
-	return puglRealize(view);
+  puglSetWindowTitle(view, title);
+  return puglRealize(view);
 }
 
 /**
@@ -1455,7 +1509,9 @@ puglCreateWindow(PuglView* view, const char* title)
 
    @deprecated Use puglPollEvents().
 */
-PUGL_API PUGL_DEPRECATED_BY("puglPollEvents") PuglStatus
+PUGL_API
+PUGL_DEPRECATED_BY("puglPollEvents")
+PuglStatus
 puglWaitForEvent(PuglView* view);
 
 /**
@@ -1467,7 +1523,9 @@ puglWaitForEvent(PuglView* view);
 
    @deprecated Use puglDispatchEvents().
 */
-PUGL_API PUGL_DEPRECATED_BY("puglDispatchEvents") PuglStatus
+PUGL_API
+PUGL_DEPRECATED_BY("puglDispatchEvents")
+PuglStatus
 puglProcessEvents(PuglView* view);
 
 /**
@@ -1485,7 +1543,9 @@ puglProcessEvents(PuglView* view);
 
    @deprecated Use puglUpdate().
 */
-PUGL_API PUGL_DEPRECATED_BY("puglUpdate") PuglStatus
+PUGL_API
+PUGL_DEPRECATED_BY("puglUpdate")
+PuglStatus
 puglPollEvents(PuglWorld* world, double timeout);
 
 /**
@@ -1498,13 +1558,19 @@ puglPollEvents(PuglWorld* world, double timeout);
 
    @deprecated Use puglUpdate().
 */
-PUGL_API PUGL_DEPRECATED_BY("puglUpdate") PuglStatus
+PUGL_API
+PUGL_DEPRECATED_BY("puglUpdate")
+PuglStatus
 puglDispatchEvents(PuglWorld* world);
 
-PUGL_API PUGL_DEPRECATED_BY("puglShow") PuglStatus
+PUGL_API
+PUGL_DEPRECATED_BY("puglShow")
+PuglStatus
 puglShowWindow(PuglView* view);
 
-PUGL_API PUGL_DEPRECATED_BY("puglHide") PuglStatus
+PUGL_API
+PUGL_DEPRECATED_BY("puglHide")
+PuglStatus
 puglHideWindow(PuglView* view);
 
 #endif // PUGL_DISABLE_DEPRECATED
diff --git a/subprojects/nk_pugl/pugl/include/pugl/stub.h b/subprojects/nk_pugl/pugl/include/pugl/stub.h
index d2d1236..d1a699a 100644
--- a/subprojects/nk_pugl/pugl/include/pugl/stub.h
+++ b/subprojects/nk_pugl/pugl/include/pugl/stub.h
@@ -34,7 +34,7 @@ PUGL_BEGIN_DECLS
    This backend just creates a simple native window without setting up any
    portable graphics API.
 */
-PUGL_API PUGL_CONST_FUNC
+PUGL_CONST_API
 const PuglBackend*
 puglStubBackend(void);
 
diff --git a/subprojects/nk_pugl/pugl/include/pugl/vulkan.h b/subprojects/nk_pugl/pugl/include/pugl/vulkan.h
index bd4ad8e..f12ad97 100644
--- a/subprojects/nk_pugl/pugl/include/pugl/vulkan.h
+++ b/subprojects/nk_pugl/pugl/include/pugl/vulkan.h
@@ -1,5 +1,5 @@
 /*
-  Copyright 2012-2020 David Robillard <http://drobilla.net>
+  Copyright 2012-2020 David Robillard <d@drobilla.net>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
@@ -25,7 +25,9 @@
 
 #include "pugl/pugl.h"
 
-#include <vulkan/vulkan.h>
+#include <vulkan/vulkan_core.h>
+
+#include <stdint.h>
 
 PUGL_BEGIN_DECLS
 
@@ -66,11 +68,13 @@ typedef struct PuglVulkanLoaderImpl PuglVulkanLoader;
 /**
    Create a new dynamic loader for Vulkan functions.
 
-   This dynamically loads the Vulkan library and gets the load functions from it.
+   This dynamically loads the Vulkan library and gets the load functions from
+   it.
 
    @return A new Vulkan loader, or null on failure.
 */
-PUGL_API PuglVulkanLoader*
+PUGL_API
+PuglVulkanLoader*
 puglNewVulkanLoader(PuglWorld* world);
 
 /**
@@ -79,7 +83,8 @@ puglNewVulkanLoader(PuglWorld* world);
    Note that this closes the Vulkan library, so no Vulkan objects or API may be
    used after this is called.
 */
-PUGL_API void
+PUGL_API
+void
 puglFreeVulkanLoader(PuglVulkanLoader* loader);
 
 /**
@@ -88,7 +93,8 @@ puglFreeVulkanLoader(PuglVulkanLoader* loader);
    @return Null if the Vulkan library does not contain this function (which is
    unlikely and indicates a broken system).
 */
-PUGL_API PFN_vkGetInstanceProcAddr
+PUGL_API
+PFN_vkGetInstanceProcAddr
 puglGetInstanceProcAddrFunc(const PuglVulkanLoader* loader);
 
 /**
@@ -97,7 +103,8 @@ puglGetInstanceProcAddrFunc(const PuglVulkanLoader* loader);
    @return Null if the Vulkan library does not contain this function (which is
    unlikely and indicates a broken system).
 */
-PUGL_API PFN_vkGetDeviceProcAddr
+PUGL_API
+PFN_vkGetDeviceProcAddr
 puglGetDeviceProcAddrFunc(const PuglVulkanLoader* loader);
 
 /**
@@ -109,7 +116,8 @@ puglGetDeviceProcAddrFunc(const PuglVulkanLoader* loader);
    @param[out] count The number of extensions in the returned array.
    @return An array of extension name strings.
 */
-PUGL_API const char* const*
+PUGL_API
+const char* const*
 puglGetInstanceExtensions(uint32_t* count);
 
 /**
@@ -122,7 +130,8 @@ puglGetInstanceExtensions(uint32_t* count);
    @param[out] surface Pointed to a newly created Vulkan surface.
    @return `VK_SUCCESS` on success, or a Vulkan error code.
 */
-PUGL_API VkResult
+PUGL_API
+VkResult
 puglCreateSurface(PFN_vkGetInstanceProcAddr    vkGetInstanceProcAddr,
                   PuglView*                    view,
                   VkInstance                   instance,
@@ -134,7 +143,8 @@ puglCreateSurface(PFN_vkGetInstanceProcAddr    vkGetInstanceProcAddr,
 
    Pass the returned value to puglSetBackend() to draw to a view with Vulkan.
 */
-PUGL_API PUGL_CONST_FUNC const PuglBackend*
+PUGL_CONST_API
+const PuglBackend*
 puglVulkanBackend(void);
 
 /**
diff --git a/subprojects/nk_pugl/pugl/src/.clang-tidy b/subprojects/nk_pugl/pugl/src/.clang-tidy
index 808cbb1..11b620e 100644
--- a/subprojects/nk_pugl/pugl/src/.clang-tidy
+++ b/subprojects/nk_pugl/pugl/src/.clang-tidy
@@ -11,9 +11,7 @@ Checks: >
   -clang-diagnostic-unused-macros,
   -hicpp-multiway-paths-covered,
   -hicpp-signed-bitwise,
-  -llvm-else-after-return,
   -llvm-header-guard,
   -llvmlibc-*,
-  -readability-else-after-return,
 FormatStyle: file
 HeaderFilterRegex: 'pugl/.*'
diff --git a/subprojects/nk_pugl/pugl/src/implementation.c b/subprojects/nk_pugl/pugl/src/implementation.c
index e9b7e5a..47b52b8 100644
--- a/subprojects/nk_pugl/pugl/src/implementation.c
+++ b/subprojects/nk_pugl/pugl/src/implementation.c
@@ -26,249 +26,250 @@
 const char*
 puglStrerror(const PuglStatus status)
 {
-	// clang-format off
-	switch (status) {
-	case PUGL_SUCCESS:               return "Success";
-	case PUGL_FAILURE:               return "Non-fatal failure";
-	case PUGL_UNKNOWN_ERROR:         return "Unknown system error";
-	case PUGL_BAD_BACKEND:           return "Invalid or missing backend";
-	case PUGL_BAD_CONFIGURATION:     return "Invalid view configuration";
-	case PUGL_BAD_PARAMETER:         return "Invalid parameter";
-	case PUGL_BACKEND_FAILED:        return "Backend initialisation failed";
-	case PUGL_REGISTRATION_FAILED:   return "Class registration failed";
-	case PUGL_REALIZE_FAILED:        return "View creation failed";
-	case PUGL_SET_FORMAT_FAILED:     return "Failed to set pixel format";
-	case PUGL_CREATE_CONTEXT_FAILED: return "Failed to create drawing context";
-	case PUGL_UNSUPPORTED_TYPE:      return "Unsupported data type";
-	}
-	// clang-format on
-
-	return "Unknown error";
+  // clang-format off
+  switch (status) {
+  case PUGL_SUCCESS:               return "Success";
+  case PUGL_FAILURE:               return "Non-fatal failure";
+  case PUGL_UNKNOWN_ERROR:         return "Unknown system error";
+  case PUGL_BAD_BACKEND:           return "Invalid or missing backend";
+  case PUGL_BAD_CONFIGURATION:     return "Invalid view configuration";
+  case PUGL_BAD_PARAMETER:         return "Invalid parameter";
+  case PUGL_BACKEND_FAILED:        return "Backend initialisation failed";
+  case PUGL_REGISTRATION_FAILED:   return "Class registration failed";
+  case PUGL_REALIZE_FAILED:        return "View creation failed";
+  case PUGL_SET_FORMAT_FAILED:     return "Failed to set pixel format";
+  case PUGL_CREATE_CONTEXT_FAILED: return "Failed to create drawing context";
+  case PUGL_UNSUPPORTED_TYPE:      return "Unsupported data type";
+  }
+  // clang-format on
+
+  return "Unknown error";
 }
 
 void
 puglSetString(char** dest, const char* string)
 {
-	if (*dest != string) {
-		const size_t len = strlen(string);
+  if (*dest != string) {
+    const size_t len = strlen(string);
 
-		*dest = (char*)realloc(*dest, len + 1);
-		strncpy(*dest, string, len + 1);
-	}
+    *dest = (char*)realloc(*dest, len + 1);
+    strncpy(*dest, string, len + 1);
+  }
 }
 
 void
 puglSetBlob(PuglBlob* const dest, const void* const data, const size_t len)
 {
-	if (data) {
-		dest->len  = len;
-		dest->data = realloc(dest->data, len + 1);
-		memcpy(dest->data, data, len);
-		((char*)dest->data)[len] = 0;
-	} else {
-		dest->len  = 0;
-		dest->data = NULL;
-	}
+  if (data) {
+    dest->len  = len;
+    dest->data = realloc(dest->data, len + 1);
+    memcpy(dest->data, data, len);
+    ((char*)dest->data)[len] = 0;
+  } else {
+    dest->len  = 0;
+    dest->data = NULL;
+  }
 }
 
 static void
 puglSetDefaultHints(PuglHints hints)
 {
-	hints[PUGL_USE_COMPAT_PROFILE]    = PUGL_TRUE;
-	hints[PUGL_CONTEXT_VERSION_MAJOR] = 2;
-	hints[PUGL_CONTEXT_VERSION_MINOR] = 0;
-	hints[PUGL_RED_BITS]              = 8;
-	hints[PUGL_GREEN_BITS]            = 8;
-	hints[PUGL_BLUE_BITS]             = 8;
-	hints[PUGL_ALPHA_BITS]            = 8;
-	hints[PUGL_DEPTH_BITS]            = 0;
-	hints[PUGL_STENCIL_BITS]          = 0;
-	hints[PUGL_SAMPLES]               = 0;
-	hints[PUGL_DOUBLE_BUFFER]         = PUGL_TRUE;
-	hints[PUGL_SWAP_INTERVAL]         = PUGL_DONT_CARE;
-	hints[PUGL_RESIZABLE]             = PUGL_FALSE;
-	hints[PUGL_IGNORE_KEY_REPEAT]     = PUGL_FALSE;
-	hints[PUGL_REFRESH_RATE]          = PUGL_DONT_CARE;
+  hints[PUGL_USE_COMPAT_PROFILE]    = PUGL_TRUE;
+  hints[PUGL_CONTEXT_VERSION_MAJOR] = 2;
+  hints[PUGL_CONTEXT_VERSION_MINOR] = 0;
+  hints[PUGL_RED_BITS]              = 8;
+  hints[PUGL_GREEN_BITS]            = 8;
+  hints[PUGL_BLUE_BITS]             = 8;
+  hints[PUGL_ALPHA_BITS]            = 8;
+  hints[PUGL_DEPTH_BITS]            = 0;
+  hints[PUGL_STENCIL_BITS]          = 0;
+  hints[PUGL_SAMPLES]               = 0;
+  hints[PUGL_DOUBLE_BUFFER]         = PUGL_TRUE;
+  hints[PUGL_SWAP_INTERVAL]         = PUGL_DONT_CARE;
+  hints[PUGL_RESIZABLE]             = PUGL_FALSE;
+  hints[PUGL_IGNORE_KEY_REPEAT]     = PUGL_FALSE;
+  hints[PUGL_REFRESH_RATE]          = PUGL_DONT_CARE;
 }
 
 PuglWorld*
 puglNewWorld(PuglWorldType type, PuglWorldFlags flags)
 {
-	PuglWorld* world = (PuglWorld*)calloc(1, sizeof(PuglWorld));
-	if (!world || !(world->impl = puglInitWorldInternals(type, flags))) {
-		free(world);
-		return NULL;
-	}
+  PuglWorld* world = (PuglWorld*)calloc(1, sizeof(PuglWorld));
+  if (!world || !(world->impl = puglInitWorldInternals(type, flags))) {
+    free(world);
+    return NULL;
+  }
 
-	world->startTime = puglGetTime(world);
+  world->startTime = puglGetTime(world);
 
-	puglSetString(&world->className, "Pugl");
+  puglSetString(&world->className, "Pugl");
 
-	return world;
+  return world;
 }
 
 void
 puglFreeWorld(PuglWorld* const world)
 {
-	puglFreeWorldInternals(world);
-	free(world->className);
-	free(world->views);
-	free(world);
+  puglFreeWorldInternals(world);
+  free(world->className);
+  free(world->views);
+  free(world);
 }
 
 void
 puglSetWorldHandle(PuglWorld* world, PuglWorldHandle handle)
 {
-	world->handle = handle;
+  world->handle = handle;
 }
 
 PuglWorldHandle
 puglGetWorldHandle(PuglWorld* world)
 {
-	return world->handle;
+  return world->handle;
 }
 
 PuglStatus
 puglSetClassName(PuglWorld* const world, const char* const name)
 {
-	puglSetString(&world->className, name);
-	return PUGL_SUCCESS;
+  puglSetString(&world->className, name);
+  return PUGL_SUCCESS;
 }
 
 PuglView*
 puglNewView(PuglWorld* const world)
 {
-	PuglView* view = (PuglView*)calloc(1, sizeof(PuglView));
-	if (!view || !(view->impl = puglInitViewInternals())) {
-		free(view);
-		return NULL;
-	}
+  PuglView* view = (PuglView*)calloc(1, sizeof(PuglView));
+  if (!view || !(view->impl = puglInitViewInternals())) {
+    free(view);
+    return NULL;
+  }
 
-	view->world     = world;
-	view->minWidth  = 1;
-	view->minHeight = 1;
+  view->world     = world;
+  view->minWidth  = 1;
+  view->minHeight = 1;
 
-	puglSetDefaultHints(view->hints);
+  puglSetDefaultHints(view->hints);
 
-	// Add to world view list
-	++world->numViews;
-	world->views = (PuglView**)realloc(world->views,
-	                                   world->numViews * sizeof(PuglView*));
+  // Add to world view list
+  ++world->numViews;
+  world->views =
+    (PuglView**)realloc(world->views, world->numViews * sizeof(PuglView*));
 
-	world->views[world->numViews - 1] = view;
+  world->views[world->numViews - 1] = view;
 
-	return view;
+  return view;
 }
 
 void
 puglFreeView(PuglView* view)
 {
-	puglDispatchSimpleEvent(view, PUGL_DESTROY);
-
-	// Remove from world view list
-	PuglWorld* world = view->world;
-	for (size_t i = 0; i < world->numViews; ++i) {
-		if (world->views[i] == view) {
-			if (i == world->numViews - 1) {
-				world->views[i] = NULL;
-			} else {
-				memmove(world->views + i, world->views + i + 1,
-				        sizeof(PuglView*) * (world->numViews - i - 1));
-				world->views[world->numViews - 1] = NULL;
-			}
-			--world->numViews;
-		}
-	}
-
-	free(view->title);
-	free(view->clipboard.data);
+  puglDispatchSimpleEvent(view, PUGL_DESTROY);
+
+  // Remove from world view list
+  PuglWorld* world = view->world;
+  for (size_t i = 0; i < world->numViews; ++i) {
+    if (world->views[i] == view) {
+      if (i == world->numViews - 1) {
+        world->views[i] = NULL;
+      } else {
+        memmove(world->views + i,
+                world->views + i + 1,
+                sizeof(PuglView*) * (world->numViews - i - 1));
+        world->views[world->numViews - 1] = NULL;
+      }
+      --world->numViews;
+    }
+  }
+
+  free(view->title);
+  free(view->clipboard.data);
 	free(view->clipboardType.data);
-	puglFreeViewInternals(view);
-	free(view);
+  puglFreeViewInternals(view);
+  free(view);
 }
 
 PuglWorld*
 puglGetWorld(PuglView* view)
 {
-	return view->world;
+  return view->world;
 }
 
 PuglStatus
 puglSetViewHint(PuglView* view, PuglViewHint hint, int value)
 {
-	if (value == PUGL_DONT_CARE) {
-		switch (hint) {
-		case PUGL_USE_COMPAT_PROFILE:
-		case PUGL_USE_DEBUG_CONTEXT:
-		case PUGL_CONTEXT_VERSION_MAJOR:
-		case PUGL_CONTEXT_VERSION_MINOR:
-		case PUGL_SWAP_INTERVAL:
-			return PUGL_BAD_PARAMETER;
-		default:
-			break;
-		}
-	}
+  if (value == PUGL_DONT_CARE) {
+    switch (hint) {
+    case PUGL_USE_COMPAT_PROFILE:
+    case PUGL_USE_DEBUG_CONTEXT:
+    case PUGL_CONTEXT_VERSION_MAJOR:
+    case PUGL_CONTEXT_VERSION_MINOR:
+    case PUGL_SWAP_INTERVAL:
+      return PUGL_BAD_PARAMETER;
+    default:
+      break;
+    }
+  }
 
-	if (hint < PUGL_NUM_VIEW_HINTS) {
-		view->hints[hint] = value;
-		return PUGL_SUCCESS;
-	}
+  if (hint < PUGL_NUM_VIEW_HINTS) {
+    view->hints[hint] = value;
+    return PUGL_SUCCESS;
+  }
 
-	return PUGL_BAD_PARAMETER;
+  return PUGL_BAD_PARAMETER;
 }
 
 int
 puglGetViewHint(const PuglView* view, PuglViewHint hint)
 {
-	if (hint < PUGL_NUM_VIEW_HINTS) {
-		return view->hints[hint];
-	}
+  if (hint < PUGL_NUM_VIEW_HINTS) {
+    return view->hints[hint];
+  }
 
-	return PUGL_DONT_CARE;
+  return PUGL_DONT_CARE;
 }
 
 PuglStatus
 puglSetParentWindow(PuglView* view, PuglNativeView parent)
 {
-	view->parent = parent;
-	return PUGL_SUCCESS;
+  view->parent = parent;
+  return PUGL_SUCCESS;
 }
 
 PuglStatus
 puglSetBackend(PuglView* view, const PuglBackend* backend)
 {
-	view->backend = backend;
-	return PUGL_SUCCESS;
+  view->backend = backend;
+  return PUGL_SUCCESS;
 }
 
 void
 puglSetHandle(PuglView* view, PuglHandle handle)
 {
-	view->handle = handle;
+  view->handle = handle;
 }
 
 PuglHandle
 puglGetHandle(PuglView* view)
 {
-	return view->handle;
+  return view->handle;
 }
 
 bool
 puglGetVisible(const PuglView* view)
 {
-	return view->visible;
+  return view->visible;
 }
 
 PuglRect
 puglGetFrame(const PuglView* view)
 {
-	return view->frame;
+  return view->frame;
 }
 
 void*
 puglGetContext(PuglView* view)
 {
-	return view->backend->getContext(view);
+  return view->backend->getContext(view);
 }
 
 #ifndef PUGL_DISABLE_DEPRECATED
@@ -276,25 +277,25 @@ puglGetContext(PuglView* view)
 PuglStatus
 puglPollEvents(PuglWorld* world, double timeout)
 {
-	return puglUpdate(world, timeout);
+  return puglUpdate(world, timeout);
 }
 
 PuglStatus
 puglDispatchEvents(PuglWorld* world)
 {
-	return puglUpdate(world, 0.0);
+  return puglUpdate(world, 0.0);
 }
 
 PuglStatus
 puglShowWindow(PuglView* view)
 {
-	return puglShow(view);
+  return puglShow(view);
 }
 
 PuglStatus
 puglHideWindow(PuglView* view)
 {
-	return puglHide(view);
+  return puglHide(view);
 }
 
 #endif
@@ -302,112 +303,125 @@ puglHideWindow(PuglView* view)
 PuglStatus
 puglSetEventFunc(PuglView* view, PuglEventFunc eventFunc)
 {
-	view->eventFunc = eventFunc;
-	return PUGL_SUCCESS;
+  view->eventFunc = eventFunc;
+  return PUGL_SUCCESS;
 }
 
 /// Return the code point for buf, or the replacement character on error
 uint32_t
 puglDecodeUTF8(const uint8_t* buf)
 {
-#define FAIL_IF(cond) do { if (cond) return 0xFFFD; } while (0)
-
-	// http://en.wikipedia.org/wiki/UTF-8
-
-	if (buf[0] < 0x80) {
-		return buf[0];
-	} else if (buf[0] < 0xC2) {
-		return 0xFFFD;
-	} else if (buf[0] < 0xE0) {
-		FAIL_IF((buf[1] & 0xC0u) != 0x80);
-		return ((uint32_t)buf[0] << 6u) + buf[1] - 0x3080u;
-	} else if (buf[0] < 0xF0) {
-		FAIL_IF((buf[1] & 0xC0u) != 0x80);
-		FAIL_IF(buf[0] == 0xE0 && buf[1] < 0xA0);
-		FAIL_IF((buf[2] & 0xC0u) != 0x80);
-		return ((uint32_t)buf[0] << 12u) + //
-		       ((uint32_t)buf[1] << 6u) +  //
-		       ((uint32_t)buf[2] - 0xE2080u);
-	} else if (buf[0] < 0xF5) {
-		FAIL_IF((buf[1] & 0xC0u) != 0x80);
-		FAIL_IF(buf[0] == 0xF0 && buf[1] < 0x90);
-		FAIL_IF(buf[0] == 0xF4 && buf[1] >= 0x90);
-		FAIL_IF((buf[2] & 0xC0u) != 0x80u);
-		FAIL_IF((buf[3] & 0xC0u) != 0x80u);
-		return (((uint32_t)buf[0] << 18u) + //
-		        ((uint32_t)buf[1] << 12u) + //
-		        ((uint32_t)buf[2] << 6u) +  //
-		        ((uint32_t)buf[3] - 0x3C82080u));
-	}
-	return 0xFFFD;
+#define FAIL_IF(cond) \
+  do {                \
+    if (cond)         \
+      return 0xFFFD;  \
+  } while (0)
+
+  // http://en.wikipedia.org/wiki/UTF-8
+
+  if (buf[0] < 0x80) {
+    return buf[0];
+  }
+
+  if (buf[0] < 0xC2) {
+    return 0xFFFD;
+  }
+
+  if (buf[0] < 0xE0) {
+    FAIL_IF((buf[1] & 0xC0u) != 0x80);
+    return ((uint32_t)buf[0] << 6u) + buf[1] - 0x3080u;
+  }
+
+  if (buf[0] < 0xF0) {
+    FAIL_IF((buf[1] & 0xC0u) != 0x80);
+    FAIL_IF(buf[0] == 0xE0 && buf[1] < 0xA0);
+    FAIL_IF((buf[2] & 0xC0u) != 0x80);
+    return ((uint32_t)buf[0] << 12u) + //
+           ((uint32_t)buf[1] << 6u) +  //
+           ((uint32_t)buf[2] - 0xE2080u);
+  }
+
+  if (buf[0] < 0xF5) {
+    FAIL_IF((buf[1] & 0xC0u) != 0x80);
+    FAIL_IF(buf[0] == 0xF0 && buf[1] < 0x90);
+    FAIL_IF(buf[0] == 0xF4 && buf[1] >= 0x90);
+    FAIL_IF((buf[2] & 0xC0u) != 0x80u);
+    FAIL_IF((buf[3] & 0xC0u) != 0x80u);
+    return (((uint32_t)buf[0] << 18u) + //
+            ((uint32_t)buf[1] << 12u) + //
+            ((uint32_t)buf[2] << 6u) +  //
+            ((uint32_t)buf[3] - 0x3C82080u));
+  }
+
+  return 0xFFFD;
 }
 
 static inline bool
 puglMustConfigure(PuglView* view, const PuglEventConfigure* configure)
 {
-	return memcmp(configure, &view->lastConfigure, sizeof(PuglEventConfigure));
+  return memcmp(configure, &view->lastConfigure, sizeof(PuglEventConfigure));
 }
 
 void
 puglDispatchSimpleEvent(PuglView* view, const PuglEventType type)
 {
-	assert(type == PUGL_CREATE || type == PUGL_DESTROY || type == PUGL_MAP ||
-	       type == PUGL_UNMAP || type == PUGL_UPDATE || type == PUGL_CLOSE ||
-	       type == PUGL_LOOP_ENTER || type == PUGL_LOOP_LEAVE);
+  assert(type == PUGL_CREATE || type == PUGL_DESTROY || type == PUGL_MAP ||
+         type == PUGL_UNMAP || type == PUGL_UPDATE || type == PUGL_CLOSE ||
+         type == PUGL_LOOP_ENTER || type == PUGL_LOOP_LEAVE);
 
-	const PuglEvent event = {{type, 0}};
-	puglDispatchEvent(view, &event);
+  const PuglEvent event = {{type, 0}};
+  puglDispatchEvent(view, &event);
 }
 
 void
 puglDispatchEventInContext(PuglView* view, const PuglEvent* event)
 {
-	if (event->type == PUGL_CONFIGURE) {
-		view->frame.x      = event->configure.x;
-		view->frame.y      = event->configure.y;
-		view->frame.width  = event->configure.width;
-		view->frame.height = event->configure.height;
-
-		if (puglMustConfigure(view, &event->configure)) {
-			view->eventFunc(view, event);
-			view->lastConfigure = event->configure;
-		}
-	} else if (event->type == PUGL_EXPOSE) {
-		if (event->expose.width > 0 && event->expose.height > 0) {
-			view->eventFunc(view, event);
-		}
-	} else {
-		view->eventFunc(view, event);
-	}
+  if (event->type == PUGL_CONFIGURE) {
+    view->frame.x      = event->configure.x;
+    view->frame.y      = event->configure.y;
+    view->frame.width  = event->configure.width;
+    view->frame.height = event->configure.height;
+
+    if (puglMustConfigure(view, &event->configure)) {
+      view->eventFunc(view, event);
+      view->lastConfigure = event->configure;
+    }
+  } else if (event->type == PUGL_EXPOSE) {
+    if (event->expose.width > 0 && event->expose.height > 0) {
+      view->eventFunc(view, event);
+    }
+  } else {
+    view->eventFunc(view, event);
+  }
 }
 
 void
 puglDispatchEvent(PuglView* view, const PuglEvent* event)
 {
-	switch (event->type) {
-	case PUGL_NOTHING:
-		break;
-	case PUGL_CREATE:
-	case PUGL_DESTROY:
-		view->backend->enter(view, NULL);
-		view->eventFunc(view, event);
-		view->backend->leave(view, NULL);
-		break;
-	case PUGL_CONFIGURE:
-		if (puglMustConfigure(view, &event->configure)) {
-			view->backend->enter(view, NULL);
-			puglDispatchEventInContext(view, event);
-			view->backend->leave(view, NULL);
-		}
-		break;
-	case PUGL_EXPOSE:
-		view->backend->enter(view, &event->expose);
-		puglDispatchEventInContext(view, event);
-		view->backend->leave(view, &event->expose);
-		break;
-	default:
-		view->eventFunc(view, event);
-	}
+  switch (event->type) {
+  case PUGL_NOTHING:
+    break;
+  case PUGL_CREATE:
+  case PUGL_DESTROY:
+    view->backend->enter(view, NULL);
+    view->eventFunc(view, event);
+    view->backend->leave(view, NULL);
+    break;
+  case PUGL_CONFIGURE:
+    if (puglMustConfigure(view, &event->configure)) {
+      view->backend->enter(view, NULL);
+      puglDispatchEventInContext(view, event);
+      view->backend->leave(view, NULL);
+    }
+    break;
+  case PUGL_EXPOSE:
+    view->backend->enter(view, &event->expose);
+    puglDispatchEventInContext(view, event);
+    view->backend->leave(view, &event->expose);
+    break;
+  default:
+    view->eventFunc(view, event);
+  }
 }
 
 const void*
@@ -415,15 +429,15 @@ puglGetInternalClipboard(const PuglView* const view,
                          const char** const    type,
                          size_t* const         len)
 {
-	if (len) {
-		*len = view->clipboard.len;
-	}
+  if (len) {
+    *len = view->clipboard.len;
+  }
 
-	if (type) {
+  if (type) {
 		*type = view->clipboardType.data;
-	}
+  }
 
-	return view->clipboard.data;
+  return view->clipboard.data;
 }
 
 PuglStatus
@@ -433,11 +447,10 @@ puglSetInternalClipboard(PuglView* const   view,
                          const size_t      len)
 {
 	if (!type) {
-		return PUGL_UNSUPPORTED_TYPE;
-	}
+    return PUGL_UNSUPPORTED_TYPE;
+  }
 
 	puglSetBlob(&view->clipboardType, type, strlen(type) + 1);
-	puglSetBlob(&view->clipboard, data, len);
-	return PUGL_SUCCESS;
+  puglSetBlob(&view->clipboard, data, len);
+  return PUGL_SUCCESS;
 }
-
diff --git a/subprojects/nk_pugl/pugl/src/mac.h b/subprojects/nk_pugl/pugl/src/mac.h
index d17c74f..35e6e0d 100644
--- a/subprojects/nk_pugl/pugl/src/mac.h
+++ b/subprojects/nk_pugl/pugl/src/mac.h
@@ -38,18 +38,18 @@
 @end
 
 struct PuglWorldInternalsImpl {
-	NSApplication*     app;
-	NSAutoreleasePool* autoreleasePool;
+  NSApplication*     app;
+  NSAutoreleasePool* autoreleasePool;
 };
 
 struct PuglInternalsImpl {
-	NSApplication*   app;
-	PuglWrapperView* wrapperView;
-	NSView*          drawView;
-	NSCursor*        cursor;
-	PuglWindow*      window;
-	uint32_t         mods;
-	bool             mouseTracked;
+  NSApplication*   app;
+  PuglWrapperView* wrapperView;
+  NSView*          drawView;
+  NSCursor*        cursor;
+  PuglWindow*      window;
+  uint32_t         mods;
+  bool             mouseTracked;
 };
 
 #endif // PUGL_DETAIL_MAC_H
diff --git a/subprojects/nk_pugl/pugl/src/mac.m b/subprojects/nk_pugl/pugl/src/mac.m
index 90fcfd0..58f16c7 100644
--- a/subprojects/nk_pugl/pugl/src/mac.m
+++ b/subprojects/nk_pugl/pugl/src/mac.m
@@ -40,85 +40,85 @@ typedef NSUInteger NSWindowStyleMask;
 static NSRect
 rectToScreen(NSScreen* screen, NSRect rect)
 {
-	const double screenHeight = [screen frame].size.height;
+  const double screenHeight = [screen frame].size.height;
 
-	rect.origin.y = screenHeight - rect.origin.y - rect.size.height;
-	return rect;
+  rect.origin.y = screenHeight - rect.origin.y - rect.size.height;
+  return rect;
 }
 
 static NSScreen*
 viewScreen(PuglView* view)
 {
-	return view->impl->window ? [view->impl->window screen] : [NSScreen mainScreen];
+  return view->impl->window ? [view->impl->window screen]
+                            : [NSScreen mainScreen];
 }
 
 static NSRect
 nsRectToPoints(PuglView* view, const NSRect rect)
 {
-	const double scaleFactor = [viewScreen(view) backingScaleFactor];
+  const double scaleFactor = [viewScreen(view) backingScaleFactor];
 
-	return NSMakeRect(rect.origin.x / scaleFactor,
-	                  rect.origin.y / scaleFactor,
-	                  rect.size.width / scaleFactor,
-	                  rect.size.height / scaleFactor);
+  return NSMakeRect(rect.origin.x / scaleFactor,
+                    rect.origin.y / scaleFactor,
+                    rect.size.width / scaleFactor,
+                    rect.size.height / scaleFactor);
 }
 
 static NSRect
 nsRectFromPoints(PuglView* view, const NSRect rect)
 {
-	const double scaleFactor = [viewScreen(view) backingScaleFactor];
+  const double scaleFactor = [viewScreen(view) backingScaleFactor];
 
-	return NSMakeRect(rect.origin.x * scaleFactor,
-	                  rect.origin.y * scaleFactor,
-	                  rect.size.width * scaleFactor,
-	                  rect.size.height * scaleFactor);
+  return NSMakeRect(rect.origin.x * scaleFactor,
+                    rect.origin.y * scaleFactor,
+                    rect.size.width * scaleFactor,
+                    rect.size.height * scaleFactor);
 }
 
 static NSPoint
 nsPointFromPoints(PuglView* view, const NSPoint point)
 {
-	const double scaleFactor = [viewScreen(view) backingScaleFactor];
+  const double scaleFactor = [viewScreen(view) backingScaleFactor];
 
-	return NSMakePoint(point.x * scaleFactor, point.y * scaleFactor);
+  return NSMakePoint(point.x * scaleFactor, point.y * scaleFactor);
 }
 
 static NSRect
 rectToNsRect(const PuglRect rect)
 {
-	return NSMakeRect(rect.x, rect.y, rect.width, rect.height);
+  return NSMakeRect(rect.x, rect.y, rect.width, rect.height);
 }
 
 static NSSize
 sizePoints(PuglView* view, const double width, const double height)
 {
-	const double scaleFactor = [viewScreen(view) backingScaleFactor];
+  const double scaleFactor = [viewScreen(view) backingScaleFactor];
 
-	return NSMakeSize(width / scaleFactor, height / scaleFactor);
+  return NSMakeSize(width / scaleFactor, height / scaleFactor);
 }
 
 static void
 updateViewRect(PuglView* view)
 {
-	NSWindow* const window = view->impl->window;
-	if (window) {
-		const NSRect screenFramePt = [[NSScreen mainScreen] frame];
-		const NSRect screenFramePx = nsRectFromPoints(view, screenFramePt);
-		const NSRect framePt       = [window frame];
-		const NSRect contentPt     = [window contentRectForFrameRect:framePt];
-		const NSRect contentPx     = nsRectFromPoints(view, contentPt);
-		const double screenHeight  = screenFramePx.size.height;
-
-		view->frame.x      = contentPx.origin.x;
-		view->frame.y      = screenHeight - contentPx.origin.y - contentPx.size.height;
-		view->frame.width  = contentPx.size.width;
-		view->frame.height = contentPx.size.height;
-	}
+  NSWindow* const window = view->impl->window;
+  if (window) {
+    const NSRect screenFramePt = [[NSScreen mainScreen] frame];
+    const NSRect screenFramePx = nsRectFromPoints(view, screenFramePt);
+    const NSRect framePt       = [window frame];
+    const NSRect contentPt     = [window contentRectForFrameRect:framePt];
+    const NSRect contentPx     = nsRectFromPoints(view, contentPt);
+    const double screenHeight  = screenFramePx.size.height;
+
+    view->frame.x = contentPx.origin.x;
+    view->frame.y = screenHeight - contentPx.origin.y - contentPx.size.height;
+    view->frame.width  = contentPx.size.width;
+    view->frame.height = contentPx.size.height;
+  }
 }
 
-@implementation PuglWindow
-{
+@implementation PuglWindow {
 @public
-	PuglView* puglview;
+  PuglView* puglview;
 }
 
 - (id)initWithContentRect:(NSRect)contentRect
@@ -126,617 +126,638 @@ updateViewRect(PuglView* view)
                   backing:(NSBackingStoreType)bufferingType
                     defer:(BOOL)flag
 {
-	(void)flag;
+  (void)flag;
 
-	NSWindow* result = [super initWithContentRect:contentRect
-	                                    styleMask:aStyle
-	                                      backing:bufferingType
-	                                        defer:NO];
+  NSWindow* result = [super initWithContentRect:contentRect
+                                      styleMask:aStyle
+                                        backing:bufferingType
+                                          defer:NO];
 
-	[result setAcceptsMouseMovedEvents:YES];
-	return (PuglWindow*)result;
+  [result setAcceptsMouseMovedEvents:YES];
+  return (PuglWindow*)result;
 }
 
 - (void)setPuglview:(PuglView*)view
 {
-	puglview = view;
+  puglview = view;
 
-	[self
-	    setContentSize:sizePoints(view, view->frame.width, view->frame.height)];
+  [self setContentSize:sizePoints(view, view->frame.width, view->frame.height)];
 }
 
 - (BOOL)canBecomeKeyWindow
 {
-	return YES;
+  return YES;
 }
 
 - (BOOL)canBecomeMainWindow
 {
-	return YES;
+  return YES;
 }
 
 - (void)setIsVisible:(BOOL)flag
 {
-	if (flag && !puglview->visible) {
-		const PuglEventConfigure ev =  {
-			PUGL_CONFIGURE,
-			0,
-			puglview->frame.x,
-			puglview->frame.y,
-			puglview->frame.width,
-			puglview->frame.height,
-		};
-
-		puglDispatchEvent(puglview, (const PuglEvent*)&ev);
-		puglDispatchSimpleEvent(puglview, PUGL_MAP);
-	} else if (!flag && puglview->visible) {
-		puglDispatchSimpleEvent(puglview, PUGL_UNMAP);
-	}
+  if (flag && !puglview->visible) {
+    const PuglEventConfigure ev = {
+      PUGL_CONFIGURE,
+      0,
+      puglview->frame.x,
+      puglview->frame.y,
+      puglview->frame.width,
+      puglview->frame.height,
+    };
+
+    puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+    puglDispatchSimpleEvent(puglview, PUGL_MAP);
+  } else if (!flag && puglview->visible) {
+    puglDispatchSimpleEvent(puglview, PUGL_UNMAP);
+  }
 
-	puglview->visible = flag;
+  puglview->visible = flag;
 
-	[super setIsVisible:flag];
+  [super setIsVisible:flag];
 }
 
 @end
 
-@implementation PuglWrapperView
-{
+@implementation PuglWrapperView {
 @public
-	PuglView*                  puglview;
-	NSTrackingArea*            trackingArea;
-	NSMutableAttributedString* markedText;
-	NSMutableDictionary*       userTimers;
-	bool                       reshaped;
+  PuglView*                  puglview;
+  NSTrackingArea*            trackingArea;
+  NSMutableAttributedString* markedText;
+  NSMutableDictionary*       userTimers;
+  bool                       reshaped;
 }
 
 - (void)dispatchExpose:(NSRect)rect
 {
-	const double scaleFactor = [[NSScreen mainScreen] backingScaleFactor];
+  const double scaleFactor = [[NSScreen mainScreen] backingScaleFactor];
 
-	if (reshaped) {
-		updateViewRect(puglview);
+  if (reshaped) {
+    updateViewRect(puglview);
 
-		const PuglEventConfigure ev = {
-			PUGL_CONFIGURE,
-			0,
-			puglview->frame.x,
-			puglview->frame.y,
-			puglview->frame.width,
-			puglview->frame.height,
-		};
+    const PuglEventConfigure ev = {
+      PUGL_CONFIGURE,
+      0,
+      puglview->frame.x,
+      puglview->frame.y,
+      puglview->frame.width,
+      puglview->frame.height,
+    };
 
-		puglDispatchEvent(puglview, (const PuglEvent*)&ev);
-		reshaped = false;
-	}
+    puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+    reshaped = false;
+  }
 
-	if (![[puglview->impl->drawView window] isVisible]) {
-		return;
-	}
+  if (![[puglview->impl->drawView window] isVisible]) {
+    return;
+  }
 
-	const PuglEventExpose ev = {
-		PUGL_EXPOSE,
-		0,
-		rect.origin.x * scaleFactor,
-		rect.origin.y * scaleFactor,
-		rect.size.width * scaleFactor,
-		rect.size.height * scaleFactor,
-	};
+  const PuglEventExpose ev = {
+    PUGL_EXPOSE,
+    0,
+    rect.origin.x * scaleFactor,
+    rect.origin.y * scaleFactor,
+    rect.size.width * scaleFactor,
+    rect.size.height * scaleFactor,
+  };
 
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (NSSize)intrinsicContentSize
 {
-	if (puglview->defaultWidth || puglview->defaultHeight) {
-		return sizePoints(puglview,
-		                  puglview->defaultWidth,
-		                  puglview->defaultHeight);
-	}
+  if (puglview->defaultWidth || puglview->defaultHeight) {
+    return sizePoints(
+      puglview, puglview->defaultWidth, puglview->defaultHeight);
+  }
 
-	return NSMakeSize(NSViewNoInstrinsicMetric, NSViewNoInstrinsicMetric);
+  return NSMakeSize(NSViewNoInstrinsicMetric, NSViewNoInstrinsicMetric);
 }
 
 - (BOOL)isFlipped
 {
-	return YES;
+  return YES;
 }
 
 - (BOOL)acceptsFirstResponder
 {
-	return YES;
+  return YES;
 }
 
 - (void)setReshaped
 {
-	reshaped = true;
+  reshaped = true;
 }
 
 static uint32_t
 getModifiers(const NSEvent* const ev)
 {
-	const NSEventModifierFlags modifierFlags = [ev modifierFlags];
+  const NSEventModifierFlags modifierFlags = [ev modifierFlags];
 
-	return (((modifierFlags & NSShiftKeyMask)     ? PUGL_MOD_SHIFT : 0) |
-	        ((modifierFlags & NSControlKeyMask)   ? PUGL_MOD_CTRL  : 0) |
-	        ((modifierFlags & NSAlternateKeyMask) ? PUGL_MOD_ALT   : 0) |
-	        ((modifierFlags & NSCommandKeyMask)   ? PUGL_MOD_SUPER : 0));
+  return (((modifierFlags & NSShiftKeyMask) ? PUGL_MOD_SHIFT : 0) |
+          ((modifierFlags & NSControlKeyMask) ? PUGL_MOD_CTRL : 0) |
+          ((modifierFlags & NSAlternateKeyMask) ? PUGL_MOD_ALT : 0) |
+          ((modifierFlags & NSCommandKeyMask) ? PUGL_MOD_SUPER : 0));
 }
 
 static PuglKey
 keySymToSpecial(const NSEvent* const ev)
 {
-	NSString* chars = [ev charactersIgnoringModifiers];
-	if ([chars length] == 1) {
-		switch ([chars characterAtIndex:0]) {
-		case NSF1FunctionKey:          return PUGL_KEY_F1;
-		case NSF2FunctionKey:          return PUGL_KEY_F2;
-		case NSF3FunctionKey:          return PUGL_KEY_F3;
-		case NSF4FunctionKey:          return PUGL_KEY_F4;
-		case NSF5FunctionKey:          return PUGL_KEY_F5;
-		case NSF6FunctionKey:          return PUGL_KEY_F6;
-		case NSF7FunctionKey:          return PUGL_KEY_F7;
-		case NSF8FunctionKey:          return PUGL_KEY_F8;
-		case NSF9FunctionKey:          return PUGL_KEY_F9;
-		case NSF10FunctionKey:         return PUGL_KEY_F10;
-		case NSF11FunctionKey:         return PUGL_KEY_F11;
-		case NSF12FunctionKey:         return PUGL_KEY_F12;
-		case NSDeleteCharacter:        return PUGL_KEY_BACKSPACE;
-		case NSDeleteFunctionKey:      return PUGL_KEY_DELETE;
-		case NSLeftArrowFunctionKey:   return PUGL_KEY_LEFT;
-		case NSUpArrowFunctionKey:     return PUGL_KEY_UP;
-		case NSRightArrowFunctionKey:  return PUGL_KEY_RIGHT;
-		case NSDownArrowFunctionKey:   return PUGL_KEY_DOWN;
-		case NSPageUpFunctionKey:      return PUGL_KEY_PAGE_UP;
-		case NSPageDownFunctionKey:    return PUGL_KEY_PAGE_DOWN;
-		case NSHomeFunctionKey:        return PUGL_KEY_HOME;
-		case NSEndFunctionKey:         return PUGL_KEY_END;
-		case NSInsertFunctionKey:      return PUGL_KEY_INSERT;
-		case NSMenuFunctionKey:        return PUGL_KEY_MENU;
-		case NSScrollLockFunctionKey:  return PUGL_KEY_SCROLL_LOCK;
-		case NSClearLineFunctionKey:   return PUGL_KEY_NUM_LOCK;
-		case NSPrintScreenFunctionKey: return PUGL_KEY_PRINT_SCREEN;
-		case NSPauseFunctionKey:       return PUGL_KEY_PAUSE;
-		}
-		// SHIFT, CTRL, ALT, and SUPER are handled in [flagsChanged]
-	}
-	return (PuglKey)0;
+  NSString* chars = [ev charactersIgnoringModifiers];
+  if ([chars length] == 1) {
+    switch ([chars characterAtIndex:0]) {
+    case NSF1FunctionKey:
+      return PUGL_KEY_F1;
+    case NSF2FunctionKey:
+      return PUGL_KEY_F2;
+    case NSF3FunctionKey:
+      return PUGL_KEY_F3;
+    case NSF4FunctionKey:
+      return PUGL_KEY_F4;
+    case NSF5FunctionKey:
+      return PUGL_KEY_F5;
+    case NSF6FunctionKey:
+      return PUGL_KEY_F6;
+    case NSF7FunctionKey:
+      return PUGL_KEY_F7;
+    case NSF8FunctionKey:
+      return PUGL_KEY_F8;
+    case NSF9FunctionKey:
+      return PUGL_KEY_F9;
+    case NSF10FunctionKey:
+      return PUGL_KEY_F10;
+    case NSF11FunctionKey:
+      return PUGL_KEY_F11;
+    case NSF12FunctionKey:
+      return PUGL_KEY_F12;
+    case NSDeleteCharacter:
+      return PUGL_KEY_BACKSPACE;
+    case NSDeleteFunctionKey:
+      return PUGL_KEY_DELETE;
+    case NSLeftArrowFunctionKey:
+      return PUGL_KEY_LEFT;
+    case NSUpArrowFunctionKey:
+      return PUGL_KEY_UP;
+    case NSRightArrowFunctionKey:
+      return PUGL_KEY_RIGHT;
+    case NSDownArrowFunctionKey:
+      return PUGL_KEY_DOWN;
+    case NSPageUpFunctionKey:
+      return PUGL_KEY_PAGE_UP;
+    case NSPageDownFunctionKey:
+      return PUGL_KEY_PAGE_DOWN;
+    case NSHomeFunctionKey:
+      return PUGL_KEY_HOME;
+    case NSEndFunctionKey:
+      return PUGL_KEY_END;
+    case NSInsertFunctionKey:
+      return PUGL_KEY_INSERT;
+    case NSMenuFunctionKey:
+      return PUGL_KEY_MENU;
+    case NSScrollLockFunctionKey:
+      return PUGL_KEY_SCROLL_LOCK;
+    case NSClearLineFunctionKey:
+      return PUGL_KEY_NUM_LOCK;
+    case NSPrintScreenFunctionKey:
+      return PUGL_KEY_PRINT_SCREEN;
+    case NSPauseFunctionKey:
+      return PUGL_KEY_PAUSE;
+    }
+    // SHIFT, CTRL, ALT, and SUPER are handled in [flagsChanged]
+  }
+  return (PuglKey)0;
 }
 
 - (void)updateTrackingAreas
 {
-	if (trackingArea != nil) {
-		[self removeTrackingArea:trackingArea];
-		[trackingArea release];
-	}
+  if (trackingArea != nil) {
+    [self removeTrackingArea:trackingArea];
+    [trackingArea release];
+  }
 
-	const int opts = (NSTrackingMouseEnteredAndExited |
-	                  NSTrackingMouseMoved |
-	                  NSTrackingActiveAlways);
-	trackingArea = [[NSTrackingArea alloc] initWithRect:[self bounds]
-	                                            options:opts
-	                                              owner:self
-	                                           userInfo:nil];
-	[self addTrackingArea:trackingArea];
-	[super updateTrackingAreas];
+  const int opts = (NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+                    NSTrackingActiveAlways);
+  trackingArea   = [[NSTrackingArea alloc] initWithRect:[self bounds]
+                                              options:opts
+                                                owner:self
+                                             userInfo:nil];
+  [self addTrackingArea:trackingArea];
+  [super updateTrackingAreas];
 }
 
 - (NSPoint)eventLocation:(NSEvent*)event
 {
-	return nsPointFromPoints(puglview,
-	                         [self convertPoint:[event locationInWindow]
-	                                   fromView:nil]);
+  return nsPointFromPoints(
+    puglview, [self convertPoint:[event locationInWindow] fromView:nil]);
 }
 
 static void
 handleCrossing(PuglWrapperView* view, NSEvent* event, const PuglEventType type)
 {
-	const NSPoint           wloc = [view eventLocation:event];
-	const NSPoint           rloc = [NSEvent mouseLocation];
-	const PuglEventCrossing ev   = {
-		type,
-		0,
-		[event timestamp],
-		wloc.x,
-		wloc.y,
-		rloc.x,
-		[[NSScreen mainScreen] frame].size.height - rloc.y,
-		getModifiers(event),
-		PUGL_CROSSING_NORMAL,
-	};
+  const NSPoint           wloc = [view eventLocation:event];
+  const NSPoint           rloc = [NSEvent mouseLocation];
+  const PuglEventCrossing ev   = {
+    type,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+    PUGL_CROSSING_NORMAL,
+  };
 
-	puglDispatchEvent(view->puglview, (const PuglEvent*)&ev);
+  puglDispatchEvent(view->puglview, (const PuglEvent*)&ev);
 }
 
 - (void)mouseEntered:(NSEvent*)event
 {
-	handleCrossing(self, event, PUGL_POINTER_IN);
-	[puglview->impl->cursor set];
-	puglview->impl->mouseTracked = true;
+  handleCrossing(self, event, PUGL_POINTER_IN);
+  [puglview->impl->cursor set];
+  puglview->impl->mouseTracked = true;
 }
 
 - (void)mouseExited:(NSEvent*)event
 {
-	[[NSCursor arrowCursor] set];
-	handleCrossing(self, event, PUGL_POINTER_OUT);
-	puglview->impl->mouseTracked = false;
+  [[NSCursor arrowCursor] set];
+  handleCrossing(self, event, PUGL_POINTER_OUT);
+  puglview->impl->mouseTracked = false;
 }
 
 - (void)cursorUpdate:(NSEvent*)event
 {
-	(void)event;
-	[puglview->impl->cursor set];
+  (void)event;
+  [puglview->impl->cursor set];
 }
 
 - (void)mouseMoved:(NSEvent*)event
 {
-	const NSPoint         wloc = [self eventLocation:event];
-	const NSPoint         rloc = [NSEvent mouseLocation];
-	const PuglEventMotion ev   = {
-		PUGL_MOTION,
-		0,
-		[event timestamp],
-		wloc.x,
-		wloc.y,
-		rloc.x,
-		[[NSScreen mainScreen] frame].size.height - rloc.y,
-		getModifiers(event),
-	};
+  const NSPoint         wloc = [self eventLocation:event];
+  const NSPoint         rloc = [NSEvent mouseLocation];
+  const PuglEventMotion ev   = {
+    PUGL_MOTION,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+  };
 
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (void)mouseDragged:(NSEvent*)event
 {
-	[self mouseMoved: event];
+  [self mouseMoved:event];
 }
 
 - (void)rightMouseDragged:(NSEvent*)event
 {
-	[self mouseMoved: event];
+  [self mouseMoved:event];
 }
 
 - (void)otherMouseDragged:(NSEvent*)event
 {
-	[self mouseMoved: event];
+  [self mouseMoved:event];
 }
 
 - (void)mouseDown:(NSEvent*)event
 {
-	const NSPoint         wloc = [self eventLocation:event];
-	const NSPoint         rloc = [NSEvent mouseLocation];
-	const PuglEventButton ev   = {
-		PUGL_BUTTON_PRESS,
-		0,
-		[event timestamp],
-		wloc.x,
-		wloc.y,
-		rloc.x,
-		[[NSScreen mainScreen] frame].size.height - rloc.y,
-		getModifiers(event),
-		(uint32_t)[event buttonNumber] + 1,
-	};
+  const NSPoint         wloc = [self eventLocation:event];
+  const NSPoint         rloc = [NSEvent mouseLocation];
+  const PuglEventButton ev   = {
+    PUGL_BUTTON_PRESS,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+    (uint32_t)[event buttonNumber] + 1,
+  };
 
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (void)mouseUp:(NSEvent*)event
 {
-	const NSPoint         wloc = [self eventLocation:event];
-	const NSPoint         rloc = [NSEvent mouseLocation];
-	const PuglEventButton ev   = {
-		PUGL_BUTTON_RELEASE,
-		0,
-		[event timestamp],
-		wloc.x,
-		wloc.y,
-		rloc.x,
-		[[NSScreen mainScreen] frame].size.height - rloc.y,
-		getModifiers(event),
-		(uint32_t)[event buttonNumber] + 1,
-	};
+  const NSPoint         wloc = [self eventLocation:event];
+  const NSPoint         rloc = [NSEvent mouseLocation];
+  const PuglEventButton ev   = {
+    PUGL_BUTTON_RELEASE,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+    (uint32_t)[event buttonNumber] + 1,
+  };
 
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (void)rightMouseDown:(NSEvent*)event
 {
-	[self mouseDown: event];
+  [self mouseDown:event];
 }
 
 - (void)rightMouseUp:(NSEvent*)event
 {
-	[self mouseUp: event];
+  [self mouseUp:event];
 }
 
 - (void)otherMouseDown:(NSEvent*)event
 {
-	[self mouseDown: event];
+  [self mouseDown:event];
 }
 
 - (void)otherMouseUp:(NSEvent*)event
 {
-	[self mouseUp: event];
+  [self mouseUp:event];
 }
 
 - (void)scrollWheel:(NSEvent*)event
 {
-	const NSPoint             wloc = [self eventLocation:event];
-	const NSPoint             rloc = [NSEvent mouseLocation];
-	const double              dx   = [event scrollingDeltaX];
-	const double              dy   = [event scrollingDeltaY];
-	const PuglScrollDirection dir =
-	    ((dx == 0.0 && dy > 0.0)
-	         ? PUGL_SCROLL_UP
-	         : ((dx == 0.0 && dy < 0.0)
-	                ? PUGL_SCROLL_DOWN
-	                : ((dy == 0.0 && dx > 0.0)
-	                       ? PUGL_SCROLL_RIGHT
-	                       : ((dy == 0.0 && dx < 0.0) ? PUGL_SCROLL_LEFT
-	                                                  : PUGL_SCROLL_SMOOTH))));
-
-	const PuglEventScroll ev = {
-	    PUGL_SCROLL,
-	    0,
-	    [event timestamp],
-	    wloc.x,
-	    wloc.y,
-	    rloc.x,
-	    [[NSScreen mainScreen] frame].size.height - rloc.y,
-	    getModifiers(event),
-	    [event hasPreciseScrollingDeltas] ? PUGL_SCROLL_SMOOTH : dir,
-	    dx,
-	    dy,
-	};
-
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  const NSPoint             wloc = [self eventLocation:event];
+  const NSPoint             rloc = [NSEvent mouseLocation];
+  const double              dx   = [event scrollingDeltaX];
+  const double              dy   = [event scrollingDeltaY];
+  const PuglScrollDirection dir =
+    ((dx == 0.0 && dy > 0.0)
+       ? PUGL_SCROLL_UP
+       : ((dx == 0.0 && dy < 0.0)
+            ? PUGL_SCROLL_DOWN
+            : ((dy == 0.0 && dx > 0.0)
+                 ? PUGL_SCROLL_RIGHT
+                 : ((dy == 0.0 && dx < 0.0) ? PUGL_SCROLL_LEFT
+                                            : PUGL_SCROLL_SMOOTH))));
+
+  const PuglEventScroll ev = {
+    PUGL_SCROLL,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+    [event hasPreciseScrollingDeltas] ? PUGL_SCROLL_SMOOTH : dir,
+    dx,
+    dy,
+  };
+
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (void)keyDown:(NSEvent*)event
 {
-	if (puglview->hints[PUGL_IGNORE_KEY_REPEAT] && [event isARepeat]) {
-		return;
-	}
-
-	const NSPoint   wloc  = [self eventLocation:event];
-	const NSPoint   rloc  = [NSEvent mouseLocation];
-	const PuglKey   spec  = keySymToSpecial(event);
-	const NSString* chars = [event charactersIgnoringModifiers];
-	const char*     str   = [[chars lowercaseString] UTF8String];
-	const uint32_t  code  = (spec ? spec : puglDecodeUTF8((const uint8_t*)str));
-
-	const PuglEventKey ev = {
-		PUGL_KEY_PRESS,
-		0,
-		[event timestamp],
-		wloc.x,
-		wloc.y,
-		rloc.x,
-		[[NSScreen mainScreen] frame].size.height - rloc.y,
-		getModifiers(event),
-		[event keyCode],
-		(code != 0xFFFD) ? code : 0,
-	};
-
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
-
-	if (!spec) {
-		[self interpretKeyEvents:@[event]];
-	}
+  if (puglview->hints[PUGL_IGNORE_KEY_REPEAT] && [event isARepeat]) {
+    return;
+  }
+
+  const NSPoint   wloc  = [self eventLocation:event];
+  const NSPoint   rloc  = [NSEvent mouseLocation];
+  const PuglKey   spec  = keySymToSpecial(event);
+  const NSString* chars = [event charactersIgnoringModifiers];
+  const char*     str   = [[chars lowercaseString] UTF8String];
+  const uint32_t  code  = (spec ? spec : puglDecodeUTF8((const uint8_t*)str));
+
+  const PuglEventKey ev = {
+    PUGL_KEY_PRESS,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+    [event keyCode],
+    (code != 0xFFFD) ? code : 0,
+  };
+
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+
+  if (!spec) {
+    [self interpretKeyEvents:@[event]];
+  }
 }
 
 - (void)keyUp:(NSEvent*)event
 {
-	const NSPoint   wloc  = [self eventLocation:event];
-	const NSPoint   rloc  = [NSEvent mouseLocation];
-	const PuglKey   spec  = keySymToSpecial(event);
-	const NSString* chars = [event charactersIgnoringModifiers];
-	const char*     str   = [[chars lowercaseString] UTF8String];
-	const uint32_t  code  = (spec ? spec : puglDecodeUTF8((const uint8_t*)str));
-
-	const PuglEventKey ev = {
-		PUGL_KEY_RELEASE,
-		0,
-		[event timestamp],
-		wloc.x,
-		wloc.y,
-		rloc.x,
-		[[NSScreen mainScreen] frame].size.height - rloc.y,
-		getModifiers(event),
-		[event keyCode],
-		(code != 0xFFFD) ? code : 0,
-	};
-
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  const NSPoint   wloc  = [self eventLocation:event];
+  const NSPoint   rloc  = [NSEvent mouseLocation];
+  const PuglKey   spec  = keySymToSpecial(event);
+  const NSString* chars = [event charactersIgnoringModifiers];
+  const char*     str   = [[chars lowercaseString] UTF8String];
+  const uint32_t  code  = (spec ? spec : puglDecodeUTF8((const uint8_t*)str));
+
+  const PuglEventKey ev = {
+    PUGL_KEY_RELEASE,
+    0,
+    [event timestamp],
+    wloc.x,
+    wloc.y,
+    rloc.x,
+    [[NSScreen mainScreen] frame].size.height - rloc.y,
+    getModifiers(event),
+    [event keyCode],
+    (code != 0xFFFD) ? code : 0,
+  };
+
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (BOOL)hasMarkedText
 {
-	return [markedText length] > 0;
+  return [markedText length] > 0;
 }
 
 - (NSRange)markedRange
 {
-	return (([markedText length] > 0)
-	        ? NSMakeRange(0, [markedText length] - 1)
-	        : NSMakeRange(NSNotFound, 0));
+  return (([markedText length] > 0) ? NSMakeRange(0, [markedText length] - 1)
+                                    : NSMakeRange(NSNotFound, 0));
 }
 
 - (NSRange)selectedRange
 {
-	return NSMakeRange(NSNotFound, 0);
+  return NSMakeRange(NSNotFound, 0);
 }
 
 - (void)setMarkedText:(id)string
         selectedRange:(NSRange)selected
      replacementRange:(NSRange)replacement
 {
-	(void)selected;
-	(void)replacement;
-	[markedText release];
-	markedText = (
-		[(NSObject*)string isKindOfClass:[NSAttributedString class]]
-		? [[NSMutableAttributedString alloc] initWithAttributedString:string]
-		: [[NSMutableAttributedString alloc] initWithString:string]);
+  (void)selected;
+  (void)replacement;
+  [markedText release];
+  markedText =
+    ([(NSObject*)string isKindOfClass:[NSAttributedString class]]
+       ? [[NSMutableAttributedString alloc] initWithAttributedString:string]
+       : [[NSMutableAttributedString alloc] initWithString:string]);
 }
 
 - (void)unmarkText
 {
-	[[markedText mutableString] setString:@""];
+  [[markedText mutableString] setString:@""];
 }
 
 - (NSArray*)validAttributesForMarkedText
 {
-	return @[];
+  return @[];
 }
 
 - (NSAttributedString*)attributedSubstringForProposedRange:(NSRange)range
                                                actualRange:
-                                                   (NSRangePointer)actual
+                                                 (NSRangePointer)actual
 {
-	(void)range;
-	(void)actual;
-	return nil;
+  (void)range;
+  (void)actual;
+  return nil;
 }
 
 - (NSUInteger)characterIndexForPoint:(NSPoint)point
 {
-	(void)point;
-	return 0;
+  (void)point;
+  return 0;
 }
 
 - (NSRect)firstRectForCharacterRange:(NSRange)range
                          actualRange:(NSRangePointer)actual
 {
-	(void)range;
-	(void)actual;
+  (void)range;
+  (void)actual;
 
-	const NSRect frame = [self bounds];
-	return NSMakeRect(frame.origin.x, frame.origin.y, 0.0, 0.0);
+  const NSRect frame = [self bounds];
+  return NSMakeRect(frame.origin.x, frame.origin.y, 0.0, 0.0);
 }
 
 - (void)doCommandBySelector:(SEL)selector
 {
-	(void)selector;
+  (void)selector;
 }
 
 - (void)insertText:(id)string replacementRange:(NSRange)replacement
 {
-	(void)replacement;
-
-	NSEvent* const  event      = [NSApp currentEvent];
-	NSString* const characters =
-		([(NSObject*)string isKindOfClass:[NSAttributedString class]]
-		 ? [(NSAttributedString*)string string]
-		 : (NSString*)string);
-
-	const NSPoint wloc = [self eventLocation:event];
-	const NSPoint rloc = [NSEvent mouseLocation];
-	for (size_t i = 0; i < [characters length]; ++i) {
-		const uint32_t code    = [characters characterAtIndex:i];
-		char           utf8[8] = {0};
-		NSUInteger     len     = 0;
-
-		[characters getBytes:utf8
-		           maxLength:sizeof(utf8)
-		          usedLength:&len
-		            encoding:NSUTF8StringEncoding
-		             options:0
-		               range:NSMakeRange(i, i + 1)
-		      remainingRange:nil];
-
-		PuglEventText ev = {
-			PUGL_TEXT,
-			0,
-			[event timestamp],
-			wloc.x,
-			wloc.y,
-			rloc.x,
-			[[NSScreen mainScreen] frame].size.height - rloc.y,
-			getModifiers(event),
-			[event keyCode],
-			code,
-			{ 0, 0, 0, 0, 0, 0, 0, 0 },
-		};
-
-		memcpy(ev.string, utf8, len);
-		puglDispatchEvent(puglview, (const PuglEvent*)&ev);
-	}
+  (void)replacement;
+
+  NSEvent* const  event = [NSApp currentEvent];
+  NSString* const characters =
+    ([(NSObject*)string isKindOfClass:[NSAttributedString class]]
+       ? [(NSAttributedString*)string string]
+       : (NSString*)string);
+
+  const NSPoint wloc = [self eventLocation:event];
+  const NSPoint rloc = [NSEvent mouseLocation];
+  for (size_t i = 0; i < [characters length]; ++i) {
+    const uint32_t code    = [characters characterAtIndex:i];
+    char           utf8[8] = {0};
+    NSUInteger     len     = 0;
+
+    [characters getBytes:utf8
+               maxLength:sizeof(utf8)
+              usedLength:&len
+                encoding:NSUTF8StringEncoding
+                 options:0
+                   range:NSMakeRange(i, i + 1)
+          remainingRange:nil];
+
+    PuglEventText ev = {
+      PUGL_TEXT,
+      0,
+      [event timestamp],
+      wloc.x,
+      wloc.y,
+      rloc.x,
+      [[NSScreen mainScreen] frame].size.height - rloc.y,
+      getModifiers(event),
+      [event keyCode],
+      code,
+      { 0, 0, 0, 0, 0, 0, 0, 0 },
+    };
+
+    memcpy(ev.string, utf8, len);
+    puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  }
 }
 
 - (void)flagsChanged:(NSEvent*)event
 {
-	const uint32_t mods    = getModifiers(event);
-	PuglEventType  type    = PUGL_NOTHING;
-	PuglKey        special = (PuglKey)0;
-
-	if ((mods & PUGL_MOD_SHIFT) != (puglview->impl->mods & PUGL_MOD_SHIFT)) {
-		type = mods & PUGL_MOD_SHIFT ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
-		special = PUGL_KEY_SHIFT;
-	} else if ((mods & PUGL_MOD_CTRL) != (puglview->impl->mods & PUGL_MOD_CTRL)) {
-		type = mods & PUGL_MOD_CTRL ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
-		special = PUGL_KEY_CTRL;
-	} else if ((mods & PUGL_MOD_ALT) != (puglview->impl->mods & PUGL_MOD_ALT)) {
-		type = mods & PUGL_MOD_ALT ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
-		special = PUGL_KEY_ALT;
-	} else if ((mods & PUGL_MOD_SUPER) != (puglview->impl->mods & PUGL_MOD_SUPER)) {
-		type = mods & PUGL_MOD_SUPER ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
-		special = PUGL_KEY_SUPER;
-	}
-
-	if (special != 0) {
-		const NSPoint wloc = [self eventLocation:event];
-		const NSPoint rloc = [NSEvent mouseLocation];
-		PuglEventKey  ev   = {
-			type,
-			0,
-			[event timestamp],
-			wloc.x,
-			wloc.y,
-			rloc.x,
-			[[NSScreen mainScreen] frame].size.height - rloc.y,
-			mods,
-			[event keyCode],
-			special
-		};
-		puglDispatchEvent(puglview, (const PuglEvent*)&ev);
-	}
-
-	puglview->impl->mods = mods;
+  const uint32_t mods    = getModifiers(event);
+  PuglEventType  type    = PUGL_NOTHING;
+  PuglKey        special = (PuglKey)0;
+
+  if ((mods & PUGL_MOD_SHIFT) != (puglview->impl->mods & PUGL_MOD_SHIFT)) {
+    type    = mods & PUGL_MOD_SHIFT ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
+    special = PUGL_KEY_SHIFT;
+  } else if ((mods & PUGL_MOD_CTRL) != (puglview->impl->mods & PUGL_MOD_CTRL)) {
+    type    = mods & PUGL_MOD_CTRL ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
+    special = PUGL_KEY_CTRL;
+  } else if ((mods & PUGL_MOD_ALT) != (puglview->impl->mods & PUGL_MOD_ALT)) {
+    type    = mods & PUGL_MOD_ALT ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
+    special = PUGL_KEY_ALT;
+  } else if ((mods & PUGL_MOD_SUPER) !=
+             (puglview->impl->mods & PUGL_MOD_SUPER)) {
+    type    = mods & PUGL_MOD_SUPER ? PUGL_KEY_PRESS : PUGL_KEY_RELEASE;
+    special = PUGL_KEY_SUPER;
+  }
+
+  if (special != 0) {
+    const NSPoint wloc = [self eventLocation:event];
+    const NSPoint rloc = [NSEvent mouseLocation];
+    PuglEventKey  ev   = {type,
+                       0,
+                       [event timestamp],
+                       wloc.x,
+                       wloc.y,
+                       rloc.x,
+                       [[NSScreen mainScreen] frame].size.height - rloc.y,
+                       mods,
+                       [event keyCode],
+                       special};
+    puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  }
+
+  puglview->impl->mods = mods;
 }
 
 - (BOOL)preservesContentInLiveResize
 {
-	return NO;
+  return NO;
 }
 
 - (void)viewWillStartLiveResize
 {
-	puglDispatchSimpleEvent(puglview, PUGL_LOOP_ENTER);
+  puglDispatchSimpleEvent(puglview, PUGL_LOOP_ENTER);
 }
 
 - (void)viewWillDraw
 {
-	puglDispatchSimpleEvent(puglview, PUGL_UPDATE);
-	[super viewWillDraw];
+  puglDispatchSimpleEvent(puglview, PUGL_UPDATE);
+  [super viewWillDraw];
 }
 
 - (void)resizeTick
 {
-	puglPostRedisplay(puglview);
+  puglPostRedisplay(puglview);
 }
 
 - (void)timerTick:(NSTimer*)userTimer
 {
-	const NSNumber*      userInfo = userTimer.userInfo;
-	const PuglEventTimer ev       = {PUGL_TIMER, 0, userInfo.unsignedLongValue};
+  const NSNumber*      userInfo = userTimer.userInfo;
+  const PuglEventTimer ev       = {PUGL_TIMER, 0, userInfo.unsignedLongValue};
 
-	puglDispatchEvent(puglview, (const PuglEvent*)&ev);
+  puglDispatchEvent(puglview, (const PuglEvent*)&ev);
 }
 
 - (void)viewDidEndLiveResize
 {
-	puglDispatchSimpleEvent(puglview, PUGL_LOOP_LEAVE);
+  puglDispatchSimpleEvent(puglview, PUGL_LOOP_LEAVE);
 }
 
 @end
@@ -747,51 +768,50 @@ handleCrossing(PuglWrapperView* view, NSEvent* event, const PuglEventType type)
 
 @end
 
-@implementation PuglWindowDelegate
-{
-	PuglWindow* window;
+@implementation PuglWindowDelegate {
+  PuglWindow* window;
 }
 
 - (instancetype)initWithPuglWindow:(PuglWindow*)puglWindow
 {
-	if ((self = [super init])) {
-		window = puglWindow;
-	}
+  if ((self = [super init])) {
+    window = puglWindow;
+  }
 
-	return self;
+  return self;
 }
 
 - (BOOL)windowShouldClose:(id)sender
 {
-	(void)sender;
+  (void)sender;
 
-	puglDispatchSimpleEvent(window->puglview, PUGL_CLOSE);
-	return YES;
+  puglDispatchSimpleEvent(window->puglview, PUGL_CLOSE);
+  return YES;
 }
 
 - (void)windowDidMove:(NSNotification*)notification
 {
-	(void)notification;
+  (void)notification;
 
-	updateViewRect(window->puglview);
+  updateViewRect(window->puglview);
 }
 
 - (void)windowDidBecomeKey:(NSNotification*)notification
 {
-	(void)notification;
+  (void)notification;
 
-	PuglEvent ev = {{PUGL_FOCUS_IN, 0}};
-	ev.focus.mode = PUGL_CROSSING_NORMAL;
-	puglDispatchEvent(window->puglview, &ev);
+  PuglEvent ev  = {{PUGL_FOCUS_IN, 0}};
+  ev.focus.mode = PUGL_CROSSING_NORMAL;
+  puglDispatchEvent(window->puglview, &ev);
 }
 
 - (void)windowDidResignKey:(NSNotification*)notification
 {
-	(void)notification;
+  (void)notification;
 
-	PuglEvent ev = {{PUGL_FOCUS_OUT, 0}};
-	ev.focus.mode = PUGL_CROSSING_NORMAL;
-	puglDispatchEvent(window->puglview, &ev);
+  PuglEvent ev  = {{PUGL_FOCUS_OUT, 0}};
+  ev.focus.mode = PUGL_CROSSING_NORMAL;
+  puglDispatchEvent(window->puglview, &ev);
 }
 
 @end
@@ -799,532 +819,526 @@ handleCrossing(PuglWrapperView* view, NSEvent* event, const PuglEventType type)
 PuglWorldInternals*
 puglInitWorldInternals(PuglWorldType type, PuglWorldFlags PUGL_UNUSED(flags))
 {
-	PuglWorldInternals* impl = (PuglWorldInternals*)calloc(
-		1, sizeof(PuglWorldInternals));
+  PuglWorldInternals* impl =
+    (PuglWorldInternals*)calloc(1, sizeof(PuglWorldInternals));
 
-	impl->app = [NSApplication sharedApplication];
+  impl->app = [NSApplication sharedApplication];
 
-	if (type == PUGL_PROGRAM) {
-		impl->autoreleasePool = [NSAutoreleasePool new];
-	}
+  if (type == PUGL_PROGRAM) {
+    impl->autoreleasePool = [NSAutoreleasePool new];
+  }
 
-	return impl;
+  return impl;
 }
 
 void
 puglFreeWorldInternals(PuglWorld* world)
 {
-	if (world->impl->autoreleasePool) {
-		[world->impl->autoreleasePool drain];
-	}
+  if (world->impl->autoreleasePool) {
+    [world->impl->autoreleasePool drain];
+  }
 
-	free(world->impl);
+  free(world->impl);
 }
 
 void*
 puglGetNativeWorld(PuglWorld* PUGL_UNUSED(world))
 {
-	return NULL;
+  return NULL;
 }
 
 PuglInternals*
 puglInitViewInternals(void)
 {
-	PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals));
+  PuglInternals* impl = (PuglInternals*)calloc(1, sizeof(PuglInternals));
 
-	impl->cursor = [NSCursor arrowCursor];
+  impl->cursor = [NSCursor arrowCursor];
 
-	return impl;
+  return impl;
 }
 
 static NSLayoutConstraint*
 puglConstraint(id item, NSLayoutAttribute attribute, float constant)
 {
-	return [NSLayoutConstraint
-		       constraintWithItem: item
-		                attribute: attribute
-		                relatedBy: NSLayoutRelationGreaterThanOrEqual
-		                   toItem: nil
-		                attribute: NSLayoutAttributeNotAnAttribute
-		               multiplier: 1.0
-		                 constant: (CGFloat)constant];
+  return
+    [NSLayoutConstraint constraintWithItem:item
+                                 attribute:attribute
+                                 relatedBy:NSLayoutRelationGreaterThanOrEqual
+                                    toItem:nil
+                                 attribute:NSLayoutAttributeNotAnAttribute
+                                multiplier:1.0
+                                  constant:(CGFloat)constant];
 }
 
 PuglStatus
 puglRealize(PuglView* view)
 {
-	PuglInternals* impl = view->impl;
-	if (impl->wrapperView) {
-		return PUGL_FAILURE;
-	}
-
-	const NSScreen* const screen      = [NSScreen mainScreen];
-	const double          scaleFactor = [screen backingScaleFactor];
+  PuglInternals* impl = view->impl;
+  if (impl->wrapperView) {
+    return PUGL_FAILURE;
+  }
+
+  const NSScreen* const screen      = [NSScreen mainScreen];
+  const double          scaleFactor = [screen backingScaleFactor];
+
+  // Getting depth from the display mode seems tedious, just set usual values
+  if (view->hints[PUGL_RED_BITS] == PUGL_DONT_CARE) {
+    view->hints[PUGL_RED_BITS] = 8;
+  }
+  if (view->hints[PUGL_BLUE_BITS] == PUGL_DONT_CARE) {
+    view->hints[PUGL_BLUE_BITS] = 8;
+  }
+  if (view->hints[PUGL_GREEN_BITS] == PUGL_DONT_CARE) {
+    view->hints[PUGL_GREEN_BITS] = 8;
+  }
+  if (view->hints[PUGL_ALPHA_BITS] == PUGL_DONT_CARE) {
+    view->hints[PUGL_ALPHA_BITS] = 8;
+  }
+
+  CGDirectDisplayID displayId = CGMainDisplayID();
+  CGDisplayModeRef  mode      = CGDisplayCopyDisplayMode(displayId);
+
+  // Try to get refresh rate from mode (usually fails)
+  view->hints[PUGL_REFRESH_RATE] = (int)CGDisplayModeGetRefreshRate(mode);
+
+  CGDisplayModeRelease(mode);
+  if (view->hints[PUGL_REFRESH_RATE] == 0) {
+    // Get refresh rate from a display link
+    // TODO: Keep and actually use the display link for something?
+    CVDisplayLinkRef link;
+    CVDisplayLinkCreateWithCGDisplay(displayId, &link);
+
+    const CVTime p = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(link);
+    const double r = p.timeScale / (double)p.timeValue;
+    view->hints[PUGL_REFRESH_RATE] = (int)lrint(r);
+
+    CVDisplayLinkRelease(link);
+  }
+
+  if (view->frame.width == 0.0 && view->frame.height == 0.0) {
+    if (view->defaultWidth == 0.0 && view->defaultHeight == 0.0) {
+      return PUGL_BAD_CONFIGURATION;
+    }
 
-	// Getting depth from the display mode seems tedious, just set usual values
-	if (view->hints[PUGL_RED_BITS] == PUGL_DONT_CARE) {
-		view->hints[PUGL_RED_BITS] = 8;
-	}
-	if (view->hints[PUGL_BLUE_BITS] == PUGL_DONT_CARE) {
-		view->hints[PUGL_BLUE_BITS] = 8;
-	}
-	if (view->hints[PUGL_GREEN_BITS] == PUGL_DONT_CARE) {
-		view->hints[PUGL_GREEN_BITS] = 8;
-	}
-	if (view->hints[PUGL_ALPHA_BITS] == PUGL_DONT_CARE) {
-		view->hints[PUGL_ALPHA_BITS] = 8;
-	}
+    const double screenWidthPx  = [screen frame].size.width * scaleFactor;
+    const double screenHeightPx = [screen frame].size.height * scaleFactor;
+
+    view->frame.width  = view->defaultWidth;
+    view->frame.height = view->defaultHeight;
+    view->frame.x      = screenWidthPx / 2.0 - view->frame.width / 2.0;
+    view->frame.y      = screenHeightPx / 2.0 - view->frame.height / 2.0;
+  }
+
+  const NSRect framePx = rectToNsRect(view->frame);
+  const NSRect framePt = NSMakeRect(framePx.origin.x / scaleFactor,
+                                    framePx.origin.y / scaleFactor,
+                                    framePx.size.width / scaleFactor,
+                                    framePx.size.height / scaleFactor);
+
+  // Create wrapper view to handle input
+  impl->wrapperView             = [PuglWrapperView alloc];
+  impl->wrapperView->puglview   = view;
+  impl->wrapperView->userTimers = [[NSMutableDictionary alloc] init];
+  impl->wrapperView->markedText = [[NSMutableAttributedString alloc] init];
+  [impl->wrapperView setAutoresizesSubviews:YES];
+  [impl->wrapperView initWithFrame:framePt];
+  [impl->wrapperView addConstraint:puglConstraint(impl->wrapperView,
+                                                  NSLayoutAttributeWidth,
+                                                  view->minWidth)];
+  [impl->wrapperView addConstraint:puglConstraint(impl->wrapperView,
+                                                  NSLayoutAttributeHeight,
+                                                  view->minHeight)];
+
+  // Create draw view to be rendered to
+  PuglStatus st = PUGL_SUCCESS;
+  if ((st = view->backend->configure(view)) ||
+      (st = view->backend->create(view))) {
+    return st;
+  }
+
+  // Add draw view to wrapper view
+  [impl->wrapperView addSubview:impl->drawView];
+  [impl->wrapperView setHidden:NO];
+  [impl->drawView setHidden:NO];
+
+  if (view->parent) {
+    NSView* pview = (NSView*)view->parent;
+    [pview addSubview:impl->wrapperView];
+    [impl->drawView setHidden:NO];
+    [[impl->drawView window] makeFirstResponder:impl->wrapperView];
+  } else {
+    unsigned style =
+      (NSClosableWindowMask | NSTitledWindowMask | NSMiniaturizableWindowMask);
+    if (view->hints[PUGL_RESIZABLE]) {
+      style |= NSResizableWindowMask;
+    }
 
-	CGDirectDisplayID displayId = CGMainDisplayID();
-	CGDisplayModeRef  mode      = CGDisplayCopyDisplayMode(displayId);
+    PuglWindow* window = [[[PuglWindow alloc]
+      initWithContentRect:rectToScreen([NSScreen mainScreen], framePt)
+                styleMask:style
+                  backing:NSBackingStoreBuffered
+                    defer:NO] retain];
+    [window setPuglview:view];
 
-	// Try to get refresh rate from mode (usually fails)
-	view->hints[PUGL_REFRESH_RATE] = (int)CGDisplayModeGetRefreshRate(mode);
+    if (view->title) {
+      NSString* titleString =
+        [[NSString alloc] initWithBytes:view->title
+                                 length:strlen(view->title)
+                               encoding:NSUTF8StringEncoding];
 
-	CGDisplayModeRelease(mode);
-	if (view->hints[PUGL_REFRESH_RATE] == 0) {
-		// Get refresh rate from a display link
-		// TODO: Keep and actually use the display link for something?
-		CVDisplayLinkRef link;
-		CVDisplayLinkCreateWithCGDisplay(displayId, &link);
+      [window setTitle:titleString];
+    }
 
-		const CVTime p = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(link);
-		const double r = p.timeScale / (double)p.timeValue;
-		view->hints[PUGL_REFRESH_RATE] = (int)lrint(r);
+    if (view->minWidth || view->minHeight) {
+      [window
+        setContentMinSize:sizePoints(view, view->minWidth, view->minHeight)];
+    }
+    impl->window = window;
 
-		CVDisplayLinkRelease(link);
-	}
+    ((NSWindow*)window).delegate =
+      [[PuglWindowDelegate alloc] initWithPuglWindow:window];
 
-	if (view->frame.width == 0.0 && view->frame.height == 0.0) {
-		if (view->defaultWidth == 0.0 && view->defaultHeight == 0.0) {
-			return PUGL_BAD_CONFIGURATION;
-		}
+    if (view->minAspectX && view->minAspectY) {
+      [window setContentAspectRatio:sizePoints(view,
+                                               view->minAspectX,
+                                               view->minAspectY)];
+    }
 
-		const double screenWidthPx  = [screen frame].size.width * scaleFactor;
-		const double screenHeightPx = [screen frame].size.height * scaleFactor;
+    puglSetFrame(view, view->frame);
 
-		view->frame.width  = view->defaultWidth;
-		view->frame.height = view->defaultHeight;
-		view->frame.x      = screenWidthPx / 2.0 - view->frame.width / 2.0;
-		view->frame.y      = screenHeightPx / 2.0 - view->frame.height / 2.0;
-	}
+    [window setContentView:impl->wrapperView];
+    [view->world->impl->app activateIgnoringOtherApps:YES];
+    [window makeFirstResponder:impl->wrapperView];
+    [window makeKeyAndOrderFront:window];
+    [impl->window setIsVisible:NO];
+  }
 
-	const NSRect framePx = rectToNsRect(view->frame);
-	const NSRect framePt = NSMakeRect(framePx.origin.x / scaleFactor,
-	                                  framePx.origin.y / scaleFactor,
-	                                  framePx.size.width / scaleFactor,
-	                                  framePx.size.height / scaleFactor);
-
-	// Create wrapper view to handle input
-	impl->wrapperView             = [PuglWrapperView alloc];
-	impl->wrapperView->puglview   = view;
-	impl->wrapperView->userTimers = [[NSMutableDictionary alloc] init];
-	impl->wrapperView->markedText = [[NSMutableAttributedString alloc] init];
-	[impl->wrapperView setAutoresizesSubviews:YES];
-	[impl->wrapperView initWithFrame:framePt];
-	[impl->wrapperView addConstraint:
-		     puglConstraint(impl->wrapperView, NSLayoutAttributeWidth, view->minWidth)];
-	[impl->wrapperView addConstraint:
-		     puglConstraint(impl->wrapperView, NSLayoutAttributeHeight, view->minHeight)];
-
-	// Create draw view to be rendered to
-	PuglStatus st = PUGL_SUCCESS;
-	if ((st = view->backend->configure(view)) ||
-	    (st = view->backend->create(view))) {
-		return st;
-	}
+  [impl->wrapperView updateTrackingAreas];
 
-	// Add draw view to wrapper view
-	[impl->wrapperView addSubview:impl->drawView];
-	[impl->wrapperView setHidden:NO];
-	[impl->drawView setHidden:NO];
-
-	if (view->parent) {
-		NSView* pview = (NSView*)view->parent;
-		[pview addSubview:impl->wrapperView];
-		[impl->drawView setHidden:NO];
-		[[impl->drawView window] makeFirstResponder:impl->wrapperView];
-	} else {
-		unsigned style = (NSClosableWindowMask |
-		                  NSTitledWindowMask |
-		                  NSMiniaturizableWindowMask );
-		if (view->hints[PUGL_RESIZABLE]) {
-			style |= NSResizableWindowMask;
-		}
-
-		PuglWindow* window = [[[PuglWindow alloc]
-			initWithContentRect:rectToScreen([NSScreen mainScreen], framePt)
-			          styleMask:style
-			            backing:NSBackingStoreBuffered
-			              defer:NO
-		              ] retain];
-		[window setPuglview:view];
-
-		if (view->title) {
-			NSString* titleString = [[NSString alloc]
-				                        initWithBytes:view->title
-				                               length:strlen(view->title)
-				                             encoding:NSUTF8StringEncoding];
-
-			[window setTitle:titleString];
-		}
-
-		if (view->minWidth || view->minHeight) {
-			[window setContentMinSize:sizePoints(view,
-			                                     view->minWidth,
-			                                     view->minHeight)];
-		}
-		impl->window = window;
-
-		((NSWindow*)window).delegate = [[PuglWindowDelegate alloc]
-			                  initWithPuglWindow:window];
-
-		if (view->minAspectX && view->minAspectY) {
-			[window setContentAspectRatio:sizePoints(view,
-			                                         view->minAspectX,
-			                                         view->minAspectY)];
-		}
-
-		puglSetFrame(view, view->frame);
-
-		[window setContentView:impl->wrapperView];
-		[view->world->impl->app activateIgnoringOtherApps:YES];
-		[window makeFirstResponder:impl->wrapperView];
-		[window makeKeyAndOrderFront:window];
-		[impl->window setIsVisible:NO];
-	}
+  puglDispatchSimpleEvent(view, PUGL_CREATE);
 
-	[impl->wrapperView updateTrackingAreas];
-
-	puglDispatchSimpleEvent(view, PUGL_CREATE);
-
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 PuglStatus
 puglShow(PuglView* view)
 {
-	if (!view->impl->wrapperView) {
-		const PuglStatus st = puglRealize(view);
-		if (st) {
-			return st;
-		}
-	}
+  if (!view->impl->wrapperView) {
+    const PuglStatus st = puglRealize(view);
+    if (st) {
+      return st;
+    }
+  }
 
-	if (![view->impl->window isVisible]) {
-		[view->impl->window setIsVisible:YES];
-		[view->impl->drawView setNeedsDisplay: YES];
-		updateViewRect(view);
-	}
+  if (![view->impl->window isVisible]) {
+    [view->impl->window setIsVisible:YES];
+    [view->impl->drawView setNeedsDisplay:YES];
+    updateViewRect(view);
+  }
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 PuglStatus
 puglHide(PuglView* view)
 {
-	[view->impl->window setIsVisible:NO];
-	return PUGL_SUCCESS;
+  [view->impl->window setIsVisible:NO];
+  return PUGL_SUCCESS;
 }
 
 void
 puglFreeViewInternals(PuglView* view)
 {
-	if (view) {
-		if (view->backend) {
-			view->backend->destroy(view);
-		}
-
-		if (view->impl) {
-			[view->impl->wrapperView removeFromSuperview];
-			view->impl->wrapperView->puglview = NULL;
-			if (view->impl->window) {
-				[view->impl->window close];
-			}
-			[view->impl->wrapperView release];
-			if (view->impl->window) {
-				[view->impl->window release];
-			}
-			free(view->impl);
-		}
-	}
+  if (view) {
+    if (view->backend) {
+      view->backend->destroy(view);
+    }
+
+    if (view->impl) {
+      [view->impl->wrapperView removeFromSuperview];
+      view->impl->wrapperView->puglview = NULL;
+      if (view->impl->window) {
+        [view->impl->window close];
+      }
+      [view->impl->wrapperView release];
+      if (view->impl->window) {
+        [view->impl->window release];
+      }
+      free(view->impl);
+    }
+  }
 }
 
 PuglStatus
 puglGrabFocus(PuglView* view)
 {
-	NSWindow* window = [view->impl->wrapperView window];
+  NSWindow* window = [view->impl->wrapperView window];
 
-	[window makeKeyWindow];
-	[window makeFirstResponder:view->impl->wrapperView];
-	return PUGL_SUCCESS;
+  [window makeKeyWindow];
+  [window makeFirstResponder:view->impl->wrapperView];
+  return PUGL_SUCCESS;
 }
 
 bool
 puglHasFocus(const PuglView* view)
 {
-	PuglInternals* const impl = view->impl;
+  PuglInternals* const impl = view->impl;
 
-	return ([[impl->wrapperView window] isKeyWindow] &&
-	        [[impl->wrapperView window] firstResponder] == impl->wrapperView);
+  return ([[impl->wrapperView window] isKeyWindow] &&
+          [[impl->wrapperView window] firstResponder] == impl->wrapperView);
 }
 
 PuglStatus
 puglRequestAttention(PuglView* view)
 {
-	if (![view->impl->window isKeyWindow]) {
-		[view->world->impl->app requestUserAttention:NSInformationalRequest];
-	}
+  if (![view->impl->window isKeyWindow]) {
+    [view->world->impl->app requestUserAttention:NSInformationalRequest];
+  }
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 PuglStatus
 puglStartTimer(PuglView* view, uintptr_t id, double timeout)
 {
-	puglStopTimer(view, id);
+  puglStopTimer(view, id);
 
-	NSNumber* idNumber = [NSNumber numberWithUnsignedLong:id];
+  NSNumber* idNumber = [NSNumber numberWithUnsignedLong:id];
 
-	NSTimer* timer = [NSTimer timerWithTimeInterval:timeout
-	                                         target:view->impl->wrapperView
-	                                       selector:@selector(timerTick:)
-	                                       userInfo:idNumber
-	                                        repeats:YES];
+  NSTimer* timer = [NSTimer timerWithTimeInterval:timeout
+                                           target:view->impl->wrapperView
+                                         selector:@selector(timerTick:)
+                                         userInfo:idNumber
+                                          repeats:YES];
 
-	[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
+  [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
 
-	view->impl->wrapperView->userTimers[idNumber] = timer;
+  view->impl->wrapperView->userTimers[idNumber] = timer;
 
-	return PUGL_SUCCESS;
+  return PUGL_SUCCESS;
 }
 
 PuglStatus
 puglStopTimer(PuglView* view, uintptr_t id)
 {
-	NSNumber* idNumber = [NSNumber numberWithUnsignedLong:id];
-	NSTimer*  timer    = view->impl->wrapperView->userTimers[idNumber];
+  NSNumber* idNumber = [NSNumber numberWithUnsignedLong:id];
+  NSTimer*  timer    = view->impl->wrapperView->userTimers[idNumber];
 
-	if (timer) {
-		[view->impl->wrapperView->userTimers removeObjectForKey:timer];
-		[timer invalidate];
-		return PUGL_SUCCESS;
-	}
+  if (timer) {
+    [view->impl->wrapperView->userTimers removeObjectForKey:timer];
+    [timer invalidate];
+    return PUGL_SUCCESS;
+  }
 
-	return PUGL_UNKNOWN_ERROR;
+  return PUGL_UNKNOWN_ERROR;
 }
 
 PuglStatus
 puglSendEvent(PuglView* view, const PuglEvent* event)
 {
-    if (event->type == PUGL_CLIENT) {
-		PuglWrapperView* wrapper = view->impl->wrapperView;
-		const NSWindow*  window  = [wrapper window];
-		const NSRect     rect    = [wrapper frame];
-		const NSPoint    center  = {NSMidX(rect), NSMidY(rect)};
-
-		NSEvent* nsevent = [NSEvent
-		    otherEventWithType:NSApplicationDefined
-		              location:center
-		         modifierFlags:0
-		             timestamp:[[NSProcessInfo processInfo] systemUptime]
-		          windowNumber:window.windowNumber
-		               context:nil
-		               subtype:PUGL_CLIENT
-		                 data1:(NSInteger)event->client.data1
-		                 data2:(NSInteger)event->client.data2];
-
-		[view->world->impl->app postEvent:nsevent atStart:false];
-        return PUGL_SUCCESS;
-    }
+  if (event->type == PUGL_CLIENT) {
+    PuglWrapperView* wrapper = view->impl->wrapperView;
+    const NSWindow*  window  = [wrapper window];
+    const NSRect     rect    = [wrapper frame];
+    const NSPoint    center  = {NSMidX(rect), NSMidY(rect)};
+
+    NSEvent* nsevent =
+      [NSEvent otherEventWithType:NSApplicationDefined
+                         location:center
+                    modifierFlags:0
+                        timestamp:[[NSProcessInfo processInfo] systemUptime]
+                     windowNumber:window.windowNumber
+                          context:nil
+                          subtype:PUGL