diff --git a/TODO.MD b/TODO.MD
index 94bd4d0..a637c0c 100644
--- a/TODO.MD
+++ b/TODO.MD
@@ -1,14 +1,4 @@
 - Centered justification in UI
+- Make web build
+- Zoom sensitivity
 - Web read/write
-- Ship with default setup
-- Set grid
-- Math evaluation field
-
-DONE:
-- Fix -vet errors
-- When there is no matrix it should still draw the rectangle
-- Always show coordinates
-- Web build
-- Escape closes dialogue if on dialogue. Otherwise stops program if on desktop, but not without an unsaved changes warning.
-- Set animation value
-- Snap to grid option
diff --git a/build_linux.sh b/build_desktop.sh
similarity index 56%
rename from build_linux.sh
rename to build_desktop.sh
index c744945..6bd7d99 100755
--- a/build_linux.sh
+++ b/build_desktop.sh
@@ -1,14 +1,16 @@
 #!/bin/bash -eu
 
 EXE_NAME="Transformation Visualizer"
-OUT_DIR="build/linux"
+OUT_DIR="build/desktop"
 ASSETS_DIR="src/assets/"
 
 if [[ -v 1 ]]; then
     if [ "$1" = "DEBUG" ]; then
         ODIN_FLAGS="-debug"
     elif [ "$1" = "RELEASE" ]; then
-        ODIN_FLAGS="-o:speed -extra-linker-flags:\"-Wl,--gc-sections\""
+        ODIN_FLAGS="-no-bounds-check -disable-assert -o:size -extra-linker-flags:\"-Wl,--gc-sections,-s\""
+    elif [ "$1" = "TEST" ]; then
+        ODIN_FLAGS="-o:minimal -no-bounds-check -disable-assert -extra-linker-flags:\"-Wl,--gc-sections,-s\""
     else
         echo "Usage: <script> <DEBUG/RELEASE>"
         exit 1
@@ -19,10 +21,6 @@ else
 fi
 
 mkdir -p $OUT_DIR
-odin build src/desktop -out:"$OUT_DIR/$EXE_NAME" $ODIN_FLAGS
+odin build src/ -out:"$OUT_DIR/$EXE_NAME" $ODIN_FLAGS
 cp -R $ASSETS_DIR ./$OUT_DIR/
 echo "Desktop build created in ${OUT_DIR}"
-
-if [ "$1" = "RELEASE" ]; then
-    upx "$OUT_DIR/$EXE_NAME"
-fi
diff --git a/build_web.sh b/build_web.sh
index 7874e75..76ab1cd 100755
--- a/build_web.sh
+++ b/build_web.sh
@@ -1,19 +1,12 @@
 #!/bin/bash -eu
 
-PROJECT_NAME="transformation_visualizer"
-ASSETS_DIR="src/assets"
-RAYLIB_PATH="src/libraries/raylib"
-EMSCRIPTEN_SDK_DIR="$HOME/programs/emsdk"
-OUT_DIR="build/web"
-WEB_SOURCE_PATH="src/web"
-
 if [[ -v 1 ]]; then
     if [ "$1" = "DEBUG" ]; then
         ODIN_FLAGS="-debug"
-        EMCC_FLAGS="-O0 -g"
     elif [ "$1" = "RELEASE" ]; then
-        ODIN_FLAGS="-o:size"
-        EMCC_FLAGS="-O2"
+        ODIN_FLAGS="-no-bounds-check -disable-assert -o:size -extra-linker-flags:\"-Wl,--gc-sections,-s\""
+    elif [ "$1" = "TEST" ]; then
+        ODIN_FLAGS="-o:minimal -extra-linker-flags:\"-Wl,--gc-sections,-s\""
     else
         echo "Usage: <script> <DEBUG/RELEASE>"
         exit 1
@@ -23,8 +16,11 @@ else
     exit 1
 fi
 
-WASM_OBJ_NAME="transformation_visualizer.wasm.obj"
-rm -rf $OUT_DIR
+RAYLIB_PATH="src/libraries/raylib"
+EMSCRIPTEN_SDK_DIR="$HOME/programs/emsdk"
+OUT_DIR="build/web"
+WASM_OBJ_NAME="transformation_visulalizer.wasm.obj"
+
 mkdir -p $OUT_DIR
 
 export EMSDK_QUIET=1
@@ -36,17 +32,21 @@ export EMSDK_QUIET=1
 # The emcc call will be fed the actual raylib library file. That stuff will end
 # up in env.o
 ODIN_DEFINES="-define:RAYLIB_WASM_LIB=env.o -define:RAYGUI_WASM_LIB=env.o"
-odin build src/web/ -target:js_wasm32 -target-features:simd128 -build-mode:obj $ODIN_DEFINES $ODIN_FLAGS -out:$OUT_DIR/$WASM_OBJ_NAME
+odin build src/ -target:js_wasm32 -build-mode:obj $ODIN_DEFINES $ODIN_FLAGS -out:$OUT_DIR/$WASM_OBJ_NAME
 
-cp ${WEB_SOURCE_PATH}/odin.js $OUT_DIR
+ODIN_PATH=$(odin root)
 
+cp $ODIN_PATH/core/sys/wasm/js/odin.js $OUT_DIR
 
-# TODO (synthas): Investigate why emcc's size optimization flag causes a linker error on itch.io
-EMCC_SETTINGS="-sEXPORTED_RUNTIME_METHODS=['HEAPF32'] -sUSE_GLFW=3 -sWARN_ON_UNDEFINED_SYMBOLS=0"
-EMCC_FILES="$OUT_DIR/$WASM_OBJ_NAME $RAYLIB_PATH/wasm/libraylib.a $RAYLIB_PATH/wasm/libraygui.a"
-emcc -o $OUT_DIR/index.html $EMCC_FLAGS $EMCC_FILES $EMCC_SETTINGS --shell-file $WEB_SOURCE_PATH/index_template.html --preload-file src/assets
+files="$OUT_DIR/$WASM_OBJ_NAME $RAYLIB_PATH/wasm/libraylib.a $RAYLIB_PATH/wasm/libraygui.a"
+
+# index_template.html contains the javascript code that calls the procedures in
+# source/main_web/main_web.odin
+flags="-Oz -sASSERTIONS=0 --closure 0 -sEXPORTED_RUNTIME_METHODS=['HEAPF32'] -sUSE_GLFW=3 -sWASM_BIGINT -sWARN_ON_UNDEFINED_SYMBOLS=0 -sDECLARE_ASM_MODULE_EXPORTS=0 --shell-file index_template.html --preload-file src/assets"
+
+# For debugging: Add `-g` to `emcc` (gives better error callstack in chrome)
+emcc -o $OUT_DIR/index.html $files $flags
 
 rm -f $OUT_DIR/$WASM_OBJ_NAME
-zip -r $OUT_DIR/${PROJECT_NAME}.zip $OUT_DIR
 
 echo "Web build created in ${OUT_DIR}"
diff --git a/cloc.sh b/cloc.sh
deleted file mode 100755
index d8a2ee8..0000000
--- a/cloc.sh
+++ /dev/null
@@ -1 +0,0 @@
-find src -maxdepth 1 -type f -print0 | xargs -0 cloc
diff --git a/default b/default
index a628ad7..ac30279 100755
Binary files a/default and b/default differ
diff --git a/src/web/index_template.html b/index_template.html
similarity index 75%
rename from src/web/index_template.html
rename to index_template.html
index f6ab227..ddd686c 100644
--- a/src/web/index_template.html
+++ b/index_template.html
@@ -4,26 +4,16 @@
 	<meta charset="utf-8">
 	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 
-	<title>Transformation Visualizer</title>
-	<meta name="title" content="Transformation Visualizer">
-	<meta name="description" content="Math visualization tool">
+	<title>Odin + Raylib on the web</title>
+	<meta name="title" content="Odin + Raylib on the web">
+	<meta name="description" content="Make games using Odin + Raylib that work in the browser">
 	<meta name="viewport" content="width=device-width">
 
 	<style>
-        * {
-            vertical-align: baseline;
-            border: 0 none;
-            outline: 0;
-            padding: 0;
-            margin: 0;
-            box-sizing: border-box;
-       	}
 		body {
 			margin: 0px;
 			overflow: hidden;
 			background-color: black;
-			width: 100%;
-			height: 100%;
 		}
 		canvas.game_canvas {
 			border: 0px none;
@@ -33,13 +23,6 @@
 			margin-left: auto;
 			margin-right: auto;
 			display: block;
-			width: 100%;
-			height: 100%;
-
-			overflow: hidden;
-			position: fixed;
-			top: 0;
-			left: 0;
 		}
 	</style>
 </head>
@@ -71,25 +54,34 @@
 			// done setting up. At that point we can run code.
 			onRuntimeInitialized: () => {
 				var e = wasmExports;
+
+				// Calls any procedure marked with @init
 				e._start();
+
+				// See source/main_web/main_web.odin for main_start,
+				// main_update and main_end.
 				e.main_start();
 
-function send_resize() {
-	var canvas = document.getElementById('canvas');
-	canvas.width = document.documentElement.clientWidth;
-    canvas.height = document.documentElement.clientHeight;
-	e.web_window_size_changed(canvas.width, canvas.height);
-}
+				function send_resize() {
+					var canvas = document.getElementById('canvas');
+					e.web_window_size_changed(canvas.width, canvas.height);
+				}
 
-window.addEventListener('resize', function(event) {
-	send_resize();
-}, true);
+				window.addEventListener('resize', function(event) {
+					send_resize();
+				}, true);
 
+				// This can probably be done better: Ideally we'd feed the
+				// initial size to `main_start`. But there seems to be a
+				// race condition. `canvas` doesn't have it's correct size yet.
 				send_resize();
 
+				// Runs the "main loop".
 				function do_main_update() {
 					if (!e.main_update()) {
 						e.main_end();
+
+						// Calls procedures marked with @fini
 						e._end();
 						return;
 					}
diff --git a/src/animation.odin b/src/animation.odin
index b034a8e..998ab02 100644
--- a/src/animation.odin
+++ b/src/animation.odin
@@ -1,4 +1,4 @@
-package game
+package main
 
 import rl "libraries/raylib"
 import "core:math"
@@ -6,6 +6,7 @@ import "core:math/ease"
 import "core:math/linalg"
 import "core:slice"
 import "core:sort"
+import "core:fmt"
 
 ANIMATION_COLOR_ORIGIN :: rl.RED
 ANIMATION_COLOR_END :: rl.BLUE
@@ -53,25 +54,53 @@ rectangle_corners_move_corner :: proc "contextless" (corners: RectangleCorners,
 	corners := corners
 	switch corner {
 	case .Tl:
-		corners.tl = position
-		corners.bl.x = position.x
-		corners.tr.y = position.y
+		corners = _rectangle_corners_move_corner_resolve_tl(corners, position)
 	case .Tr:
-		corners.tr = position
-		corners.br.x = position.x
-		corners.tl.y = position.y
+		corners = _rectangle_corners_move_corner_resolve_tr(corners, position)
 	case .Br:
-		corners.br = position
-		corners.tr.x = position.x
-		corners.bl.y = position.y
+		corners = _rectangle_corners_move_corner_resolve_br(corners, position)
 	case .Bl:
-		corners.bl = position
-		corners.tl.x = position.x
-		corners.br.y = position.y
+		corners = _rectangle_corners_move_corner_resolve_bl(corners, position)
 	}
 	return corners
 }
 
+_rectangle_corners_move_corner_resolve_tl :: proc "contextless" (corners: RectangleCorners, position: v2) -> RectangleCorners {
+	corners := corners
+	corners.tl = position
+	corners.bl.x = position.x
+	corners.tr.y = position.y
+	return corners
+}
+
+_rectangle_corners_move_corner_resolve_tr :: proc "contextless" (corners: RectangleCorners, position: v2) -> RectangleCorners {
+	corners := corners
+	corners.tr = position
+	corners.br.x = position.x
+	corners.tl.y = position.y
+	return corners
+}
+
+_rectangle_corners_move_corner_resolve_br :: proc "contextless" (corners: RectangleCorners, position: v2) -> RectangleCorners {
+	corners := corners
+	corners.br = position
+	corners.tr.x = position.x
+	corners.bl.y = position.y
+	return corners
+}
+
+_rectangle_corners_move_corner_resolve_bl :: proc "contextless" (corners: RectangleCorners, position: v2) -> RectangleCorners {
+	corners := corners
+	corners.bl = position
+	corners.tl.x = position.x
+	corners.br.y = position.y
+	return corners
+}
+
+rectangle_corners_transform_mat2 :: proc "contextless" (corners: RectangleCorners, transform: mat2) -> RectangleCorners {
+	return {corners.tl * transform, corners.tr * transform, corners.br * transform, corners.bl * transform}
+}
+
 draw_animation_rectangle_corners :: proc(corners: RectangleCorners, color: rl.Color) {
 	triangles := rectangle_corners_get_triangles(corners)
 	draw_triangle(triangles[0], {**color.rgb, color.a >> 1})
@@ -132,7 +161,6 @@ Animation :: struct {
 	matrix_count: int,
 	matrix_type: AnimationMatrixType,
 	shapes: AnimationShapes,
-	shapes_animated_last: AnimationShapes,
 	ease: ease.Ease,
 	type: AnimationType,
 }
@@ -143,11 +171,6 @@ AnimationMatrixType :: enum {
 	Mat4,
 }
 
-AnimationMode :: enum {
-	Step,
-	All,
-}
-
 @private @rodata animation_matrix_type_size := [AnimationMatrixType]int {
 	.Mat2 = size_of(mat2),
 	.Mat3 = size_of(mat3),
@@ -167,7 +190,6 @@ animation_init :: proc(animation: ^Animation, matrices: []f32) {
 			rectangle = rectangle_corners_from_rect(rect2{-16, -16, 32, 32})
 		},
 	}
-	animation.shapes_animated_last = animation.shapes
 }
 
 animation_is_finished :: proc(animation: Animation) -> bool {
@@ -178,58 +200,38 @@ animation_get_eased_progress :: proc(animation: Animation) -> f32 {
 	return math.floor(animation.matrix_index) + ease.ease(animation.ease, fract(animation.matrix_index))
 }
 
-animation_draw :: proc(animation: ^Animation, global_transform: mat3, mode: AnimationMode, temp_allocator := context.temp_allocator) {
+animation_draw :: proc(animation: Animation, global_transform: mat3, temp_allocator := context.temp_allocator) {
 	color_origin := cast([4]f32)ANIMATION_COLOR_ORIGIN
 	color_end := cast([4]f32)ANIMATION_COLOR_END
 
 	switch animation.type {
 	case .Rectangle:
 		rectangles := make([]RectangleCorners, animation.matrix_count + 1, temp_allocator)
-		rectangles[0] = animation.shapes.rectangle
+		rectangles[0] = rectangle_corners_transform_mat3(global_transform, animation.shapes.rectangle)
 		transform := linalg.identity(mat3)
 		matrices := slice.reinterpret([]mat3, animation.matrices[:animation.matrix_count * 9])
 		for mat, i in matrices {
-			transform = mat * transform
-			rectangles[i + 1] = rectangle_corners_transform_mat3(transform, animation.shapes.rectangle)
+			transform *= mat
+			rectangle_transformed := rectangle_corners_transform_mat3(transform, animation.shapes.rectangle)
+			rectangles[i + 1] = rectangle_corners_transform_mat3(global_transform, rectangle_transformed)
 		}
-		if animation.matrix_count == 0 {
-			rectangle_world := rectangle_corners_transform_mat3(global_transform, rectangles[0])
-			draw_animation_rectangle_corners(rectangle_world, ANIMATION_COLOR_ORIGIN)
-		} else {
-			for rectangle, i in rectangles {
-				color := linalg.lerp(color_origin, color_end, f32(i) / f32(animation.matrix_count))
-				rectangle_world := rectangle_corners_transform_mat3(global_transform, rectangle)
-				draw_animation_rectangle_corners(rectangle_world, rl.Color(color))
-			}
+		for rectangle, i in rectangles {
+			color := linalg.lerp(color_origin, color_end, f32(i) / f32(animation.matrix_count))
+			draw_animation_rectangle_corners(rectangle, rl.Color(color))
 		}
 		if animation.matrix_count <= 0 {
-			animation.shapes_animated_last.rectangle = rectangles[0]
 			break
 		}
-		switch mode {
-		case .Step:
-			animation_progress := math.clamp(animation.matrix_index, 0.0, f32(animation.matrix_count))
-			animation_progress_frame := ease.ease(animation.ease, fract(animation.matrix_index))
-			animation_progress_total := math.floor(animation_progress) + animation_progress_frame
-			// TODO (synthas): math.min is a temp fix because I lost track of the math and got lazy with it
-			animation_progress_fraction := math.min(animation_progress_total / f32(animation.matrix_count), 1.0)
-			rectangle_previous := rectangles[int(animation_progress)]
-			rectangle_next := rectangles[min(int(animation_progress + 1), animation.matrix_count)]
-			rectangle := rectangle_corners_lerp(rectangle_previous, rectangle_next, animation_progress_frame)
-			rectangle_world := rectangle_corners_transform_mat3(global_transform, rectangle)
-			rectangle_color := linalg.lerp(color_origin, color_end, animation_progress_fraction)
-			draw_animation_rectangle_corners(rectangle_world, rl.Color(rectangle_color))
-			animation.shapes_animated_last.rectangle = rectangle
-		case .All:
-			animation_progress := math.clamp(animation.matrix_index / f32(animation.matrix_count), 0.0, 1.0)
-			animation_progress = ease.ease(animation.ease, animation_progress)
-			color := linalg.lerp(color_origin, color_end, animation_progress)
-			rectangle_end := rectangle_corners_transform_mat3(transform, animation.shapes.rectangle)
-			rectangle := rectangle_corners_lerp(animation.shapes.rectangle, rectangle_end, animation_progress)
-			rectangle_world := rectangle_corners_transform_mat3(global_transform, rectangle)
-			draw_animation_rectangle_corners(rectangle_world, rl.Color(color))
-			animation.shapes_animated_last.rectangle = rectangle
-		}
+		animation_progress := math.clamp(animation.matrix_index, 0.0, f32(animation.matrix_count))
+		animation_progress_frame := ease.ease(animation.ease, fract(animation.matrix_index))
+		animation_progress_total := math.floor(animation_progress) + animation_progress_frame
+		// TODO (synthas): math.min is a temp fix because I lost track of the math and got lazy with it
+		animation_progress_fraction := math.min(animation_progress_total / f32(animation.matrix_count), 1.0)
+		rectangle_previous := rectangles[int(animation_progress)]
+		rectangle_next := rectangles[min(int(animation_progress + 1), animation.matrix_count)]
+		rectangle_current := rectangle_corners_lerp(rectangle_previous, rectangle_next, animation_progress_frame)
+		rectangle_current_color := linalg.lerp(color_origin, color_end, animation_progress_fraction)
+		draw_animation_rectangle_corners(rectangle_current, rl.Color(rectangle_current_color))
 	}
 }
 
diff --git a/src/desktop/main.odin b/src/desktop/main.odin
deleted file mode 100644
index 07c8382..0000000
--- a/src/desktop/main.odin
+++ /dev/null
@@ -1,17 +0,0 @@
-package main
-
-import game ".."
-import "core:os"
-import "core:path/filepath"
-
-main :: proc() {
-	exe_path := os.args[0]
-	exe_dir := filepath.dir(string(exe_path))
-	os.set_working_directory(exe_dir)
-
-	game.init()
-	for game.should_run() {
-		game.update()
-	}
-	game.shutdown()
-}
diff --git a/src/grid.odin b/src/grid.odin
index 680edee..98909a9 100644
--- a/src/grid.odin
+++ b/src/grid.odin
@@ -1,4 +1,4 @@
-package game
+package main
 
 import "core:math/linalg"
 import rl "libraries/raylib"
diff --git a/src/libraries/back/LICENSE b/src/libraries/back/LICENSE
new file mode 100644
index 0000000..d97adb1
--- /dev/null
+++ b/src/libraries/back/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2023 Laytan Laats
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/libraries/back/README.md b/src/libraries/back/README.md
new file mode 100644
index 0000000..50f25bf
--- /dev/null
+++ b/src/libraries/back/README.md
@@ -0,0 +1,188 @@
+# Back
+
+Backtraces for Odin, see examples below and in the examples folder.
+
+To change the size (amount of stackframes to print) in places where this can't be set directly, you can use the `-define:BACKTRACE_SIZE=16`.
+
+## Targets
+
+### Windows, MacoOS & Linux
+
+These targets use debug information that's added by compiling with `-debug` to provide traces and give rough information when compiled without it.
+
+Performance is not impacted at all during normal running, just when you ask for a trace or lines.
+
+Per platform notes below:
+
+#### Windows
+
+For Windows support, all credit goes to [DaseinPhaos/pdb](https://github.com/DaseinPhaos/pdb).
+
+Windows is not able to get *any* information when not compiled with `-debug`.
+
+NOTE: The pdb package allocates a lot of stuff and does not really provide a way of deleting the allocations, so, before calling into the package, this package sets it to use the `context.temporary_allocator`.
+
+#### MacOS
+
+Uses a private framework for symbolication, and thus will not get through Apple's review process.
+
+#### Linux
+
+On Linux, the `addr2line` command is invoked, which comes pre-installed (maybe in binutils).
+
+The `addr2line` command can be changed by setting the `-define:BACK_ADDR2LINE_PATH=your/atos` flag.
+
+The path to the running binary is also needed for this command, this is `os.args[0]` by default and to my knowledge is always correct.
+Nevertheless it can be changed with the `-define:BACK_PROGRAM=path/to/binary` flag.
+
+I am planning on rewriting this implementation to not require an external command like this by parsing the DWARF debug information manually.
+
+### Others
+
+Other targets use the instrumentation features of Odin to keep track of stack frames, this has a minimal impact on performance and size.
+
+Forcing the instrumentation based implementation on Windows, Linux and Darwin can be done with `-define:BACK_FORCE_FALLBACK=true`.
+
+NOTE: this implementation requires at least `-o:minimal` as it requires `#force_inline` procs to actually be inlined, this is not the case with `-o:none`.
+
+NOTE: the instrumentation features and WASM combination is a bit fragile and seems to only work on `-o:minimal` exclusively, this is almost certainly a codegen bug.
+
+## Manual
+
+```odin
+package manual
+
+import "core:fmt"
+
+import back "../.."
+
+main :: proc() {
+	// Allocates for 16 frames.
+	bt := back.trace_n(16)
+	print(bt)
+
+	// Or, doesn't allocate, returns `-define:BACKTRACE_SIZE` frames.
+	btc := back.trace()
+	print(btc.trace[:btc.len])
+
+	// Or, fill in a slice.
+	bt = make(back.Trace, 16)
+	bt = bt[:back.trace_fill(bt)]
+	print(bt)
+}
+
+print :: proc(bt: back.Trace) {
+	lines, err := back.lines(bt)
+	if err != nil {
+		fmt.eprintf("Could not retrieve backtrace lines: %v\n", err)
+	} else {
+		defer back.lines_destroy(lines)
+
+		fmt.eprintln("[back trace]")
+		back.print(lines)
+	}
+}
+
+// [back trace]
+//     back.trace_n - /Users/laytan/projects/back/back.odin:59
+//     manual.main  - /Users/laytan/projects/back/examples/manual/main.odin:9
+//     main         - /Users/laytan/third-party/Odin/core/runtime/entry_unix.odin:53
+// [back trace]
+//     back.trace  - /Users/laytan/projects/back/back.odin:52
+//     manual.main - /Users/laytan/projects/back/examples/manual/main.odin:13
+//     main        - /Users/laytan/third-party/Odin/core/runtime/entry_unix.odin:53
+// [back trace]
+//     back.trace_fill - /Users/laytan/projects/back/back.odin:64
+//     manual.main     - /Users/laytan/projects/back/examples/manual/main.odin:18
+//     main            - /Users/laytan/third-party/Odin/core/runtime/entry_unix.odin:53
+```
+
+## Tracking Allocator
+
+```odin
+package main
+
+import "back"
+
+_main :: proc() {
+	_ = new(int)
+	free(rawptr(uintptr(100)))
+}
+
+main :: proc() {
+	track: back.Tracking_Allocator
+	back.tracking_allocator_init(&track, context.allocator)
+	defer back.tracking_allocator_destroy(&track)
+
+	context.allocator = back.tracking_allocator(&track)
+	defer back.tracking_allocator_print_results(&track)
+
+	_main()
+}
+
+// /Users/laytan/projects/back/examples/allocator/main.odin(6:6) leaked 8b
+// [back trace]
+//     back.trace                   - /Users/laytan/projects/back/back.odin:52
+//     back.tracking_allocator_proc - /Users/laytan/projects/back/allocator.odin:129
+//     runtime.mem_alloc_bytes      - /Users/laytan/third-party/Odin/core/runtime/internal.odin:141
+//     runtime.new_aligned-13136    - /Users/laytan/third-party/Odin/core/runtime/core_builtin.odin:250
+//     runtime.new-13097            - /Users/laytan/third-party/Odin/core/runtime/core_builtin.odin:246
+//     main._main                   - /Users/laytan/projects/back/examples/allocator/main.odin:6
+//     main.main                    - /Users/laytan/projects/back/examples/allocator/main.odin:18
+//     main                         - /Users/laytan/third-party/Odin/core/runtime/entry_unix.odin:53
+//
+//
+// /Users/laytan/projects/back/examples/allocator/main.odin(7:2) allocation 64 was freed badly
+// [back trace]
+//     back.trace                   - /Users/laytan/projects/back/back.odin:52
+//     back.tracking_allocator_proc - /Users/laytan/projects/back/allocator.odin:102
+//     runtime.mem_free             - /Users/laytan/third-party/Odin/core/runtime/internal.odin:162
+//     main._main                   - /Users/laytan/projects/back/examples/allocator/main.odin:8
+//     main.main                    - /Users/laytan/projects/back/examples/allocator/main.odin:18
+//     main                         - /Users/laytan/third-party/Odin/core/runtime/entry_unix.odin:53
+```
+
+## Printing a backtrace on assertion failures / panics
+
+```odin
+package main
+
+import "back"
+
+main :: proc() {
+    context.assertion_failure_proc = back.assertion_failure_proc
+    assert(3 == 2)
+}
+
+// [back trace]
+//     back.trace                  - /Users/laytan/projects/back/back.odin:52
+//     back.assertion_failure_proc - /Users/laytan/projects/back/back.odin:97
+//     runtime.assert.internal-0   - /Users/laytan/third-party/Odin/core/runtime/core_builtin.odin:818
+//     runtime.assert              - /Users/laytan/third-party/Odin/core/runtime/core_builtin.odin:820
+//     main.main                   - /Users/laytan/projects/back/examples/assert_backtrace/main.odin:8
+//     main                        - /Users/laytan/third-party/Odin/core/runtime/entry_unix.odin:53
+// /Users/laytan/projects/back/examples/assert_backtrace/main.odin(7:5) runtime assertion
+```
+
+## Printing a backtrace on segmentation faults
+
+```odin
+package main
+
+import "back"
+
+main :: proc() {
+	back.register_segfault_handler()
+
+	ptr: ^int
+	bad := ptr^ + 2
+	_ = bad
+}
+
+// Segmentation Fault
+// [back trace]
+//     back.trace                            - /Users/laytan/projects/back/back.odin:52
+//     back.register_segfault_handler$anon-1 - /Users/laytan/projects/back/back.odin:114
+//     ??                                    - ??
+//     main.main                             - /Users/laytan/projects/back/examples/segfault/main.odin:8
+```
diff --git a/src/libraries/back/allocator.odin b/src/libraries/back/allocator.odin
new file mode 100644
index 0000000..986e424
--- /dev/null
+++ b/src/libraries/back/allocator.odin
@@ -0,0 +1,230 @@
+#+vet explicit-allocators
+package back
+
+import "base:runtime"
+
+import "core:fmt"
+import "core:mem"
+import "core:sync"
+
+// The backtrace tracking allocator is a similar allocator as the `core:mem` tracking allocator but keeps
+// backtraces for each allocation.
+//
+// See examples/allocator for a usage snippet.
+//
+// Print results at the end using tracking_allocator_print_results().
+Tracking_Allocator :: struct {
+	backing:              mem.Allocator,
+	internals_allocator:  mem.Allocator,
+	allocation_map:       map[rawptr]Tracking_Allocator_Entry,
+	bad_free_array:       [dynamic]Tracking_Allocator_Bad_Free_Entry,
+	mutex:                sync.Mutex,
+	clear_on_free_all:    bool,
+}
+
+Tracking_Allocator_Entry :: struct {
+	memory:    rawptr,
+	size:      int,
+	alignment: int,
+	mode:      mem.Allocator_Mode,
+	err:       mem.Allocator_Error,
+	location:  runtime.Source_Code_Location,
+	backtrace: Trace_Const,
+}
+
+Tracking_Allocator_Bad_Free_Entry :: struct {
+	memory:    rawptr,
+	location:  runtime.Source_Code_Location,
+	backtrace: Trace_Const,
+}
+
+tracking_allocator_init :: proc(
+	t: ^Tracking_Allocator,
+	backing_allocator: mem.Allocator,
+	internals_allocator := context.allocator,
+) {
+	t.backing = backing_allocator
+	t.internals_allocator = internals_allocator
+	t.allocation_map.allocator = internals_allocator
+	t.bad_free_array.allocator = internals_allocator
+
+	if .Free_All in mem.query_features(t.backing) {
+		t.clear_on_free_all = true
+	}
+}
+
+tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) {
+	delete(t.allocation_map)
+	delete(t.bad_free_array)
+}
+
+tracking_allocator_clear :: proc(t: ^Tracking_Allocator) {
+	sync.guard(&t.mutex)
+
+	clear(&t.allocation_map)
+	clear(&t.bad_free_array)
+}
+
+@(require_results)
+tracking_allocator :: proc(data: ^Tracking_Allocator) -> mem.Allocator {
+	return mem.Allocator{data = data, procedure = tracking_allocator_proc}
+}
+
+tracking_allocator_proc :: proc(
+	allocator_data: rawptr,
+	mode: mem.Allocator_Mode,
+	size, alignment: int,
+	old_memory: rawptr,
+	old_size: int,
+	loc := #caller_location,
+) -> (
+	result: []byte,
+	err: mem.Allocator_Error,
+) {
+	data := (^Tracking_Allocator)(allocator_data)
+
+	sync.mutex_guard(&data.mutex)
+
+	if mode == .Query_Info {
+		info := (^mem.Allocator_Query_Info)(old_memory)
+		if info != nil && info.pointer != nil {
+			if entry, ok := data.allocation_map[info.pointer]; ok {
+				info.size = entry.size
+				info.alignment = entry.alignment
+			}
+			info.pointer = nil
+		}
+
+		return
+	}
+
+	if mode == .Free && old_memory != nil && old_memory not_in data.allocation_map {
+		append(
+			&data.bad_free_array,
+			Tracking_Allocator_Bad_Free_Entry{
+				memory = old_memory,
+				location = loc,
+				backtrace = trace(),
+			},
+		)
+	} else {
+		result = data.backing.procedure(
+			data.backing.data,
+			mode,
+			size,
+			alignment,
+			old_memory,
+			old_size,
+			loc,
+		) or_return
+	}
+	result_ptr := raw_data(result)
+
+	if data.allocation_map.allocator.procedure == nil {
+		data.allocation_map.allocator = context.allocator
+	}
+
+	switch mode {
+	case .Alloc, .Alloc_Non_Zeroed:
+		data.allocation_map[result_ptr] = Tracking_Allocator_Entry {
+			memory    = result_ptr,
+			size      = size,
+			mode      = mode,
+			alignment = alignment,
+			err       = err,
+			location  = loc,
+			backtrace = trace(),
+		}
+	case .Free:
+		delete_key(&data.allocation_map, old_memory)
+	case .Free_All:
+		if data.clear_on_free_all {
+			clear_map(&data.allocation_map)
+		}
+	case .Resize, .Resize_Non_Zeroed:
+		if old_memory != result_ptr {
+			delete_key(&data.allocation_map, old_memory)
+		}
+		data.allocation_map[result_ptr] = Tracking_Allocator_Entry {
+			memory    = result_ptr,
+			size      = size,
+			mode      = mode,
+			alignment = alignment,
+			err       = err,
+			location  = loc,
+			backtrace = trace(),
+		}
+
+	case .Query_Features:
+		set := (^mem.Allocator_Mode_Set)(old_memory)
+		if set != nil {
+			set^ = {
+				.Alloc,
+				.Alloc_Non_Zeroed,
+				.Free,
+				.Free_All,
+				.Resize,
+				.Query_Features,
+				.Query_Info,
+			}
+		}
+		return nil, nil
+
+	case .Query_Info:
+		unreachable()
+	}
+
+	return
+}
+
+tracking_allocator_print_results :: proc(t: ^Tracking_Allocator, temp_allocator := context.temp_allocator) {
+	i: int
+	ALLOCATOR_MAX_BACKTRACES :: 16
+
+	for _, leak in t.allocation_map {
+		fmt.eprintfln("\x1b[31m%v leaked %m\x1b[0m", leak.location, leak.size)
+
+		defer i += 1
+		if i > ALLOCATOR_MAX_BACKTRACES {
+			continue
+		}
+
+		trace, err := lines(leak.backtrace, temp_allocator, temp_allocator)
+		defer lines_destroy(trace, temp_allocator)
+
+		fmt.eprintln("[back trace]")
+
+		if err != nil {
+			fmt.eprintfln("backtrace error: %v", err)
+			continue
+		}
+
+		print(trace, temp_allocator=temp_allocator)
+		fmt.eprintln()
+	}
+
+	for bad_free, _ in t.bad_free_array {
+		fmt.eprintfln(
+			"\x1b[31m%v allocation %p was freed badly\x1b[0m",
+			bad_free.location,
+			bad_free.memory,
+		)
+
+		defer i += 1
+		if i > ALLOCATOR_MAX_BACKTRACES {
+			continue
+		}
+
+		trace, err := lines(bad_free.backtrace, temp_allocator, temp_allocator)
+		defer lines_destroy(trace, temp_allocator)
+
+		fmt.eprintln("[back trace]")
+
+		if err != nil {
+			fmt.eprintf("backtrace error: %v\n", err)
+			continue
+		}
+
+		print(trace, temp_allocator=temp_allocator)
+	}
+}
diff --git a/src/libraries/back/back.odin b/src/libraries/back/back.odin
new file mode 100644
index 0000000..80a4136
--- /dev/null
+++ b/src/libraries/back/back.odin
@@ -0,0 +1,147 @@
+#+vet explicit-allocators
+package back
+
+import "base:runtime"
+
+import "core:fmt"
+import "core:io"
+import "core:os"
+import "core:sync"
+import "core:text/table"
+
+// Size of a constant backtrace, as used by the tracking allocator for example.
+BACKTRACE_SIZE :: #config(BACKTRACE_SIZE, 16)
+
+// For targets that do not have native support (using debug info),
+// backtraces are done through instrumentation, Odin only allows one enter/exit instrumentation
+// procedure though, so you can set this to true, add your own instrumentation procs, and have
+// them call `back.other_instrumentation_enter` and `back.other_instrumentation_exit` to hook
+// up the backtraces.
+// The custom proc must have `#force_inline`.
+OTHER_CUSTOM_INSTRUMENTATION :: #config(BACK_OTHER_CUSTOM_INSTRUMENTATION, false)
+
+// Force the fallback instrumentation based implementation instead of debug info based.
+FORCE_FALLBACK :: #config(BACK_FORCE_FALLBACK, false)
+
+// Fallback requires a single module (subtle bugs with multiple modules and instrumentation in Odin),
+// and at least -o:minimal (#force_inline has to actually inline).
+_COULD_USE_FALLBACK_WITHOUT_ERROR :: !ODIN_USE_SEPARATE_MODULES && ODIN_OPTIMIZATION_MODE >= .Minimal
+
+// Use the fallback (instrumentation based) implementation:
+// if it is forced, or it can be used without error and debug info is off, or if the target has no debug info based support.
+USE_FALLBACK :: FORCE_FALLBACK || (_COULD_USE_FALLBACK_WITHOUT_ERROR && !ODIN_DEBUG) || (ODIN_OS != .Darwin && ODIN_OS != .Linux && ODIN_OS != .Windows)
+
+ADDR2LINE_PATH :: #config(TRACE_ADDR2LINE_PATH, "addr2line")
+
+Trace :: []Trace_Entry
+
+Trace_Const :: struct {
+	trace: [BACKTRACE_SIZE]Trace_Entry,
+	len:   int,
+}
+
+// Platform specific.
+Trace_Entry :: _Trace_Entry
+
+Line :: struct {
+	location: string,
+	symbol:   string,
+}
+
+// TODO: improve errors.
+Lines_Error :: enum {
+	None,
+	Parse_Address_Fail,
+	Addr2line_Unexpected_EOF,
+	Addr2line_Output_Error,
+	Addr2line_Unresolved,
+	Addr2line_Process_Error,
+	Out_Of_Memory,
+	Info_Not_Found,
+}
+
+// TODO: arbitrary skip (argument).
+
+trace :: #force_no_inline proc() -> (bt: Trace_Const) {
+	bt.len = _trace(bt.trace[:])
+	return
+}
+
+trace_n :: #force_no_inline proc(max_len: i32, allocator := context.allocator) -> Trace {
+	bt := make([]Trace_Entry, max_len, allocator)
+	n  := _trace(bt[:])
+	return bt[:n]
+}
+
+trace_fill :: #force_no_inline proc(buf: Trace) -> int {
+	return _trace(buf)
+}
+
+trace_n_destroy :: proc(b: Trace, allocator := context.allocator) {
+	delete(b, allocator)
+}
+
+// Processes the message trying to get more/useful information.
+// This adds file and line information if the program is running in debug mode.
+//
+// If an error is returned the original message will be the result and is save to use.
+lines :: proc {
+	lines_n,
+	lines_const,
+}
+
+lines_n :: proc(bt: Trace, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (out: []Line, err: Lines_Error) {
+	return _lines(bt, allocator, temp_allocator)
+}
+
+lines_const :: proc(bt: Trace_Const, allocator := context.allocator, temp_allocator := context.temp_allocator) -> (out: []Line, err: Lines_Error) {
+	bt := bt
+	return _lines(bt.trace[:bt.len], allocator, temp_allocator)
+}
+
+lines_destroy :: proc(lines: []Line, allocator := context.allocator) {
+	_lines_destroy(lines, allocator)
+}
+
+assertion_failure_proc :: proc(prefix, message: string, loc: runtime.Source_Code_Location) -> ! {
+	{
+		runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD()
+
+		lines, err := lines(trace(), context.temp_allocator, context.temp_allocator)
+		if err != nil {
+			fmt.eprintf("could not get backtrace for assertion failure: %v\n", err)
+		} else {
+			fmt.eprintln("[back trace]")
+			print(lines, temp_allocator=context.temp_allocator)
+		}
+	}
+
+	runtime.default_assertion_failure_proc(prefix, message, loc)
+}
+
+register_segfault_handler :: proc() {
+	_register_segfault_handler()
+}
+
+print :: proc(lines: []Line, padding := "    ", w: Maybe(io.Writer) = nil, temp_allocator := context.temp_allocator) {
+	w := w.? or_else os.to_writer(os.stderr)
+
+	tbl := table.init(&table.Table{}, temp_allocator, temp_allocator)
+
+	for line in lines {
+		table.row(tbl, padding, line.symbol, " - ", line.location)
+	}
+
+	table.build(tbl, table.unicode_width_proc)
+
+	for row in 0..<tbl.nr_rows {
+		for col in 0..<tbl.nr_cols {
+			table.write_table_cell(w, tbl, row, col)
+		}
+		io.write_byte(w, '\n')
+	}
+}
+
+// The dbghelp library of win32 is not thread safe, this library uses this mutex to get exclusive access.
+// It is provided in case you want to use the dbghelp library, and want to coordinate access with this package.
+_win32_dbghelp_mutex: sync.Mutex
diff --git a/src/libraries/back/back_darwin.odin b/src/libraries/back/back_darwin.odin
new file mode 100644
index 0000000..78bf2bc
--- /dev/null
+++ b/src/libraries/back/back_darwin.odin
@@ -0,0 +1,160 @@
+#+vet explicit-allocators
+#+private file
+package back
+
+@require import "base:runtime"
+
+@require import "core:strings"
+@require import "core:sys/posix"
+
+when !USE_FALLBACK {
+
+foreign import system "system:System.framework"
+
+// NOTE: CoreSymbolication is a private framework, Apple is allowed to break it and doesn't provide
+// headers, although the API has as of my knowledge been the same in the past 10 years at least.
+@(extra_linker_flags="-iframework /System/Library/PrivateFrameworks")
+foreign import symbolication "system:CoreSymbolication.framework"
+
+@(private="package")
+_Trace_Entry :: rawptr
+
+@(private="package")
+_trace :: #force_no_inline proc(buf: Trace) -> (n: int) {
+	ctx:    unw_context_t
+	cursor: unw_cursor_t
+
+	ret: i32
+	ret = unw_getcontext(&ctx)
+	assert(ret == 0)
+	ret = unw_init_local(&cursor, &ctx)
+	assert(ret == 0)
+
+	// Skip this function's frame and the caller.
+	if unw_step(&cursor) <= 0 { return }
+
+	pc: uintptr
+	for ; unw_step(&cursor) > 0 && n < len(buf); n += 1 {
+		ret = unw_get_reg(&cursor, .IP, &pc)
+		assert(ret == 0)
+		buf[n] = rawptr(pc)
+	}
+
+	return
+}
+
+@(private="package")
+_lines_destroy :: proc(lines: []Line, allocator: runtime.Allocator) {
+	for line in lines {
+		delete(line.location, allocator)
+		delete(line.symbol, allocator)
+	}
+	delete(lines, allocator)
+}
+
+@(private="package")
+_lines :: proc(bt: Trace, allocator, _: runtime.Allocator) -> (out: []Line, err: Lines_Error) {
+	out = make([]Line, len(bt), allocator)
+	defer if err != nil { _lines_destroy(out, allocator) }
+
+	symbolicator := CSSymbolicatorCreateWithPid(posix.getpid())
+	defer CSRelease(symbolicator)
+
+	for &msg, i in out {
+		symbol := CSSymbolicatorGetSymbolWithAddressAtTime(symbolicator, uintptr(bt[i]), CSNow)
+		info   := CSSymbolicatorGetSourceInfoWithAddressAtTime(symbolicator, uintptr(bt[i]), CSNow)
+
+		msg.symbol = strings.clone_from(CSSymbolGetName(symbol), allocator)
+
+		// No debug info.
+		if CSIsNull(info) {
+			owner := CSSymbolGetSymbolOwner(symbol)
+			msg.location = strings.clone_from(CSSymbolOwnerGetPath(owner), allocator)
+		} else {
+			path := string(CSSourceInfoGetPath(info))
+			location := strings.builder_make(allocator)
+			strings.write_string(&location, path)
+			when ODIN_ERROR_POS_STYLE == .Default {
+				strings.write_byte(&location, '(')
+				strings.write_int (&location,  int(CSSourceInfoGetLineNumber(info)))
+				strings.write_byte(&location, ')')
+			} else when ODIN_ERROR_POS_STYLE == .Unix {
+				strings.write_byte(&location, ':')
+				strings.write_int (&location,  int(CSSourceInfoGetLineNumber(info)))
+			} else {
+				#panic("unhandled ODIN_ERROR_POS_STYLE")
+			}
+			msg.location = strings.to_string(location)
+		}
+	}
+	return
+}
+
+CSTypeRef :: struct {
+	csCppData: rawptr,
+	csCppObj:  rawptr,
+}
+
+CSSymbolicatorRef :: distinct CSTypeRef
+CSSymbolRef       :: distinct CSTypeRef
+CSSourceInfoRef   :: distinct CSTypeRef
+CSSymbolOwnerRef  :: distinct CSTypeRef
+
+CSNow :: 0x80000000
+
+foreign symbolication {
+	@(link_name="CSIsNull")
+	_CSIsNull :: proc(ref: CSTypeRef) -> bool ---
+	@(link_name="CSRelease")
+	_CSRelease :: proc(ref: CSTypeRef) ---
+
+	CSSymbolicatorCreateWithPid :: proc(pid: posix.pid_t) -> CSSymbolicatorRef ---
+
+	CSSymbolicatorGetSymbolWithAddressAtTime     :: proc(symbolicator: CSSymbolicatorRef, addr: uintptr, time: u64) -> CSSymbolRef ---
+	CSSymbolicatorGetSourceInfoWithAddressAtTime :: proc(symbolicator: CSSymbolicatorRef, adrr: uintptr, time: u64) -> CSSourceInfoRef ---
+
+	CSSymbolGetName        :: proc(symbol: CSSymbolRef) -> cstring ---
+	CSSymbolGetSymbolOwner :: proc(symbol: CSSymbolRef) -> CSSymbolOwnerRef ---
+
+	CSSourceInfoGetPath       :: proc(info: CSSourceInfoRef) -> cstring ---
+	CSSourceInfoGetLineNumber :: proc(info: CSSourceInfoRef) -> i32 ---
+	CSSourceInfoGetSymbol     :: proc(info: CSSourceInfoRef) -> CSSymbolRef ---
+
+	CSSymbolOwnerGetPath :: proc(owner: CSSymbolOwnerRef) -> cstring ---
+}
+
+CSRelease :: #force_inline proc(ref: $T) {
+	_CSRelease(CSTypeRef(ref))
+}
+
+CSIsNull :: #force_inline proc(ref: $T) -> bool {
+	return _CSIsNull(CSTypeRef(ref))
+}
+
+// These could actually be smaller, but then we would have to define and check the size on each
+// architecture, the sizes here are the largest they can be.
+_LIBUNWIND_CONTEXT_SIZE :: 167
+_LIBUNWIND_CURSOR_SIZE :: 204
+
+unw_context_t :: struct {
+	data: [_LIBUNWIND_CONTEXT_SIZE]u64,
+}
+
+unw_cursor_t :: struct {
+	data: [_LIBUNWIND_CURSOR_SIZE]u64,
+}
+
+// Cross-platform registers, each architecture has additional registers but these are enough for us.
+Register :: enum i32 {
+	SP = -2,
+	IP = -1,
+}
+
+foreign system {
+	unw_getcontext :: proc(ctx: ^unw_context_t) -> i32 ---
+	unw_init_local :: proc(cursor: ^unw_cursor_t, ctx: ^unw_context_t) -> i32 ---
+	unw_get_reg    :: proc(cursor: ^unw_cursor_t, name: Register, reg: ^uintptr) -> i32 ---
+	unw_step       :: proc(cursor: ^unw_cursor_t) -> i32 ---
+}
+
+}
diff --git a/src/libraries/back/back_linux.odin b/src/libraries/back/back_linux.odin
new file mode 100644
index 0000000..081a270
--- /dev/null
+++ b/src/libraries/back/back_linux.odin
@@ -0,0 +1,169 @@
+#+vet explicit-allocators
+#+private file
+package back
+
+@require import "base:runtime"
+@require import "base:intrinsics"
+
+@require import "core:c"
+@require import "core:c/libc"
+@require import "core:os"
+@require import "core:strings"
+
+when !USE_FALLBACK {
+
+foreign import lib "system:c"
+
+@(private="package")
+_Trace_Entry :: rawptr
+
+@(private="package")
+_trace :: #force_no_inline proc(buf: Trace) -> (n: int) {
+	// In order to omit this function's frame and the caller, we alloca a temp buffer with 2 extra slots.
+	bigger_buf := ([^]Trace_Entry)(intrinsics.alloca((2 + len(buf)) * size_of(Trace_Entry), align_of(Trace_Entry)))[:len(buf)+2]
+	_n         := int(backtrace(raw_data(bigger_buf), i32(len(bigger_buf))))
+	if _n > 2 {
+		copy(buf, bigger_buf[2:])
+		return _n-2
+	}
+
+	return 0
+}
+
+@(private="package")
+_lines_destroy :: proc(msgs: []Line, allocator: runtime.Allocator) {
+	for msg in msgs {
+		delete(msg.location, allocator)
+		if msg.symbol != "??OOM" && msg.symbol != "??" { delete(msg.symbol, allocator) }
+	}
+	delete(msgs, allocator)
+}
+
+@(private="package")
+_lines :: proc(bt: Trace, allocator, temp_allocator: runtime.Allocator) -> (out: []Line, err: Lines_Error) {
+	msgs := backtrace_symbols(raw_data(bt), i32(len(bt)))[:len(bt)]
+	defer libc.free(raw_data(msgs))
+
+	out = make([]Line, len(bt), allocator)
+	defer if err != nil { _lines_destroy(out, allocator) }
+
+	// Debug info is needed.
+	when !ODIN_DEBUG {
+		for msg, i in msgs {
+			location, mem_err := strings.clone_from(msg, allocator)
+			if mem_err != nil { return out, .Out_Of_Memory }
+
+			out[i] = Line {
+				location = location,
+				symbol   = "??",
+			}
+		}
+		return
+	}
+
+	i := 0
+
+	command := make([dynamic]string, temp_allocator)
+	defer delete(command)
+
+	if _, err := append(&command, ADDR2LINE_PATH, "--functions", "--exe", ""); err != nil { return out, .Out_Of_Memory }
+
+	COMMAND_EXE_POS   :: 3
+	COMMAND_START_LEN :: 4
+
+	for msg in msgs {
+		exe, addr := parse_address(msg) or_return
+		if command[COMMAND_EXE_POS] == "" {
+			command[COMMAND_EXE_POS] = exe
+		} else if command[COMMAND_EXE_POS] != exe {
+			i += exec_and_fill(command[:], out[i:], msgs[i:], allocator, temp_allocator) or_return
+
+			command[COMMAND_EXE_POS] = exe
+			resize(&command, COMMAND_START_LEN)
+		}
+
+		if _, err := append(&command, addr); err != nil { return out, .Out_Of_Memory }
+	}
+
+	if len(command) > COMMAND_START_LEN {
+		i += exec_and_fill(command[:], out[i:], msgs[i:], allocator, temp_allocator) or_return
+	}
+
+	return
+
+	// Parses the exe and address out of a backtrace line.
+	// Example: .../main(+0x20) [0x100000] -> .../main, +0x20, nil
+	parse_address :: proc(cmsg: cstring) -> (string, string, Lines_Error) {
+		msg := string(cmsg)
+		close_idx := strings.last_index_byte(msg, ')')
+		if close_idx < 1 {
+			return "", "", .Parse_Address_Fail
+		}
+
+		open_idx := strings.last_index_byte(msg[:close_idx], '(')
+		if open_idx < 0 {
+			return "", "", .Parse_Address_Fail
+		}
+
+		return msg[:open_idx], msg[open_idx+1:close_idx], nil
+	}
+
+	exec_and_fill :: proc(command: []string, out: []Line, msgs: []cstring, allocator, temp_allocator: runtime.Allocator) -> (filled: int, err: Lines_Error) {
+		state, stdout, stderr, perr := os.process_exec({command = command}, temp_allocator)
+		defer delete(stdout, temp_allocator)
+		defer delete(stderr, temp_allocator)
+
+		if perr != nil || !state.success {
+			return 0, .Addr2line_Process_Error
+		}
+
+		count := len(command)-COMMAND_START_LEN
+
+		sstdout := string(stdout)
+		for i in 0..<count {
+			out[i].symbol, err = process_line(strings.split_lines_iterator(&sstdout), allocator)
+			if err == .Out_Of_Memory {
+				out[i].symbol = "??OOM"
+			} else if err != nil {
+				return
+			}
+
+			// TODO: parse location and transform to ODIN_ERROR_POS_STYLE
+			out[i].location, err = process_line(strings.split_lines_iterator(&sstdout), allocator)
+			if err == .Out_Of_Memory {
+				out[i].location = "??OOM"
+			} else if err != nil {
+				return
+			}
+
+			if out[i].location == "" || out[i].location == "??" {
+				fallback, mem_err := strings.clone_from(msgs[i], allocator)
+				if mem_err != nil { return 0, .Out_Of_Memory }
+				out[i].location = fallback
+			}
+		}
+
+		return count, nil
+	}
+
+	process_line :: proc(line: string, ok: bool, allocator: runtime.Allocator) -> (string, Lines_Error) {
+		if !ok { return "", .Addr2line_Unexpected_EOF }
+		if line == "" { return "", .Addr2line_Output_Error }
+
+		if line == "??" {
+			return "??", nil
+		}
+
+		ret, err := strings.clone(strings.trim_right_space(line), allocator)
+		return ret, err == nil ? nil : .Out_Of_Memory
+	}
+
+}
+
+foreign lib {
+	backtrace :: proc(buffer: [^]rawptr, size: c.int) -> c.int ---
+	backtrace_symbols :: proc(buffer: [^]rawptr, size: c.int) -> [^]cstring ---
+	backtrace_symbols_fd :: proc(buffer: [^]rawptr, size: c.int, fd: ^libc.FILE) ---
+}
+
+}
diff --git a/src/libraries/back/back_other.odin b/src/libraries/back/back_other.odin
new file mode 100644
index 0000000..e51ef4a
--- /dev/null
+++ b/src/libraries/back/back_other.odin
@@ -0,0 +1,127 @@
+#+vet explicit-allocators
+package back
+
+@require import "base:runtime"
+
+@require import "core:strings"
+
+when USE_FALLBACK {
+
+when ODIN_OPTIMIZATION_MODE == .None {
+	#panic("the `back` package's `other` mode requires at least `-o:minimal` to work (it requires `#force_inline` to actually be applied)")
+}
+
+when ODIN_USE_SEPARATE_MODULES {
+	#panic("the `back` package's `other` mode requires `-use-single-module` to work (there are subtle instrumentation bugs to hunt down)")
+}
+
+@(no_instrumentation)
+other_instrumentation_enter :: #force_inline proc "contextless" (a, b: rawptr, loc: runtime.Source_Code_Location) {
+	_other_instrumentation_enter(a, b, loc)
+}
+
+@(no_instrumentation)
+other_instrumentation_exit :: #force_inline proc "contextless" (a, b: rawptr, loc: runtime.Source_Code_Location) {
+	_other_instrumentation_exit(a, b, loc)
+}
+
+@(private="package")
+_Trace_Entry :: runtime.Source_Code_Location
+
+@(private="package")
+_trace :: #force_no_inline proc(buf: Trace) -> (n: int) {
+	lframe := frame
+
+	// Omit this function's frame and the caller.
+	if lframe != nil { lframe = lframe.prev }
+	if lframe != nil { lframe = lframe.prev }
+
+	for lframe != nil && n < len(buf) {
+		buf[n] = lframe.loc
+
+		n += 1
+		lframe = lframe.prev
+	}
+
+	return
+}
+
+@(private="package")
+_lines_destroy :: proc(lines: []Line, allocator: runtime.Allocator) {
+	for line in lines {
+		delete(line.location, allocator)
+	}
+}
+
+@(private="package")
+_lines :: proc(bt: Trace, allocator, temp_allocator: runtime.Allocator) -> (out: []Line, err: Lines_Error) {
+	out = make([]Line, len(bt), allocator)
+
+	for t, i in bt {
+		out[i].symbol = t.procedure
+
+		location := strings.builder_make(allocator)
+		strings.write_string(&location, t.file_path)
+		when ODIN_ERROR_POS_STYLE == .Default {
+			strings.write_byte(&location, '(')
+			strings.write_int (&location, int(t.line))
+			if t.column != 0 {
+				strings.write_byte(&location, ':')
+				strings.write_int (&location, int(t.column))
+			}
+			strings.write_byte(&location, ')')
+		} else when ODIN_ERROR_POS_STYLE == .Unix {
+			strings.write_byte(&location, ':')
+			strings.write_int (&location, int(t.line))
+			if t.column != 0 {
+				strings.write_byte(&location, ':')
+				strings.write_int (&location, int(t.column))
+			}
+		} else {
+			#panic("unhandled ODIN_ERROR_POS_STYLE")
+		}
+
+		out[i].location = strings.to_string(location)
+	}
+
+	return
+}
+
+@(private="file")
+Frame :: struct {
+    prev: ^Frame,
+    loc:  runtime.Source_Code_Location,
+}
+
+@(thread_local, private="file")
+frame: ^Frame
+
+when OTHER_CUSTOM_INSTRUMENTATION {
+	@(no_instrumentation, private="file")
+	_other_instrumentation_enter :: #force_inline proc "contextless" (_, _: rawptr, loc: runtime.Source_Code_Location) {
+		frame = &Frame{
+			prev = frame,
+			loc  = loc,
+		}
+	}
+
+	@(no_instrumentation, private="file")
+	_other_instrumentation_exit :: #force_inline proc "contextless" (_, _: rawptr, loc: runtime.Source_Code_Location) {
+		frame = frame.prev
+	}
+} else {
+	@(instrumentation_enter, private="file")
+	_other_instrumentation_enter :: #force_inline proc "contextless" (_, _: rawptr, loc: runtime.Source_Code_Location) {
+		frame = &Frame{
+			prev = frame,
+			loc  = loc,
+		}
+	}
+
+	@(instrumentation_exit, private="file")
+	_other_instrumentation_exit :: #force_inline proc "contextless" (_, _: rawptr, loc: runtime.Source_Code_Location) {
+		frame = frame.prev
+	}
+}
+
+}
diff --git a/src/libraries/back/back_windows.odin b/src/libraries/back/back_windows.odin
new file mode 100644
index 0000000..485f6d0
--- /dev/null
+++ b/src/libraries/back/back_windows.odin
@@ -0,0 +1,140 @@
+#+vet explicit-allocators
+#+private
+package back
+
+@require import "base:intrinsics"
+@require import "base:runtime"
+
+@require import     "core:io"
+@require import     "core:strings"
+@require import     "core:sync"
+@require import     "core:unicode/utf16"
+@require import win "core:sys/windows"
+
+when !USE_FALLBACK {
+
+SYMOPT_DEFERRED_LOADS :: 0x00000004
+
+_Trace_Entry :: uintptr
+
+_trace :: #force_no_inline proc(buf: Trace) -> (n: int) {
+	frame_count := win.RtlCaptureStackBackTrace(2, u32(len(buf)), ([^]rawptr)(raw_data(buf)), nil)
+
+	for &frame in buf[:frame_count] {
+		// NOTE: Return address is one after the call instruction so subtract a byte to
+		// end up back inside the call instruction which is needed for SymFromAddr.
+		frame -= 1
+	}
+
+	return int(frame_count)
+}
+
+_lines_destroy :: proc(lines: []Line, allocator: runtime.Allocator) {
+	for line in lines {
+		delete(line.location, allocator)
+		if line.symbol != "??" && line.symbol != "??OOM" {
+			delete(line.symbol, allocator)
+		}
+	}
+	delete(lines, allocator)
+}
+
+_lines :: proc(bt: Trace, allocator, temp_allocator: runtime.Allocator) -> (out: []Line, err: Lines_Error) {
+	// Debug info is needed, if we call with out-of-date debug symbols it will return out-of-date info, so better to short-circuit right away.
+	when !ODIN_DEBUG {
+		out = make([]Line, len(bt), allocator)
+		for &line, i in out {
+			line.symbol = "??"
+
+			location := strings.builder_make(allocator)
+			strings.write_string(&location, "0x")
+			strings.write_i64   (&location, i64(bt[i]), 16)
+			line.location = strings.to_string(location)
+		}
+
+		return
+	}
+
+	out = make([]Line, len(bt), allocator)
+	defer if err != nil { _lines_destroy(out, allocator) }
+
+	process := win.GetCurrentProcess()
+
+	sync.guard(&_win32_dbghelp_mutex)
+
+	if !win.SymInitialize(process, nil, true) {
+		err = .Info_Not_Found
+		return
+	}
+	defer win.SymCleanup(process)
+
+	win.SymSetOptions(win.SYMOPT_LOAD_LINES|SYMOPT_DEFERRED_LOADS)
+
+	data: [size_of(win.SYMBOL_INFOW) + size_of([256]win.WCHAR)]byte
+	symbol := (^win.SYMBOL_INFOW)(&data[0])
+	// The value of SizeOfStruct must be the size of the whole struct,
+	// not just the size of the pointer
+	symbol.SizeOfStruct = size_of(symbol^)
+	symbol.MaxNameLen = 255
+
+	for &line, i in out {
+		if win.SymFromAddrW(process, win.DWORD64(bt[i]), nil, symbol) {
+			symbol, mem_err := win.wstring_to_utf8(cstring16(&symbol.Name[0]), int(symbol.NameLen), allocator)
+			if mem_err != nil {
+				line.symbol = "??OOM"
+			} else if symbol == "??" {
+				delete(symbol, allocator)
+				line.symbol = "??"
+			} else {
+				line.symbol = symbol
+			}
+		} else {
+			line.symbol = "??"
+		}
+
+		lineInfo: win.IMAGEHLP_LINE64
+		lineInfo.SizeOfStruct = size_of(lineInfo)
+		if win.SymGetLineFromAddrW64(process, win.DWORD64(bt[i]), &{}, &lineInfo) {
+			location := strings.builder_make(allocator)
+			write_string16(&location, string16(lineInfo.FileName))
+			when ODIN_ERROR_POS_STYLE == .Default {
+				strings.write_byte(&location, '(')
+				strings.write_int (&location, int(lineInfo.LineNumber))
+				strings.write_byte(&location, ')')
+			} else when ODIN_ERROR_POS_STYLE == .Unix {
+				strings.write_byte(&location, ':')
+				strings.write_int (&location, int(lineInfo.LineNumber))
+			} else {
+				#panic("unhandled ODIN_ERROR_POS_STYLE")
+			}
+			line.location = strings.to_string(location)
+		} else {
+			location := strings.builder_make(allocator)
+			strings.write_string(&location, "0x")
+			strings.write_i64   (&location, i64(bt[i]), 16)
+			line.location = strings.to_string(location)
+		}
+	}
+
+	return
+}
+
+write_string16 :: proc(b: ^strings.Builder, s: string16, loc := #caller_location) -> (n: int, err: io.Error) {
+	for i := 0; i < len(s); i += 1 {
+		r := rune(utf16.REPLACEMENT_CHAR)
+
+		switch c := s[i]; {
+		case c < utf16._surr1, utf16._surr3 <= c:
+			r = rune(c)
+		case utf16._surr1 <= c && c < utf16._surr2 && i+1 < len(s) &&
+		utf16._surr2 <= s[i+1] && s[i+1] < utf16._surr3:
+			r = utf16.decode_surrogate_pair(rune(c), rune(s[i+1]))
+			i += 1
+		}
+
+		n += strings.write_rune(b, rune(r)) or_return
+	}
+	return
+}
+
+}
diff --git a/src/libraries/back/signal_handler_other.odin b/src/libraries/back/signal_handler_other.odin
new file mode 100644
index 0000000..37d1a94
--- /dev/null
+++ b/src/libraries/back/signal_handler_other.odin
@@ -0,0 +1,11 @@
+#+vet explicit-allocators
+#+build !linux
+#+build !darwin
+#+build !netbsd
+#+build !openbsd
+#+build !freebsd
+#+build !windows
+package back
+
+@(private="package")
+_register_segfault_handler :: proc() {}
diff --git a/src/libraries/back/signal_handler_posix.odin b/src/libraries/back/signal_handler_posix.odin
new file mode 100644
index 0000000..7066c33
--- /dev/null
+++ b/src/libraries/back/signal_handler_posix.odin
@@ -0,0 +1,37 @@
+#+vet explicit-allocators
+#+build linux, darwin, netbsd, openbsd, freebsd
+package back
+
+import "base:runtime"
+
+import "core:fmt"
+import "core:mem"
+import "core:sys/posix"
+
+@(private="package")
+_register_segfault_handler :: proc() {
+	posix.signal(.SIGSEGV, proc "c" (code: posix.Signal) {
+		context = runtime.default_context()
+
+		space: [16*mem.Kilobyte]byte
+		arena: mem.Arena
+		mem.arena_init(&arena, space[:])
+		allocator := mem.arena_allocator(&arena)
+
+		context.allocator      = allocator
+		context.temp_allocator = allocator
+
+		backtrace: {
+			lines, err := lines(trace(), allocator, allocator)
+			if err != nil {
+				fmt.eprintf("Exception (Code: %i)\nCould not get backtrace: %v\n", code, err)
+				break backtrace
+			}
+
+			fmt.eprintf("Exception (Code: %i)\n[back trace]\n", code)
+			print(lines, temp_allocator=allocator)
+		}
+
+		runtime.exit(int(code))
+	})
+}
diff --git a/src/libraries/back/signal_handler_windows.odin b/src/libraries/back/signal_handler_windows.odin
new file mode 100644
index 0000000..de5b33a
--- /dev/null
+++ b/src/libraries/back/signal_handler_windows.odin
@@ -0,0 +1,38 @@
+#+vet explicit-allocators
+package back
+
+import     "base:runtime"
+
+import     "core:fmt"
+import     "core:mem"
+import win "core:sys/windows"
+
+_register_segfault_handler :: proc() {
+	win.SetUnhandledExceptionFilter(proc "stdcall" (exception_info: ^win.EXCEPTION_POINTERS) -> win.LONG {
+		context = runtime.default_context()
+
+		space: [16*mem.Kilobyte]byte
+		arena: mem.Arena
+		mem.arena_init(&arena, space[:])
+		allocator := mem.arena_allocator(&arena)
+
+		context.allocator      = allocator
+		context.temp_allocator = allocator
+
+		fmt.eprint("Exception ")
+		if exception_info.ExceptionRecord != nil {
+			fmt.eprintf("(Type: %x, Flags: %x)\n", exception_info.ExceptionRecord.ExceptionCode, exception_info.ExceptionRecord.ExceptionFlags)
+		}
+
+		lines, err := lines(trace(), allocator, allocator)
+		if err != nil {
+			fmt.eprintln("Could not get backtrace: %v", err)
+			return win.EXCEPTION_CONTINUE_SEARCH
+		}
+
+		fmt.eprintln("[back trace]")
+		print(lines, temp_allocator=allocator)
+
+		return win.EXCEPTION_CONTINUE_SEARCH
+	})
+}
diff --git a/src/libraries/raylib/build.sh b/src/libraries/raylib/build.sh
index 7f5fe36..0296a23 100755
--- a/src/libraries/raylib/build.sh
+++ b/src/libraries/raylib/build.sh
@@ -2,86 +2,12 @@
 # Currently not cross compiling for windows and darwin
 set -euo pipefail
 
-emsdk_env="$HOME/programs/emsdk/emsdk_env.sh"
-linux_library_dest="linux"
-windows_library_dest="windows"
-darwin_library_dest="darwin"
-wasm_library_dest="wasm"
-
-CONFIG_FLAGS="\
-    -DSUPPORT_MODULE_RSHAPES=1 \
-    -DSUPPORT_MODULE_RTEXTURES=1 \
-    -DSUPPORT_MODULE_RTEXT=1 \
-    -DSUPPORT_MODULE_RMODELS=0 \
-    -DSUPPORT_MODULE_RAUDIO=0 \
-    \
-    -DSUPPORT_TRACELOG=1 \
-    -DSUPPORT_CAMERA_SYSTEM=1 \
-    -DSUPPORT_GESTURES_SYSTEM=1 \
-    -DSUPPORT_RPRAND_GENERATOR=0 \
-    -DSUPPORT_MOUSE_GESTURES=0 \
-    -DSUPPORT_SSH_KEYBOARD_RPI=0 \
-    -DSUPPORT_WINMM_HIGHRES_TIMER=1 \
-    -DSUPPORT_BUSY_WAIT_LOOP=0 \
-    -DSUPPORT_PARTIALBUSY_WAIT_LOOP=1 \
-    -DSUPPORT_SCREEN_CAPTURE=0 \
-    -DSUPPORT_COMPRESSION_API=0 \
-    -DSUPPORT_AUTOMATION_EVENTS=0 \
-    -DSUPPORT_CUSTOM_FRAME_CONTROL=0 \
-    -DSUPPORT_CLIPBOARD_IMAGE=0 \
-    \
-    -DRLGL_ENABLE_OPENGL_DEBUG_CONTEXT=0 \
-    -DRLGL_SHOW_GL_DETAILS_INFO=0 \
-    \
-    -DSUPPORT_QUADS_DRAW_MODE=0 \
-    \
-    -DSUPPORT_FILEFORMAT_PNG=0 \
-    -DSUPPORT_FILEFORMAT_BMP=0 \
-    -DSUPPORT_FILEFORMAT_TGA=0 \
-    -DSUPPORT_FILEFORMAT_JPG=0 \
-    -DSUPPORT_FILEFORMAT_GIF=0 \
-    -DSUPPORT_FILEFORMAT_QOI=0 \
-    -DSUPPORT_FILEFORMAT_PEP=0 \
-    -DSUPPORT_FILEFORMAT_PSD=0 \
-    -DSUPPORT_FILEFORMAT_DDS=0 \
-    -DSUPPORT_FILEFORMAT_HDR=0 \
-    -DSUPPORT_FILEFORMAT_PIC=0 \
-    -DSUPPORT_FILEFORMAT_PNM=0 \
-    -DSUPPORT_FILEFORMAT_KTX=0 \
-    -DSUPPORT_FILEFORMAT_ASTC=0 \
-    -DSUPPORT_FILEFORMAT_PKM=0 \
-    -DSUPPORT_FILEFORMAT_PVR=0 \
-    -DSUPPORT_IMAGE_EXPORT=0 \
-    -DSUPPORT_IMAGE_GENERATION=0 \
-    \
-    -DSUPPORT_FILEFORMAT_TTF=1 \
-    -DSUPPORT_FILEFORMAT_FNT=1 \
-    -DSUPPORT_FILEFORMAT_BDF=0 \
-    \
-    -DSUPPORT_FILEFORMAT_OBJ=0 \
-    -DSUPPORT_FILEFORMAT_MTL=0 \
-    -DSUPPORT_FILEFORMAT_IQM=0 \
-    -DSUPPORT_FILEFORMAT_GLTF=0 \
-    -DSUPPORT_FILEFORMAT_VOX=0 \
-    -DSUPPORT_FILEFORMAT_M3D=0 \
-    -DSUPPORT_MESH_GENERATION=0 \
-    -DSUPPORT_GPU_SKINNING=0 \
-    \
-    -DSUPPORT_FILEFORMAT_WAV=0 \
-    -DSUPPORT_FILEFORMAT_OGG=0 \
-    -DSUPPORT_FILEFORMAT_MP3=0 \
-    -DSUPPORT_FILEFORMAT_QOA=0 \
-    -DSUPPORT_FILEFORMAT_FLAC=0 \
-    -DSUPPORT_FILEFORMAT_XM=0 \
-    -DSUPPORT_FILEFORMAT_MOD=0"
-
-
 if [[ -v 1 ]]; then
     if [ "$1" = "DEBUG" ]; then
-        MAKE_FLAGS="RAYLIB_BUILD_MODE=DEBUG"
+        MFLAGS="RAYLIB_BUILD_MODE=DEBUG"
         CFLAGS="-g"
     elif [ "$1" = "RELEASE" ]; then
-        MAKE_FLAGS="RAYLIB_BUILD_MODE=RELEASE"
+        MFLAGS="RAYLIB_BUILD_MODE=RELEASE"
         CFLAGS="-Os -ffunction-sections -fdata-sections"
     else
         echo "Usage: <script> <DEBUG/RELEASE>"
@@ -92,16 +18,83 @@ else
     exit 1
 fi
 
+emsdk_env="$HOME/programs/emsdk/emsdk_env.sh"
+modules="RAYLIB_MODULE_AUDIO=FALSE RAYLIB_MODULE_RAYGUI=FALSE RAYLIB_MODULE_MODELS=FALSE"
+linux_library_dest="linux"
+windows_library_dest="windows"
+darwin_library_dest="darwin"
+wasm_library_dest="wasm"
+
 mkdir -p $linux_library_dest
 mkdir -p $windows_library_dest
 mkdir -p $darwin_library_dest
 mkdir -p $wasm_library_dest
 
+config_cflags="\
+-DSUPPORT_MODULE_RSHAPES=1 \
+-DSUPPORT_MODULE_RTEXTURES=1 \
+-DSUPPORT_MODULE_RTEXT=1 \
+-DSUPPORT_MODULE_RMODELS=0 \
+-DSUPPORT_MODULE_RAUDIO=0 \
+-DSUPPORT_TRACELOG=1 \
+-DSUPPORT_CAMERA_SYSTEM=0 \
+-DSUPPORT_GESTURES_SYSTEM=0 \
+-DSUPPORT_RPRAND_GENERATOR=0 \
+-DSUPPORT_MOUSE_GESTURES=0 \
+-DSUPPORT_SSH_KEYBOARD_RPI=0 \
+-DSUPPORT_WINMM_HIGHRES_TIMER=0 \
+-DSUPPORT_BUSY_WAIT_LOOP=0 \
+-DSUPPORT_PARTIALBUSY_WAIT_LOOP=0 \
+-DSUPPORT_SCREEN_CAPTURE=0 \
+-DSUPPORT_COMPRESSION_API=0 \
+-DSUPPORT_AUTOMATION_EVENTS=0 \
+-DSUPPORT_CUSTOM_FRAME_CONTROL=0 \
+-DSUPPORT_CLIPBOARD_IMAGE=0 \
+-DRLGL_ENABLE_OPENGL_DEBUG_CONTEXT=0 \
+-DRLGL_SHOW_GL_DETAILS_INFO=0 \
+-DSUPPORT_QUADS_DRAW_MODE=0 \
+-DSUPPORT_FILEFORMAT_PNG=0 \
+-DSUPPORT_FILEFORMAT_BMP=0 \
+-DSUPPORT_FILEFORMAT_TGA=0 \
+-DSUPPORT_FILEFORMAT_JPG=0 \
+-DSUPPORT_FILEFORMAT_GIF=0 \
+-DSUPPORT_FILEFORMAT_QOI=0 \
+-DSUPPORT_FILEFORMAT_PEP=0 \
+-DSUPPORT_FILEFORMAT_PSD=0 \
+-DSUPPORT_FILEFORMAT_DDS=0 \
+-DSUPPORT_FILEFORMAT_HDR=0 \
+-DSUPPORT_FILEFORMAT_PIC=0 \
+-DSUPPORT_FILEFORMAT_PNM=0 \
+-DSUPPORT_FILEFORMAT_KTX=0 \
+-DSUPPORT_FILEFORMAT_ASTC=0 \
+-DSUPPORT_FILEFORMAT_PKM=0 \
+-DSUPPORT_FILEFORMAT_PVR=0 \
+-DSUPPORT_IMAGE_EXPORT=0 \
+-DSUPPORT_IMAGE_GENERATION=0 \
+-DSUPPORT_FILEFORMAT_TTF=1 \
+-DSUPPORT_FILEFORMAT_FNT=0 \
+-DSUPPORT_FILEFORMAT_BDF=0 \
+-DSUPPORT_FILEFORMAT_OBJ=0 \
+-DSUPPORT_FILEFORMAT_MTL=0 \
+-DSUPPORT_FILEFORMAT_IQM=0 \
+-DSUPPORT_FILEFORMAT_GLTF=0 \
+-DSUPPORT_FILEFORMAT_VOX=0 \
+-DSUPPORT_FILEFORMAT_M3D=0 \
+-DSUPPORT_MESH_GENERATION=0 \
+-DSUPPORT_GPU_SKINNING=0 \
+-DSUPPORT_FILEFORMAT_WAV=0 \
+-DSUPPORT_FILEFORMAT_OGG=0 \
+-DSUPPORT_FILEFORMAT_MP3=0 \
+-DSUPPORT_FILEFORMAT_QOA=0 \
+-DSUPPORT_FILEFORMAT_FLAC=0 \
+-DSUPPORT_FILEFORMAT_XM=0 \
+-DSUPPORT_FILEFORMAT_MOD=0"
+
 source $emsdk_env
 
 pushd raylib/src
 echo "Compiling raylib static library for linux"
-make --silent RAYLIB_CONFIG_FLAGS="$CONFIG_FLAGS" CUSTOM_CFLAGS="$CFLAGS" $MAKE_FLAGS PLATFORM_OS=LINUX -B
+make --silent $modules $MFLAGS RAYLIB_CONFIG_FLAGS="$config_cflags" CUSTOM_CFLAGS="$CFLAGS" PLATFORM_OS=LINUX
 mv libraylib.a "../../${linux_library_dest}"
 make --silent clean
 
@@ -111,7 +104,7 @@ make --silent clean
 # make --silent clean
 
 echo "Compiling raylib static library for web"
-make --silent RAYLIB_CONFIG_FLAGS="$CONFIG_FLAGS" CUSTOM_CFLAGS="$CFLAGS" $MAKE_FLAGS PLATFORM=PLATFORM_WEB -B
+make --silent $modules RAYLIB_CONFIG_FLAGS="$config_cflags" PLATFORM=PLATFORM_WEB
 mv libraylib.web.a libraylib.a
 mv libraylib.a "../../${wasm_library_dest}"
 make --silent clean
@@ -124,7 +117,7 @@ ar rcs ../${linux_library_dest}/libraygui.a raygui.o
 rm raygui.o
 
 echo "Compiling raygui static library for web"
-emcc $CFLAGS -c -x c -DRAYGUI_IMPLEMENTATION -DPLATFORM_WEB -I../raylib/src raygui.h -o raygui_wasm.o
+emcc -c -Os -ffunction-sections -fdata-sections -x c -DRAYGUI_IMPLEMENTATION -DPLATFORM_WEB -I../raylib/src raygui.h -o raygui_wasm.o
 emar rcs ../${wasm_library_dest}/libraygui.a raygui_wasm.o
 rm raygui_wasm.o
 popd
diff --git a/src/libraries/raylib/raygui.odin b/src/libraries/raylib/raygui.odin
index 56b4a5d..fba81e1 100644
--- a/src/libraries/raylib/raygui.odin
+++ b/src/libraries/raylib/raygui.odin
@@ -1,355 +1,7 @@
-/*******************************************************************************************
-*
-*   raygui v5.0 - A simple and easy-to-use immediate-mode gui library
-*
-*   DESCRIPTION:
-*       raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also
-*       available as a standalone library, as long as input and drawing functions are provided
-*
-*   FEATURES:
-*       - Immediate-mode gui, minimal retained data
-*       - +25 controls provided (basic and advanced)
-*       - Styling system for colors, font and metrics
-*       - Icons supported, embedded as a 1-bit icons pack
-*       - Standalone mode option (custom input/graphics backend)
-*       - Multiple support tools provided for raygui development
-*
-*   POSSIBLE IMPROVEMENTS:
-*       - Better standalone mode API for easy plug of custom backends
-*       - Externalize required inputs, allow user easier customization
-*
-*   LIMITATIONS:
-*       - No editable multi-line word-wraped text box supported
-*       - No auto-layout mechanism, up to the user to define controls position and size
-*       - Standalone mode requires library modification and some user work to plug another backend
-*
-*   NOTES:
-*       - WARNING: GuiLoadStyle() and GuiLoadStyle{Custom}() functions, allocate memory for
-*         font atlas recs and glyphs, freeing that memory is (usually) up to the user,
-*         no unload function is explicitly provided... but note that GuiLoadStyleDefault() unloads
-*         by default any previously loaded font (texture, recs, glyphs)
-*       - Global UI alpha (guiAlpha) is applied inside GuiDrawRectangle() and GuiDrawText() functions
-*
-*   CONTROLS PROVIDED:
-*     # Container/separators Controls
-*       - WindowBox     --> StatusBar, Panel
-*       - GroupBox      --> Line
-*       - Line
-*       - Panel         --> StatusBar
-*       - ScrollPanel   --> StatusBar
-*       - TabBar        --> Toggle, Button
-*
-*     # Basic Controls
-*       - Label
-*       - LabelButton   --> Label
-*       - Button
-*       - Toggle
-*       - ToggleGroup   --> Toggle
-*       - ToggleSlider
-*       - CheckBox
-*       - ComboBox
-*       - DropdownBox
-*       - TextBox
-*       - ValueBox      --> TextBox
-*       - Spinner       --> Button, ValueBox
-*       - Slider
-*       - SliderBar     --> Slider
-*       - ProgressBar
-*       - StatusBar
-*       - DummyRec
-*       - Grid
-*
-*     # Advance Controls
-*       - ListView
-*       - ColorPicker   --> ColorPanel, ColorBarHue
-*       - MessageBox    --> Window, Label, Button
-*       - TextInputBox  --> Window, Label, TextBox, Button
-*
-*     It also provides a set of functions for styling the controls based on its properties (size, color)
-*
-*
-*   RAYGUI STYLE (guiStyle):
-*       raygui uses a global data array for all gui style properties (allocated on data segment by default),
-*       when a new style is loaded, it is loaded over the global style... but a default gui style could always be
-*       recovered with GuiLoadStyleDefault() function, that overwrites the current style to the default one
-*
-*       The global style array size is fixed and depends on the number of controls and properties:
-*
-*           static unsigned int guiStyle[RAYGUI_MAX_CONTROLS*(RAYGUI_MAX_PROPS_BASE + RAYGUI_MAX_PROPS_EXTENDED)];
-*
-*       guiStyle size is by default: 16*(16 + 8) = 384 int = 384*4 bytes = 1536 bytes = 1.5 KB
-*
-*       Note that the first set of BASE properties (by default guiStyle[0..15]) belong to the generic style
-*       used for all controls, when any of those base values is set, it is automatically populated to all
-*       controls, so, specific control values overwriting generic style should be set after base values
-*
-*       After the first BASE properties set, the EXTENDED properties set is defined (by default guiStyle[16..23]),
-*       those properties are actually common to all controls and can not be overwritten individually (like BASE ones)
-*       Some of those properties are: TEXT_SIZE, TEXT_SPACING, LINE_COLOR, BACKGROUND_COLOR
-*
-*       Custom control properties can be defined using the EXTENDED properties for each independent control.
-*
-*       TOOL: rGuiStyler is a visual tool to customize raygui style: github.com/raysan5/rguistyler
-*
-*
-*   RAYGUI ICONS (guiIcons):
-*       raygui could use a global array containing icons data (allocated on data segment by default),
-*       a custom icons set could be loaded over this array using GuiLoadIcons(), but loaded icons set
-*       must be same RAYGUI_ICON_SIZE and no more than RAYGUI_ICON_MAX_ICONS will be loaded
-*
-*       Every icon is codified in binary form, using 1 bit per pixel, so, every 16x16 icon
-*       requires 8 integers (16*16/32) to be stored in memory.
-*
-*       When the icon is draw, actually one quad per pixel is drawn if the bit for that pixel is set
-*
-*       The global icons array size is fixed and depends on the number of icons and size:
-*
-*           static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS];
-*
-*       guiIcons size is by default: 256*(16*16/32) = 2048*4 = 8192 bytes = 8 KB
-*
-*       TOOL: rGuiIcons is a visual tool to customize/create raygui icons: github.com/raysan5/rguiicons
-*
-*   RAYGUI LAYOUT:
-*       raygui currently does not provide an auto-layout mechanism like other libraries,
-*       layouts must be defined manually on controls drawing, providing the right bounds Rectangle for it
-*
-*       TOOL: rGuiLayout is a visual tool to create raygui layouts: github.com/raysan5/rguilayout
-*
-*   CONFIGURATION:
-*       #define RAYGUI_IMPLEMENTATION
-*           Generates the implementation of the library into the included file
-*           If not defined, the library is in header only mode and can be included in other headers
-*           or source files without problems. But only ONE file should hold the implementation
-*
-*       #define RAYGUI_STANDALONE
-*           Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined
-*           internally in the library and input management and drawing functions must be provided by
-*           the user (check library implementation for further details)
-*
-*       #define RAYGUI_NO_ICONS
-*           Avoid including embedded ricons data (256 icons, 16x16 pixels, 1-bit per pixel, 2KB)
-*
-*       #define RAYGUI_CUSTOM_ICONS
-*           Includes custom ricons.h header defining a set of custom icons,
-*           this file can be generated using rGuiIcons tool
-*
-*       #define RAYGUI_FONT_ICONS_BAKING
-*           On gui font loading from style file, append the icons to font atlas image, so,
-*           icons can be drawn along the text as a texture, instead of using shapes to draw them
-*
-*       #define RAYGUI_DEBUG_RECS_BOUNDS
-*           Draw control bounds rectangles for debug
-*
-*       #define RAYGUI_DEBUG_TEXT_BOUNDS
-*           Draw text bounds rectangles for debug
-*
-*   VERSIONS HISTORY:
-*       5.0 (20-Jul-2026) ADDED: NEW control: GuiTabBar()
-*                         ADDED: Support up to 512 icons (v500)
-*                         ADDED: Support icons baking into font atlas image
-*                         ADDED: guiControlExclusiveMode and guiControlExclusiveRec for exclusive modes
-*                         ADDED: GuiValueBoxFloat(), with floats support
-*                         ADDED: GuiDropdonwBox() properties: DROPDOWN_ARROW_HIDDEN, DROPDOWN_ROLL_UP
-*                         ADDED: GuiListView() property: LIST_ITEMS_BORDER_WIDTH
-*                         ADDED: GuiLoadIconsFromMemory(), used by GuiLoadIcons()
-*                         ADDED: Macros for inputs customization, raylib decoupling
-*                         ADDED: Control result return values: 1-RESULT_PRESSED, 2-RESULT_CHANGED, >2-Control_custom
-*                         REMOVED: GuiSpinner() from controls list, using BUTTON + VALUEBOX properties
-*                         REMOVED: GuiSliderPro(), functionality was redundant
-*                         REMOVED: TextSplit() raylib function requirement on RAYGUI_STANDALONE
-*                         REDESIGNED: WARNING: GuiLoadStyleFromMemory() to support icons baking into font atlas
-*                         REDESIGNED: GuiToggleGroup() to process rows/cols with no need for GuiTextSplit()
-*                         REDESIGNED: GuiColorPanel(), improved HSV <-> RGBA convertion
-*                         REDESIGNED: WARNING: TEXT_LINE_SPACING does not consider text height, only lines spacing
-*                         REDESIGNED: WARNING: GuiMessageBox(), added parameter for btn return, unify result
-*                         REDESIGNED: WARNING: GuiTextInputBox(), added parameter for btn return, unify result
-*                         REVIEWED: GuiLoadIconsFromMemory(), fixed memory issues
-*                         REVIEWED: Controls using text labels to use LABEL properties
-*                         REVIEWED: Replaced sprintf() by snprintf() for more safety
-*                         REVIEWED: GuiTabBar(), close tab with mouse middle button
-*                         REVIEWED: GuiScrollPanel(), scroll speed proportional to content
-*                         REVIEWED: GuiDropdownBox(), support roll up and hidden arrow
-*                         REVIEWED: GuiTextBox(), cursor position initialization
-*                         REVIEWED: GuiSliderPro(), control value change check
-*                         REVIEWED: GuiGrid(), simplified implementation
-*                         REVIEWED: GuiIconText(), increase buffer size and reviewed padding
-*                         REVIEWED: GuiDrawText(), improved wrap mode drawing
-*                         REVIEWED: GuiScrollBar(), minor tweaks
-*                         REVIEWED: GuiProgressBar(), improved borders computing
-*                         REVIEWED: GuiTextBox(), multiple improvements: autocursor and more
-*                         REVIEWED: Functions descriptions, removed wrong return value reference
-*
-*       4.0 (12-Sep-2023) ADDED: GuiToggleSlider()
-*                         ADDED: GuiColorPickerHSV() and GuiColorPanelHSV()
-*                         ADDED: Multiple new icons, mostly compiler related
-*                         ADDED: New DEFAULT properties: TEXT_LINE_SPACING, TEXT_ALIGNMENT_VERTICAL, TEXT_WRAP_MODE
-*                         ADDED: New enum values: GuiTextAlignment, GuiTextAlignmentVertical, GuiTextWrapMode
-*                         ADDED: Support loading styles with custom font charset from external file
-*                         REDESIGNED: GuiTextBox(), support mouse cursor positioning
-*                         REDESIGNED: GuiDrawText(), support multiline and word-wrap modes (read only)
-*                         REDESIGNED: GuiProgressBar() to be more visual, progress affects border color
-*                         REDESIGNED: Global alpha consideration moved to GuiDrawRectangle() and GuiDrawText()
-*                         REDESIGNED: GuiScrollPanel(), get parameters by reference and return result value
-*                         REDESIGNED: GuiToggleGroup(), get parameters by reference and return result value
-*                         REDESIGNED: GuiComboBox(), get parameters by reference and return result value
-*                         REDESIGNED: GuiCheckBox(), get parameters by reference and return result value
-*                         REDESIGNED: GuiSlider(), get parameters by reference and return result value
-*                         REDESIGNED: GuiSliderBar(), get parameters by reference and return result value
-*                         REDESIGNED: GuiProgressBar(), get parameters by reference and return result value
-*                         REDESIGNED: GuiListView(), get parameters by reference and return result value
-*                         REDESIGNED: GuiColorPicker(), get parameters by reference and return result value
-*                         REDESIGNED: GuiColorPanel(), get parameters by reference and return result value
-*                         REDESIGNED: GuiColorBarAlpha(), get parameters by reference and return result value
-*                         REDESIGNED: GuiColorBarHue(), get parameters by reference and return result value
-*                         REDESIGNED: GuiGrid(), get parameters by reference and return result value
-*                         REDESIGNED: GuiGrid(), added extra parameter
-*                         REDESIGNED: GuiListViewEx(), change parameters order
-*                         REDESIGNED: All controls return result as int value
-*                         REVIEWED: GuiScrollPanel() to avoid smallish scroll-bars
-*                         REVIEWED: All examples and specially controls_test_suite
-*                         RENAMED: gui_file_dialog module to gui_window_file_dialog
-*                         UPDATED: All styles to include ISO-8859-15 charset (as much as possible)
-*
-*       3.6 (10-May-2023) ADDED: New icon: SAND_TIMER
-*                         ADDED: GuiLoadStyleFromMemory() (binary only)
-*                         REVIEWED: GuiScrollBar() horizontal movement key
-*                         REVIEWED: GuiTextBox() crash on cursor movement
-*                         REVIEWED: GuiTextBox(), additional inputs support
-*                         REVIEWED: GuiLabelButton(), avoid text cut
-*                         REVIEWED: GuiTextInputBox(), password input
-*                         REVIEWED: Local GetCodepointNext(), aligned with raylib
-*                         REDESIGNED: GuiSlider*()/GuiScrollBar() to support out-of-bounds
-*
-*       3.5 (20-Apr-2023) ADDED: GuiTabBar(), based on GuiToggle()
-*                         ADDED: Helper functions to split text in separate lines
-*                         ADDED: Multiple new icons, useful for code editing tools
-*                         REMOVED: Unneeded icon editing functions
-*                         REMOVED: GuiTextBoxMulti(), very limited and broken
-*                         REMOVED: MeasureTextEx() dependency, logic directly implemented
-*                         REMOVED: DrawTextEx() dependency, logic directly implemented
-*                         REVIEWED: GuiScrollBar(), improve mouse-click behaviour
-*                         REVIEWED: Library header info, more info, better organized
-*                         REDESIGNED: GuiTextBox() to support cursor movement
-*                         REDESIGNED: GuiDrawText() to divide drawing by lines
-*
-*       3.2 (22-May-2022) RENAMED: Some enum values, for unification, avoiding prefixes
-*                         REMOVED: GuiScrollBar(), only internal
-*                         REDESIGNED: GuiPanel() to support text parameter
-*                         REDESIGNED: GuiScrollPanel() to support text parameter
-*                         REDESIGNED: GuiColorPicker() to support text parameter
-*                         REDESIGNED: GuiColorPanel() to support text parameter
-*                         REDESIGNED: GuiColorBarAlpha() to support text parameter
-*                         REDESIGNED: GuiColorBarHue() to support text parameter
-*                         REDESIGNED: GuiTextInputBox() to support password
-*
-*       3.1 (12-Jan-2022) REVIEWED: Default style for consistency (aligned with rGuiLayout v2.5 tool)
-*                         REVIEWED: GuiLoadStyle() to support compressed font atlas image data and unload previous textures
-*                         REVIEWED: External icons usage logic
-*                         REVIEWED: GuiLine() for centered alignment when including text
-*                         RENAMED: Multiple controls properties definitions to prepend RAYGUI_
-*                         RENAMED: RICON_ references to RAYGUI_ICON_ for library consistency
-*                         Projects updated and multiple tweaks
-*
-*       3.0 (04-Nov-2021) Integrated ricons data to avoid external file
-*                         REDESIGNED: GuiTextBoxMulti()
-*                         REMOVED: GuiImageButton*()
-*                         Multiple minor tweaks and bugs corrected
-*
-*       2.9 (17-Mar-2021) REMOVED: Tooltip API
-*       2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle()
-*       2.7 (20-Feb-2020) ADDED: Possible tooltips API
-*       2.6 (09-Sep-2019) ADDED: GuiTextInputBox()
-*                         REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox()
-*                         REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle()
-*                         Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties
-*                         ADDED: 8 new custom styles ready to use
-*                         Multiple minor tweaks and bugs corrected
-*
-*       2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner()
-*       2.3 (29-Apr-2019) ADDED: rIcons auxiliar library and support for it, multiple controls reviewed
-*                         Refactor all controls drawing mechanism to use control state
-*       2.2 (05-Feb-2019) ADDED: GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls
-*       2.1 (26-Dec-2018) REDESIGNED: GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string
-*                         REDESIGNED: Style system (breaking change)
-*       2.0 (08-Nov-2018) ADDED: Support controls guiLock and custom fonts
-*                         REVIEWED: GuiComboBox(), GuiListView()...
-*       1.9 (09-Oct-2018) REVIEWED: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()...
-*       1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout
-*       1.5 (21-Jun-2017) Working in an improved styles system
-*       1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones)
-*       1.3 (12-Jun-2017) Complete redesign of style system
-*       1.1 (01-Jun-2017) Complete review of the library
-*       1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria
-*       0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria
-*       0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria
-*
-*   DEPENDENCIES:
-*       raylib 6.1-dev  - Inputs reading (keyboard/mouse), shapes drawing, font loading and text drawing
-*
-*   STANDALONE MODE:
-*       By default raygui depends on raylib mostly for the inputs and the drawing functionality but that dependency can be disabled
-*       with the config flag RAYGUI_STANDALONE. In that case is up to the user to provide another backend to cover library needs
-*
-*       The following functions should be redefined for a custom backend:
-*
-*           - Vector2 GetMousePosition(void);
-*           - float GetMouseWheelMove(void);
-*           - bool IsMouseButtonDown(int button);
-*           - bool IsMouseButtonPressed(int button);
-*           - bool IsMouseButtonReleased(int button);
-*           - bool IsKeyDown(int key);
-*           - bool IsKeyPressed(int key);
-*           - int GetCharPressed(void);         // -- GuiTextBox(), GuiValueBox()
-*
-*           - void DrawRectangle(int x, int y, int width, int height, Color color); // -- GuiDrawRectangle()
-*           - void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // -- GuiColorPicker()
-*
-*           - Font GetFontDefault(void);                            // -- GuiLoadStyleDefault()
-*           - Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // -- GuiLoadStyle()
-*           - Texture2D LoadTextureFromImage(Image image);          // -- GuiLoadStyle(), required to load texture from embedded font atlas image
-*           - void SetShapesTexture(Texture2D tex, Rectangle rec);  // -- GuiLoadStyle(), required to set shapes rec to font white rec (optimization)
-*           - char *LoadFileText(const char *fileName);             // -- GuiLoadStyle(), required to load charset data
-*           - void UnloadFileText(char *text);                      // -- GuiLoadStyle(), required to unload charset data
-*           - const char *GetDirectoryPath(const char *filePath);   // -- GuiLoadStyle(), required to find charset/font file from text .rgs
-*           - int *LoadCodepoints(const char *text, int *count);    // -- GuiLoadStyle(), required to load required font codepoints list
-*           - void UnloadCodepoints(int *codepoints);               // -- GuiLoadStyle(), required to unload codepoints list
-*           - unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // -- GuiLoadStyle()
-*
-*   CONTRIBUTORS:
-*       Ramon Santamaria:   Supervision, review, redesign, update and maintenance
-*       Vlad Adrian:        Complete rewrite of GuiTextBox() to support extended features (2019)
-*       Sergio Martinez:    Review, testing (2015) and redesign of multiple controls (2018)
-*       Adria Arranz:       Testing and implementation of additional controls (2018)
-*       Jordi Jorba:        Testing and implementation of additional controls (2018)
-*       Albert Martos:      Review and testing of the library (2015)
-*       Ian Eito:           Review and testing of the library (2015)
-*       Kevin Gato:         Initial implementation of basic components (2014)
-*       Daniel Nicolas:     Initial implementation of basic components (2014)
-*
-*
-*   LICENSE: zlib/libpng
-*
-*   Copyright (c) 2014-2026 Ramon Santamaria (@raysan5)
-*
-*   This software is provided "as-is", without any express or implied warranty. In no event
-*   will the authors be held liable for any damages arising from the use of this software.
-*
-*   Permission is granted to anyone to use this software for any purpose, including commercial
-*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
-*
-*     1. The origin of this software must not be misrepresented; you must not claim that you
-*     wrote the original software. If you use this software in a product, an acknowledgment
-*     in the product documentation would be appreciated but is not required.
-*
-*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*     as being the original software.
-*
-*     3. This notice may not be removed or altered from any source distribution.
-*
-**********************************************************************************************/
 package raylib
 
+import "core:c"
+
 RAYGUI_SHARED :: #config(RAYGUI_SHARED, false)
 RAYGUI_WASM_LIB :: #config(RAYGUI_WASM_LIB, "wasm/libraygui.a")
 
@@ -379,554 +31,537 @@ when ODIN_OS == .Windows {
 	foreign import lib "system:raygui"
 }
 
-
-RAYGUI_VERSION_MAJOR :: 5
-RAYGUI_VERSION_MINOR :: 0
-RAYGUI_VERSION_PATCH :: 0
-RAYGUI_VERSION       :: "5.0"
-
-// Style property
-// NOTE: Used when exporting style as code for convenience
-GuiStyleProp :: struct {
-	controlId:     u16, // Control identifier
-	propertyId:    u16, // Property identifier
-	propertyValue: i32, // Property value
-}
-
-// Gui control result
-GuiResult :: enum u32 {
-	NONE      = 0,
-	PRESSED   = 1,
-	CHANGED   = 2,
-	TAB_CLOSE = 4, // GuiTabBar(), tab close request
-}
+RAYGUI_VERSION :: "4.0"
 
 // Gui control state
-GuiState :: enum u32 {
-	NORMAL   = 0,
-	FOCUSED  = 1,
-	PRESSED  = 2,
-	DISABLED = 3,
+GuiState :: enum c.int {
+	STATE_NORMAL = 0,
+	STATE_FOCUSED,
+	STATE_PRESSED,
+	STATE_DISABLED,
 }
 
 // Gui control text alignment
-GuiTextAlignment :: enum u32 {
-	LEFT   = 0,
-	CENTER = 1,
-	RIGHT  = 2,
+GuiTextAlignment :: enum c.int {
+	TEXT_ALIGN_LEFT = 0,
+	TEXT_ALIGN_CENTER,
+	TEXT_ALIGN_RIGHT,
 }
 
-// Gui control text alignment vertical
-// NOTE: Text vertical position inside the text bounds
-GuiTextAlignmentVertical :: enum u32 {
-	TOP    = 0,
-	MIDDLE = 1,
-	BOTTOM = 2,
+GuiTextAlignmentVertical :: enum c.int {
+	TEXT_ALIGN_TOP = 0,
+	TEXT_ALIGN_MIDDLE,
+	TEXT_ALIGN_BOTTOM,
 }
 
-// Gui control text wrap mode
-// NOTE: Useful for multiline text
-GuiTextWrapMode :: enum u32 {
-	NONE = 0,
-	CHAR = 1,
-	WORD = 2,
+GuiTextWrapMode :: enum c.int {
+	TEXT_WRAP_NONE = 0,
+	TEXT_WRAP_CHAR,
+	TEXT_WRAP_WORD,
 }
 
 // Gui controls
-// NOTE: Up to 16 controls supported or 32 controls (v500)
-GuiControl :: enum u32 {
+GuiControl :: enum c.int {
 	// Default -> populates to all controls when set
-	DEFAULT     = 0,
-
+	DEFAULT = 0,
 	// Basic controls
-	LABEL       = 1, // Used also for: LABELBUTTON
-	BUTTON      = 2,
-	TOGGLE      = 3, // Used also for: TOGGLEGROUP
-	SLIDER      = 4, // Used also for: SLIDERBAR, TOGGLESLIDER
-	PROGRESSBAR = 5,
-	CHECKBOX    = 6,
-	COMBOBOX    = 7,
-	DROPDOWNBOX = 8,
-	TEXTBOX     = 9, // Used also for: TEXTBOXMULTI
-	VALUEBOX    = 10,
-	TABBAR      = 11,
-	LISTVIEW    = 12,
-	COLORPICKER = 13,
-	SCROLLBAR   = 14,
-	STATUSBAR   = 15,
+	LABEL,          // Used also for: LABELBUTTON
+	BUTTON,
+	TOGGLE,         // Used also for: TOGGLEGROUP
+	SLIDER,         // Used also for: SLIDERBAR
+	PROGRESSBAR,
+	CHECKBOX,
+	COMBOBOX,
+	DROPDOWNBOX,
+	TEXTBOX,        // Used also for: TEXTBOXMULTI
+	VALUEBOX,
+	SPINNER,        // Uses: BUTTON, VALUEBOX
+	LISTVIEW,
+	COLORPICKER,
+	SCROLLBAR,
+	STATUSBAR,
 }
 
-// Controls BASE properties for every control (RAYGUI_MAX_PROPS_BASE = 16)
-// NOTE: Properties required for all controls, DEFAULT control sets
-// default values for them but they can be overriden per control
-GuiControlProperty :: enum u32 {
-	BORDER_COLOR_NORMAL   = 0,  // Control border color in STATE_NORMAL
-	BASE_COLOR_NORMAL     = 1,  // Control base color in STATE_NORMAL
-	TEXT_COLOR_NORMAL     = 2,  // Control text color in STATE_NORMAL
-	BORDER_COLOR_FOCUSED  = 3,  // Control border color in STATE_FOCUSED
-	BASE_COLOR_FOCUSED    = 4,  // Control base color in STATE_FOCUSED
-	TEXT_COLOR_FOCUSED    = 5,  // Control text color in STATE_FOCUSED
-	BORDER_COLOR_PRESSED  = 6,  // Control border color in STATE_PRESSED
-	BASE_COLOR_PRESSED    = 7,  // Control base color in STATE_PRESSED
-	TEXT_COLOR_PRESSED    = 8,  // Control text color in STATE_PRESSED
-	BORDER_COLOR_DISABLED = 9,  // Control border color in STATE_DISABLED
-	BASE_COLOR_DISABLED   = 10, // Control base color in STATE_DISABLED
-	TEXT_COLOR_DISABLED   = 11, // Control text color in STATE_DISABLED
-	BORDER_WIDTH          = 12, // Control border size, 0 for no border
-	TEXT_PADDING          = 13, // Control text padding, not considering border
-	TEXT_ALIGNMENT        = 14, // Control text horizontal alignment inside control text bound (after border and padding): 0-Left, 1-Center, 2-Right
-	BASEPROP16            = 15, // Not used yet...
+// Gui base properties for every control
+// NOTE: RAYGUI_MAX_PROPS_BASE properties (by default 16 properties)
+GuiControlProperty :: enum c.int {
+	BORDER_COLOR_NORMAL = 0,
+	BASE_COLOR_NORMAL,
+	TEXT_COLOR_NORMAL,
+	BORDER_COLOR_FOCUSED,
+	BASE_COLOR_FOCUSED,
+	TEXT_COLOR_FOCUSED,
+	BORDER_COLOR_PRESSED,
+	BASE_COLOR_PRESSED,
+	TEXT_COLOR_PRESSED,
+	BORDER_COLOR_DISABLED,
+	BASE_COLOR_DISABLED,
+	TEXT_COLOR_DISABLED,
+	BORDER_WIDTH,
+	TEXT_PADDING,
+	TEXT_ALIGNMENT,
+	RESERVED,
 }
 
-// Controls EXTENDED properties (RAYGUI_MAX_PROPS_EXTENDED = 8)
-// WARNING: Only 8 slots vailable for those properties per control, including DEFAULT
+// Gui extended properties depend on control
+// NOTE: RAYGUI_MAX_PROPS_EXTENDED properties (by default, max 8 properties)
 //----------------------------------------------------------------------------------
-// DEFAULT control, extended properties
-// NOTE: Those properties are global for all controls, they can not be setup per control
-GuiDefaultProperty :: enum u32 {
-	TEXT_SIZE               = 16, // Text size (glyphs max height)
-	TEXT_SPACING            = 17, // Text spacing between glyphs
-	LINE_COLOR              = 18, // Line control color
-	BACKGROUND_COLOR        = 19, // Background color
-	TEXT_LINE_SPACING       = 20, // Text spacing between lines
-	TEXT_ALIGNMENT_VERTICAL = 21, // Text vertical alignment inside text bounds (after border and padding): 0-Top, 1-Middle, 2-Bottom
-	TEXT_WRAP_MODE          = 22, // Text wrap-mode inside text bounds
-	EXTPROP08               = 23, // Not used yet...
+
+// DEFAULT extended properties
+// NOTE: Those properties are common to all controls or global
+GuiDefaultProperty :: enum c.int {
+	TEXT_SIZE = 16,             // Text size (glyphs max height)
+	TEXT_SPACING,               // Text spacing between glyphs
+	LINE_COLOR,                 // Line control color
+	BACKGROUND_COLOR,           // Background color
+	TEXT_LINE_SPACING,          // Text spacing between lines
+	TEXT_ALIGNMENT_VERTICAL,    // Text vertical alignment inside text bounds (after border and padding)
+	TEXT_WRAP_MODE,             // Text wrap-mode inside text bounds
 }
 
+// Label
+//GuiLabelProperty :: enum c.int { }
+
+// Button/Spinner
+//GuiButtonProperty :: enum c.int { }
+
 // Toggle/ToggleGroup
-GuiToggleProperty :: enum u32 {
-	PADDING    = 16, // ToggleGroup separation between toggles
-	WIDTH_FULL = 17, // ToggleGroup bounds width considers all items: 0-Width per item, 1-Full width
+GuiToggleProperty :: enum c.int {
+	GROUP_PADDING = 16,         // ToggleGroup separation between toggles
 }
 
 // Slider/SliderBar
-GuiSliderProperty :: enum u32 {
-	WIDTH   = 16, // Slider size of internal bar
-	PADDING = 17, // Slider/SliderBar internal bar padding
+GuiSliderProperty :: enum c.int {
+	SLIDER_WIDTH = 16,          // Slider size of internal bar
+	SLIDER_PADDING,             // Slider/SliderBar internal bar padding
 }
 
 // ProgressBar
-GuiProgressBarProperty :: enum u32 {
-	PADDING = 16, // ProgressBar internal padding
-	SIDE    = 17, // ProgressBar increment side: 0-Left->Right, 1-Right->Left
+GuiProgressBarProperty :: enum c.int {
+	PROGRESS_PADDING = 16,      // ProgressBar internal padding
 }
 
 // ScrollBar
-GuiScrollBarProperty :: enum u32 {
-	ARROWS_SIZE           = 16, // ScrollBar arrows size
-	ARROWS_VISIBLE        = 17, // ScrollBar arrows visible
-	SCROLL_SLIDER_PADDING = 18, // ScrollBar slider internal padding
-	SCROLL_SLIDER_SIZE    = 19, // ScrollBar slider size
-	SCROLL_PADDING        = 20, // ScrollBar scroll padding from arrows
-	SCROLL_SPEED          = 21, // ScrollBar scrolling speed
+GuiScrollBarProperty :: enum c.int {
+	ARROWS_SIZE = 16,
+	ARROWS_VISIBLE,
+	SCROLL_SLIDER_PADDING,      // (SLIDERBAR, SLIDER_PADDING)
+	SCROLL_SLIDER_SIZE,
+	SCROLL_PADDING,
+	SCROLL_SPEED,
 }
 
 // CheckBox
-GuiCheckBoxProperty :: enum u32 {
-	CHECK_PADDING = 16, // CheckBox internal check padding
+GuiCheckBoxProperty :: enum c.int {
+	CHECK_PADDING = 16,          // CheckBox internal check padding
 }
 
 // ComboBox
-GuiComboBoxProperty :: enum u32 {
-	WIDTH   = 16, // ComboBox right button width
-	SPACING = 17, // ComboBox button separation
+GuiComboBoxProperty :: enum c.int {
+	COMBO_BUTTON_WIDTH = 16,    // ComboBox right button width
+	COMBO_BUTTON_SPACING,       // ComboBox button separation
 }
 
 // DropdownBox
-GuiDropdownBoxProperty :: enum u32 {
-	ARROW_PADDING          = 16, // DropdownBox arrow separation from border and items
-	DROPDOWN_ITEMS_SPACING = 17, // DropdownBox items separation
-	DROPDOWN_ARROW_HIDDEN  = 18, // DropdownBox arrow hidden
-	DROPDOWN_ROLL_UP       = 19, // DropdownBox roll up flag: 0-Roll down, 1-Roll up
+GuiDropdownBoxProperty :: enum c.int {
+	ARROW_PADDING = 16,         // DropdownBox arrow separation from border and items
+	DROPDOWN_ITEMS_SPACING,     // DropdownBox items separation
 }
 
 // TextBox/TextBoxMulti/ValueBox/Spinner
-GuiTextBoxProperty :: enum u32 {
-	TEXT_READONLY = 16, // TextBox in read-only mode: 0-Text editable, 1-Text read-only
+GuiTextBoxProperty :: enum c.int {
+	TEXT_READONLY = 16,         // TextBox in read-only mode: 0-text editable, 1-text no-editable
 }
 
-// ValueBox/Spinner
-GuiValueBoxProperty :: enum u32 {
-	WIDTH   = 16, // Spinner left/right buttons width
-	SPACING = 17, // Spinner buttons separation
-}
-
-// TabBar
-GuiTabBarProperty :: enum u32 {
-	ITEMS_WIDTH  = 16, // TabBar tab items width
-	CLOSE_BUTTON = 17, // TabBar tab close button: 0-Not shown, 1-Shown
-	LINE_SIDE    = 18, // TabBar tabs side: 0-Bottom, 1-Top
+// Spinner
+GuiSpinnerProperty :: enum c.int {
+	SPIN_BUTTON_WIDTH = 16,     // Spinner left/right buttons width
+	SPIN_BUTTON_SPACING,        // Spinner buttons separation
 }
 
 // ListView
-SCROLLBAR_LEFT_SIDE     :: 0
-SCROLLBAR_RIGHT_SIDE    :: 1
-
-GuiListViewProperty :: enum u32 {
-	LIST_ITEMS_HEIGHT        = 16, // ListView items height
-	LIST_ITEMS_SPACING       = 17, // ListView items separation
-	SCROLLBAR_WIDTH          = 18, // ListView scrollbar size (usually width)
-	SCROLLBAR_SIDE           = 19, // ListView scrollbar side: 0-Left side, 1-Right Side
-	LIST_ITEMS_BORDER_NORMAL = 20, // ListView items border enabled in normal state
-	LIST_ITEMS_BORDER_WIDTH  = 21, // ListView items border width
+GuiListViewProperty :: enum c.int {
+	LIST_ITEMS_HEIGHT = 16,     // ListView items height
+	LIST_ITEMS_SPACING,         // ListView items separation
+	SCROLLBAR_WIDTH,            // ListView scrollbar size (usually width)
+	SCROLLBAR_SIDE,             // ListView scrollbar side (0-left, 1-right)
 }
 
 // ColorPicker
-GuiColorPickerProperty :: enum u32 {
-	COLOR_SELECTOR_SIZE      = 16, // ColorPicker selector square size
-	HUEBAR_WIDTH             = 17, // ColorPicker right hue bar width
-	HUEBAR_PADDING           = 18, // ColorPicker right hue bar separation from panel
-	HUEBAR_SELECTOR_HEIGHT   = 19, // ColorPicker right hue bar selector height
-	HUEBAR_SELECTOR_OVERFLOW = 20, // ColorPicker right hue bar selector overflow
+GuiColorPickerProperty :: enum c.int {
+	COLOR_SELECTOR_SIZE = 16,
+	HUEBAR_WIDTH,               // ColorPicker right hue bar width
+	HUEBAR_PADDING,             // ColorPicker right hue bar separation from panel
+	HUEBAR_SELECTOR_HEIGHT,     // ColorPicker right hue bar selector height
+	HUEBAR_SELECTOR_OVERFLOW,   // ColorPicker right hue bar selector overflow
 }
 
+SCROLLBAR_LEFT_SIDE  :: 0
+SCROLLBAR_RIGHT_SIDE :: 1
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+// ...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+
 @(default_calling_convention="c")
 foreign lib {
+	// WASM does not have foreign variable declarations.
+	when ODIN_ARCH != .wasm32 && ODIN_ARCH != .wasm64p32 {
+		@(link_name="raylib_version") version: cstring
+	}
 	// Global gui state control functions
-	GuiEnable   :: proc() ---           // Enable gui controls (global state)
-	GuiDisable  :: proc() ---           // Disable gui controls (global state)
-	GuiLock     :: proc() ---           // Lock gui controls (global state)
-	GuiUnlock   :: proc() ---           // Unlock gui controls (global state)
-	GuiIsLocked :: proc() -> bool ---   // Check if gui is locked (global state)
-	GuiSetAlpha :: proc(alpha: f32) --- // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
-	GuiSetState :: proc(state: i32) --- // Set gui state (global state)
-	GuiGetState :: proc() -> i32 ---    // Get gui state (global state)
+
+	GuiEnable           :: proc() ---                                                                         // Enable gui controls (global state)
+	GuiLock             :: proc() ---                                                                         // Lock gui controls (global state)
+	GuiDisable          :: proc() ---                                                                         // Disable gui controls (global state)
+	GuiUnlock           :: proc() ---                                                                         // Unlock gui controls (global state)
+	GuiIsLocked         :: proc() -> bool ---                                                                 // Check if gui is locked (global state)
+	GuiSetAlpha         :: proc(alpha: f32) ---                                                               // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
+	GuiSetState         :: proc(state: c.int) ---                                                             // Set gui state (global state)
+	GuiGetState         :: proc() -> c.int ---                                                                // Get gui state (global state)
 
 	// Font set/get functions
-	GuiSetFont :: proc(font: Font) --- // Set gui custom font (global state)
-	GuiGetFont :: proc() -> Font ---   // Get gui custom font (global state)
+
+	GuiSetFont          :: proc(font: Font) ---                                                               // Set gui custom font (global state)
+	GuiGetFont          :: proc() -> Font ---                                                                 // Get gui custom font (global state)
 
 	// Style set/get functions
-	GuiSetStyle :: proc(control: GuiControl, property: i32, value: i32) --- // Set one style property
-	GuiGetStyle :: proc(control: GuiControl, property: i32) -> i32 ---      // Get one style property
+
+	GuiSetStyle         :: proc(control: GuiControl, property: c.int, value: c.int) ---          // Set one style property
+	GuiGetStyle         :: proc(control: GuiControl, property: c.int) -> c.int ---               // Get one style property
 
 	// Styles loading functions
-	GuiLoadStyle           :: proc(fileName: cstring) ---            // Load style file over global style variable (.rgs)
-	GuiLoadStyleFromMemory :: proc(fileData: ^u8, dataSize: i32) --- // Load style from memory (binary only)
-	GuiLoadStyleDefault    :: proc() ---                             // Load style default over global style
+
+	GuiLoadStyle        :: proc(fileName: cstring) ---                                                        // Load style file over global style variable (.rgs)
+	GuiLoadStyleDefault :: proc() ---                                                                         // Load style default over global style
 
 	// Tooltips management functions
-	GuiEnableTooltip  :: proc() ---                 // Enable gui tooltips (global state)
-	GuiDisableTooltip :: proc() ---                 // Disable gui tooltips (global state)
-	GuiSetTooltip     :: proc(tooltip: cstring) --- // Set tooltip string
+
+	GuiEnableTooltip    :: proc() ---                                                                         // Enable gui tooltips (global state)
+	GuiDisableTooltip   :: proc() ---                                                                         // Disable gui tooltips (global state)
+	GuiSetTooltip       :: proc(tooltip: cstring) ---                                                         // Set tooltip string
 
 	// Icons functionality
-	GuiIconText            :: proc(iconId: i32, text: cstring) -> cstring ---              // Get text with icon id prepended (if supported)
-	GuiSetIconScale        :: proc(scale: i32) ---                                         // Set default icon drawing size
-	GuiGetIcons            :: proc() -> ^u32 ---                                           // Get raygui icons data pointer
-	GuiLoadIcons           :: proc(fileName: cstring, loadIconsName: bool) -> ^cstring --- // Load raygui icons file (.rgi) into internal icons data
-	GuiLoadIconsFromMemory :: proc(fileData: ^u8, dataSize: i32, loadIconsName: bool) -> ^cstring --- // Load raygui icons file (.rgi) from memory into internal icons data
-	GuiDrawIcon            :: proc(iconId: i32, posX: i32, posY: i32, pixelSize: i32, color: Color) --- // Draw icon using pixel size at specified position
 
-	// Utility functions
-	GuiGetTextWidth :: proc(text: cstring) -> i32 --- // Get text width considering gui style and icon size (if required)
+	GuiIconText         :: proc(iconId: GuiIconName, text: cstring) -> cstring ---                            // Get text with icon id prepended (if supported)
+	GuiSetIconScale     :: proc(scale: c.int) ---                                                             // Set default icon drawing size
+	GuiGetIcons         :: proc() -> [^]u32 ---                                                               // Get raygui icons data pointer
+	GuiLoadIcons        :: proc(fileName: cstring, loadIconsName: bool) -> [^]cstring ---                     // Load raygui icons file (.rgi) into internal icons data
+	GuiDrawIcon         :: proc(iconId: GuiIconName, posX, posY: c.int, pixelSize: c.int, color: Color) ---   // Draw icon using pixel size at specified position
+
 
 	// Controls
 	//----------------------------------------------------------------------------------------------------------
 	// Container/separator controls, useful for controls organization
-	GuiWindowBox   :: proc(bounds: Rectangle, title: cstring) -> i32 --- // Window Box control, shows a window that can be closed
-	GuiGroupBox    :: proc(bounds: Rectangle, text: cstring) -> i32 ---  // Group Box control with text name
-	GuiLine        :: proc(bounds: Rectangle, text: cstring) -> i32 ---  // Line separator control, could contain text
-	GuiPanel       :: proc(bounds: Rectangle, text: cstring) -> i32 ---  // Panel control, useful to group controls
-	GuiScrollPanel :: proc(bounds: Rectangle, text: cstring, content: Rectangle, scroll: ^Vector2, view: ^Rectangle) -> i32 --- // Scroll Panel control
+
+	GuiWindowBox        :: proc(bounds: Rectangle, title: cstring) -> c.int ---                               // Window Box control, shows a window that can be closed
+	GuiGroupBox         :: proc(bounds: Rectangle, text: cstring) -> c.int ---                                // Group Box control with text name
+	GuiLine             :: proc(bounds: Rectangle, text: cstring) -> c.int ---                                // Line separator control, could contain text
+	GuiPanel            :: proc(bounds: Rectangle, text: cstring) -> c.int ---                                // Panel control, useful to group controls
+	GuiTabBar           :: proc(bounds: Rectangle, text: [^]cstring, count: c.int, active: ^c.int) -> c.int --- // Tab Bar control, returns TAB to be closed or -1
+	GuiScrollPanel      :: proc(bounds: Rectangle, text: cstring, content: Rectangle, scroll: ^Vector2, view: ^Rectangle) -> c.int --- // Scroll Panel control
 
 	// Basic controls set
-	GuiLabel         :: proc(bounds: Rectangle, text: cstring) -> i32 ---                 // Label control
-	GuiButton        :: proc(bounds: Rectangle, text: cstring) -> i32 ---                 // Button control, returns true when clicked
-	GuiLabelButton   :: proc(bounds: Rectangle, text: cstring) -> i32 ---                 // Label button control, returns true when clicked
-	GuiToggle        :: proc(bounds: Rectangle, text: cstring, active: ^bool) -> i32 ---  // Toggle Button control
-	GuiToggleGroup   :: proc(bounds: Rectangle, text: cstring, active: ^i32) -> i32 ---   // Toggle Group control
-	GuiToggleSlider  :: proc(bounds: Rectangle, text: cstring, active: ^i32) -> i32 ---   // Toggle Slider control
-	GuiCheckBox      :: proc(bounds: Rectangle, text: cstring, checked: ^bool) -> i32 --- // Check Box control, returns true when active
-	GuiComboBox      :: proc(bounds: Rectangle, text: cstring, active: ^i32) -> i32 ---   // Combo Box control
-	GuiDropdownBox   :: proc(bounds: Rectangle, text: cstring, active: ^i32, editMode: bool) -> i32 --- // Dropdown Box control
-	GuiSpinner       :: proc(bounds: Rectangle, text: cstring, value: ^i32, minValue: i32, maxValue: i32, editMode: bool) -> i32 --- // Spinner control
-	GuiValueBox      :: proc(bounds: Rectangle, text: cstring, value: ^i32, minValue: i32, maxValue: i32, editMode: bool) -> i32 --- // Value Box control, updates input text with numbers
-	GuiValueBoxFloat :: proc(bounds: Rectangle, text: cstring, textValue: cstring, value: ^f32, editMode: bool) -> i32 --- // Value box control for float values
-	GuiTextBox       :: proc(bounds: Rectangle, text: cstring, textSize: i32, editMode: bool) -> i32 --- // Text Box control, updates input text
-	GuiSlider        :: proc(bounds: Rectangle, textLeft: cstring, textRight: cstring, value: ^f32, minValue: f32, maxValue: f32) -> i32 --- // Slider control
-	GuiSliderBar     :: proc(bounds: Rectangle, textLeft: cstring, textRight: cstring, value: ^f32, minValue: f32, maxValue: f32) -> i32 --- // Slider Bar control
-	GuiProgressBar   :: proc(bounds: Rectangle, textLeft: cstring, textRight: cstring, value: ^f32, minValue: f32, maxValue: f32) -> i32 --- // Progress Bar control
-	GuiStatusBar     :: proc(bounds: Rectangle, text: cstring) -> i32 ---                 // Status Bar control, shows info text
-	GuiDummyRec      :: proc(bounds: Rectangle, text: cstring) -> i32 ---                 // Dummy control for placeholders
-	GuiGrid          :: proc(bounds: Rectangle, text: cstring, spacing: f32, subdivs: i32, mouseCell: ^Vector2) -> i32 --- // Grid control
+
+	GuiLabel            :: proc(bounds: Rectangle, text: cstring) -> c.int ---                                // Label control, shows text
+	GuiButton           :: proc(bounds: Rectangle, text: cstring) -> bool ---                                 // Button control, returns true when clicked
+	GuiLabelButton      :: proc(bounds: Rectangle, text: cstring) -> bool ---                                 // Label button control, show true when clicked
+	GuiToggle           :: proc(bounds: Rectangle, text: cstring, active: ^bool) -> c.int ---                 // Toggle Button control, returns true when active
+	GuiToggleGroup      :: proc(bounds: Rectangle, text: cstring, active: ^c.int) -> c.int ---                // Toggle Group control, returns active toggle index
+	GuiToggleSlider     :: proc(bounds: Rectangle, text: cstring, active: ^c.int) -> c.int ---
+	GuiCheckBox         :: proc(bounds: Rectangle, text: cstring, checked: ^bool) -> bool ---                 // Check Box control, returns true when active
+	GuiComboBox         :: proc(bounds: Rectangle, text: cstring, active: ^c.int) -> c.int ---                // Combo Box control, returns selected item index
+
+	GuiDropdownBox      :: proc(bounds: Rectangle, text: cstring, active: ^c.int, editMode: bool) -> bool --- // Dropdown Box control, returns selected item
+	GuiSpinner          :: proc(bounds: Rectangle, text: cstring, value: ^c.int, minValue, maxValue: c.int, editMode: bool) -> c.int --- // Spinner control, returns selected value
+	GuiValueBox         :: proc(bounds: Rectangle, text: cstring, value: ^c.int, minValue, maxValue: c.int, editMode: bool) -> c.int --- // Value Box control, updates input text with numbers
+	GuiValueBoxFloat    :: proc(bounds: Rectangle, text: cstring, text_value: cstring, value: ^c.float, editMode: bool) -> c.int --- // Value box control for float values
+	GuiTextBox          :: proc(bounds: Rectangle, text: cstring, textSize: c.int, editMode: bool) -> bool --- // Text Box control, updates input text
+
+	GuiSlider           :: proc(bounds: Rectangle, textLeft: cstring, textRight: cstring, value: ^f32, minValue: f32, maxValue: f32) -> c.int --- // Slider control, returns selected value
+	GuiSliderBar        :: proc(bounds: Rectangle, textLeft: cstring, textRight: cstring, value: ^f32, minValue: f32, maxValue: f32) -> c.int --- // Slider Bar control, returns selected value
+	GuiProgressBar      :: proc(bounds: Rectangle, textLeft: cstring, textRight: cstring, value: ^f32, minValue: f32, maxValue: f32) -> c.int --- // Progress Bar control, shows current progress value
+	GuiStatusBar        :: proc(bounds: Rectangle, text: cstring) -> c.int ---                                // Status Bar control, shows info text
+	GuiDummyRec         :: proc(bounds: Rectangle, text: cstring) -> c.int ---                                // Dummy control for placeholders
+	GuiGrid             :: proc(bounds: Rectangle, text: cstring, spacing: f32, subdivs: c.int, mouseCell: ^Vector2) -> c.int --- // Grid control, returns mouse cell position
 
 	// Advance controls set
-	GuiListView       :: proc(bounds: Rectangle, text: cstring, scrollIndex: ^i32, active: ^i32) -> i32 --- // List View control
-	GuiListViewEx     :: proc(bounds: Rectangle, text: ^cstring, count: i32, scrollIndex: ^i32, active: ^i32, focus: ^i32) -> i32 --- // List View control, using text entries list and returning focus entry
-	GuiTabBar         :: proc(bounds: Rectangle, text: cstring, hscroll: ^i32, active: ^i32) -> i32 --- // Tab Bar control
-	GuiTabBarEx       :: proc(bounds: Rectangle, text: ^cstring, count: i32, hscroll: ^i32, active: ^i32, focus: ^i32) -> i32 --- // Tab Bar control, using text entries list and returning focus entry
-	GuiMessageBox     :: proc(bounds: Rectangle, title: cstring, message: cstring, btnText: cstring, btnActive: ^i32) -> i32 --- // Message Box control, displays a message
-	GuiTextInputBox   :: proc(bounds: Rectangle, title: cstring, message: cstring, text: cstring, textSize: i32, btnText: cstring, btnActive: ^i32, secretViewActive: ^bool) -> i32 --- // Text Input Box control, ask for text, supports secret
-	GuiColorPicker    :: proc(bounds: Rectangle, text: cstring, color: ^Color) -> i32 --- // Color Picker control, includes Color bar controls
-	GuiColorPanel     :: proc(bounds: Rectangle, text: cstring, color: ^Color) -> i32 --- // Color Panel control
-	GuiColorBarAlpha  :: proc(bounds: Rectangle, text: cstring, alpha: ^f32) -> i32 ---   // Color Bar Alpha control
-	GuiColorBarHue    :: proc(bounds: Rectangle, text: cstring, value: ^f32) -> i32 ---   // Color Bar Hue control
-	GuiColorPickerHSV :: proc(bounds: Rectangle, text: cstring, colorHsv: ^Vector3) -> i32 --- // Color Picker control, using Hue-Saturation-Value color data, includes Color bar controls
-	GuiColorPanelHSV  :: proc(bounds: Rectangle, text: cstring, colorHsv: ^Vector3) -> i32 --- // Color Panel control, using Hue-Saturation-Value color data
+	GuiListView         :: proc(bounds: Rectangle, text: cstring, scrollIndex: ^c.int, active: ^c.int) -> c.int --- // List View control, returns selected list item index
+	GuiListViewEx       :: proc(bounds: Rectangle, text:[^]cstring, count: c.int, scrollIndex: ^c.int, active: ^c.int, focus: ^c.int) -> c.int --- // List View with extended parameters
+	GuiMessageBox       :: proc(bounds: Rectangle, title: cstring, message: cstring, buttons: cstring, active: ^c.int) -> c.int --- // Message Box control, displays a message
+	GuiTextInputBox     :: proc(bounds: Rectangle, title: cstring, message: cstring, buttons: cstring, text: cstring, textMaxSize: c.int, secretViewActive: ^bool) -> c.int --- // Text Input Box control, ask for text, supports secret
+	GuiColorPicker      :: proc(bounds: Rectangle, text: cstring, color: ^Color) -> c.int ---                 // Color Picker control (multiple color controls)
+	GuiColorPanel       :: proc(bounds: Rectangle, text: cstring, color: ^Color) -> c.int ---                 // Color Panel control
+	GuiColorBarAlpha    :: proc(bounds: Rectangle, text: cstring, alpha: ^f32) -> c.int ---                   // Color Bar Alpha control
+	GuiColorBarHue      :: proc(bounds: Rectangle, text: cstring, value: ^f32) -> c.int ---                   // Color Bar Hue control
+	GuiColorPickerHSV   :: proc(bounds: Rectangle, text: cstring, colorHsv: ^Vector3) -> c.int ---            // Color Picker control that avoids conversion to RGB on each call (multiple color controls)
+	GuiColorPanelHSV    :: proc(bounds: Rectangle, text: cstring, colorHsv: ^Vector3) -> c.int ---            // Color Panel control that returns HSV color value, used by GuiColorPickerHSV()
+	//----------------------------------------------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------------------
 // Icons enumeration
 //----------------------------------------------------------------------------------
-GuiIconName :: enum u32 {
-	NONE                    = 0,
-	FOLDER_FILE_OPEN        = 1,
-	FILE_SAVE_CLASSIC       = 2,
-	FOLDER_OPEN             = 3,
-	FOLDER_SAVE             = 4,
-	FILE_OPEN               = 5,
-	FILE_SAVE               = 6,
-	FILE_EXPORT             = 7,
-	FILE_ADD                = 8,
-	FILE_DELETE             = 9,
-	FILETYPE_TEXT           = 10,
-	FILETYPE_AUDIO          = 11,
-	FILETYPE_IMAGE          = 12,
-	FILETYPE_PLAY           = 13,
-	FILETYPE_VIDEO          = 14,
-	FILETYPE_INFO           = 15,
-	FILE_COPY               = 16,
-	FILE_CUT                = 17,
-	FILE_PASTE              = 18,
-	CURSOR_HAND             = 19,
-	CURSOR_POINTER          = 20,
-	CURSOR_CLASSIC          = 21,
-	PENCIL                  = 22,
-	PENCIL_BIG              = 23,
-	BRUSH_CLASSIC           = 24,
-	BRUSH_PAINTER           = 25,
-	WATER_DROP              = 26,
-	COLOR_PICKER            = 27,
-	RUBBER                  = 28,
-	COLOR_BUCKET            = 29,
-	TEXT_T                  = 30,
-	TEXT_A                  = 31,
-	SCALE                   = 32,
-	RESIZE                  = 33,
-	FILTER_POINT            = 34,
-	FILTER_BILINEAR         = 35,
-	CROP                    = 36,
-	CROP_ALPHA              = 37,
-	SQUARE_TOGGLE           = 38,
-	SYMMETRY                = 39,
-	SYMMETRY_HORIZONTAL     = 40,
-	SYMMETRY_VERTICAL       = 41,
-	LENS                    = 42,
-	LENS_BIG                = 43,
-	EYE_ON                  = 44,
-	EYE_OFF                 = 45,
-	FILTER_TOP              = 46,
-	FILTER                  = 47,
-	TARGET_POINT            = 48,
-	TARGET_SMALL            = 49,
-	TARGET_BIG              = 50,
-	TARGET_MOVE             = 51,
-	CURSOR_MOVE             = 52,
-	CURSOR_SCALE            = 53,
-	CURSOR_SCALE_RIGHT      = 54,
-	CURSOR_SCALE_LEFT       = 55,
-	UNDO                    = 56,
-	REDO                    = 57,
-	REREDO                  = 58,
-	MUTATE                  = 59,
-	ROTATE                  = 60,
-	REPEAT                  = 61,
-	SHUFFLE                 = 62,
-	EMPTYBOX                = 63,
-	TARGET                  = 64,
-	TARGET_SMALL_FILL       = 65,
-	TARGET_BIG_FILL         = 66,
-	TARGET_MOVE_FILL        = 67,
-	CURSOR_MOVE_FILL        = 68,
-	CURSOR_SCALE_FILL       = 69,
-	CURSOR_SCALE_RIGHT_FILL = 70,
-	CURSOR_SCALE_LEFT_FILL  = 71,
-	UNDO_FILL               = 72,
-	REDO_FILL               = 73,
-	REREDO_FILL             = 74,
-	MUTATE_FILL             = 75,
-	ROTATE_FILL             = 76,
-	REPEAT_FILL             = 77,
-	SHUFFLE_FILL            = 78,
-	EMPTYBOX_SMALL          = 79,
-	BOX                     = 80,
-	BOX_TOP                 = 81,
-	BOX_TOP_RIGHT           = 82,
-	BOX_RIGHT               = 83,
-	BOX_BOTTOM_RIGHT        = 84,
-	BOX_BOTTOM              = 85,
-	BOX_BOTTOM_LEFT         = 86,
-	BOX_LEFT                = 87,
-	BOX_TOP_LEFT            = 88,
-	BOX_CENTER              = 89,
-	BOX_CIRCLE_MASK         = 90,
-	POT                     = 91,
-	ALPHA_MULTIPLY          = 92,
-	ALPHA_CLEAR             = 93,
-	DITHERING               = 94,
-	MIPMAPS                 = 95,
-	BOX_GRID                = 96,
-	GRID                    = 97,
-	BOX_CORNERS_SMALL       = 98,
-	BOX_CORNERS_BIG         = 99,
-	FOUR_BOXES              = 100,
-	GRID_FILL               = 101,
-	BOX_MULTISIZE           = 102,
-	ZOOM_SMALL              = 103,
-	ZOOM_MEDIUM             = 104,
-	ZOOM_BIG                = 105,
-	ZOOM_ALL                = 106,
-	ZOOM_CENTER             = 107,
-	BOX_DOTS_SMALL          = 108,
-	BOX_DOTS_BIG            = 109,
-	BOX_CONCENTRIC          = 110,
-	BOX_GRID_BIG            = 111,
-	OK_TICK                 = 112,
-	CROSS                   = 113,
-	ARROW_LEFT              = 114,
-	ARROW_RIGHT             = 115,
-	ARROW_DOWN              = 116,
-	ARROW_UP                = 117,
-	ARROW_LEFT_FILL         = 118,
-	ARROW_RIGHT_FILL        = 119,
-	ARROW_DOWN_FILL         = 120,
-	ARROW_UP_FILL           = 121,
-	AUDIO                   = 122,
-	FX                      = 123,
-	WAVE                    = 124,
-	WAVE_SINUS              = 125,
-	WAVE_SQUARE             = 126,
-	WAVE_TRIANGULAR         = 127,
-	CROSS_SMALL             = 128,
-	PLAYER_PREVIOUS         = 129,
-	PLAYER_PLAY_BACK        = 130,
-	PLAYER_PLAY             = 131,
-	PLAYER_PAUSE            = 132,
-	PLAYER_STOP             = 133,
-	PLAYER_NEXT             = 134,
-	PLAYER_RECORD           = 135,
-	MAGNET                  = 136,
-	LOCK_CLOSE              = 137,
-	LOCK_OPEN               = 138,
-	CLOCK                   = 139,
-	TOOLS                   = 140,
-	GEAR                    = 141,
-	GEAR_BIG                = 142,
-	BIN                     = 143,
-	HAND_POINTER            = 144,
-	LASER                   = 145,
-	COIN                    = 146,
-	EXPLOSION               = 147,
-	_1UP                    = 148,
-	PLAYER                  = 149,
-	PLAYER_JUMP             = 150,
-	KEY                     = 151,
-	DEMON                   = 152,
-	TEXT_POPUP              = 153,
-	GEAR_EX                 = 154,
-	CRACK                   = 155,
-	CRACK_POINTS            = 156,
-	STAR                    = 157,
-	DOOR                    = 158,
-	EXIT                    = 159,
-	MODE_2D                 = 160,
-	MODE_3D                 = 161,
-	CUBE                    = 162,
-	CUBE_FACE_TOP           = 163,
-	CUBE_FACE_LEFT          = 164,
-	CUBE_FACE_FRONT         = 165,
-	CUBE_FACE_BOTTOM        = 166,
-	CUBE_FACE_RIGHT         = 167,
-	CUBE_FACE_BACK          = 168,
-	CAMERA                  = 169,
-	SPECIAL                 = 170,
-	LINK_NET                = 171,
-	LINK_BOXES              = 172,
-	LINK_MULTI              = 173,
-	LINK                    = 174,
-	LINK_BROKE              = 175,
-	TEXT_NOTES              = 176,
-	NOTEBOOK                = 177,
-	SUITCASE                = 178,
-	SUITCASE_ZIP            = 179,
-	MAILBOX                 = 180,
-	MONITOR                 = 181,
-	PRINTER                 = 182,
-	PHOTO_CAMERA            = 183,
-	PHOTO_CAMERA_FLASH      = 184,
-	HOUSE                   = 185,
-	HEART                   = 186,
-	CORNER                  = 187,
-	VERTICAL_BARS           = 188,
-	VERTICAL_BARS_FILL      = 189,
-	LIFE_BARS               = 190,
-	INFO                    = 191,
-	CROSSLINE               = 192,
-	HELP                    = 193,
-	FILETYPE_ALPHA          = 194,
-	FILETYPE_HOME           = 195,
-	LAYERS_VISIBLE          = 196,
-	LAYERS                  = 197,
-	WINDOW                  = 198,
-	HIDPI                   = 199,
-	FILETYPE_BINARY         = 200,
-	HEX                     = 201,
-	SHIELD                  = 202,
-	FILE_NEW                = 203,
-	FOLDER_ADD              = 204,
-	ALARM                   = 205,
-	CPU                     = 206,
-	ROM                     = 207,
-	STEP_OVER               = 208,
-	STEP_INTO               = 209,
-	STEP_OUT                = 210,
-	RESTART                 = 211,
-	BREAKPOINT_ON           = 212,
-	BREAKPOINT_OFF          = 213,
-	BURGER_MENU             = 214,
-	CASE_SENSITIVE          = 215,
-	REG_EXP                 = 216,
-	FOLDER                  = 217,
-	FILE                    = 218,
-	SAND_TIMER              = 219,
-	WARNING                 = 220,
-	HELP_BOX                = 221,
-	INFO_BOX                = 222,
-	PRIORITY                = 223,
-	LAYERS_ISO              = 224,
-	LAYERS2                 = 225,
-	MLAYERS                 = 226,
-	MAPS                    = 227,
-	HOT                     = 228,
-	LABEL                   = 229,
-	NAME_ID                 = 230,
-	SLICING                 = 231,
-	MANUAL_CONTROL          = 232,
-	COLLISION               = 233,
-	CIRCLE_ADD              = 234,
-	CIRCLE_ADD_FILL         = 235,
-	CIRCLE_WARNING          = 236,
-	CIRCLE_WARNING_FILL     = 237,
-	BOX_MORE                = 238,
-	BOX_MORE_FILL           = 239,
-	BOX_MINUS               = 240,
-	BOX_MINUS_FILL          = 241,
-	UNION                   = 242,
-	INTERSECTION            = 243,
-	DIFFERENCE              = 244,
-	SPHERE                  = 245,
-	CYLINDER                = 246,
-	CONE                    = 247,
-	ELLIPSOID               = 248,
-	CAPSULE                 = 249,
-	FILETYPE_FONT           = 250,
-	FILETYPE_3D             = 251,
-	FILETYPE_CODE_XML       = 252,
-	FILETYPE_CODE_C         = 253,
-	FILETYPE_CODE_PYTHON    = 254,
-	FILETYPE_CODE_JS        = 255,
-	FILETYPE_ICON           = 256,
+GuiIconName :: enum c.int {
+	ICON_NONE                     = 0,
+	ICON_FOLDER_FILE_OPEN         = 1,
+	ICON_FILE_SAVE_CLASSIC        = 2,
+	ICON_FOLDER_OPEN              = 3,
+	ICON_FOLDER_SAVE              = 4,
+	ICON_FILE_OPEN                = 5,
+	ICON_FILE_SAVE                = 6,
+	ICON_FILE_EXPORT              = 7,
+	ICON_FILE_ADD                 = 8,
+	ICON_FILE_DELETE              = 9,
+	ICON_FILETYPE_TEXT            = 10,
+	ICON_FILETYPE_AUDIO           = 11,
+	ICON_FILETYPE_IMAGE           = 12,
+	ICON_FILETYPE_PLAY            = 13,
+	ICON_FILETYPE_VIDEO           = 14,
+	ICON_FILETYPE_INFO            = 15,
+	ICON_FILE_COPY                = 16,
+	ICON_FILE_CUT                 = 17,
+	ICON_FILE_PASTE               = 18,
+	ICON_CURSOR_HAND              = 19,
+	ICON_CURSOR_POINTER           = 20,
+	ICON_CURSOR_CLASSIC           = 21,
+	ICON_PENCIL                   = 22,
+	ICON_PENCIL_BIG               = 23,
+	ICON_BRUSH_CLASSIC            = 24,
+	ICON_BRUSH_PAINTER            = 25,
+	ICON_WATER_DROP               = 26,
+	ICON_COLOR_PICKER             = 27,
+	ICON_RUBBER                   = 28,
+	ICON_COLOR_BUCKET             = 29,
+	ICON_TEXT_T                   = 30,
+	ICON_TEXT_A                   = 31,
+	ICON_SCALE                    = 32,
+	ICON_RESIZE                   = 33,
+	ICON_FILTER_POINT             = 34,
+	ICON_FILTER_BILINEAR          = 35,
+	ICON_CROP                     = 36,
+	ICON_CROP_ALPHA               = 37,
+	ICON_SQUARE_TOGGLE            = 38,
+	ICON_SYMMETRY                 = 39,
+	ICON_SYMMETRY_HORIZONTAL      = 40,
+	ICON_SYMMETRY_VERTICAL        = 41,
+	ICON_LENS                     = 42,
+	ICON_LENS_BIG                 = 43,
+	ICON_EYE_ON                   = 44,
+	ICON_EYE_OFF                  = 45,
+	ICON_FILTER_TOP               = 46,
+	ICON_FILTER                   = 47,
+	ICON_TARGET_POINT             = 48,
+	ICON_TARGET_SMALL             = 49,
+	ICON_TARGET_BIG               = 50,
+	ICON_TARGET_MOVE              = 51,
+	ICON_CURSOR_MOVE              = 52,
+	ICON_CURSOR_SCALE             = 53,
+	ICON_CURSOR_SCALE_RIGHT       = 54,
+	ICON_CURSOR_SCALE_LEFT        = 55,
+	ICON_UNDO                     = 56,
+	ICON_REDO                     = 57,
+	ICON_REREDO                   = 58,
+	ICON_MUTATE                   = 59,
+	ICON_ROTATE                   = 60,
+	ICON_REPEAT                   = 61,
+	ICON_SHUFFLE                  = 62,
+	ICON_EMPTYBOX                 = 63,
+	ICON_TARGET                   = 64,
+	ICON_TARGET_SMALL_FILL        = 65,
+	ICON_TARGET_BIG_FILL          = 66,
+	ICON_TARGET_MOVE_FILL         = 67,
+	ICON_CURSOR_MOVE_FILL         = 68,
+	ICON_CURSOR_SCALE_FILL        = 69,
+	ICON_CURSOR_SCALE_RIGHT_FILL  = 70,
+	ICON_CURSOR_SCALE_LEFT_FILL   = 71,
+	ICON_UNDO_FILL                = 72,
+	ICON_REDO_FILL                = 73,
+	ICON_REREDO_FILL              = 74,
+	ICON_MUTATE_FILL              = 75,
+	ICON_ROTATE_FILL              = 76,
+	ICON_REPEAT_FILL              = 77,
+	ICON_SHUFFLE_FILL             = 78,
+	ICON_EMPTYBOX_SMALL           = 79,
+	ICON_BOX                      = 80,
+	ICON_BOX_TOP                  = 81,
+	ICON_BOX_TOP_RIGHT            = 82,
+	ICON_BOX_RIGHT                = 83,
+	ICON_BOX_BOTTOM_RIGHT         = 84,
+	ICON_BOX_BOTTOM               = 85,
+	ICON_BOX_BOTTOM_LEFT          = 86,
+	ICON_BOX_LEFT                 = 87,
+	ICON_BOX_TOP_LEFT             = 88,
+	ICON_BOX_CENTER               = 89,
+	ICON_BOX_CIRCLE_MASK          = 90,
+	ICON_POT                      = 91,
+	ICON_ALPHA_MULTIPLY           = 92,
+	ICON_ALPHA_CLEAR              = 93,
+	ICON_DITHERING                = 94,
+	ICON_MIPMAPS                  = 95,
+	ICON_BOX_GRID                 = 96,
+	ICON_GRID                     = 97,
+	ICON_BOX_CORNERS_SMALL        = 98,
+	ICON_BOX_CORNERS_BIG          = 99,
+	ICON_FOUR_BOXES               = 100,
+	ICON_GRID_FILL                = 101,
+	ICON_BOX_MULTISIZE            = 102,
+	ICON_ZOOM_SMALL               = 103,
+	ICON_ZOOM_MEDIUM              = 104,
+	ICON_ZOOM_BIG                 = 105,
+	ICON_ZOOM_ALL                 = 106,
+	ICON_ZOOM_CENTER              = 107,
+	ICON_BOX_DOTS_SMALL           = 108,
+	ICON_BOX_DOTS_BIG             = 109,
+	ICON_BOX_CONCENTRIC           = 110,
+	ICON_BOX_GRID_BIG             = 111,
+	ICON_OK_TICK                  = 112,
+	ICON_CROSS                    = 113,
+	ICON_ARROW_LEFT               = 114,
+	ICON_ARROW_RIGHT              = 115,
+	ICON_ARROW_DOWN               = 116,
+	ICON_ARROW_UP                 = 117,
+	ICON_ARROW_LEFT_FILL          = 118,
+	ICON_ARROW_RIGHT_FILL         = 119,
+	ICON_ARROW_DOWN_FILL          = 120,
+	ICON_ARROW_UP_FILL            = 121,
+	ICON_AUDIO                    = 122,
+	ICON_FX                       = 123,
+	ICON_WAVE                     = 124,
+	ICON_WAVE_SINUS               = 125,
+	ICON_WAVE_SQUARE              = 126,
+	ICON_WAVE_TRIANGULAR          = 127,
+	ICON_CROSS_SMALL              = 128,
+	ICON_PLAYER_PREVIOUS          = 129,
+	ICON_PLAYER_PLAY_BACK         = 130,
+	ICON_PLAYER_PLAY              = 131,
+	ICON_PLAYER_PAUSE             = 132,
+	ICON_PLAYER_STOP              = 133,
+	ICON_PLAYER_NEXT              = 134,
+	ICON_PLAYER_RECORD            = 135,
+	ICON_MAGNET                   = 136,
+	ICON_LOCK_CLOSE               = 137,
+	ICON_LOCK_OPEN                = 138,
+	ICON_CLOCK                    = 139,
+	ICON_TOOLS                    = 140,
+	ICON_GEAR                     = 141,
+	ICON_GEAR_BIG                 = 142,
+	ICON_BIN                      = 143,
+	ICON_HAND_POINTER             = 144,
+	ICON_LASER                    = 145,
+	ICON_COIN                     = 146,
+	ICON_EXPLOSION                = 147,
+	ICON_1UP                      = 148,
+	ICON_PLAYER                   = 149,
+	ICON_PLAYER_JUMP              = 150,
+	ICON_KEY                      = 151,
+	ICON_DEMON                    = 152,
+	ICON_TEXT_POPUP               = 153,
+	ICON_GEAR_EX                  = 154,
+	ICON_CRACK                    = 155,
+	ICON_CRACK_POINTS             = 156,
+	ICON_STAR                     = 157,
+	ICON_DOOR                     = 158,
+	ICON_EXIT                     = 159,
+	ICON_MODE_2D                  = 160,
+	ICON_MODE_3D                  = 161,
+	ICON_CUBE                     = 162,
+	ICON_CUBE_FACE_TOP            = 163,
+	ICON_CUBE_FACE_LEFT           = 164,
+	ICON_CUBE_FACE_FRONT          = 165,
+	ICON_CUBE_FACE_BOTTOM         = 166,
+	ICON_CUBE_FACE_RIGHT          = 167,
+	ICON_CUBE_FACE_BACK           = 168,
+	ICON_CAMERA                   = 169,
+	ICON_SPECIAL                  = 170,
+	ICON_LINK_NET                 = 171,
+	ICON_LINK_BOXES               = 172,
+	ICON_LINK_MULTI               = 173,
+	ICON_LINK                     = 174,
+	ICON_LINK_BROKE               = 175,
+	ICON_TEXT_NOTES               = 176,
+	ICON_NOTEBOOK                 = 177,
+	ICON_SUITCASE                 = 178,
+	ICON_SUITCASE_ZIP             = 179,
+	ICON_MAILBOX                  = 180,
+	ICON_MONITOR                  = 181,
+	ICON_PRINTER                  = 182,
+	ICON_PHOTO_CAMERA             = 183,
+	ICON_PHOTO_CAMERA_FLASH       = 184,
+	ICON_HOUSE                    = 185,
+	ICON_HEART                    = 186,
+	ICON_CORNER                   = 187,
+	ICON_VERTICAL_BARS            = 188,
+	ICON_VERTICAL_BARS_FILL       = 189,
+	ICON_LIFE_BARS                = 190,
+	ICON_INFO                     = 191,
+	ICON_CROSSLINE                = 192,
+	ICON_HELP                     = 193,
+	ICON_FILETYPE_ALPHA           = 194,
+	ICON_FILETYPE_HOME            = 195,
+	ICON_LAYERS_VISIBLE           = 196,
+	ICON_LAYERS                   = 197,
+	ICON_WINDOW                   = 198,
+	ICON_HIDPI                    = 199,
+	ICON_FILETYPE_BINARY          = 200,
+	ICON_HEX                      = 201,
+	ICON_SHIELD                   = 202,
+	ICON_FILE_NEW                 = 203,
+	ICON_FOLDER_ADD               = 204,
+	ICON_ALARM                    = 205,
+	ICON_CPU                      = 206,
+	ICON_ROM                      = 207,
+	ICON_STEP_OVER                = 208,
+	ICON_STEP_INTO                = 209,
+	ICON_STEP_OUT                 = 210,
+	ICON_RESTART                  = 211,
+	ICON_BREAKPOINT_ON            = 212,
+	ICON_BREAKPOINT_OFF           = 213,
+	ICON_BURGER_MENU              = 214,
+	ICON_CASE_SENSITIVE           = 215,
+	ICON_REG_EXP                  = 216,
+	ICON_FOLDER                   = 217,
+	ICON_FILE                     = 218,
+	ICON_SAND_TIMER               = 219,
+	ICON_220                      = 220,
+	ICON_221                      = 221,
+	ICON_222                      = 222,
+	ICON_223                      = 223,
+	ICON_224                      = 224,
+	ICON_225                      = 225,
+	ICON_226                      = 226,
+	ICON_227                      = 227,
+	ICON_228                      = 228,
+	ICON_229                      = 229,
+	ICON_230                      = 230,
+	ICON_231                      = 231,
+	ICON_232                      = 232,
+	ICON_233                      = 233,
+	ICON_234                      = 234,
+	ICON_235                      = 235,
+	ICON_236                      = 236,
+	ICON_237                      = 237,
+	ICON_238                      = 238,
+	ICON_239                      = 239,
+	ICON_240                      = 240,
+	ICON_241                      = 241,
+	ICON_242                      = 242,
+	ICON_243                      = 243,
+	ICON_244                      = 244,
+	ICON_245                      = 245,
+	ICON_246                      = 246,
+	ICON_247                      = 247,
+	ICON_248                      = 248,
+	ICON_249                      = 249,
+	ICON_250                      = 250,
+	ICON_251                      = 251,
+	ICON_252                      = 252,
+	ICON_253                      = 253,
+	ICON_254                      = 254,
+	ICON_255                      = 255,
 }
-
diff --git a/src/libraries/raylib/raygui/bindgen.sh b/src/libraries/raylib/raygui/bindgen.sh
deleted file mode 100755
index 10aedff..0000000
--- a/src/libraries/raylib/raygui/bindgen.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-# Currently not cross compiling for windows and darwin
-set -euo pipefail
-
-# This is supposed to use Karl Zylinski's odin-c-bindgen
-# https://github.com/karl-zylinski/odin-c-bindgen
-odin-c-bindgen bindgen.sjson
-rm -f ../raygui.odin
-cp bindgen_output/raygui.odin ../
-rm -r bindgen_output
diff --git a/src/libraries/raylib/raygui/bindgen.sjson b/src/libraries/raylib/raygui/bindgen.sjson
deleted file mode 100644
index 882059b..0000000
--- a/src/libraries/raylib/raygui/bindgen.sjson
+++ /dev/null
@@ -1,18 +0,0 @@
-inputs = [
-	"raygui.h"
-]
-
-imports_file = "imports.odin"
-
-output_folder = "bindgen_output"
-
-package_name = "raylib"
-
-clang_include_paths = [
-	"../raylib/src"
-]
-
-procedure_type_overrides = {
-	"GuiSetStyle.control" = "GuiControl"
-	"GuiGetStyle.control" = "GuiControl"
-}
diff --git a/src/libraries/raylib/raygui/imports.odin b/src/libraries/raylib/raygui/imports.odin
deleted file mode 100644
index d9bd13a..0000000
--- a/src/libraries/raylib/raygui/imports.odin
+++ /dev/null
@@ -1,28 +0,0 @@
-RAYGUI_SHARED :: #config(RAYGUI_SHARED, false)
-RAYGUI_WASM_LIB :: #config(RAYGUI_WASM_LIB, "wasm/libraygui.a")
-
-when ODIN_OS == .Windows {
-	foreign import lib {
-		"windows/rayguidll.lib" when RAYGUI_SHARED else "windows/raygui.lib",
-	}
-} else when ODIN_OS == .Linux  {
-	foreign import lib {
-		"linux/libraygui.so" when RAYGUI_SHARED else "linux/libraygui.a",
-	}
-} else when ODIN_OS == .Darwin {
-	when ODIN_ARCH == .arm64 {
-		foreign import lib {
-			"macos/libraygui-arm64.dylib" when RAYGUI_SHARED else "macos/libraygui-arm64.a",
-		}
-	} else {
-		foreign import lib {
-			"macos/libraygui.dylib" when RAYGUI_SHARED else "macos/libraygui.a",
-		}
-	}
-} else when ODIN_ARCH == .wasm32 || ODIN_ARCH == .wasm64p32 {
-	foreign import lib {
-		RAYGUI_WASM_LIB,
-	}
-} else {
-	foreign import lib "system:raygui"
-}
diff --git a/src/libraries/raylib/raygui/raygui.h b/src/libraries/raylib/raygui/raygui.h
index 3851d48..f7a1161 100644
--- a/src/libraries/raylib/raygui/raygui.h
+++ b/src/libraries/raylib/raygui/raygui.h
@@ -3346,19 +3346,7 @@ int GuiValueBoxFloat(Rectangle bounds, const char *text, char *textValue, float
             {
                 if (GuiGetTextWidth(textValue) < bounds.width)
                 {
-                    int key = 0;
-                    for (int i = 0; i < 10; i++) {
-                        if (GUI_KEY_PRESSED(KEY_ZERO + i)) {
-                            key = KEY_ZERO + i;
-                            break;
-                        }
-                    }
-                    if (key == 0 && GUI_KEY_PRESSED(KEY_MINUS)) {
-                        key = '-';
-                    }
-                    if (key == 0 && GUI_KEY_PRESSED(KEY_PERIOD)) {
-                        key = '.';
-                    }
+                    int key = GUI_INPUT_KEY;
                     if (((key >= 48) && (key <= 57)) ||
                         (key == '.') ||
                         ((keyCount == 0) && (key == '+')) ||  // NOTE: Sign can only be in first position
@@ -4169,22 +4157,22 @@ int GuiColorBarHue(Rectangle bounds, const char *text, float *hue)
     {
         // Draw hue bar:color bars
         // NOTE: Using DrawRectangleGradientEx(bounds, color1, color2, color2, color1);
-        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, bounds.width, bounds.height/6.0f },
+        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y, bounds.width, bounds.height/6.0f }, 
             Fade(RAYGUI_CLITERAL(Color){ 255, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 255, 0, 255 }, guiAlpha),
             Fade(RAYGUI_CLITERAL(Color){ 255, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 0, 255 }, guiAlpha));
-        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 1*(bounds.height/6.0f), bounds.width, bounds.height/6.0f },
+        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 1*(bounds.height/6.0f), bounds.width, bounds.height/6.0f }, 
             Fade(RAYGUI_CLITERAL(Color){ 255, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 0, 255 }, guiAlpha),
             Fade(RAYGUI_CLITERAL(Color){ 0, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 255, 0, 255 }, guiAlpha));
-        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 2*(bounds.height/6.0f), bounds.width, bounds.height/6.0f },
+        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 2*(bounds.height/6.0f), bounds.width, bounds.height/6.0f }, 
             Fade(RAYGUI_CLITERAL(Color){ 0, 255, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 255, 255 }, guiAlpha),
             Fade(RAYGUI_CLITERAL(Color){ 0, 255, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 0, 255 }, guiAlpha));
-        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 3*(bounds.height/6.0f), bounds.width, bounds.height/6.0f },
+        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 3*(bounds.height/6.0f), bounds.width, bounds.height/6.0f }, 
             Fade(RAYGUI_CLITERAL(Color){ 0, 255, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 255, 255 }, guiAlpha),
             Fade(RAYGUI_CLITERAL(Color){ 0, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 255, 255, 255 }, guiAlpha));
-        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 4*(bounds.height/6.0f), bounds.width, bounds.height/6.0f },
+        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 4*(bounds.height/6.0f), bounds.width, bounds.height/6.0f }, 
             Fade(RAYGUI_CLITERAL(Color){ 0, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 255, 255 }, guiAlpha),
             Fade(RAYGUI_CLITERAL(Color){ 255, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 0, 0, 255, 255 }, guiAlpha));
-        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 5*(bounds.height/6.0f), bounds.width, bounds.height/6.0f },
+        DrawRectangleGradientEx(RAYGUI_CLITERAL(Rectangle){ bounds.x, bounds.y + 5*(bounds.height/6.0f), bounds.width, bounds.height/6.0f }, 
             Fade(RAYGUI_CLITERAL(Color){ 255, 0, 255, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 0, 255 }, guiAlpha),
             Fade(RAYGUI_CLITERAL(Color){ 255, 0, 0, 255 }, guiAlpha), Fade(RAYGUI_CLITERAL(Color){ 255, 0, 255, 255 }, guiAlpha));
     }
@@ -4226,7 +4214,7 @@ int GuiColorPicker(Rectangle bounds, const char *text, Color *color)
     // NOTE: this conversion can cause low hue-resolution, if the r, g and b value are very similar, which causes the hue bar to shift around when only the GuiColorPanel is used
     Vector3 hsv = ConvertRGBtoHSV(RAYGUI_CLITERAL(Vector3){ (*color).r/255.0f, (*color).g/255.0f, (*color).b/255.0f });
 
-    result = GuiColorBarHue(boundsHue, NULL, &hsv.x);
+    if (result != RESULT_CHANGED) result = GuiColorBarHue(boundsHue, NULL, &hsv.x);
 
     //color.a = (unsigned char)(GuiColorBarAlpha(boundsAlpha, (float)color.a/255.0f)*255.0f);
     Vector3 rgb = ConvertHSVtoRGB(hsv);
@@ -4461,11 +4449,11 @@ int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, ch
     Rectangle textBounds = { 0 };
     if (message != NULL)
     {
-        int messageTextSize = GuiGetTextWidth(message) + 2;
+        int textSize = GuiGetTextWidth(message) + 2;
 
-        textBounds.x = bounds.x + bounds.width/2 - messageTextSize/2;
+        textBounds.x = bounds.x + bounds.width/2 - textSize/2;
         textBounds.y = bounds.y + RAYGUI_WINDOWBOX_STATUSBAR_HEIGHT + messageInputHeight/4 - (float)GuiGetStyle(DEFAULT, TEXT_SIZE)/2;
-        textBounds.width = (float)messageTextSize;
+        textBounds.width = (float)textSize;
         textBounds.height = (float)GuiGetStyle(DEFAULT, TEXT_SIZE);
     }
 
@@ -4653,8 +4641,8 @@ void GuiLoadStyle(const char *fileName)
                 {
                     case 'v':
                     {
-                        sscanf(buffer, "v %u", &version);
-                    } break;
+                        sscanf(buffer, "v %d", &version);
+                    }
                     case 'p':
                     {
                         // Style property: p <control_id> <property_id> <property_value> <property_name>
diff --git a/src/libraries/raylib/raylib/src/CMakeLists.txt b/src/libraries/raylib/raylib/src/CMakeLists.txt
index 25b6173..5e5dd91 100644
--- a/src/libraries/raylib/raylib/src/CMakeLists.txt
+++ b/src/libraries/raylib/raylib/src/CMakeLists.txt
@@ -30,22 +30,14 @@ set(raylib_public_headers
 
 # Sources to be compiled
 set(raylib_sources
+    raudio.c
     rcore.c
+    rmodels.c
     rshapes.c
     rtext.c
     rtextures.c
     )
 
-# Only build raudio if it's enabled
-if (NOT DEFINED SUPPORT_MODULE_RAUDIO OR SUPPORT_MODULE_RAUDIO)
-    list(APPEND raylib_sources raudio.c)
-endif()
-
-# Only build rmodels if it's enabled
-if (NOT DEFINED SUPPORT_MODULE_RMODELS OR SUPPORT_MODULE_RMODELS)
-    list(APPEND raylib_sources rmodels.c)
-endif()
-
 # <root>/cmake/GlfwImport.cmake handles the details around the inclusion of glfw
 if (NOT ${PLATFORM} MATCHES "Web")
     include(GlfwImport)
@@ -56,10 +48,10 @@ endif ()
 # Produces a variable LIBS_PRIVATE that will be used later
 include(LibraryConfigurations)
 
-if (DEFINED SUPPORT_MODULE_RAUDIO AND NOT SUPPORT_MODULE_RAUDIO)
-    MESSAGE(STATUS "Audio Backend: None (-DCUSTOMIZE_BUILD=ON -DSUPPORT_MODULE_RAUDIO=OFF)")
-else ()
+if (SUPPORT_MODULE_RAUDIO)
     MESSAGE(STATUS "Audio Backend: miniaudio")
+else ()
+    MESSAGE(STATUS "Audio Backend: None (-DCUSTOMIZE_BUILD=ON -DSUPPORT_MODULE_RAUDIO=OFF)")
 endif ()
 
 add_library(raylib ${raylib_sources} ${raylib_public_headers})
@@ -107,34 +99,6 @@ endif ()
 target_link_libraries(raylib PRIVATE $<BUILD_INTERFACE:${LIBS_PRIVATE}>)
 target_link_libraries(raylib PUBLIC ${LIBS_PUBLIC})
 
-# Static libraries must export their private link dependencies for installed consumers.
-# LINK_ONLY keeps those dependencies out of the compile interface.
-if (NOT BUILD_SHARED_LIBS)
-    set(raylib_install_private_libs ${LIBS_PRIVATE})
-
-    if (NOT glfw3_FOUND)
-        list(REMOVE_ITEM raylib_install_private_libs glfw)
-
-        # Bundled GLFW links its Cocoa backend frameworks privately, so they
-        # must be propagated to consumers of the static library, whose final
-        # link line would otherwise miss them. Only the Desktop platform uses
-        # bundled GLFW; other platforms (e.g. Memory) have no Cocoa/GLFW symbols.
-        if (APPLE AND PLATFORM STREQUAL "Desktop")
-            find_library(COCOA_FRAMEWORK Cocoa)
-            find_library(IOKIT_FRAMEWORK IOKit)
-            find_library(QUARTZCORE_FRAMEWORK QuartzCore)
-            list(APPEND raylib_install_private_libs
-                ${COCOA_FRAMEWORK}
-                ${IOKIT_FRAMEWORK}
-                ${QUARTZCORE_FRAMEWORK})
-        endif ()
-    endif()
-
-    foreach(lib IN LISTS raylib_install_private_libs)
-        target_link_libraries(raylib INTERFACE $<INSTALL_INTERFACE:$<LINK_ONLY:${lib}>>)
-    endforeach()
-endif()
-
 # Sets some compile time definitions for the pre-processor
 # If CUSTOMIZE_BUILD option is on you will not use config.h by default
 # and you will be able to select more build options
diff --git a/src/libraries/raylib/raylib/src/Makefile b/src/libraries/raylib/raylib/src/Makefile
index f0d92a5..13f1327 100644
--- a/src/libraries/raylib/raylib/src/Makefile
+++ b/src/libraries/raylib/raylib/src/Makefile
@@ -240,9 +240,6 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_ANDROID)
     ifeq ($(ANDROID_ARCH),x86_64)
         ANDROID_COMPILER_ARCH = x86_64
     endif
-    ifndef ANDROID_COMPILER_ARCH
-        $(error ANDROID_COMPILER_ARCH: Unknown ANDROID_ARCH=$(ANDROID_ARCH))
-    endif
 endif
 
 # Define raylib graphics api depending on selected platform
@@ -655,7 +652,7 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_GLFW)
         #LDLIBS += -latomic
     endif
     ifeq ($(PLATFORM_OS),OSX)
-        LDLIBS = -framework OpenGL -framework Cocoa -framework IOKit -framework CoreAudio -framework CoreVideo -framework QuartzCore
+        LDLIBS = -framework OpenGL -framework Cocoa -framework IOKit -framework CoreAudio -framework CoreVideo
     endif
     ifeq ($(PLATFORM_OS),BSD)
         LDLIBS = -lGL -lpthread
@@ -707,7 +704,7 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_RGFW)
     ifeq ($(PLATFORM_OS),OSX)
         # Libraries for Debian MacOS desktop compiling
         # NOTE: Required packages: libegl1-mesa-dev
-        LDLIBS += -lm -framework Foundation -framework AppKit -framework IOKit  -framework OpenGL -framework CoreVideo -framework QuartzCore
+        LDLIBS += -lm -framework Foundation -framework AppKit -framework IOKit  -framework OpenGL -framework CoreVideo
     endif
 endif
 ifeq ($(TARGET_PLATFORM),PLATFORM_DRM)
diff --git a/src/libraries/raylib/raylib/src/config.h b/src/libraries/raylib/raylib/src/config.h
index e77089b..97f5ba5 100644
--- a/src/libraries/raylib/raylib/src/config.h
+++ b/src/libraries/raylib/raylib/src/config.h
@@ -173,22 +173,20 @@
 //#define RL_CULL_DISTANCE_FAR                4000.0    // Default projection matrix far cull distance
 
 // Default shader vertex attribute locations
-// NOTE: Locations can be redefined by user if required
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION        0
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD        1
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL          2
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR           3
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT         4
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2       5
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES         6
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES     7
-//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS     8
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION    0
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD    1
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL      2
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR       3
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT     4
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2   5
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES     6
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES 7
+//#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
 //#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM 9
 
 // Default shader vertex attribute/uniform names to set location points
 // NOTE: When a new shader is loaded, locations are tried to be set for convenience, looking for the names defined here
-// WARNING: Location pre-defined names can not be changed, they are used by default shaders and all raylib examples shaders, they are just listed here for reference
-// WARNING: In case custom shader names are used, it's up to the user to set locations with GetShaderLocation*() functions
+// In case custom shader names are used, it's up to the user to set locations with GetShaderLocation*() functions
 //#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION       "vertexPosition"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
 //#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD       "vertexTexCoord"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
 //#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL         "vertexNormal"       // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
@@ -198,7 +196,6 @@
 //#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES    "vertexBoneIndices"  // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
 //#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS    "vertexBoneWeights"  // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
 //#define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
-
 //#define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP           "mvp"                // model-view-projection matrix
 //#define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW          "matView"            // view matrix
 //#define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION    "matProjection"      // projection matrix
@@ -206,7 +203,6 @@
 //#define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL        "matNormal"          // normal matrix (transpose(inverse(matModelView))
 //#define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR         "colDiffuse"         // color diffuse (tint color, multiplied by texture color)
 //#define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES  "boneMatrices"       // bone matrices
-
 //#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0    "texture0"           // texture0 (texture slot active 0)
 //#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1    "texture1"           // texture1 (texture slot active 1)
 //#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2    "texture2"           // texture2 (texture slot active 2)
@@ -244,9 +240,6 @@
 #ifndef SUPPORT_FILEFORMAT_QOI
     #define SUPPORT_FILEFORMAT_QOI      1
 #endif
-#ifndef SUPPORT_FILEFORMAT_PEP
-    #define SUPPORT_FILEFORMAT_PEP      0
-#endif
 #ifndef SUPPORT_FILEFORMAT_PSD
     #define SUPPORT_FILEFORMAT_PSD      0       // Disabled by default
 #endif
diff --git a/src/libraries/raylib/raylib/src/external/RGFW/RGFW.h b/src/libraries/raylib/raylib/src/external/RGFW/RGFW.h
index e114334..427db01 100644
--- a/src/libraries/raylib/raylib/src/external/RGFW/RGFW.h
+++ b/src/libraries/raylib/raylib/src/external/RGFW/RGFW.h
@@ -41,7 +41,6 @@
 
 	#define RGFW_X11 (optional) (unix only) if X11 should be used. This option is turned on by default by unix systems except for MacOS
 	#define RGFW_WAYLAND (optional) (unix only) use Wayland. (This can be used with X11)
-	#define RGFW_NO_STATIC_CONTEXT - do not initalizize with a static variable, use the heap if RGFW is not manually initalized
 	#define RGFW_NO_X11 (optional) (unix only) don't fallback to X11 when using Wayland
 	#define RGFW_NO_LOAD_WGL (optional) (windows only) if WGL should be loaded dynamically during runtime
 	#define RGFW_NO_X11_CURSOR (optional) (unix only) don't use XCursor
@@ -56,11 +55,10 @@
 	#define RGFW_COCOA_GRAPHICS_SWITCHING - (optional) (cocoa) use automatic graphics switching (allow the system to choose to use GPU or iGPU)
 	#define RGFW_COCOA_FRAME_NAME (optional) (cocoa) set frame name
 	#define RGFW_NO_DPI - do not calculate DPI and don't use libShcore (win32)
+	#define RGFW_NO_XRANDR - do use XRandr (X11)
 	#define RGFW_ADVANCED_SMOOTH_RESIZE - use advanced methods for smooth resizing (may result in a spike in memory usage or worse performance) (eg. WM_TIMER and XSyncValue)
 	#define RGFW_NO_INFO - do not define the RGFW_info struct (without RGFW_IMPLEMENTATION)
 	#define RGFW_NO_GLXWINDOW - do not use GLXWindow
-	#define RGFW_NO_ALLOCATE_MONITORS - do not allocate monitors on the heap at all (when there's no pre-allocated space left)
-	#define RGFW_NO_INCLUDE_VULKAN - do not include the Vulkan.h header, you have to include it yourself
 
 	#define RGFW_ALLOC x  - choose the default allocation function (defaults to standard malloc)
 	#define RGFW_FREE x  - choose the default deallocation function (defaults to standard free)
@@ -71,25 +69,32 @@
 
 	#define RGFW_USE_INT - force the use c-types rather than stdint.h (for systems that might not have stdint.h (msvc))
 	#define RGFW_bool x - choose what type to use for bool, by default u32 is used
-
-	#define RGFW_PREALLOCATED_MONITORS x - choose the default amount of pre-allocated monitors (can be zero)
 */
 
 /*
 Example to get you started :
 
-linux : gcc main.c -lX11 -lXrandr -lm
-windows : gcc main.c -lgdi32
-macos : gcc main.c -framework Cocoa -framework CoreVideo -framework IOKit
+linux : gcc main.c -lX11 -lXrandr -lGL
+windows : gcc main.c -lopengl32 -lgdi32
+macos : gcc main.c -framework Cocoa -framework CoreVideo -framework OpenGL -framework IOKit
 
 #define RGFW_IMPLEMENTATION
 #include "RGFW.h"
 
+u8 icon[4 * 3 * 3] = {0xFF, 0x00, 0x00, 0xFF,    0xFF, 0x00, 0x00, 0xFF,     0xFF, 0x00, 0x00, 0xFF,   0xFF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0xFF,     0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF};
+
 int main() {
-	RGFW_window* win = RGFW_createWindow("name", 100, 100, 500, 500, 0);
+	RGFW_window* win = RGFW_createWindow("name", 100, 100, 500, 500, (u64)0);
+	RGFW_event event;
+
+	RGFW_window_setExitKey(win, RGFW_escape);
+	RGFW_window_setIcon(win, icon, 3, 3, RGFW_formatRGBA8);
 
 	while (RGFW_window_shouldClose(win) == RGFW_FALSE) {
-		RGFW_pollEvents();
+		while (RGFW_window_checkEvent(win, &event)) {
+			if (event.type == RGFW_quit)
+				break;
+		}
 	}
 
 	RGFW_window_close(win);
@@ -132,6 +137,10 @@ int main() {
 	Credits :
 		EimaMei/Sacode : Code review, helped with X11, MacOS and Windows support, Silicon, siliapp.h -> referencing
 
+		stb : This project is heavily inspired by the stb single header files
+
+		SDL, GLFW and other online resources : reference implementations
+
 		contributors : (feel free to put yourself here if you contribute)
 		krisvers (@krisvers) -> code review
 		EimaMei (@SaCode) -> code review
@@ -216,18 +225,6 @@ int main() {
 	#define RGFW_MACOS
 #endif
 
-#if defined(RGFW_X11) || defined(RGFW_WASM) || defined(RGFW_WAYLAND)
-	#ifndef _POSIX_C_SOURCE
-		#define _POSIX_C_SOURCE 199309L
-	#endif
-
-	/* __USE_POSIX199309 is part of glibc internals, and isn't intended to be used outside. */
-	/* However, existing RGFW code may depend on it implicitly. */
-	#ifndef __USE_POSIX199309
-		#define __USE_POSIX199309
-	#endif
-#endif
-
 #ifndef RGFW_ASSERT
 	#include <assert.h>
 	#define RGFW_ASSERT assert
@@ -238,9 +235,25 @@ int main() {
 #endif
 
 #if !defined(RGFW_SNPRINTF) && (defined(RGFW_X11) || defined(RGFW_WAYLAND))
+
 	/* required for X11 errors */
 	#include <stdio.h>
-	#define RGFW_SNPRINTF snprintf
+
+    #ifdef RGFW_C89
+        #include <stdarg.h>
+        static int RGFW_c89_snprintf(char *dst, size_t size, const char *format, ...) {
+            va_list args;
+            size_t count = 0;
+            va_start(args, format);
+            count = (size_t)vsprintf(dst, format, args);
+            RGFW_ASSERT(count + 1 < size && "Buffer overflow");
+            va_end(args);
+            return (int)count;
+        }
+     	#define RGFW_SNPRINTF RGFW_c89_snprintf
+    #else
+     	#define RGFW_SNPRINTF snprintf
+    #endif /*RGFW_C89*/
 #endif
 
 #ifndef RGFW_USERPTR
@@ -269,12 +282,12 @@ int main() {
 	#define RGFW_FREE free
 #endif
 
-#if !defined(RGFW_MEMCPY) || !defined(RGFW_STRNCMP) || !defined(RGFW_STRNCPY) || !defined(RGFW_MEMZERO)
+#if !defined(RGFW_MEMCPY) || !defined(RGFW_STRNCMP) || !defined(RGFW_STRNCPY) || !defined(RGFW_MEMSET)
 	#include <string.h>
 #endif
 
-#ifndef RGFW_MEMZERO
-	#define RGFW_MEMZERO(ptr, num) memset(ptr, 0, num)
+#ifndef RGFW_MEMSET
+	#define RGFW_MEMSET(ptr, value, num) memset(ptr, value, num)
 #endif
 
 #ifndef RGFW_MEMCPY
@@ -306,13 +319,19 @@ int main() {
     #define RGFW_PRINTF printf
 #endif
 
+#ifndef RGFW_MAX_PATH
+	#define RGFW_MAX_PATH 260 /* max length of a path (for drag andn drop) */
+#endif
+#ifndef RGFW_MAX_DROPS
+	#define RGFW_MAX_DROPS 260 /* max items you can drop at once */
+#endif
+
 #ifndef RGFW_MAX_EVENTS
 	#define RGFW_MAX_EVENTS 32
 #endif
-#ifndef RGFW_PREALLOCATED_MONITORS
-	#define RGFW_PREALLOCATED_MONITORS 6 /* the number of preallocated monitors */
-#elif defined(RGFW_NO_ALLOCATE_MONITORS) && (RGFW_PREALLOCATED_MONITORS == 0)
-	#warning RGFW monitors have no place to be allocated
+
+#ifndef RGFW_MAX_MONITORS
+	#define RGFW_MAX_MONITORS 6
 #endif
 
 #ifndef RGFW_COCOA_FRAME_NAME
@@ -505,129 +524,129 @@ typedef void RGFW_mouse;
 /*! @brief RGFW's abstract keycodes */
 typedef RGFW_ENUM(u8, RGFW_key) {
 	RGFW_keyNULL = 0,
-	RGFW_keyEscape = '\033',
-	RGFW_keyBacktick = '`',
-	RGFW_key0 = '0',
-	RGFW_key1 = '1',
-	RGFW_key2 = '2',
-	RGFW_key3 = '3',
-	RGFW_key4 = '4',
-	RGFW_key5 = '5',
-	RGFW_key6 = '6',
-	RGFW_key7 = '7',
-	RGFW_key8 = '8',
-	RGFW_key9 = '9',
-	RGFW_keyMinus = '-',
-	RGFW_keyEqual = '=',
-	RGFW_keyEquals = RGFW_keyEqual,
-	RGFW_keyBackSpace = '\b',
-	RGFW_keyTab = '\t',
-	RGFW_keySpace = ' ',
-	RGFW_keyA = 'a',
-	RGFW_keyB = 'b',
-	RGFW_keyC = 'c',
-	RGFW_keyD = 'd',
-	RGFW_keyE = 'e',
-	RGFW_keyF = 'f',
-	RGFW_keyG = 'g',
-	RGFW_keyH = 'h',
-	RGFW_keyI = 'i',
-	RGFW_keyJ = 'j',
-	RGFW_keyK = 'k',
-	RGFW_keyL = 'l',
-	RGFW_keyM = 'm',
-	RGFW_keyN = 'n',
-	RGFW_keyO = 'o',
-	RGFW_keyP = 'p',
-	RGFW_keyQ = 'q',
-	RGFW_keyR = 'r',
-	RGFW_keyS = 's',
-	RGFW_keyT = 't',
-	RGFW_keyU = 'u',
-	RGFW_keyV = 'v',
-	RGFW_keyW = 'w',
-	RGFW_keyX = 'x',
-	RGFW_keyY = 'y',
-	RGFW_keyZ = 'z',
-	RGFW_keyPeriod = '.',
-	RGFW_keyComma = ',',
-	RGFW_keySlash = '/',
-	RGFW_keyBracket = '[',
-    RGFW_keyCloseBracket = ']',
-    RGFW_keySemicolon = ';',
-	RGFW_keyApostrophe = '\'',
-	RGFW_keyBackSlash = '\\',
-	RGFW_keyReturn = '\n',
-	RGFW_keyEnter = RGFW_keyReturn,
-	RGFW_keyDelete = '\177', /* 127 */
-	RGFW_keyF1,
-	RGFW_keyF2,
-	RGFW_keyF3,
-	RGFW_keyF4,
-	RGFW_keyF5,
-	RGFW_keyF6,
-	RGFW_keyF7,
-	RGFW_keyF8,
-	RGFW_keyF9,
-	RGFW_keyF10,
-	RGFW_keyF11,
-	RGFW_keyF12,
-    RGFW_keyF13,
-    RGFW_keyF14,
-    RGFW_keyF15,
-    RGFW_keyF16,
-    RGFW_keyF17,
-    RGFW_keyF18,
-    RGFW_keyF19,
-    RGFW_keyF20,
-    RGFW_keyF21,
-    RGFW_keyF22,
-    RGFW_keyF23,
-    RGFW_keyF24,
-    RGFW_keyF25,
-	RGFW_keyCapsLock,
-	RGFW_keyShiftL,
-	RGFW_keyControlL,
-	RGFW_keyAltL,
-	RGFW_keySuperL,
-	RGFW_keyShiftR,
-	RGFW_keyControlR,
-	RGFW_keyAltR,
-	RGFW_keySuperR,
-	RGFW_keyUp,
-	RGFW_keyDown,
-	RGFW_keyLeft,
-	RGFW_keyRight,
-	RGFW_keyInsert,
-	RGFW_keyMenu,
-	RGFW_keyEnd,
-	RGFW_keyHome,
-	RGFW_keyPageUp,
-	RGFW_keyPageDown,
-	RGFW_keyNumLock,
-	RGFW_keyPadSlash,
-	RGFW_keyPadMultiply,
-	RGFW_keyPadPlus,
-	RGFW_keyPadMinus,
-	RGFW_keyPadEqual,
-	RGFW_keyPadEquals = RGFW_keyPadEqual,
-	RGFW_keyPad1,
-	RGFW_keyPad2,
-	RGFW_keyPad3,
-	RGFW_keyPad4,
-	RGFW_keyPad5,
-	RGFW_keyPad6,
-	RGFW_keyPad7,
-	RGFW_keyPad8,
-	RGFW_keyPad9,
-	RGFW_keyPad0,
-	RGFW_keyPadPeriod,
-	RGFW_keyPadReturn,
-	RGFW_keyScrollLock,
-    RGFW_keyPrintScreen,
-    RGFW_keyPause,
-	RGFW_keyWorld1,
-    RGFW_keyWorld2,
+	RGFW_escape = '\033',
+	RGFW_backtick = '`',
+	RGFW_0 = '0',
+	RGFW_1 = '1',
+	RGFW_2 = '2',
+	RGFW_3 = '3',
+	RGFW_4 = '4',
+	RGFW_5 = '5',
+	RGFW_6 = '6',
+	RGFW_7 = '7',
+	RGFW_8 = '8',
+	RGFW_9 = '9',
+	RGFW_minus = '-',
+	RGFW_equal = '=',
+	RGFW_equals = RGFW_equal,
+	RGFW_backSpace = '\b',
+	RGFW_tab = '\t',
+	RGFW_space = ' ',
+	RGFW_a = 'a',
+	RGFW_b = 'b',
+	RGFW_c = 'c',
+	RGFW_d = 'd',
+	RGFW_e = 'e',
+	RGFW_f = 'f',
+	RGFW_g = 'g',
+	RGFW_h = 'h',
+	RGFW_i = 'i',
+	RGFW_j = 'j',
+	RGFW_k = 'k',
+	RGFW_l = 'l',
+	RGFW_m = 'm',
+	RGFW_n = 'n',
+	RGFW_o = 'o',
+	RGFW_p = 'p',
+	RGFW_q = 'q',
+	RGFW_r = 'r',
+	RGFW_s = 's',
+	RGFW_t = 't',
+	RGFW_u = 'u',
+	RGFW_v = 'v',
+	RGFW_w = 'w',
+	RGFW_x = 'x',
+	RGFW_y = 'y',
+	RGFW_z = 'z',
+	RGFW_period = '.',
+	RGFW_comma = ',',
+	RGFW_slash = '/',
+	RGFW_bracket = '[',
+    RGFW_closeBracket = ']',
+    RGFW_semicolon = ';',
+	RGFW_apostrophe = '\'',
+	RGFW_backSlash = '\\',
+	RGFW_return = '\n',
+	RGFW_enter = RGFW_return,
+	RGFW_delete = '\177', /* 127 */
+	RGFW_F1,
+	RGFW_F2,
+	RGFW_F3,
+	RGFW_F4,
+	RGFW_F5,
+	RGFW_F6,
+	RGFW_F7,
+	RGFW_F8,
+	RGFW_F9,
+	RGFW_F10,
+	RGFW_F11,
+	RGFW_F12,
+    RGFW_F13,
+    RGFW_F14,
+    RGFW_F15,
+    RGFW_F16,
+    RGFW_F17,
+    RGFW_F18,
+    RGFW_F19,
+    RGFW_F20,
+    RGFW_F21,
+    RGFW_F22,
+    RGFW_F23,
+    RGFW_F24,
+    RGFW_F25,
+	RGFW_capsLock,
+	RGFW_shiftL,
+	RGFW_controlL,
+	RGFW_altL,
+	RGFW_superL,
+	RGFW_shiftR,
+	RGFW_controlR,
+	RGFW_altR,
+	RGFW_superR,
+	RGFW_up,
+	RGFW_down,
+	RGFW_left,
+	RGFW_right,
+	RGFW_insert,
+	RGFW_menu,
+	RGFW_end,
+	RGFW_home,
+	RGFW_pageUp,
+	RGFW_pageDown,
+	RGFW_numLock,
+	RGFW_kpSlash,
+	RGFW_kpMultiply,
+	RGFW_kpPlus,
+	RGFW_kpMinus,
+	RGFW_kpEqual,
+	RGFW_kpEquals = RGFW_kpEqual,
+	RGFW_kp1,
+	RGFW_kp2,
+	RGFW_kp3,
+	RGFW_kp4,
+	RGFW_kp5,
+	RGFW_kp6,
+	RGFW_kp7,
+	RGFW_kp8,
+	RGFW_kp9,
+	RGFW_kp0,
+	RGFW_kpPeriod,
+	RGFW_kpReturn,
+	RGFW_scrollLock,
+    RGFW_printScreen,
+    RGFW_pause,
+	RGFW_world1,
+    RGFW_world2,
     RGFW_keyLast = 256 /* padding for alignment ~(175 by default) */
 };
 
@@ -651,32 +670,6 @@ typedef RGFW_ENUM(u8, RGFW_keymod) {
 	RGFW_modScrollLock = RGFW_BIT(6)
 };
 
-/*! types of dnd drag actions */
-typedef RGFW_ENUM(u8, RGFW_dndActionType) {
-	RGFW_dndActionNone = 0,
-	RGFW_dndActionEnter, /*!< data has been dragged into the window area */
-	RGFW_dndActionMove, /*!< the data that was dragged into the window area has moved inside the window */
-	RGFW_dndActionExit, /*!< the data that was dragged into the window area has left the window */
-};
-
-/*! types of transfered data (clipboard, dnd) */
-typedef RGFW_ENUM(u8, RGFW_dataTransferType) {
-	RGFW_dataNone = 0,
-	RGFW_dataText, /*!< plain text string */
-	RGFW_dataFile, /*!< file string */
-	RGFW_dataURL, /*!< URL string */
-	RGFW_dataImage, /*!< raw image data */
-	RGFW_dataUnknown /*!< unknown raw data */
-};
-
-/*! internal node for a individual data drop */
-typedef struct RGFW_dataDropNode {
-	const char* data; /*!< dropped data */
-	size_t size; /*!< the size of the data in bytes */
-	RGFW_dataTransferType type; /*!< the type of data being dropped */
-	struct RGFW_dataDropNode* next; /*!< the next drop data node if any [when handling callbacks, this will always be NULL because the linked list is built as events are processed] */
-} RGFW_dataDropNode;
-
 /*! @brief codes for the event types that can be sent */
 typedef RGFW_ENUM(u8, RGFW_eventType) {
 	RGFW_eventNone = 0, /*!< no event has been sent */
@@ -686,29 +679,44 @@ typedef RGFW_ENUM(u8, RGFW_eventType) {
 	RGFW_mouseButtonPressed, /*!< a mouse button has been pressed (left,middle,right) */
 	RGFW_mouseButtonReleased, /*!< a mouse button has been released (left,middle,right) */
 	RGFW_mouseScroll, /*!< a mouse scroll event */
-	RGFW_mouseMotion, /*!< the position of the mouse has been changed / the mouse has moved */
-	RGFW_mouseRawMotion, /*!< raw mouse motion */
-	RGFW_mouseEnter, /*!< mouse entered the window */
-	RGFW_mouseLeave, /*!< mouse left the window */
+	RGFW_mousePosChanged, /*!< the position of the mouse has been changed */
+	/*! mouse event note
+		the x and y of the mouse can be found in the vector, RGFW_x, y
+
+		RGFW_event.button.value holds which mouse button was pressed
+	*/
 	RGFW_windowMoved, /*!< the window was moved (by the user) */
 	RGFW_windowResized, /*!< the window was resized (by the user), [on WASM this means the browser was resized] */
-	RGFW_windowFocusIn, /*!< window is in focus now */
-	RGFW_windowFocusOut, /*!< window is out of focus now */
-	RGFW_windowRefresh, /*!< The window content needs to be refreshed */
-	RGFW_windowClose, /*!< the user attempts to close the window */
+	RGFW_focusIn, /*!< window is in focus now */
+	RGFW_focusOut, /*!< window is out of focus now */
+	RGFW_mouseEnter, /* mouse entered the window */
+	RGFW_mouseLeave, /* mouse left the window */
+	RGFW_windowRefresh, /* The window content needs to be refreshed */
+
+	/* attribs change event note
+		The event data is sent straight to the window structure
+		with win->x, win->y, win->w and win->h
+	*/
+	RGFW_quit, /*!< the user clicked the quit button */
+	RGFW_dataDrop, /*!< a file has been dropped into the window */
+	RGFW_dataDrag, /*!< the start of a drag and drop event, when the file is being dragged */
+	/* drop data note
+		The x and y coords of the drop are stored in the vector RGFW_x, y
+
+		RGFW_event.drop.count holds how many files were dropped
+
+		This is also the size of the array which stores all the dropped file string,
+		RGFW_event.drop.files
+	*/
 	RGFW_windowMaximized, /*!< the window was maximized */
 	RGFW_windowMinimized, /*!< the window was minimized */
 	RGFW_windowRestored, /*!< the window was restored */
-	RGFW_dataDrop, /*!< data has been dropped into the window */
-	RGFW_dataDrag, /*!< the start of a drag and drop event, when data is being dragged */
 	RGFW_scaleUpdated, /*!< content scale factor changed */
 	RGFW_monitorConnected, /*!< a monitor has been connected */
-	RGFW_monitorDisconnected, /*!< a monitor has been disconnected */
-	RGFW_eventCount, /*!< the number of event types there are */
-	RGFW_mousePosChanged = RGFW_mouseMotion, /*!< alias for RGFW_mouseMotion (may be deleted at some point) */
+	RGFW_monitorDisconnected /*!< a monitor has been disconnected */
 };
 
-/*! @brief flags for toggling whether or not an event should be processed */
+/*! @brief flags for toggling wether or not an event should be processed */
 typedef RGFW_ENUM(u32, RGFW_eventFlag) {
     RGFW_keyPressedFlag = RGFW_BIT(RGFW_keyPressed),
     RGFW_keyReleasedFlag = RGFW_BIT(RGFW_keyReleased),
@@ -716,33 +724,31 @@ typedef RGFW_ENUM(u32, RGFW_eventFlag) {
     RGFW_mouseScrollFlag = RGFW_BIT(RGFW_mouseScroll),
     RGFW_mouseButtonPressedFlag = RGFW_BIT(RGFW_mouseButtonPressed),
     RGFW_mouseButtonReleasedFlag = RGFW_BIT(RGFW_mouseButtonReleased),
-    RGFW_mouseMotionFlag = RGFW_BIT(RGFW_mouseMotion),
-    RGFW_mouseRawMotionFlag = RGFW_BIT(RGFW_mouseRawMotion),
+    RGFW_mousePosChangedFlag = RGFW_BIT(RGFW_mousePosChanged),
     RGFW_mouseEnterFlag = RGFW_BIT(RGFW_mouseEnter),
     RGFW_mouseLeaveFlag = RGFW_BIT(RGFW_mouseLeave),
     RGFW_windowMovedFlag = RGFW_BIT(RGFW_windowMoved),
     RGFW_windowResizedFlag = RGFW_BIT(RGFW_windowResized),
-    RGFW_windowFocusInFlag = RGFW_BIT(RGFW_windowFocusIn),
-    RGFW_windowFocusOutFlag = RGFW_BIT(RGFW_windowFocusOut),
+    RGFW_focusInFlag = RGFW_BIT(RGFW_focusIn),
+    RGFW_focusOutFlag = RGFW_BIT(RGFW_focusOut),
     RGFW_windowRefreshFlag = RGFW_BIT(RGFW_windowRefresh),
     RGFW_windowMaximizedFlag = RGFW_BIT(RGFW_windowMaximized),
     RGFW_windowMinimizedFlag = RGFW_BIT(RGFW_windowMinimized),
     RGFW_windowRestoredFlag = RGFW_BIT(RGFW_windowRestored),
     RGFW_scaleUpdatedFlag = RGFW_BIT(RGFW_scaleUpdated),
-    RGFW_windowCloseFlag = RGFW_BIT(RGFW_windowClose),
+    RGFW_quitFlag = RGFW_BIT(RGFW_quit),
     RGFW_dataDropFlag = RGFW_BIT(RGFW_dataDrop),
     RGFW_dataDragFlag = RGFW_BIT(RGFW_dataDrag),
 	RGFW_monitorConnectedFlag = RGFW_BIT(RGFW_monitorConnected),
 	RGFW_monitorDisconnectedFlag = RGFW_BIT(RGFW_monitorDisconnected),
-    RGFW_mousePosChangedFlag = RGFW_mouseMotionFlag, /* alias for RGFW_mouseMotionFlag (may be deleted at some point) */
 
     RGFW_keyEventsFlag = RGFW_keyPressedFlag | RGFW_keyReleasedFlag | RGFW_keyCharFlag,
-    RGFW_mouseEventsFlag = RGFW_mouseButtonPressedFlag | RGFW_mouseButtonReleasedFlag | RGFW_mouseMotionFlag | RGFW_mouseEnterFlag | RGFW_mouseLeaveFlag | RGFW_mouseScrollFlag | RGFW_mouseRawMotionFlag,
+    RGFW_mouseEventsFlag = RGFW_mouseButtonPressedFlag | RGFW_mouseButtonReleasedFlag | RGFW_mousePosChangedFlag | RGFW_mouseEnterFlag | RGFW_mouseLeaveFlag | RGFW_mouseScrollFlag ,
     RGFW_windowEventsFlag = RGFW_windowMovedFlag | RGFW_windowResizedFlag | RGFW_windowRefreshFlag | RGFW_windowMaximizedFlag | RGFW_windowMinimizedFlag | RGFW_windowRestoredFlag | RGFW_scaleUpdatedFlag,
-    RGFW_windowFocusEventsFlag = RGFW_windowFocusInFlag | RGFW_windowFocusOutFlag,
-    RGFW_dataDragDropEventsFlag = RGFW_dataDropFlag | RGFW_dataDragFlag,
+    RGFW_focusEventsFlag = RGFW_focusInFlag | RGFW_focusOutFlag,
+    RGFW_dataDropEventsFlag = RGFW_dataDropFlag | RGFW_dataDragFlag,
 	RGFW_monitorEventsFlag = RGFW_monitorConnectedFlag | RGFW_monitorDisconnectedFlag,
-    RGFW_allEventFlags = RGFW_keyEventsFlag | RGFW_mouseEventsFlag | RGFW_windowEventsFlag | RGFW_windowFocusEventsFlag | RGFW_dataDragDropEventsFlag | RGFW_windowCloseFlag | RGFW_monitorEventsFlag
+    RGFW_allEventFlags = RGFW_keyEventsFlag | RGFW_mouseEventsFlag | RGFW_windowEventsFlag | RGFW_focusEventsFlag | RGFW_dataDropEventsFlag | RGFW_quitFlag | RGFW_monitorEventsFlag
 };
 
 /*! Event structure(s) and union for checking/getting events */
@@ -753,35 +759,27 @@ typedef struct RGFW_commonEvent {
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
 } RGFW_commonEvent;
 
-/*! @brief event data for all focus events */
-typedef struct RGFW_windowFocusEvent {
-	RGFW_eventType type; /*!< which event has been sent?*/
-	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
-	RGFW_bool state; /*!< wether or not the window is in focus or not */
-} RGFW_windowFocusEvent;
-
 /*! @brief event data for any mouse button event (press/release) */
 typedef struct RGFW_mouseButtonEvent {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
 	RGFW_mouseButton value; /* !< which mouse button was pressed */
-	RGFW_bool state; /*!< if the button was pressed or released */
 } RGFW_mouseButtonEvent;
 
-/*! @brief event data for any mouse scroll or raw motion event */
-typedef struct RGFW_mouseDeltaEvent {
+/*! @brief event data for any mouse scroll event */
+typedef struct RGFW_mouseScrollEvent {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
-	float x, y; /*!< the raw mouse scroll or motion delta value */
-} RGFW_mouseDeltaEvent;
+	float x, y; /*!< the raw mouse scroll value */
+} RGFW_mouseScrollEvent;
 
-/*! @brief event data for a mouse position event (RGFW_mouseMotion) */
-typedef struct RGFW_mouseMotionEvent {
+/*! @brief event data for any mouse position event (RGFW_mousePosChanged) */
+typedef struct RGFW_mousePosEvent {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
 	i32 x, y; /*!< mouse x, y of event (or drop point) */
-	RGFW_bool inWindow; /*!< if the mouse is in the window or not */
-} RGFW_mouseMotionEvent;
+	float vecX, vecY; /*!< raw mouse movement */
+} RGFW_mousePosEvent;
 
 /*! @brief event data for a key press/release event */
 typedef struct RGFW_keyEvent {
@@ -789,8 +787,7 @@ typedef struct RGFW_keyEvent {
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
 	RGFW_key value; /*!< the physical key of the event, refers to where key is physically */
 	RGFW_bool repeat; /*!< key press event repeated (the key is being held) */
-	RGFW_keymod mod; /*!< state of the key modifier state */
-	RGFW_bool state; /*!< if the key was pressed or released */
+	RGFW_keymod mod;
 } RGFW_keyEvent;
 
 /*! @brief event data for a key character event */
@@ -804,7 +801,9 @@ typedef struct RGFW_keyCharEvent {
 typedef struct RGFW_dataDropEvent {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
-	const RGFW_dataDropNode* value;
+	/* 260 max paths with a max length of 260 */
+	char** files; /*!< dropped files */
+	size_t count; /*!< how many files were dropped */
 } RGFW_dataDropEvent;
 
 /*! @brief event data for any data drag event */
@@ -812,8 +811,6 @@ typedef struct RGFW_dataDragEvent {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
 	i32 x, y; /*!< mouse x, y of event (or drop point) */
-	RGFW_dndActionType action; /*!< the type of drag action, e.g. enter, leave, move */
-	RGFW_dataTransferType dataType; /*!< the type of data being dragged*/
 } RGFW_dataDragEvent;
 
 /*! @brief event data for when the window scale (DPI) is updated */
@@ -828,32 +825,19 @@ typedef struct RGFW_monitorEvent {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_window* win; /*!< the window this event applies to (for event queue events) */
 	const RGFW_monitor* monitor; /*!< the monitor that this event applies to */
-	RGFW_bool state; /*!< if the monitor is connected or disconnected */
 } RGFW_monitorEvent;
 
-/*! @breif event data for when the window is updated, moved, resized or refreshed */
-typedef struct RGFW_windowUpdateEvent {
-	RGFW_eventType type; /*!< the specific event type */
-	RGFW_window* win; /*!< the window that was updated */
-	i32 x; /*!< the new window x OR the x of the rectanglular refresh area */
-	i32 y; /*!< the new window y OR the y of the rectanglular refresh area */
-	i32 w; /*!< the new window width OR the width of the rectanglular refresh area */
-	i32 h; /*!< the new window height OR the height of the rectanglular refresh area */
-} RGFW_windowUpdateEvent;
-
 /*! @brief union for all of the event stucture types */
 typedef union RGFW_event {
 	RGFW_eventType type; /*!< which event has been sent?*/
 	RGFW_commonEvent common; /*!< common event data (e.g.) type and win */
-	RGFW_windowFocusEvent focus; /*!< event data  for focus in/out events */
-	RGFW_windowUpdateEvent update; /*!< data for window update/move/resize/refresh events */
 	RGFW_mouseButtonEvent button; /*!< data for a button press/release */
-	RGFW_mouseDeltaEvent delta; /*!< data for a mouse scroll or raw motion */
-	RGFW_mouseMotionEvent mouse; /*!< data for mouse motion events */
+	RGFW_mouseScrollEvent scroll; /*!< data for a mouse scroll */
+	RGFW_mousePosEvent mouse; /*!< data for mouse motion events */
 	RGFW_keyEvent key; /*!< data for key press/release/hold events */
 	RGFW_keyCharEvent keyChar; /*!< data for key character events */
-	RGFW_dataDropEvent drop; /*!< data dropping events */
-	RGFW_dataDragEvent drag; /*!< data for data dragging events */
+	RGFW_dataDropEvent drop; /*!< dropping a file events */
+	RGFW_dataDragEvent drag; /*!< data for dragging a file events */
 	RGFW_scaleUpdatedEvent scale; /*!< data for dpi scaling update events */
 	RGFW_monitorEvent monitor; /*!< data for monitor events */
 } RGFW_event;
@@ -870,23 +854,14 @@ typedef RGFW_ENUM(i32, RGFW_eventWait) {
 	RGFW_eventWaitNext = -1
 };
 
-/*! @brief generic event callback function type */
-typedef void (*RGFW_genericFunc)(const RGFW_event* e);
-
-/*! brief structure that holds an array to callback data*/
-typedef struct RGFW_callbacks {
-	RGFW_genericFunc arr[RGFW_eventCount]; /*!< an array of all the callbacks */
-} RGFW_callbacks;
-
 /*! @brief optional bitwise arguments for making a windows, these can be OR'd together */
 typedef RGFW_ENUM(u32, RGFW_windowFlags) {
-	RGFW_windowNoBorder = RGFW_BIT(0), /*!< the window doesn't have a border / frame / decor */
+	RGFW_windowNoBorder = RGFW_BIT(0), /*!< the window doesn't have a border */
 	RGFW_windowNoResize = RGFW_BIT(1), /*!< the window cannot be resized by the user */
 	RGFW_windowAllowDND = RGFW_BIT(2), /*!< the window supports drag and drop */
 	RGFW_windowHideMouse = RGFW_BIT(3), /*! the window should hide the mouse (can be toggled later on using `RGFW_window_showMouse`) */
 	RGFW_windowFullscreen = RGFW_BIT(4), /*!< the window is fullscreen by default */
-	RGFW_windowTranslucent = RGFW_BIT(5), /*!< the window is translucent (only properly works on X11 and MacOS, although it's meant for for windows) */
-	RGFW_windowTransparent = RGFW_windowTranslucent,  /*!< the window is translucent (only properly works on X11 and MacOS, although it's meant for for windows) */
+	RGFW_windowTransparent = RGFW_BIT(5), /*!< the window is transparent (only properly works on X11 and MacOS, although it's meant for for windows) */
 	RGFW_windowCenter = RGFW_BIT(6), /*! center the window on the screen */
 	RGFW_windowRawMouse = RGFW_BIT(7), /*!< use raw mouse mouse on window creation */
 	RGFW_windowScaleToMonitor = RGFW_BIT(8), /*! scale the window to the screen */
@@ -913,7 +888,7 @@ typedef RGFW_ENUM(u8, RGFW_icon) {
 };
 
 /*! @brief standard mouse icons */
-typedef RGFW_ENUM(u8, RGFW_mouseIcon) {
+typedef RGFW_ENUM(u8, RGFW_mouseIcons) {
 	RGFW_mouseNormal = 0,
 	RGFW_mouseArrow,
 	RGFW_mouseIbeam,
@@ -970,15 +945,47 @@ typedef RGFW_ENUM(u8, RGFW_errorCode) {
 	RGFW_warningWayland, RGFW_warningOpenGL
 };
 
-/*! @brief data for debug messages */
-typedef struct RGFW_debugInfo {
-	RGFW_debugType type; /*!< the type of message */
-	RGFW_errorCode code; /*!< the code for the specific type of debug message */
-	const char* msg; /*!< string message */
-} RGFW_debugInfo;
-
 /*! @brief callback function type for debug messags */
-typedef void (* RGFW_debugFunc)(const RGFW_debugInfo* info);
+typedef void (* RGFW_debugfunc)(RGFW_debugType type, RGFW_errorCode err, const char* msg);
+
+/*! @brief RGFW_windowMoved, the window and its new rect value  */
+typedef void (* RGFW_windowMovedfunc)(RGFW_window* win, i32 x, i32 y);
+/*! @brief RGFW_windowResized, the window and its new rect value  */
+typedef void (* RGFW_windowResizedfunc)(RGFW_window* win, i32 w, i32 h);
+/*! @brief RGFW_windowRestored, the window and its new rect value  */
+typedef void (* RGFW_windowRestoredfunc)(RGFW_window* win, i32 x, i32 y, i32 w, i32 h);
+/*! @brief RGFW_windowMaximized, the window and its new rect value  */
+typedef void (* RGFW_windowMaximizedfunc)(RGFW_window* win, i32 x, i32 y, i32 w, i32 h);
+/*! @brief RGFW_windowMinimized, the window and its new rect value  */
+typedef void (* RGFW_windowMinimizedfunc)(RGFW_window* win);
+/*! @brief RGFW_quit, the window that was closed */
+typedef void (* RGFW_windowQuitfunc)(RGFW_window* win);
+/*! @brief RGFW_focusIn / RGFW_focusOut, the window who's focus has changed and if its in focus */
+typedef void (* RGFW_focusfunc)(RGFW_window* win, RGFW_bool inFocus);
+/*! @brief RGFW_mouseEnter / RGFW_mouseLeave, the window that changed, the point of the mouse (enter only) and if the mouse has entered */
+typedef void (* RGFW_mouseNotifyfunc)(RGFW_window* win, i32 x, i32 y, RGFW_bool status);
+/*! @brief RGFW_mousePosChanged, the window that the move happened on, and the new point of the mouse  */
+typedef void (* RGFW_mousePosfunc)(RGFW_window* win, i32 x, i32 y, float vecX, float vecY);
+/*! @brief RGFW_dataDrag, the window, the point of the drop on the windows */
+typedef void (* RGFW_dataDragfunc)(RGFW_window* win, i32 x, i32 y);
+/*! @brief RGFW_windowRefresh, the window that needs to be refreshed */
+typedef void (* RGFW_windowRefreshfunc)(RGFW_window* win);
+/*! @brief RGFW_keyChar, the window that got the event, the unicode key value */
+typedef void (* RGFW_keyCharfunc)(RGFW_window* win, u32 codepoint);
+/*! @brief RGFW_mouseButtonPressed / RGFW_mouseButtonReleased, the window that got the event, the button that was pressed, the scroll value, if it was a press (else it's a release)  */
+
+/*! @brief RGFW_keyPressed / RGFW_keyReleased, the window that got the event, the mapped key, the physical key, the string version, the state of the mod keys, if it was a press (else it's a release) */
+typedef void (* RGFW_keyfunc)(RGFW_window* win, u8 key, RGFW_keymod mod, RGFW_bool repeat, RGFW_bool pressed);
+/*! @brief RGFW_mouseButtonPressed / RGFW_mouseButtonReleased, the window that got the event, the button that was pressed, the scroll value, if it was a press (else it's a release)  */
+typedef void (* RGFW_mouseButtonfunc)(RGFW_window* win, RGFW_mouseButton button, RGFW_bool pressed);
+/*! @brief RGFW_mouseScroll, the window that got the event, the x scroll value, the y scroll value */
+typedef void (* RGFW_mouseScrollfunc)(RGFW_window* win, float x, float y);
+/*! @brief RGFW_dataDrop the window that had the drop, the drop data and the number of files dropped */
+typedef void (* RGFW_dataDropfunc)(RGFW_window* win, char** files, size_t count);
+/*! @brief RGFW_scaleUpdated, the window the event was sent to, content scaleX, content scaleY */
+typedef void (* RGFW_scaleUpdatedfunc)(RGFW_window* win, float scaleX, float scaleY);
+/*! @brief RGFW_monitorConnected / RGFW_monitorDisconnected, there was a monitor connected/disconnected */
+typedef void (* RGFW_monitorfunc)(RGFW_window* win, const RGFW_monitor* monitor, RGFW_bool connected);
 
 /*! @brief function pointer equivalent of void* */
 typedef void (*RGFW_proc)(void);
@@ -1002,8 +1009,7 @@ typedef RGFW_ENUM(i32, RGFW_glProfile)  {
 	RGFW_glCore = 0, /*!< the core OpenGL version, e.g. just support for that version */
 	RGFW_glForwardCompatibility, /*!< only compatibility for newer versions of OpenGL as well as the requested version */
 	RGFW_glCompatibility, /*!< allow compatibility for older versions of OpenGL as well as the requested version */
-	RGFW_glES, /*!< use OpenGL ES */
-	RGFW_glWeb /*!< use WebGL version (otherwise the version is changed to match it's GLES equivalent) */
+	RGFW_glES /*!< use OpenGL ES */
 };
 
 /*! values for the renderer hint */
@@ -1182,7 +1188,7 @@ RGFWDEF void RGFW_surface_freePtr(RGFW_surface* surface);
 
 
 /**!
- * @brief create a mouse icon from bitmap data (similar to RGFW_window_setIcon).
+ * @brief Loads a mouse icon from bitmap data (similar to RGFW_window_setIcon).
  * @param data A pointer to the bitmap pixel data.
  * @param w The width of the mouse icon in pixels.
  * @param h The height of the mouse icon in pixels.
@@ -1191,14 +1197,7 @@ RGFWDEF void RGFW_surface_freePtr(RGFW_surface* surface);
  *
  * @note The icon is not resized by default.
 */
-RGFWDEF RGFW_mouse* RGFW_createMouse(u8* data, i32 w, i32 h, RGFW_format format);
-
-/**!
- * @brief create a standard mouse icon
- * @param mouse The standard cursor type (see RGFW_MOUSE enum).
- * @return A pointer to the newly loaded RGFW_mouse structure.
-*/
-RGFWDEF RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon mouse);
+RGFWDEF RGFW_mouse* RGFW_loadMouse(u8* data, i32 w, i32 h, RGFW_format format);
 
 /**!
  * @brief Frees the data associated with an RGFW_mouse structure.
@@ -1356,21 +1355,12 @@ RGFWDEF RGFW_bool RGFW_monitor_getMode(RGFW_monitor* monitor, RGFW_monitorMode*
 RGFWDEF void RGFW_pollMonitors(void);
 
 /**!
- * @brief Allocates and returns an array of all available monitors.
- * @param len [OUTPUT] A pointer to store the number of monitors found.
- * @return An allocated array of pointers to RGFW_monitor structures that must be freed.
+ * @brief Retrieves an array of all available monitors.
+ * @param len [OUTPUT] A pointer to store the number of monitors found (maximum of RGFW_MAX_MONITORS [6 by default]).
+ * @return An array of pointers to RGFW_monitor structures.
 */
 RGFWDEF RGFW_monitor** RGFW_getMonitors(size_t* len);
 
-/**!
- * @brief fills a pre-allocated array with available monitors.
- * @param maximum number of monitors that the passed [monitors] buffer supports, can be zero to get the length alone
- * @param pre-allocated buffer of monitors, can be NULL to get the length alone
- * @param len [OUTPUT] A pointer to store the number of monitors found, if max is not zero and monitors is not NULL, length will be set to max.
- * @return An array of pointers to RGFW_monitor structures or NULL if the function failed.
-*/
-RGFWDEF RGFW_bool RGFW_getMonitorsPtr(size_t max, RGFW_monitor** monitors, size_t* len);
-
 /**!
  * @brief Retrieves the primary monitor.
  * @return A pointer to the RGFW_monitor structure representing the primary monitor.
@@ -1419,13 +1409,6 @@ RGFWDEF RGFW_bool RGFW_monitor_scaleToWindow(RGFW_monitor* mon, struct RGFW_wind
 */
 RGFWDEF void RGFW_setRawMouseMode(RGFW_bool state);
 
-/**!
- * @brief toggles building the drag-and-drop (DND) linked list
- * @param allow RGFW_TRUE to allow DND building, RGFW_FALSE to disable
- * @note this is for state checking, the list is created by default if you are using the event queue
-*/
-RGFWDEF void RGFW_setBuildDND(RGFW_bool allow);
-
 /**!
 * @brief sleep until RGFW gets an event or the timer ends (defined by OS)
 * @param waitMS how long to wait for the next event (in miliseconds)
@@ -1438,29 +1421,6 @@ RGFWDEF void RGFW_waitForEvent(i32 waitMS);
 */
 RGFWDEF void RGFW_setQueueEvents(RGFW_bool queue);
 
-/**!
- * @brief Sets the callback function for the event.
- * @param the event type for the callback
- * @param func The function to be called when the event is triggered.
- * @return The previously set callback function, if any.
-*/
-RGFWDEF RGFW_genericFunc RGFW_setEventCallback(RGFW_eventType type, RGFW_genericFunc func);
-
-/**!
- * @brief Sets the callback function for two continuous events.
- * @param func The function to be called when the event is triggered.
- * @param [OUTPUT] The previously set callback function for the first event, if any.
- * @param [OUTPUT] The previously set callback function for the second event, if any.
-*/
-RGFWDEF void RGFW_setDualEventCallback(RGFW_eventType type, RGFW_genericFunc func, RGFW_genericFunc* first, RGFW_genericFunc* second);
-
-/**!
- * @brief Sets the callback function for all events.
- * @param func The function to be called when the event is triggered.
- * @param [OUTPUT] a structure that holds an array of all the event callbacks
-*/
-RGFWDEF void RGFW_setAllEventCallbacks(RGFW_genericFunc func, RGFW_callbacks* callbacks);
-
 /**!
 * @brief check all the events until there are none left and updates window structure attributes
 */
@@ -1893,11 +1853,13 @@ RGFWDEF RGFW_bool RGFW_window_getDataDrag(RGFW_window* win, i32* x, i32* y);
 RGFWDEF RGFW_bool RGFW_window_didDataDrop(RGFW_window* win);
 
 /**!
- * @brief retrieves data from a data drop (drag and drop)
+ * @brief retrieves files from a data drop (drag and drop)
  * @param win a pointer to the target window
- * @return a valid pointer to the root drag node if a data drop occurred, NULL otherwise
+ * @param files [OUTPUT] a pointer to the array of file paths
+ * @param count [OUTPUT] the number of dropped files
+ * @return RGFW_TRUE if a data drop occurred, RGFW_FALSE otherwise
 */
-RGFWDEF RGFW_dataDropNode* RGFW_window_getDataDrop(RGFW_window* win);
+RGFWDEF RGFW_bool RGFW_window_getDataDrop(RGFW_window* win, const char*** files, size_t* count);
 
 /**!
  * @brief closes the window and frees its associated structure
@@ -1911,15 +1873,6 @@ RGFWDEF void RGFW_window_close(RGFW_window* win);
 */
 RGFWDEF void RGFW_window_closePtr(RGFW_window* win);
 
-/**!
- * @brief fetches the size of the window through the OS (and updates the internal values)
- * @param win a pointer to the window
- * @param w [OUTPUT] the width of the window
- * @param h [OUTPUT] the height of the window
- * @return a bool if the function was successful
-*/
-RGFWDEF RGFW_bool RGFW_window_fetchSize(RGFW_window* win, i32* w, i32* h);
-
 /**!
  * @brief moves the window to a new position on the screen
  * @param win a pointer to the target window
@@ -2032,14 +1985,14 @@ RGFWDEF void RGFW_window_setFloating(RGFW_window* win, RGFW_bool floating);
 RGFWDEF void RGFW_window_setOpacity(RGFW_window* win, u8 opacity);
 
 /**!
- * @brief toggles window borders / frame / decor
+ * @brief toggles window borders
  * @param win a pointer to the target window
  * @param border RGFW_TRUE for bordered, RGFW_FALSE for borderless
 */
 RGFWDEF void RGFW_window_setBorder(RGFW_window* win, RGFW_bool border);
 
 /**!
- * @brief checks if the window is borderless (has a border, frame or decor)
+ * @brief checks if the window is borderless
  * @param win a pointer to the target window
  * @return RGFW_TRUE if borderless, RGFW_FALSE otherwise
 */
@@ -2102,19 +2055,19 @@ RGFWDEF RGFW_bool RGFW_window_setIcon(RGFW_window* win, u8* data, i32 w, i32 h,
 RGFWDEF RGFW_bool RGFW_window_setIconEx(RGFW_window* win, u8* data, i32 w, i32 h, RGFW_format format, RGFW_icon type);
 
 /**!
- * @brief sets the mouse icon for the window using a loaded mouse icon
+ * @brief sets the mouse icon for the window using a loaded bitmap
  * @param win a pointer to the target window
  * @param mouse a pointer to the RGFW_mouse struct containing the icon
 */
-RGFWDEF RGFW_bool RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse);
+RGFWDEF void RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse);
 
 /**!
- * @brief Sets the mouse to a preloaded [by RGFW] standard system cursor.
+ * @brief Sets the mouse to a standard system cursor.
  * @param win The target window.
- * @param mouse The standardmouse icon (see RGFW_mouseIcon enum).
+ * @param mouse The standard cursor type (see RGFW_MOUSE enum).
  * @return True if the standard cursor was successfully applied.
 */
-RGFWDEF RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, RGFW_mouseIcon icon);
+RGFWDEF RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, RGFW_mouseIcons mouse);
 
 /**!
  * @brief Sets the mouse to the default cursor icon.
@@ -2328,7 +2281,7 @@ RGFWDEF void RGFW_writeClipboard(const char* text, u32 textLen);
  * @param func The function pointer to be used as the debug callback.
  * @return The previously set debug callback function.
 */
-RGFWDEF RGFW_debugFunc RGFW_setDebugCallback(RGFW_debugFunc func);
+RGFWDEF RGFW_debugfunc RGFW_setDebugCallback(RGFW_debugfunc func);
 
 /**!
  * @brief Sends a debug message manually through the currently set debug callback.
@@ -2336,7 +2289,146 @@ RGFWDEF RGFW_debugFunc RGFW_setDebugCallback(RGFW_debugFunc func);
  * @param err The associated error code.
  * @param msg The debug message text.
 */
-RGFWDEF void RGFW_debugCallback(RGFW_debugType type, RGFW_errorCode code, const char* msg);
+RGFWDEF void RGFW_sendDebugInfo(RGFW_debugType type, RGFW_errorCode err, const char* msg);
+/** @} */
+
+/**
+
+
+	event callbacks.
+	These are completely optional, so you can use the normal
+	RGFW_checkEvent() method if you prefer that
+
+* @defgroup Callbacks
+* @{
+*/
+
+/**!
+ * @brief Sets the callback function for window move events.
+ * @param func The function to be called when the window is moved.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowMovedfunc RGFW_setWindowMovedCallback(RGFW_windowMovedfunc func);
+
+/**!
+ * @brief Sets the callback function for window resize events.
+ * @param func The function to be called when the window is resized.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowResizedfunc RGFW_setWindowResizedCallback(RGFW_windowResizedfunc func);
+
+/**!
+ * @brief Sets the callback function for window quit events.
+ * @param func The function to be called when the window receives a quit signal.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowQuitfunc RGFW_setWindowQuitCallback(RGFW_windowQuitfunc func);
+
+/**!
+ * @brief Sets the callback function for mouse move events.
+ * @param func The function to be called when the mouse moves within the window.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_mousePosfunc RGFW_setMousePosCallback(RGFW_mousePosfunc func);
+
+/**!
+ * @brief Sets the callback function for window refresh events.
+ * @param func The function to be called when the window needs to be refreshed.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowRefreshfunc RGFW_setWindowRefreshCallback(RGFW_windowRefreshfunc func);
+
+/**!
+ * @brief Sets the callback function for focus change events.
+ * @param func The function to be called when the window gains or loses focus.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_focusfunc RGFW_setFocusCallback(RGFW_focusfunc func);
+
+/**!
+ * @brief Sets the callback function for mouse notification events.
+ * @param func The function to be called when a mouse notification event occurs.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_mouseNotifyfunc RGFW_setMouseNotifyCallback(RGFW_mouseNotifyfunc func);
+
+/**!
+ * @brief Sets the callback function for data drop events.
+ * @param func The function to be called when data is dropped into the window.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_dataDropfunc RGFW_setDataDropCallback(RGFW_dataDropfunc func);
+
+/**!
+ * @brief Sets the callback function for the start of a data drag event.
+ * @param func The function to be called when data dragging begins.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_dataDragfunc RGFW_setDataDragCallback(RGFW_dataDragfunc func);
+
+/**!
+ * @brief Sets the callback function for key press and release events.
+ * @param func The function to be called when a key is pressed or released.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_keyfunc RGFW_setKeyCallback(RGFW_keyfunc func);
+
+/**!
+ * @brief Sets the callback function for key character events.
+ * @param func The function to be called when a key is pressed or released.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_keyCharfunc RGFW_setKeyCharCallback(RGFW_keyCharfunc func);
+
+/**!
+ * @brief Sets the callback function for mouse button press and release events.
+ * @param func The function to be called when a mouse button is pressed or released.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_mouseButtonfunc RGFW_setMouseButtonCallback(RGFW_mouseButtonfunc func);
+
+/**!
+ * @brief Sets the callback function for mouse scroll events.
+ * @param func The function to be called when the mouse wheel is scrolled.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_mouseScrollfunc RGFW_setMouseScrollCallback(RGFW_mouseScrollfunc func);
+
+/**!
+ * @brief Sets the callback function for window maximize events.
+ * @param func The function to be called when the window is maximized.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowMaximizedfunc RGFW_setWindowMaximizedCallback(RGFW_windowMaximizedfunc func);
+
+/**!
+ * @brief Sets the callback function for window minimize events.
+ * @param func The function to be called when the window is minimized.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowMinimizedfunc RGFW_setWindowMinimizedCallback(RGFW_windowMinimizedfunc func);
+
+/**!
+ * @brief Sets the callback function for window restore events.
+ * @param func The function to be called when the window is restored from a minimized or maximized state.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_windowRestoredfunc RGFW_setWindowRestoredCallback(RGFW_windowRestoredfunc func);
+
+/**!
+ * @brief Sets the callback function for DPI (scale) update events.
+ * @param func The function to be called when the window’s DPI or scale changes.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_scaleUpdatedfunc RGFW_setScaleUpdatedCallback(RGFW_scaleUpdatedfunc func);
+
+/**!
+ * @brief Sets the callback function for monitor connected and disconnect events.
+ * @param func The function to be called when a monitor is connected or disconnected.
+ * @return The previously set callback function, if any.
+*/
+RGFWDEF RGFW_monitorfunc RGFW_setMonitorCallback(RGFW_monitorfunc func);
+
 /** @} */
 
 /** * @defgroup graphics_API
@@ -2626,9 +2718,7 @@ RGFWDEF RGFW_bool RGFW_extensionSupportedPlatform_EGL(const char* extension, siz
 #endif
 
 #ifdef RGFW_VULKAN
-#ifndef RGFW_NO_INCLUDE_VULKAN
-	#include <vulkan/vulkan.h>
-#endif
+#include <vulkan/vulkan.h>
 
 /* if you don't want to use the above macros */
 
@@ -2714,12 +2804,6 @@ RGFWDEF RGFW_window* RGFW_getRootWindow(void);
 */
 RGFWDEF void RGFW_eventQueuePush(const RGFW_event* event);
 
-/**!
- * @brief Pushes an event into the standard RGFW event queue and call the callback.
- * @param event A pointer to the RGFW_event to be added to the queue.
-*/
-RGFWDEF void RGFW_eventQueuePushAndCall(const RGFW_event* event);
-
 /**!
  * @brief Clears all events from the RGFW event queue without processing them.
 */
@@ -2766,14 +2850,14 @@ RGFWDEF RGFW_key RGFW_physicalToMappedKey(RGFW_key keycode);
 RGFWDEF size_t RGFW_sizeofInfo(void);
 
 /**!
- * @brief Initializes the RGFW library internally.
- * @return 0 on success, a negative number error error on failure.
+ * @brief Initializes the RGFW library.
+ * @return 0 on success, or a negative error code on failure.
  * @note This is automatically called when the first window is created.
 */
 RGFWDEF i32 RGFW_init(void);
 
 /**!
- * @brief Deinitializes the current instance of the RGFW library.
+ * @brief Deinitializes the RGFW library.
  * @note This is automatically called when the last open window is closed.
 */
 RGFWDEF void RGFW_deinit(void);
@@ -2781,7 +2865,7 @@ RGFWDEF void RGFW_deinit(void);
 /**!
  * @brief Initializes RGFW using a user-provided RGFW_info structure.
  * @param info A pointer to an RGFW_info structure to be used for initialization.
- * @return  0 on success, a negative number error error on failure and a positive number for a warning.
+ * @return 0 on success, or a negative error code on failure.
 */
 RGFWDEF i32 RGFW_init_ptr(RGFW_info* info);
 
@@ -2872,11 +2956,9 @@ RGFWDEF RGFW_info* RGFW_getInfo(void);
 		#include <X11/Xlib.h>
 		#include <X11/Xutil.h>
 
-		#include <X11/extensions/Xrandr.h>
-		#include <X11/Xresource.h>
-
-		#ifndef RGFW_XDND_VERSION
-			#define RGFW_XDND_VERSION 5
+		#ifndef RGFW_NO_XRANDR
+			#include <X11/extensions/Xrandr.h>
+			#include <X11/Xresource.h>
 		#endif
 	#endif
 
@@ -3036,8 +3118,6 @@ typedef struct RGFW_windowInternal {
 	RGFW_eventFlag enabledEvents;
 	u32 flags; /*!< windows flags (for RGFW to check and modify) */
 	i32 oldX, oldY, oldW, oldH;
-	RGFW_monitorMode oldMode;
-	RGFW_mouse* mouse;
 } RGFW_windowInternal;
 
 struct RGFW_window {
@@ -3051,7 +3131,7 @@ typedef struct RGFW_windowState {
 	RGFW_bool mouseEnter;
 	RGFW_bool dataDragging;
 	RGFW_bool dataDrop;
-	size_t dataSize;
+	size_t filesCount;
 	i32 dropX, dropY;
 	RGFW_window* win; /*!< it's not possible for one of these events to happen in the frame that the other event happened */
 
@@ -3075,7 +3155,7 @@ struct RGFW_monitorNode {
 	RGFW_monitorMode* modes;
 	size_t modeCount;
 #endif
-#if defined(RGFW_X11)
+#if defined(RGFW_X11) && !defined(RGFW_NO_XRANDR)
 	i32 screen;
 	RROutput rrOutput;
 	RRCrtc crtc;
@@ -3099,24 +3179,22 @@ typedef struct RGFW_monitorList {
 
 typedef struct RGFW_monitors {
 	RGFW_monitorList list;
+	RGFW_monitorList freeList;
 	size_t count;
 
 	RGFW_monitorNode* primary;
-	#if (RGFW_PREALLOCATED_MONITORS)
-		RGFW_monitorList freeList;
-		RGFW_monitorNode data[RGFW_PREALLOCATED_MONITORS];
-	#endif
+	RGFW_monitorNode data[RGFW_MAX_MONITORS];
 } RGFW_monitors;
 
+RGFWDEF RGFW_monitorNode* RGFW_monitors_add(const RGFW_monitor* mon);
+RGFWDEF void RGFW_monitors_remove(RGFW_monitorNode* node, RGFW_monitorNode* prev);
+
 struct RGFW_info {
     RGFW_window* root;
     i32 windowCount;
 
 	RGFW_mouse* hiddenMouse;
-	RGFW_mouse* standardMice[RGFW_mouseIconCount];
 
-	RGFW_debugFunc debugCallbackSrc;
-	RGFW_genericFunc callbacks[RGFW_eventCount];
     RGFW_event events[RGFW_MAX_EVENTS]; /* A circular buffer (FIFO), using eventBottom/Len  */
 
 	i32 eventBottom;
@@ -3143,11 +3221,8 @@ struct RGFW_info {
     char* clipboard_data;
     char* clipboard; /* for writing to the clipboard selection */
     size_t clipboard_len;
-
-	RGFW_bool dndBuild;
-	RGFW_dataDropNode* dndRoot;
-	RGFW_dataDropNode* dndCur;
-
+    char filesSrc[RGFW_MAX_PATH * RGFW_MAX_DROPS];
+	char** files;
 	#ifdef RGFW_X11
         Display* display;
 		XContext context;
@@ -3156,10 +3231,6 @@ struct RGFW_info {
         XErrorEvent* x11Error;
 		i32 xrandrEventBase;
 		XIM im;
-		Window x11Source;
-		long x11Version;
-		i32 x11Format;
-		RGFW_dataTransferType x11TransferType;
     #endif
     #ifdef RGFW_WAYLAND
         struct wl_display* wl_display;
@@ -3193,9 +3264,6 @@ struct RGFW_info {
         RGFW_window* kbOwner;
 		RGFW_window* mouseOwner; /* what window has access to the mouse */
 
-		u32 last_key;  /* wayland key repeat data */
-		i32 wl_repeat_info_rate, wl_repeat_info_delay;
-		u32 last_key_time;
     #endif
 
     RGFW_monitors monitors;
@@ -3244,7 +3312,6 @@ struct RGFW_info {
 /* for C++ / C89 */
 RGFWDEF RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags, RGFW_window* win);
 RGFWDEF void RGFW_window_closePlatform(RGFW_window* win);
-RGFWDEF RGFW_bool RGFW_window_setMousePlatform(RGFW_window* win, RGFW_mouse* mouse);
 
 RGFWDEF void RGFW_window_setFlagsInternal(RGFW_window* win, RGFW_windowFlags flags, RGFW_windowFlags cmpFlags);
 
@@ -3253,28 +3320,24 @@ RGFWDEF void RGFW_initKeycodesPlatform(void);
 RGFWDEF void RGFW_resetPrevState(void);
 RGFWDEF void RGFW_resetKey(void);
 RGFWDEF void RGFW_unloadEGL(void);
-RGFWDEF void RGFW_keyUpdateKeyModsEx(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool control, RGFW_bool alt, RGFW_bool shift, RGFW_bool super, RGFW_bool scroll);
-RGFWDEF void RGFW_keyUpdateKeyMods(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool scroll);
+RGFWDEF void RGFW_updateKeyModsEx(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool control, RGFW_bool alt, RGFW_bool shift, RGFW_bool super, RGFW_bool scroll);
+RGFWDEF void RGFW_updateKeyMods(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool scroll);
 RGFWDEF void RGFW_window_showMouseFlags(RGFW_window* win, RGFW_bool show);
-RGFWDEF void RGFW_keyUpdateKeyMod(RGFW_window* win, RGFW_keymod mod, RGFW_bool value);
-
+RGFWDEF void RGFW_updateKeyMod(RGFW_window* win, RGFW_keymod mod, RGFW_bool value);
 RGFWDEF void RGFW_monitors_refresh(void);
-RGFWDEF RGFW_monitorNode* RGFW_monitors_add(const RGFW_monitor* mon);
-RGFWDEF void RGFW_monitors_remove(RGFW_monitorNode* node, RGFW_monitorNode* prev);
 
 RGFWDEF void RGFW_windowMaximizedCallback(RGFW_window* win, i32 x, i32 y, i32 w, i32 h);
 RGFWDEF void RGFW_windowMinimizedCallback(RGFW_window* win);
 RGFWDEF void RGFW_windowRestoredCallback(RGFW_window* win, i32 x, i32 y, i32 w, i32 h);
 RGFWDEF void RGFW_windowMovedCallback(RGFW_window* win, i32 x, i32 y);
 RGFWDEF void RGFW_windowResizedCallback(RGFW_window* win, i32 w, i32 h);
-RGFWDEF void RGFW_windowCloseCallback(RGFW_window* win);
-RGFWDEF void RGFW_mouseMotionCallback(RGFW_window* win, i32 x, i32 y);
-RGFWDEF void RGFW_rawMotionCallback(RGFW_window* win, float x, float y);
-RGFWDEF void RGFW_windowRefreshCallback(RGFW_window* win, i32 x, i32 y, i32 w, i32 h);
-RGFWDEF void RGFW_windowFocusCallback(RGFW_window* win, RGFW_bool inFocus);
+RGFWDEF void RGFW_windowQuitCallback(RGFW_window* win);
+RGFWDEF void RGFW_mousePosCallback(RGFW_window* win, i32 x, i32 y, float vecX, float vecY);
+RGFWDEF void RGFW_windowRefreshCallback(RGFW_window* win);
+RGFWDEF void RGFW_focusCallback(RGFW_window* win, RGFW_bool inFocus);
 RGFWDEF void RGFW_mouseNotifyCallback(RGFW_window* win, i32 x, i32 y, RGFW_bool status);
-RGFWDEF void RGFW_dataDropCallback(RGFW_window* win, const char* data, size_t count, RGFW_dataTransferType dataType);
-RGFWDEF void RGFW_dataDragCallback(RGFW_window* win, RGFW_dataTransferType dataType, RGFW_dndActionType action, i32 x, i32 y);
+RGFWDEF void RGFW_dataDropCallback(RGFW_window* win, char** files, size_t count);
+RGFWDEF void RGFW_dataDragCallback(RGFW_window* win, i32 x, i32 y);
 RGFWDEF void RGFW_keyCharCallback(RGFW_window* win, u32 codepoint);
 RGFWDEF void RGFW_keyCallback(RGFW_window* win, RGFW_key key, RGFW_keymod mod, RGFW_bool repeat, RGFW_bool press);
 RGFWDEF void RGFW_mouseButtonCallback(RGFW_window* win, RGFW_mouseButton button, RGFW_bool press);
@@ -3360,10 +3423,16 @@ const char* RGFW_readClipboard(size_t* len) {
 	return (const char*)str;
 }
 
-/* generic RGFW defines */
+/*
+RGFW_IMPLEMENTATION starts with generic RGFW defines
+
+This is the start of keycode data
+*/
+
+
 
 void RGFW_initKeycodes(void) {
-	RGFW_MEMZERO(_RGFW->keycodes, sizeof(_RGFW->keycodes));
+	RGFW_MEMSET(_RGFW->keycodes, 0, sizeof(_RGFW->keycodes));
 	RGFW_initKeycodesPlatform();
 	size_t i, y;
     for (i = 0; i < RGFW_keyLast; i++) {
@@ -3392,66 +3461,64 @@ u32 RGFW_rgfwToApiKey(RGFW_key keycode) {
 	return _RGFW->apiKeycodes[keycode];
 }
 
-void RGFW_resetKey(void) { RGFW_MEMZERO(_RGFW->keyboard, sizeof(_RGFW->keyboard)); }
+void RGFW_resetKey(void) { RGFW_MEMSET(_RGFW->keyboard, 0, sizeof(_RGFW->keyboard)); }
 /*
 	this is the end of keycode data
 */
 
-RGFW_genericFunc RGFW_setEventCallback(RGFW_eventType type, RGFW_genericFunc func) {
-	RGFW_ASSERT(type > RGFW_eventNone && type < RGFW_eventCount);
-	RGFW_init();
+/*
+	event callback defines start here
+*/
 
-	RGFW_genericFunc old = _RGFW->callbacks[type];
-	_RGFW->callbacks[type] = func;
 
-	return old;
+/*
+	These exist to avoid the
+	if (func == NULL) check
+	for (allegedly) better performance
+
+	RGFW_EMPTY_DEF exists to prevent the missing-prototypes warning
+*/
+#define RGFW_CALLBACK_DEFINE(x, x2) \
+RGFW_##x##func RGFW_##x##CallbackSrc = NULL; \
+RGFW_##x##func RGFW_set##x2##Callback(RGFW_##x##func func) { \
+    RGFW_##x##func prev = RGFW_##x##CallbackSrc; \
+    RGFW_##x##CallbackSrc = func; \
+    return prev; \
 }
 
-void RGFW_setDualEventCallback(RGFW_eventType type, RGFW_genericFunc func, RGFW_genericFunc* first, RGFW_genericFunc* second) {
-	RGFW_genericFunc func1 = RGFW_setEventCallback(type, func);
-	RGFW_genericFunc func2 = RGFW_setEventCallback(type + 1, func);
-
-	if (first) *first = func1;
-	if (second) *second = func2;
-}
-
-void RGFW_setAllEventCallbacks(RGFW_genericFunc func, RGFW_callbacks* callbacks) {
-	for (RGFW_eventType i = RGFW_eventNone + 1; i < RGFW_eventCount; i++) {
-		if (callbacks) callbacks->arr[i] = _RGFW->callbacks[i];
-		RGFW_setEventCallback(i, func);
-	}
-}
-
-RGFW_debugFunc RGFW_setDebugCallback(RGFW_debugFunc func) {
-	RGFW_init();
-	RGFW_debugFunc prev = _RGFW->debugCallbackSrc;
-	_RGFW->debugCallbackSrc = func;
-	return prev;
-}
-
-void RGFW_eventQueuePushAndCall(const RGFW_event* event) {
-	RGFW_ASSERT(event->type > RGFW_eventNone && event->type < RGFW_eventCount);
-	if (_RGFW->callbacks[event->type]) (_RGFW->callbacks[event->type])(event);
-	RGFW_eventQueuePush(event);
-}
+RGFW_CALLBACK_DEFINE(windowMaximized, WindowMaximized)
+RGFW_CALLBACK_DEFINE(windowMinimized, WindowMinimized)
+RGFW_CALLBACK_DEFINE(windowRestored, WindowRestored)
+RGFW_CALLBACK_DEFINE(windowMoved, WindowMoved)
+RGFW_CALLBACK_DEFINE(windowResized, WindowResized)
+RGFW_CALLBACK_DEFINE(windowQuit, WindowQuit)
+RGFW_CALLBACK_DEFINE(mousePos, MousePos)
+RGFW_CALLBACK_DEFINE(windowRefresh, WindowRefresh)
+RGFW_CALLBACK_DEFINE(focus, Focus)
+RGFW_CALLBACK_DEFINE(mouseNotify, MouseNotify)
+RGFW_CALLBACK_DEFINE(dataDrop, DataDrop)
+RGFW_CALLBACK_DEFINE(dataDrag, DataDrag)
+RGFW_CALLBACK_DEFINE(key, Key)
+RGFW_CALLBACK_DEFINE(keyChar, KeyChar)
+RGFW_CALLBACK_DEFINE(mouseButton, MouseButton)
+RGFW_CALLBACK_DEFINE(mouseScroll, MouseScroll)
+RGFW_CALLBACK_DEFINE(scaleUpdated, ScaleUpdated)
+RGFW_CALLBACK_DEFINE(monitor, Monitor)
+RGFW_CALLBACK_DEFINE(debug, Debug)
+#define RGFW_debugCallback(type, err, msg) if (RGFW_debugCallbackSrc) RGFW_debugCallbackSrc(type, err, msg);
+#undef RGFW_CALLBACK_DEFINE
 
 void RGFW_windowMaximizedCallback(RGFW_window* win, i32 x, i32 y, i32 w, i32 h) {
 	win->internal.flags |= RGFW_windowMaximize;
-	win->x = x;
-	win->y = y;
-	win->w = w;
-	win->h = h;
 
 	if (!(win->internal.enabledEvents & RGFW_windowMaximizedFlag)) return;
 
 	RGFW_event event;
 	event.type = RGFW_windowMaximized;
-	event.update.x = x;
-	event.update.y = y;
-	event.update.w = w;
-	event.update.h = h;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowMaximizedCallbackSrc) RGFW_windowMaximizedCallbackSrc(win, x, y, w, h);
 }
 
 void RGFW_windowMinimizedCallback(RGFW_window* win) {
@@ -3461,33 +3528,24 @@ void RGFW_windowMinimizedCallback(RGFW_window* win) {
 
 	RGFW_event event;
 	event.type = RGFW_windowMinimized;
-	event.update.x = win->x;
-	event.update.y = win->y;
-	event.update.w = win->w;
-	event.update.h = win->h;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowMinimizedCallbackSrc) RGFW_windowMinimizedCallbackSrc(win);
 }
 
 void RGFW_windowRestoredCallback(RGFW_window* win, i32 x, i32 y, i32 w, i32 h) {
 	win->internal.flags &= ~(u32)RGFW_windowMinimize;
-	win->x = x;
-	win->y = y;
-	win->w = w;
-	win->h = h;
-
 	if (RGFW_window_isMaximized(win) == RGFW_FALSE) win->internal.flags &= ~(u32)RGFW_windowMaximize;
 
 	if (!(win->internal.enabledEvents & RGFW_windowRestoredFlag)) return;
 
 	RGFW_event event;
 	event.type = RGFW_windowRestored;
-	event.update.x = x;
-	event.update.y = y;
-	event.update.w = w;
-	event.update.h = h;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowRestoredCallbackSrc) RGFW_windowRestoredCallbackSrc(win, x, y, w, h);
 }
 
 void RGFW_windowMovedCallback(RGFW_window* win, i32 x, i32 y) {
@@ -3497,12 +3555,10 @@ void RGFW_windowMovedCallback(RGFW_window* win, i32 x, i32 y) {
 
 	RGFW_event event;
 	event.type = RGFW_windowMoved;
-	event.update.x = x;
-	event.update.y = y;
-	event.update.w = win->w;
-	event.update.h = win->h;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowMovedCallbackSrc) RGFW_windowMovedCallbackSrc(win, x, y);
 }
 
 void RGFW_windowResizedCallback(RGFW_window* win, i32 w, i32 h) {
@@ -3512,64 +3568,55 @@ void RGFW_windowResizedCallback(RGFW_window* win, i32 w, i32 h) {
 	if (!(win->internal.enabledEvents & RGFW_windowResizedFlag)) return;
 	RGFW_event event;
 	event.type = RGFW_windowResized;
-	event.update.x = win->x;
-	event.update.y = win->y;
-	event.update.w = w;
-	event.update.h = h;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowResizedCallbackSrc) RGFW_windowResizedCallbackSrc(win, w, h);
 }
 
-void RGFW_windowCloseCallback(RGFW_window* win) {
+void RGFW_windowQuitCallback(RGFW_window* win) {
 	win->internal.shouldClose = RGFW_TRUE;
 
 	RGFW_event event;
-	event.type = RGFW_windowClose;
+	event.type = RGFW_quit;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowQuitCallbackSrc) RGFW_windowQuitCallbackSrc(win);
 }
 
-void RGFW_mouseMotionCallback(RGFW_window* win, i32 x, i32 y) {
+void RGFW_mousePosCallback(RGFW_window* win, i32 x, i32 y, float vecX, float vecY) {
 	win->internal.lastMouseX = x;
 	win->internal.lastMouseY = y;
+	_RGFW->vectorX = vecX;
+	_RGFW->vectorY = vecY;
 
-	if (!(win->internal.enabledEvents & RGFW_mouseMotionFlag)) return;
+	if (!(win->internal.enabledEvents & RGFW_mousePosChangedFlag)) return;
 
 	RGFW_event event;
-	event.type = RGFW_mouseMotion;
+	event.type = RGFW_mousePosChanged;
 	event.mouse.x = x;
 	event.mouse.y = y;
-	event.mouse.inWindow = win->internal.mouseInside;
+	event.mouse.vecX = vecX;
+	event.mouse.vecY = vecY;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_mousePosCallbackSrc) RGFW_mousePosCallbackSrc(win, x, y, vecX, vecY);
 }
 
-void RGFW_rawMotionCallback(RGFW_window* win, float x, float y) {
-	_RGFW->vectorX = x;
-	_RGFW->vectorY = y;
-	if (!(win->internal.enabledEvents & RGFW_mouseRawMotionFlag)) return;
-
-	RGFW_event event;
-	event.type = RGFW_mouseRawMotion;
-	event.delta.x = x;
-	event.delta.y = y;
-	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
-}
-
-void RGFW_windowRefreshCallback(RGFW_window* win, i32 x, i32 y, i32 w, i32 h) {
+void RGFW_windowRefreshCallback(RGFW_window* win) {
 	if (!(win->internal.enabledEvents & RGFW_windowRefreshFlag)) return;
 	RGFW_event event;
 	event.type = RGFW_windowRefresh;
-	event.update.x = x;
-	event.update.y = y;
-	event.update.w = w;
-	event.update.h = h;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_windowRefreshCallbackSrc) RGFW_windowRefreshCallbackSrc(win);
 }
 
-void RGFW_windowFocusCallback(RGFW_window* win, RGFW_bool inFocus) {
+void RGFW_focusCallback(RGFW_window* win, RGFW_bool inFocus) {
 	win->internal.inFocus = inFocus;
 
 	if (win->internal.captureMouse) {
@@ -3578,13 +3625,12 @@ void RGFW_windowFocusCallback(RGFW_window* win, RGFW_bool inFocus) {
 
 	RGFW_event event;
 	event.common.win = win;
-	event.focus.state = inFocus;
 
 	if (inFocus == RGFW_TRUE) {
 		if ((win->internal.flags & RGFW_windowFullscreen))
 			RGFW_window_raise(win);
 
-		event.type = RGFW_windowFocusIn;
+		event.type = RGFW_focusIn;
 	} else if (inFocus == RGFW_FALSE) {
 		if ((win->internal.flags & RGFW_windowFullscreen))
 			RGFW_window_minimize(win);
@@ -3600,12 +3646,14 @@ void RGFW_windowFocusCallback(RGFW_window* win, RGFW_bool inFocus) {
 		}
 
 		RGFW_resetKey();
-		event.type = RGFW_windowFocusOut;
+		event.type = RGFW_focusOut;
 	}
 
 	event.common.win = win;
 
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_focusCallbackSrc) RGFW_focusCallbackSrc(win, inFocus);
 }
 
 void RGFW_mouseNotifyCallback(RGFW_window* win, i32 x, i32 y, RGFW_bool status) {
@@ -3619,7 +3667,6 @@ void RGFW_mouseNotifyCallback(RGFW_window* win, i32 x, i32 y, RGFW_bool status)
 	event.common.win = win;
 	event.mouse.x = x;
 	event.mouse.y = y;
-	event.mouse.inWindow = win->internal.mouseInside;
 
 	if (status) {
 		if (!(win->internal.enabledEvents & RGFW_mouseEnterFlag)) return;
@@ -3633,68 +3680,45 @@ void RGFW_mouseNotifyCallback(RGFW_window* win, i32 x, i32 y, RGFW_bool status)
 		event.type = RGFW_mouseLeave;
 	}
 
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_mouseNotifyCallbackSrc) RGFW_mouseNotifyCallbackSrc(win, x, y, status);
 }
 
-void RGFW_dataDropCallback(RGFW_window* win, const char* data, size_t size, RGFW_dataTransferType dataType) {
+void RGFW_dataDropCallback(RGFW_window* win, char** files, size_t count) {
 	if (!(win->internal.enabledEvents & RGFW_dataDropFlag) || !(win->internal.flags & RGFW_windowAllowDND))
 		return;
 
 	_RGFW->windowState.win = win;
 	_RGFW->windowState.dataDrop = RGFW_TRUE;
-	_RGFW->windowState.dataSize = size;
-
-	RGFW_dataDropNode node;
-	RGFW_MEMZERO(&node, sizeof(node));
-	node.data = data;
-	node.size = size;
-	node.type = dataType;
-	node.next = NULL;
+	_RGFW->windowState.filesCount = count;
 
 	RGFW_event event;
 	event.type = RGFW_dataDrop;
-	event.drop.value = &node;
-	event.drop.win = win;
+	event.drop.files = files;
+	event.drop.count = count;
+	event.common.win = win;
+	RGFW_eventQueuePush(&event);
 
-	if (_RGFW->callbacks[event.type]) (_RGFW->callbacks[event.type])(&event);
-
-	if (_RGFW->queueEvents == RGFW_TRUE || _RGFW->dndBuild) {
-		if (_RGFW->dndRoot == NULL) {
-			_RGFW->dndRoot = (RGFW_dataDropNode*)RGFW_ALLOC(sizeof(RGFW_dataDropNode));
-			_RGFW->dndCur =	_RGFW->dndRoot;
-		} else if (_RGFW->dndCur) {
-			_RGFW->dndCur->next = (RGFW_dataDropNode*)RGFW_ALLOC(sizeof(RGFW_dataDropNode));
-			_RGFW->dndCur = _RGFW->dndCur->next;
-		} else { RGFW_ASSERT(0); }
-
-		char* dataCopy = (char*)RGFW_ALLOC(size);
-		RGFW_MEMCPY(dataCopy, data, size);
-		node.data = dataCopy;
-
-		RGFW_MEMCPY(_RGFW->dndCur, &node, sizeof(node));
-
-		event.drop.value = _RGFW->dndCur;
-		RGFW_eventQueuePush(&event);
-	}
+	if (RGFW_dataDropCallbackSrc) RGFW_dataDropCallbackSrc(win, files, count);
 }
 
-void RGFW_dataDragCallback(RGFW_window* win, RGFW_dataTransferType dataType, RGFW_dndActionType action, i32 x, i32 y) {
-	if (!(win->internal.enabledEvents & RGFW_dataDragFlag) || !(win->internal.flags & RGFW_windowAllowDND)) return;
-
+void RGFW_dataDragCallback(RGFW_window* win, i32 x, i32 y) {
 	_RGFW->windowState.win = win;
 	_RGFW->windowState.dataDragging = RGFW_TRUE;
 	_RGFW->windowState.dropX = x;
 	_RGFW->windowState.dropY = y;
 
+	if (win->internal.enabledEvents & RGFW_dataDragFlag) return;
+
 	RGFW_event event;
 	event.type = RGFW_dataDrag;
 	event.drag.x = x;
 	event.drag.y = y;
-	event.drag.action = action;
-	event.drag.dataType = dataType;
 	event.common.win = win;
+	RGFW_eventQueuePush(&event);
 
-	RGFW_eventQueuePushAndCall(&event);
+	if (RGFW_dataDragCallbackSrc) RGFW_dataDragCallbackSrc(win, x, y);
 }
 
 void RGFW_keyCharCallback(RGFW_window* win, u32 codepoint) {
@@ -3704,7 +3728,9 @@ void RGFW_keyCharCallback(RGFW_window* win, u32 codepoint) {
 	event.type = RGFW_keyChar;
 	event.keyChar.value = codepoint;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_keyCharCallbackSrc) RGFW_keyCharCallbackSrc(win, codepoint);
 }
 
 void RGFW_keyCallback(RGFW_window* win, RGFW_key key, RGFW_keymod mod, RGFW_bool repeat, RGFW_bool press) {
@@ -3722,16 +3748,16 @@ void RGFW_keyCallback(RGFW_window* win, RGFW_key key, RGFW_keymod mod, RGFW_bool
 	_RGFW->keyboard[key].current = press;
 
 	event.key.value = key;
-	event.key.repeat = repeat;
+	event.key.mod = repeat;
 	event.key.mod = mod;
-	event.key.state = press;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_keyCallbackSrc) RGFW_keyCallbackSrc(win, key, mod, repeat, press);
 }
 
 void RGFW_mouseButtonCallback(RGFW_window* win, RGFW_mouseButton button, RGFW_bool press) {
 	RGFW_event event;
-
 	if (press) {
 		if (!(win->internal.enabledEvents & RGFW_mouseButtonPressedFlag)) return;
 		event.type = RGFW_mouseButtonPressed;
@@ -3744,9 +3770,10 @@ void RGFW_mouseButtonCallback(RGFW_window* win, RGFW_mouseButton button, RGFW_bo
 	_RGFW->mouseButtons[button].current = press;
 
 	event.button.value = button;
-	event.button.state = press;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_mouseButtonCallbackSrc) RGFW_mouseButtonCallbackSrc(win, button, press);
 }
 
 void RGFW_mouseScrollCallback(RGFW_window* win, float x, float y) {
@@ -3756,13 +3783,16 @@ void RGFW_mouseScrollCallback(RGFW_window* win, float x, float y) {
 
 	RGFW_event event;
 	event.type = RGFW_mouseScroll;
-	event.delta.x = x;
-	event.delta.y = y;
+	event.scroll.x = x;
+	event.scroll.y = y;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_mouseScrollCallbackSrc) RGFW_mouseScrollCallbackSrc(win, x, y);
 }
 
 void RGFW_scaleUpdatedCallback(RGFW_window* win, float scaleX, float scaleY) {
+	if (win->internal.flags & RGFW_windowScaleToMonitor) RGFW_window_scaleToMonitor(win);
 	if (!(win->internal.enabledEvents & RGFW_scaleUpdatedFlag)) return;
 
 	RGFW_event event;
@@ -3770,7 +3800,9 @@ void RGFW_scaleUpdatedCallback(RGFW_window* win, float scaleX, float scaleY) {
 	event.scale.x = scaleX;
 	event.scale.y = scaleY;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_scaleUpdatedCallbackSrc) RGFW_scaleUpdatedCallbackSrc(win, scaleX, scaleY);
 }
 
 void RGFW_monitorCallback(RGFW_window* win, const RGFW_monitor* monitor, RGFW_bool connected) {
@@ -3780,30 +3812,26 @@ void RGFW_monitorCallback(RGFW_window* win, const RGFW_monitor* monitor, RGFW_bo
 	}
 
 	RGFW_event event;
-	event.type = (connected) ? (RGFW_eventType)(RGFW_monitorConnected) : (RGFW_eventType)(RGFW_monitorDisconnected);
+	event.type = (connected) ? (RGFW_monitorConnected) : (RGFW_monitorDisconnected);
 	event.monitor.monitor = monitor;
-	event.monitor.state = connected;
 	event.common.win = win;
-	RGFW_eventQueuePushAndCall(&event);
+	RGFW_eventQueuePush(&event);
+
+	if (RGFW_monitorCallbackSrc) RGFW_monitorCallbackSrc(win, monitor, connected);
 }
 
 #ifdef RGFW_DEBUG
 #include <stdio.h>
 #endif
 
-void RGFW_debugCallback(RGFW_debugType type, RGFW_errorCode code, const char* msg) {
-	RGFW_debugInfo info;
-	info.type = type;
-	info.code = code;
-	info.msg = msg;
-
-	if (_RGFW && _RGFW->debugCallbackSrc) _RGFW->debugCallbackSrc(&info);
+void RGFW_sendDebugInfo(RGFW_debugType type, RGFW_errorCode err, const char* msg) {
+	RGFW_debugCallback(type, err, msg);
 
     #ifdef RGFW_DEBUG
 	switch (type) {
-		case RGFW_typeInfo: RGFW_PRINTF("RGFW INFO (%i %i): %s", type, code, msg); break;
-		case RGFW_typeError: RGFW_PRINTF("RGFW DEBUG (%i %i): %s", type, code, msg); break;
-		case RGFW_typeWarning: RGFW_PRINTF("RGFW WARNING (%i %i): %s", type, code, msg); break;
+		case RGFW_typeInfo: RGFW_PRINTF("RGFW INFO (%i %i): %s", type, err, msg); break;
+		case RGFW_typeError: RGFW_PRINTF("RGFW DEBUG (%i %i): %s", type, err, msg); break;
+		case RGFW_typeWarning: RGFW_PRINTF("RGFW WARNING (%i %i): %s", type, err, msg); break;
 		default: break;
 	}
 
@@ -3862,40 +3890,13 @@ RGFW_bool RGFW_window_getSizeInPixels(RGFW_window* win, i32* w, i32* h) {
 	#include "XDL.h"
 #endif
 
-#ifndef RGFW_NO_STATIC_CONTEXT
-
-i32 RGFW_init(void) {
-	static RGFW_info _rgfwGlobal;
-	return RGFW_init_ptr(&_rgfwGlobal);
-}
-
-
-void RGFW_deinit(void) { RGFW_deinit_ptr(_RGFW); }
-
-#else
-
-RGFW_info* _rgfwGlobal;
-
-i32 RGFW_init(void) {
-	if (_rgfwGlobal != NULL) {
-		RGFW_FREE(_rgfwGlobal);
-	}
-
-	_rgfwGlobal = (RGFW_info*)RGFW_ALLOC(sizeof(RGFW_info));
-
-	return RGFW_init_ptr(&_rgfwGlobal);
-}
-
-void RGFW_deinit(void) {
-	if (_RGFW == _rgfwGlobal) {
-		RGFW_FREE(_rgfwGlobal);
-		_rgfwGlobal = NULL;
-	}
-	RGFW_deinit_ptr(_RGFW);
-}
-
+#ifndef RGFW_FORCE_INIT
+RGFW_info _rgfwGlobal;
 #endif
 
+i32 RGFW_init(void) { return RGFW_init_ptr(&_rgfwGlobal); }
+void RGFW_deinit(void) { RGFW_deinit_ptr(&_rgfwGlobal); }
+
 i32 RGFW_initPlatform(void);
 void RGFW_deinitPlatform(void);
 
@@ -3903,36 +3904,35 @@ i32 RGFW_init_ptr(RGFW_info* info) {
     if (info == _RGFW || info == NULL) return 1;
 
     RGFW_setInfo(info);
-    RGFW_MEMZERO(_RGFW, sizeof(RGFW_info));
+    RGFW_MEMSET(_RGFW, 0, sizeof(RGFW_info));
 	_RGFW->queueEvents = RGFW_FALSE;
 	_RGFW->polledEvents = RGFW_FALSE;
 #ifdef RGFW_WAYLAND
 	_RGFW->useWaylandBool = RGFW_TRUE;
 #endif
 
-	#if (RGFW_PREALLOCATED_MONITORS)
-		_RGFW->monitors.freeList.head = &_RGFW->monitors.data[0];
-		_RGFW->monitors.freeList.cur = _RGFW->monitors.freeList.head;
+	_RGFW->files = (char**)(void*)_RGFW->filesSrc;
+	u32 i;
+	for (i = 0; i < RGFW_MAX_DROPS; i++)
+		_RGFW->files[i] = (char*)(_RGFW->filesSrc + RGFW_MAX_DROPS + (i * RGFW_MAX_PATH));
 
-		for (size_t i = 1; i < RGFW_PREALLOCATED_MONITORS; i++) {
-			RGFW_monitorNode* newNode = &_RGFW->monitors.data[i];
-			_RGFW->monitors.freeList.cur->next = newNode;
-			_RGFW->monitors.freeList.cur = _RGFW->monitors.freeList.cur->next;
-		}
-	#endif
+	_RGFW->monitors.freeList.head = &_RGFW->monitors.data[0];
+	_RGFW->monitors.freeList.cur = _RGFW->monitors.freeList.head;
+
+	for (i = 1; i < RGFW_MAX_MONITORS; i++) {
+		RGFW_monitorNode* newNode = &_RGFW->monitors.data[i];
+		_RGFW->monitors.freeList.cur->next = newNode;
+		_RGFW->monitors.freeList.cur = _RGFW->monitors.freeList.cur->next;
+	}
 
 	_RGFW->monitors.list.head = NULL;
 	_RGFW->monitors.list.head = NULL;
     RGFW_initKeycodes();
     i32 out = RGFW_initPlatform();
 
-	for (size_t i = 0; i < RGFW_mouseIconCount; i++) {
-        _RGFW->standardMice[i] = RGFW_createMouseStandard((RGFW_mouseIcon)i);
-	}
-
 	RGFW_pollMonitors();
 
-    RGFW_debugCallback(RGFW_typeInfo, RGFW_infoGlobal, "global context initialized");
+    RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoGlobal, "global context initialized");
 
 	return out;
 }
@@ -3946,17 +3946,12 @@ void RGFW_deinit_ptr(RGFW_info* info) {
 
     RGFW_setInfo(info);
 	RGFW_unloadEGL();
-
-	for (RGFW_mouseIcon i = 0; i < RGFW_mouseIconCount; i++) {
-		if (_RGFW->standardMice[i]) RGFW_freeMouse(_RGFW->standardMice[i]);
-	}
-
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoGlobal, "global context deinitialized");
 	RGFW_deinitPlatform();
 
     _RGFW->root = NULL;
     _RGFW->windowCount = 0;
     RGFW_setInfo(NULL);
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoGlobal, "global context deinitialized");
 }
 
 RGFW_window* RGFW_createWindow(const char* name, i32 x, i32 y, i32 w, i32 h, RGFW_windowFlags flags) {
@@ -3975,7 +3970,7 @@ RGFW_window* RGFW_createWindowPtr(const char* name, i32 x, i32 y, i32 w, i32 h,
 	RGFW_ASSERT(win != NULL);
 	if (name == NULL) name = "\0";
 
-	RGFW_MEMZERO(win, sizeof(RGFW_window));
+	RGFW_MEMSET(win, 0, sizeof(RGFW_window));
 
 	if (_RGFW == NULL) RGFW_init();
 	_RGFW->windowCount++;
@@ -3990,17 +3985,11 @@ RGFW_window* RGFW_createWindowPtr(const char* name, i32 x, i32 y, i32 w, i32 h,
 	win->y = y;
 	win->w = w;
 	win->h = h;
-	win->internal.mouse = _RGFW->standardMice[RGFW_mouseNormal];
 	win->internal.flags = flags;
 	win->internal.enabledEvents = RGFW_allEventFlags;
 
-	RGFW_windowFlags reservedFlags = flags & (RGFW_windowScaleToMonitor);
-	flags &= ~reservedFlags;
-
 	RGFW_window* ret = RGFW_createWindowPlatform(name, flags, win);
 
-	flags |= reservedFlags;
-
 #ifndef RGFW_X11
 	RGFW_window_setFlagsInternal(win, flags, 0);
 #endif
@@ -4038,7 +4027,7 @@ RGFW_window* RGFW_createWindowPtr(const char* name, i32 x, i32 y, i32 w, i32 h,
 		/* NOTE: this is a hack so that way wayland spawns a window, even if nothing is drawn */
 		if (!(flags & RGFW_windowOpenGL) && !(flags & RGFW_windowEGL)) {
 			u8* data = (u8*)RGFW_ALLOC((u32)(win->w * win->h * 3));
-			RGFW_MEMZERO(data, (u32)(win->w * win->h * 3) * sizeof(u8));
+			RGFW_MEMSET(data, 0, (u32)(win->w * win->h * 3) * sizeof(u8));
 			RGFW_surface* surface = RGFW_createSurface(data, win->w, win->h, RGFW_formatBGR8);
 			RGFW_window_blitSurface(win, surface);
 			RGFW_FREE(data);
@@ -4057,7 +4046,7 @@ RGFW_window* RGFW_createWindowPtr(const char* name, i32 x, i32 y, i32 w, i32 h,
 		RGFW_window_show(win);
 	}
 
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoWindow, "a new window was created");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoWindow, "a new window was created");
 
 	return ret;
 }
@@ -4088,7 +4077,7 @@ void RGFW_window_closePtr(RGFW_window* win) {
 	RGFW_clipboard_switch(NULL);
 
 	_RGFW->windowCount--;
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoWindow, "a window was freed");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoWindow, "a window was freed");
 
 	if (_RGFW->windowCount == 0 && !(win->internal.flags & RGFW_noDeinitOnClose)) RGFW_deinit();
 }
@@ -4102,7 +4091,7 @@ void RGFW_eventQueuePush(const RGFW_event* event) {
 	RGFW_ASSERT(_RGFW->eventLen >= 0);
 
 	if (_RGFW->eventLen >= RGFW_MAX_EVENTS) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errEventQueue, "Event queue limit 'RGFW_MAX_EVENTS' has been reached automatically flushing queue.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errEventQueue, "Event queue limit 'RGFW_MAX_EVENTS' has been reached automatically flushing queue.");
 		RGFW_eventQueueFlush();
 		return;
 	}
@@ -4163,16 +4152,7 @@ void RGFW_resetPrevState(void) {
 	_RGFW->scrollY = 0.0f;
 	_RGFW->vectorX = (float)0.0f;
 	_RGFW->vectorY = (float)0.0f;
-	RGFW_MEMZERO(&_RGFW->windowState, sizeof(_RGFW->windowState));
-
-	for (RGFW_dataDropNode* node = _RGFW->dndRoot; node; ) {
-		RGFW_dataDropNode* next = node->next;
-		RGFW_FREE(node);
-		node = next;
-	}
-
-	_RGFW->dndRoot = NULL;
-	_RGFW->dndCur = NULL;
+	RGFW_MEMSET(&_RGFW->windowState, 0, sizeof(_RGFW->windowState));
 }
 
 RGFW_bool RGFW_isKeyPressed(RGFW_key key) {
@@ -4219,7 +4199,7 @@ RGFW_bool RGFW_window_didMouseEnter(RGFW_window* win) { return _RGFW->windowStat
 RGFW_bool RGFW_window_isMouseInside(RGFW_window* win) { return win->internal.mouseInside;  }
 
 RGFW_bool RGFW_window_isDataDragging(RGFW_window* win) { return RGFW_window_getDataDrag(win, (i32*)NULL, (i32*)NULL); }
-RGFW_bool RGFW_window_didDataDrop(RGFW_window* win) { return RGFW_window_getDataDrop(win) != NULL;}
+RGFW_bool RGFW_window_didDataDrop(RGFW_window* win) { return RGFW_window_getDataDrop(win, (const char***)NULL, (size_t*)NULL);}
 
 
 RGFW_bool RGFW_window_getDataDrag(RGFW_window* win, i32* x, i32* y) {
@@ -4228,9 +4208,11 @@ RGFW_bool RGFW_window_getDataDrag(RGFW_window* win, i32* x, i32* y) {
 	if (y) *y =  _RGFW->windowState.dropY;
 	return RGFW_TRUE;
 }
-RGFW_dataDropNode* RGFW_window_getDataDrop(RGFW_window* win) {
-	if (_RGFW->windowState.win != win || _RGFW->windowState.dataDrop == RGFW_FALSE) return NULL;
-	return _RGFW->dndRoot;
+RGFW_bool RGFW_window_getDataDrop(RGFW_window* win, const char*** files, size_t* count) {
+	if (_RGFW->windowState.win != win || _RGFW->windowState.dataDrop == RGFW_FALSE) return RGFW_FALSE;
+	if (files) *files = (const char**)_RGFW->files;
+	if (count) *count = _RGFW->windowState.filesCount;
+	return RGFW_TRUE;
 }
 
 RGFW_bool RGFW_window_checkEvent(RGFW_window* win, RGFW_event* event) {
@@ -4286,6 +4268,7 @@ RGFW_bool RGFW_loadEGL(void) { return RGFW_FALSE; }
 void RGFW_window_setFlagsInternal(RGFW_window* win, RGFW_windowFlags flags, RGFW_windowFlags cmpFlags) {
 	if (flags & RGFW_windowNoBorder)            RGFW_window_setBorder(win, 0);
 	else if (cmpFlags & RGFW_windowNoBorder)    RGFW_window_setBorder(win, 1);
+	if (flags & RGFW_windowScaleToMonitor)      RGFW_window_scaleToMonitor(win);
 	if (flags & RGFW_windowMaximize)            RGFW_window_maximize(win);
 	else if (cmpFlags & RGFW_windowMaximize)    RGFW_window_restore(win);
 	if (flags & RGFW_windowMinimize)            RGFW_window_minimize(win);
@@ -4305,7 +4288,6 @@ void RGFW_window_setFlagsInternal(RGFW_window* win, RGFW_windowFlags flags, RGFW
 	if (flags & RGFW_windowCaptureMouse)			RGFW_window_captureRawMouse(win, RGFW_TRUE);
 	else if (cmpFlags & RGFW_windowCaptureMouse)	RGFW_window_captureMouse(win, RGFW_FALSE);
 	if (flags & RGFW_windowFocus)               RGFW_window_focus(win);
-	if (flags & RGFW_windowScaleToMonitor)      RGFW_window_scaleToMonitor(win);
 
 	if (flags & RGFW_windowNoResize) {
 	    RGFW_window_setMaxSize(win, win->w, win->h);
@@ -4330,7 +4312,6 @@ RGFW_bool RGFW_window_isInFocus(RGFW_window* win) {
 }
 
 void RGFW_setClassName(const char* name) { RGFW_init(); _RGFW->className = name; }
-void RGFW_setBuildDND(RGFW_bool state) { _RGFW->dndBuild = state; }
 
 #ifndef RGFW_X11
 void RGFW_setXInstName(const char* name) { RGFW_UNUSED(name); }
@@ -4385,7 +4366,7 @@ void RGFW_window_center(RGFW_window* win) {
 	RGFW_monitor* mon = RGFW_window_getMonitor(win);
 	if (mon == NULL) return;
 
-	RGFW_window_move(win, mon->x + ((i32)(mon->mode.w - win->w) / 2), mon->y + ((mon->mode.h - win->h) / 2));
+	RGFW_window_move(win, (i32)(mon->mode.w - win->w) / 2, (mon->mode.h - win->h) / 2);
 }
 
 RGFW_bool RGFW_monitor_scaleToWindow(RGFW_monitor* mon, RGFW_window* win) {
@@ -4396,6 +4377,7 @@ RGFW_bool RGFW_monitor_scaleToWindow(RGFW_monitor* mon, RGFW_window* win) {
 	mode.h = win->h;
 	RGFW_bool ret = RGFW_monitor_requestMode(mon, &mode, RGFW_monitorScale);
 
+
 	/* move window to monitor origin so it doesn't move to the next monitor */
 	RGFW_window_move(win, mon->x, mon->y);
 
@@ -4421,12 +4403,12 @@ RGFW_bool RGFW_monitorModeCompare(RGFW_monitorMode* mon, RGFW_monitorMode* mon2,
 }
 
 RGFW_bool RGFW_window_shouldClose(RGFW_window* win) {
-	return (win == NULL || win->internal.shouldClose || (win->internal.exitKey && RGFW_isKeyDown(win->internal.exitKey)));
+	return (win == NULL || win->internal.shouldClose || (win->internal.exitKey && RGFW_window_isKeyDown(win, win->internal.exitKey)));
 }
 
 void RGFW_window_setShouldClose(RGFW_window* win, RGFW_bool shouldClose) {
 	if (shouldClose)  {
-		RGFW_windowCloseCallback(win);
+		RGFW_windowQuitCallback(win);
 	} else {
 		win->internal.shouldClose = RGFW_FALSE;
 	}
@@ -4446,7 +4428,7 @@ void RGFW_window_moveToMonitor(RGFW_window* win, RGFW_monitor* m) {
 
 RGFW_surface* RGFW_createSurface(u8* data, i32 w, i32 h, RGFW_format format) {
 	RGFW_surface* surface = (RGFW_surface*)RGFW_ALLOC(sizeof(RGFW_surface));
-	RGFW_MEMZERO(surface, sizeof(RGFW_surface));
+	RGFW_MEMSET(surface, 0, sizeof(RGFW_surface));
 	RGFW_createSurfacePtr(data, w, h, format, surface);
 	return surface;
 }
@@ -4466,7 +4448,7 @@ RGFW_nativeImage* RGFW_surface_getNativeImage(RGFW_surface* surface) {
 
 RGFW_surface* RGFW_window_createSurface(RGFW_window* win, u8* data, i32 w, i32 h, RGFW_format format) {
 	RGFW_surface* surface = (RGFW_surface*)RGFW_ALLOC(sizeof(RGFW_surface));
-	RGFW_MEMZERO(surface, sizeof(RGFW_surface));
+	RGFW_MEMSET(surface, 0, sizeof(RGFW_surface));
 	RGFW_window_createSurfacePtr(win, data, w, h, format, surface);
 	return surface;
 }
@@ -4538,22 +4520,14 @@ void RGFW_copyImageData64(u8* dest_data, i32 dest_w, i32 dest_h, RGFW_format des
 
 RGFW_monitorNode* RGFW_monitors_add(const RGFW_monitor* mon) {
 	RGFW_monitorNode* node = NULL;
+	if (_RGFW->monitors.freeList.head == NULL) return node;
 
-	#if (RGFW_PREALLOCATED_MONITORS)
-		node = _RGFW->monitors.freeList.head;
-		if (node) {
-			_RGFW->monitors.freeList.head = node->next;
-			if (_RGFW->monitors.freeList.head == NULL) {
-				_RGFW->monitors.freeList.cur = NULL;
-			}
-		} else
-	#elif !defined(RGFW_NO_ALLOCATE_MONITORS)
-	{
-		node = (RGFW_monitorNode*)RGFW_ALLOC(sizeof(RGFW_monitorNode));
+	node = _RGFW->monitors.freeList.head;
+
+	_RGFW->monitors.freeList.head = node->next;
+	if (_RGFW->monitors.freeList.head == NULL) {
+		_RGFW->monitors.freeList.cur = NULL;
 	}
-	#endif
-
-	if (node == NULL) return NULL;
 
 	node->next = NULL;
 
@@ -4585,23 +4559,14 @@ void RGFW_monitors_remove(RGFW_monitorNode* node, RGFW_monitorNode* prev) {
 
 	node->next = NULL;
 
-	#if (RGFW_PREALLOCATED_MONITORS)
-	/* check if the monitor was allocated in the heap or not */
-	if (node >= _RGFW->monitors.data && node <= &_RGFW->monitors.data[RGFW_PREALLOCATED_MONITORS - 1]) {
-		/* move node to the free list */
-		if (_RGFW->monitors.freeList.head == NULL) {
-			_RGFW->monitors.freeList.head = node;
-		} else {
-			_RGFW->monitors.freeList.cur->next = node;
-		}
-
-		_RGFW->monitors.freeList.cur = node;
-	} else
-	{
-	#elif !defined(RGFW_NO_ALLOCATE_MONITORS)
-		RGFW_FREE(node);
-	#endif
+	/* move node to the free list */
+	if (_RGFW->monitors.freeList.head == NULL) {
+		_RGFW->monitors.freeList.head = node;
+	} else {
+		_RGFW->monitors.freeList.cur->next = node;
 	}
+
+	_RGFW->monitors.freeList.cur = node;
 }
 
 void RGFW_monitors_refresh(void) {
@@ -4746,49 +4711,23 @@ RGFW_bool RGFW_monitor_setGamma(RGFW_monitor* monitor, float gamma) {
 }
 
 RGFW_monitor** RGFW_getMonitors(size_t* len) {
-	if (len != NULL) *len = 0;
-
-	size_t count = 0;
-	if (RGFW_getMonitorsPtr(0, NULL, &count) == RGFW_FALSE || count == 0) return NULL;
-
-	RGFW_monitor** monitors = (RGFW_monitor**)RGFW_ALLOC(sizeof(RGFW_monitor*) * count);
-
-	if (RGFW_getMonitorsPtr(count, monitors, &count) == RGFW_FALSE) {
-		RGFW_FREE(monitors);
-		return NULL;
-	}
-
-	if (len != NULL) *len = count;
-
-	return monitors;
-}
-
-RGFW_bool RGFW_getMonitorsPtr(size_t max, RGFW_monitor** monitors, size_t* len) {
+	static RGFW_monitor* monitors[RGFW_MAX_MONITORS];
 	RGFW_init();
 	if (len != NULL) {
 		*len = _RGFW->monitors.count;
 	}
 
-	if (monitors == NULL || max == 0) return RGFW_TRUE;
-
-
-	if (len != NULL) {
-		*len = max;
-	}
-
-	size_t i = 0;
+	u8 i = 0;
 	RGFW_monitorNode* cur_node = _RGFW->monitors.list.head;
-	while (cur_node != NULL && i < max) {
+	while (cur_node != NULL) {
 		monitors[i] = &cur_node->mon;
 		i++;
 		cur_node = cur_node->next;
 	}
-
-	return RGFW_TRUE;
+    return monitors;
 }
 
 RGFW_monitor* RGFW_getPrimaryMonitor(void) {
-	RGFW_init();
 	if (_RGFW->monitors.primary == NULL) {
 		_RGFW->monitors.primary = _RGFW->monitors.list.head;
 	}
@@ -4818,27 +4757,27 @@ void RGFW_window_captureRawMouse(RGFW_window* win, RGFW_bool state) {
 RGFW_bool RGFW_window_isRawMouseMode(RGFW_window* win) { return RGFW_BOOL(win->internal.rawMouse); }
 RGFW_bool RGFW_window_isCaptured(RGFW_window* win) { return RGFW_BOOL(win->internal.captureMouse);  }
 
-void RGFW_keyUpdateKeyMod(RGFW_window* win, RGFW_keymod mod, RGFW_bool value) {
+void RGFW_updateKeyMod(RGFW_window* win, RGFW_keymod mod, RGFW_bool value) {
 	if (value) win->internal.mod |= mod;
 	else win->internal.mod &= ~mod;
 }
 
-void RGFW_keyUpdateKeyModsEx(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool control, RGFW_bool alt, RGFW_bool shift, RGFW_bool super, RGFW_bool scroll) {
-	RGFW_keyUpdateKeyMod(win, RGFW_modCapsLock, capital);
-	RGFW_keyUpdateKeyMod(win, RGFW_modNumLock, numlock);
-	RGFW_keyUpdateKeyMod(win, RGFW_modControl, control);
-	RGFW_keyUpdateKeyMod(win, RGFW_modAlt, alt);
-	RGFW_keyUpdateKeyMod(win, RGFW_modShift, shift);
-	RGFW_keyUpdateKeyMod(win, RGFW_modSuper, super);
-	RGFW_keyUpdateKeyMod(win, RGFW_modScrollLock, scroll);
+void RGFW_updateKeyModsEx(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool control, RGFW_bool alt, RGFW_bool shift, RGFW_bool super, RGFW_bool scroll) {
+	RGFW_updateKeyMod(win, RGFW_modCapsLock, capital);
+	RGFW_updateKeyMod(win, RGFW_modNumLock, numlock);
+	RGFW_updateKeyMod(win, RGFW_modControl, control);
+	RGFW_updateKeyMod(win, RGFW_modAlt, alt);
+	RGFW_updateKeyMod(win, RGFW_modShift, shift);
+	RGFW_updateKeyMod(win, RGFW_modSuper, super);
+	RGFW_updateKeyMod(win, RGFW_modScrollLock, scroll);
 }
 
-void RGFW_keyUpdateKeyMods(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool scroll) {
-	RGFW_keyUpdateKeyModsEx(win, capital, numlock,
-					RGFW_isKeyDown(RGFW_keyControlL) || RGFW_isKeyDown(RGFW_keyControlR),
-					RGFW_isKeyDown(RGFW_keyAltL) || RGFW_isKeyDown(RGFW_keyAltR),
-					RGFW_isKeyDown(RGFW_keyShiftL) || RGFW_isKeyDown(RGFW_keyShiftR),
-					RGFW_isKeyDown(RGFW_keySuperL) || RGFW_isKeyDown(RGFW_keySuperR),
+void RGFW_updateKeyMods(RGFW_window* win, RGFW_bool capital, RGFW_bool numlock, RGFW_bool scroll) {
+	RGFW_updateKeyModsEx(win, capital, numlock,
+					RGFW_window_isKeyDown(win, RGFW_controlL) || RGFW_window_isKeyDown(win, RGFW_controlR),
+					RGFW_window_isKeyDown(win, RGFW_altL) || RGFW_window_isKeyDown(win, RGFW_altR),
+					RGFW_window_isKeyDown(win, RGFW_shiftL) || RGFW_window_isKeyDown(win, RGFW_shiftR),
+					RGFW_window_isKeyDown(win, RGFW_superL) || RGFW_window_isKeyDown(win, RGFW_superR),
 					scroll);
 }
 
@@ -4860,39 +4799,27 @@ RGFW_bool RGFW_window_borderless(RGFW_window* win) {
 RGFW_bool RGFW_window_isFullscreen(RGFW_window* win){ return RGFW_BOOL(win->internal.flags & RGFW_windowFullscreen); }
 RGFW_bool RGFW_window_allowsDND(RGFW_window* win) { return RGFW_BOOL(win->internal.flags & RGFW_windowAllowDND); }
 
-RGFW_bool RGFW_window_setMouseDefault(RGFW_window* win) {
-	return RGFW_window_setMouseStandard(win, RGFW_mouseNormal);
-}
-
-RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, RGFW_mouseIcon icon) {
-	RGFW_ASSERT(win);
-	RGFW_ASSERT(icon < RGFW_mouseIconCount);
-	return RGFW_window_setMouse(win, _RGFW->standardMice[icon]);
-}
-
-RGFW_bool RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse) {
-	RGFW_ASSERT(win && mouse);
-	if (mouse != _RGFW->hiddenMouse) {
-		win->internal.mouse = mouse;
-	}
-
-	return RGFW_window_setMousePlatform(win, mouse);
-}
-
 #ifndef RGFW_WINDOWS
 void RGFW_window_setDND(RGFW_window* win, RGFW_bool allow) {
 	RGFW_setBit(&win->internal.flags, RGFW_windowAllowDND, allow);
 }
 #endif
 
+#if defined(RGFW_X11) || defined(RGFW_MACOS) || defined(RGFW_WASM) || defined(RGFW_WAYLAND)
+#ifndef __USE_POSIX199309
+	#define __USE_POSIX199309
+#endif
+#include <time.h>
+struct timespec;
+#endif
+
 #if defined(RGFW_WAYLAND) || defined(RGFW_X11) || defined(RGFW_WINDOWS)
 void RGFW_window_showMouse(RGFW_window* win, RGFW_bool show) {
 	RGFW_window_showMouseFlags(win, show);
-	if (show == RGFW_FALSE) {
+	if (show == RGFW_FALSE)
 		RGFW_window_setMouse(win, _RGFW->hiddenMouse);
-	} else {
-		RGFW_window_setMouse(win, win->internal.mouse);
-	}
+	else
+		RGFW_window_setMouseDefault(win);
 }
 #endif
 
@@ -5111,6 +5038,7 @@ void RGFW_attribStack_pushAttribs(RGFW_attribStack* stack, i32 attrib1, i32 attr
 
 /* EGL */
 #ifdef RGFW_EGL
+#include <EGL/eglplatform.h>
 #include <EGL/egl.h>
 
 PFNEGLINITIALIZEPROC RGFW_eglInitialize;
@@ -5394,7 +5322,7 @@ RGFW_bool RGFW_window_createContextPtr_EGL(RGFW_window* win, RGFW_eglContext* ct
 		if (visualID) {
 			desired.visualid = (VisualID)visualID;
 			result = XGetVisualInfo(_RGFW->display, VisualIDMask, &desired, &count);
-		} else  RGFW_debugCallback(RGFW_typeError, RGFW_errEGLContext,  "Failed to fetch a valid EGL VisualID");
+		} else  RGFW_sendDebugInfo(RGFW_typeError, RGFW_errEGLContext,  "Failed to fetch a valid EGL VisualID");
 
 		if (result == NULL || count == 0) {
 			if (win->src.window == 0) {
@@ -5402,7 +5330,7 @@ RGFW_bool RGFW_window_createContextPtr_EGL(RGFW_window* win, RGFW_eglContext* ct
 				win->internal.flags &= ~(u32)RGFW_windowEGL;
 				RGFW_createWindowPlatform("", win->internal.flags, win);
 			}
-			RGFW_debugCallback(RGFW_typeError, RGFW_errEGLContext,  "Failed to find a valid visual for the EGL config");
+			RGFW_sendDebugInfo(RGFW_typeError, RGFW_errEGLContext,  "Failed to find a valid visual for the EGL config");
 		} else {
 			RGFW_bool showWindow = RGFW_FALSE;
 			if (win->src.window) {
@@ -5479,7 +5407,7 @@ RGFW_bool RGFW_window_createContextPtr_EGL(RGFW_window* win, RGFW_eglContext* ct
 	#endif
 
 	if (win->src.ctx.egl->surface == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errEGLContext, "Failed to create an EGL surface.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errEGLContext, "Failed to create an EGL surface.");
 		return RGFW_FALSE;
 	}
 
@@ -5530,13 +5458,13 @@ RGFW_bool RGFW_window_createContextPtr_EGL(RGFW_window* win, RGFW_eglContext* ct
 	win->src.ctx.egl->ctx = RGFW_eglCreateContext(_RGFW->EGL_display, config, hints->shareEGL, attribs);
 
 	if (win->src.ctx.egl->ctx == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errEGLContext,  "Failed to create an EGL context.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errEGLContext,  "Failed to create an EGL context.");
 		return RGFW_FALSE;
 	}
 
 	RGFW_eglMakeCurrent(_RGFW->EGL_display, win->src.ctx.egl->surface, win->src.ctx.egl->surface, win->src.ctx.egl->ctx);
 	RGFW_eglSwapBuffers(_RGFW->EGL_display, win->src.ctx.egl->surface);
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "EGL context initalized.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "EGL context initalized.");
 	return RGFW_TRUE;
 }
 
@@ -5550,11 +5478,11 @@ void RGFW_window_deleteContextPtr_EGL(RGFW_window* win, RGFW_eglContext* ctx) {
 
 	RGFW_eglDestroySurface(_RGFW->EGL_display, ctx->surface);
 	RGFW_eglDestroyContext(_RGFW->EGL_display, ctx->ctx);
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "EGL context freed");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "EGL context freed");
 	#ifdef RGFW_WAYLAND
 		if (_RGFW->useWaylandBool == RGFW_FALSE) return;
 		wl_egl_window_destroy(win->src.ctx.egl->eglWindow);
-		RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "EGL window context freed");
+		RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "EGL window context freed");
 	#endif
 	win->src.ctx.egl = NULL;
 }
@@ -5704,11 +5632,9 @@ This is where OS specific stuff starts
 /* start of unix (wayland or X11 (unix) ) defines */
 
 #ifdef RGFW_UNIX
-
 #include <fcntl.h>
 #include <poll.h>
 #include <unistd.h>
-#include <time.h>
 
 void RGFW_stopCheckEvents(void) {
 
@@ -5820,7 +5746,7 @@ void RGFW_waitForEvent(i32 waitMS) {
 	/* drain any data in the stop request */
 	if (_RGFW->eventWait_forceStop[2]) {
 		char data[64];
-        RGFW_MEMZERO(data, sizeof(data));
+        RGFW_MEMSET(data, 0, sizeof(data));
         (void)!read(_RGFW->eventWait_forceStop[0], data, sizeof(data));
 
 		_RGFW->eventWait_forceStop[2] = 0;
@@ -5900,129 +5826,129 @@ void RGFW_load_Wayland(void) { }
  * We can't use linux enums, because the headers don't exist on BSD
  */
 void RGFW_initKeycodesPlatform(void) {
-	_RGFW->keycodes[49] = RGFW_keyBacktick;
-	_RGFW->keycodes[19] = RGFW_key0;
-	_RGFW->keycodes[10] = RGFW_key1;
-	_RGFW->keycodes[11] = RGFW_key2;
-	_RGFW->keycodes[12] = RGFW_key3;
-	_RGFW->keycodes[13] = RGFW_key4;
-	_RGFW->keycodes[14] = RGFW_key5;
-	_RGFW->keycodes[15] = RGFW_key6;
-	_RGFW->keycodes[16] = RGFW_key7;
-	_RGFW->keycodes[17] = RGFW_key8;
-	_RGFW->keycodes[18] = RGFW_key9;
-	_RGFW->keycodes[65] = RGFW_keySpace;
-	_RGFW->keycodes[38] = RGFW_keyA;
-	_RGFW->keycodes[56] = RGFW_keyB;
-	_RGFW->keycodes[54] = RGFW_keyC;
-	_RGFW->keycodes[40] = RGFW_keyD;
-	_RGFW->keycodes[26] = RGFW_keyE;
-	_RGFW->keycodes[41] = RGFW_keyF;
-	_RGFW->keycodes[42] = RGFW_keyG;
-	_RGFW->keycodes[43] = RGFW_keyH;
-	_RGFW->keycodes[31] = RGFW_keyI;
-	_RGFW->keycodes[44] = RGFW_keyJ;
-	_RGFW->keycodes[45] = RGFW_keyK;
-	_RGFW->keycodes[46] = RGFW_keyL;
-	_RGFW->keycodes[58] = RGFW_keyM;
-	_RGFW->keycodes[57] = RGFW_keyN;
-	_RGFW->keycodes[32] = RGFW_keyO;
-	_RGFW->keycodes[33] = RGFW_keyP;
-	_RGFW->keycodes[24] = RGFW_keyQ;
-	_RGFW->keycodes[27] = RGFW_keyR;
-	_RGFW->keycodes[39] = RGFW_keyS;
-	_RGFW->keycodes[28] = RGFW_keyT;
-	_RGFW->keycodes[30] = RGFW_keyU;
-	_RGFW->keycodes[55] = RGFW_keyV;
-	_RGFW->keycodes[25] = RGFW_keyW;
-	_RGFW->keycodes[53] = RGFW_keyX;
-	_RGFW->keycodes[29] = RGFW_keyY;
-	_RGFW->keycodes[52] = RGFW_keyZ;
-	_RGFW->keycodes[60] = RGFW_keyPeriod;
-	_RGFW->keycodes[59] = RGFW_keyComma;
-	_RGFW->keycodes[61] = RGFW_keySlash;
-	_RGFW->keycodes[34] = RGFW_keyBracket;
-	_RGFW->keycodes[35] = RGFW_keyCloseBracket;
-	_RGFW->keycodes[47] = RGFW_keySemicolon;
-	_RGFW->keycodes[48] = RGFW_keyApostrophe;
-	_RGFW->keycodes[51] = RGFW_keyBackSlash;
-	_RGFW->keycodes[36] = RGFW_keyReturn;
-	_RGFW->keycodes[119] = RGFW_keyDelete;
-	_RGFW->keycodes[77] = RGFW_keyNumLock;
-	_RGFW->keycodes[106] = RGFW_keyPadSlash;
-	_RGFW->keycodes[63] = RGFW_keyPadMultiply;
-	_RGFW->keycodes[86] = RGFW_keyPadPlus;
-	_RGFW->keycodes[82] = RGFW_keyPadMinus;
-	_RGFW->keycodes[87] = RGFW_keyPad1;
-	_RGFW->keycodes[88] = RGFW_keyPad2;
-	_RGFW->keycodes[89] = RGFW_keyPad3;
-	_RGFW->keycodes[83] = RGFW_keyPad4;
-	_RGFW->keycodes[84] = RGFW_keyPad5;
-	_RGFW->keycodes[85] = RGFW_keyPad6;
-	_RGFW->keycodes[81] = RGFW_keyPad9;
-	_RGFW->keycodes[90] = RGFW_keyPad0;
-	_RGFW->keycodes[91] = RGFW_keyPadPeriod;
-	_RGFW->keycodes[104] = RGFW_keyPadReturn;
-	_RGFW->keycodes[20] = RGFW_keyMinus;
-	_RGFW->keycodes[21] = RGFW_keyEquals;
-	_RGFW->keycodes[22] = RGFW_keyBackSpace;
-	_RGFW->keycodes[23] = RGFW_keyTab;
-	_RGFW->keycodes[66] = RGFW_keyCapsLock;
-	_RGFW->keycodes[50] = RGFW_keyShiftL;
-	_RGFW->keycodes[37] = RGFW_keyControlL;
-	_RGFW->keycodes[64] = RGFW_keyAltL;
-	_RGFW->keycodes[133] = RGFW_keySuperL;
-	_RGFW->keycodes[105] = RGFW_keyControlR;
-	_RGFW->keycodes[134] = RGFW_keySuperR;
-	_RGFW->keycodes[62] = RGFW_keyShiftR;
-	_RGFW->keycodes[108] = RGFW_keyAltR;
-	_RGFW->keycodes[67] = RGFW_keyF1;
-	_RGFW->keycodes[68] = RGFW_keyF2;
-	_RGFW->keycodes[69] = RGFW_keyF3;
-	_RGFW->keycodes[70] = RGFW_keyF4;
-	_RGFW->keycodes[71] = RGFW_keyF5;
-	_RGFW->keycodes[72] = RGFW_keyF6;
-	_RGFW->keycodes[73] = RGFW_keyF7;
-	_RGFW->keycodes[74] = RGFW_keyF8;
-	_RGFW->keycodes[75] = RGFW_keyF9;
-	_RGFW->keycodes[76] = RGFW_keyF10;
-	_RGFW->keycodes[95] = RGFW_keyF11;
-	_RGFW->keycodes[96] = RGFW_keyF12;
-	_RGFW->keycodes[111] = RGFW_keyUp;
-	_RGFW->keycodes[116] = RGFW_keyDown;
-	_RGFW->keycodes[113] = RGFW_keyLeft;
-	_RGFW->keycodes[114] = RGFW_keyRight;
-	_RGFW->keycodes[118] = RGFW_keyInsert;
-	_RGFW->keycodes[115] = RGFW_keyEnd;
-	_RGFW->keycodes[112] = RGFW_keyPageUp;
-	_RGFW->keycodes[117] = RGFW_keyPageDown;
-	_RGFW->keycodes[9] = RGFW_keyEscape;
-	_RGFW->keycodes[110] = RGFW_keyHome;
-	_RGFW->keycodes[78] = RGFW_keyScrollLock;
-	_RGFW->keycodes[107] = RGFW_keyPrintScreen;
-	_RGFW->keycodes[128] = RGFW_keyPause;
-    _RGFW->keycodes[191] = RGFW_keyF13;
-    _RGFW->keycodes[192] = RGFW_keyF14;
-    _RGFW->keycodes[193] = RGFW_keyF15;
-    _RGFW->keycodes[194] = RGFW_keyF16;
-    _RGFW->keycodes[195] = RGFW_keyF17;
-    _RGFW->keycodes[196] = RGFW_keyF18;
-    _RGFW->keycodes[197] = RGFW_keyF19;
-    _RGFW->keycodes[198] = RGFW_keyF20;
-    _RGFW->keycodes[199] = RGFW_keyF21;
-    _RGFW->keycodes[200] = RGFW_keyF22;
-    _RGFW->keycodes[201] = RGFW_keyF23;
-    _RGFW->keycodes[202] = RGFW_keyF24;
-    _RGFW->keycodes[203] = RGFW_keyF25;
-	_RGFW->keycodes[142] = RGFW_keyPadEqual;
-	_RGFW->keycodes[161] = RGFW_keyWorld1; /* non-US key #1 */
-    _RGFW->keycodes[162] = RGFW_keyWorld2; /* non-US key #2 */
+	_RGFW->keycodes[49] = RGFW_backtick;
+	_RGFW->keycodes[19] = RGFW_0;
+	_RGFW->keycodes[10] = RGFW_1;
+	_RGFW->keycodes[11] = RGFW_2;
+	_RGFW->keycodes[12] = RGFW_3;
+	_RGFW->keycodes[13] = RGFW_4;
+	_RGFW->keycodes[14] = RGFW_5;
+	_RGFW->keycodes[15] = RGFW_6;
+	_RGFW->keycodes[16] = RGFW_7;
+	_RGFW->keycodes[17] = RGFW_8;
+	_RGFW->keycodes[18] = RGFW_9;
+	_RGFW->keycodes[65] = RGFW_space;
+	_RGFW->keycodes[38] = RGFW_a;
+	_RGFW->keycodes[56] = RGFW_b;
+	_RGFW->keycodes[54] = RGFW_c;
+	_RGFW->keycodes[40] = RGFW_d;
+	_RGFW->keycodes[26] = RGFW_e;
+	_RGFW->keycodes[41] = RGFW_f;
+	_RGFW->keycodes[42] = RGFW_g;
+	_RGFW->keycodes[43] = RGFW_h;
+	_RGFW->keycodes[31] = RGFW_i;
+	_RGFW->keycodes[44] = RGFW_j;
+	_RGFW->keycodes[45] = RGFW_k;
+	_RGFW->keycodes[46] = RGFW_l;
+	_RGFW->keycodes[58] = RGFW_m;
+	_RGFW->keycodes[57] = RGFW_n;
+	_RGFW->keycodes[32] = RGFW_o;
+	_RGFW->keycodes[33] = RGFW_p;
+	_RGFW->keycodes[24] = RGFW_q;
+	_RGFW->keycodes[27] = RGFW_r;
+	_RGFW->keycodes[39] = RGFW_s;
+	_RGFW->keycodes[28] = RGFW_t;
+	_RGFW->keycodes[30] = RGFW_u;
+	_RGFW->keycodes[55] = RGFW_v;
+	_RGFW->keycodes[25] = RGFW_w;
+	_RGFW->keycodes[53] = RGFW_x;
+	_RGFW->keycodes[29] = RGFW_y;
+	_RGFW->keycodes[52] = RGFW_z;
+	_RGFW->keycodes[60] = RGFW_period;
+	_RGFW->keycodes[59] = RGFW_comma;
+	_RGFW->keycodes[61] = RGFW_slash;
+	_RGFW->keycodes[34] = RGFW_bracket;
+	_RGFW->keycodes[35] = RGFW_closeBracket;
+	_RGFW->keycodes[47] = RGFW_semicolon;
+	_RGFW->keycodes[48] = RGFW_apostrophe;
+	_RGFW->keycodes[51] = RGFW_backSlash;
+	_RGFW->keycodes[36] = RGFW_return;
+	_RGFW->keycodes[119] = RGFW_delete;
+	_RGFW->keycodes[77] = RGFW_numLock;
+	_RGFW->keycodes[106] = RGFW_kpSlash;
+	_RGFW->keycodes[63] = RGFW_kpMultiply;
+	_RGFW->keycodes[86] = RGFW_kpPlus;
+	_RGFW->keycodes[82] = RGFW_kpMinus;
+	_RGFW->keycodes[87] = RGFW_kp1;
+	_RGFW->keycodes[88] = RGFW_kp2;
+	_RGFW->keycodes[89] = RGFW_kp3;
+	_RGFW->keycodes[83] = RGFW_kp4;
+	_RGFW->keycodes[84] = RGFW_kp5;
+	_RGFW->keycodes[85] = RGFW_kp6;
+	_RGFW->keycodes[81] = RGFW_kp9;
+	_RGFW->keycodes[90] = RGFW_kp0;
+	_RGFW->keycodes[91] = RGFW_kpPeriod;
+	_RGFW->keycodes[104] = RGFW_kpReturn;
+	_RGFW->keycodes[20] = RGFW_minus;
+	_RGFW->keycodes[21] = RGFW_equals;
+	_RGFW->keycodes[22] = RGFW_backSpace;
+	_RGFW->keycodes[23] = RGFW_tab;
+	_RGFW->keycodes[66] = RGFW_capsLock;
+	_RGFW->keycodes[50] = RGFW_shiftL;
+	_RGFW->keycodes[37] = RGFW_controlL;
+	_RGFW->keycodes[64] = RGFW_altL;
+	_RGFW->keycodes[133] = RGFW_superL;
+	_RGFW->keycodes[105] = RGFW_controlR;
+	_RGFW->keycodes[134] = RGFW_superR;
+	_RGFW->keycodes[62] = RGFW_shiftR;
+	_RGFW->keycodes[108] = RGFW_altR;
+	_RGFW->keycodes[67] = RGFW_F1;
+	_RGFW->keycodes[68] = RGFW_F2;
+	_RGFW->keycodes[69] = RGFW_F3;
+	_RGFW->keycodes[70] = RGFW_F4;
+	_RGFW->keycodes[71] = RGFW_F5;
+	_RGFW->keycodes[72] = RGFW_F6;
+	_RGFW->keycodes[73] = RGFW_F7;
+	_RGFW->keycodes[74] = RGFW_F8;
+	_RGFW->keycodes[75] = RGFW_F9;
+	_RGFW->keycodes[76] = RGFW_F10;
+	_RGFW->keycodes[95] = RGFW_F11;
+	_RGFW->keycodes[96] = RGFW_F12;
+	_RGFW->keycodes[111] = RGFW_up;
+	_RGFW->keycodes[116] = RGFW_down;
+	_RGFW->keycodes[113] = RGFW_left;
+	_RGFW->keycodes[114] = RGFW_right;
+	_RGFW->keycodes[118] = RGFW_insert;
+	_RGFW->keycodes[115] = RGFW_end;
+	_RGFW->keycodes[112] = RGFW_pageUp;
+	_RGFW->keycodes[117] = RGFW_pageDown;
+	_RGFW->keycodes[9] = RGFW_escape;
+	_RGFW->keycodes[110] = RGFW_home;
+	_RGFW->keycodes[78] = RGFW_scrollLock;
+	_RGFW->keycodes[107] = RGFW_printScreen;
+	_RGFW->keycodes[128] = RGFW_pause;
+    _RGFW->keycodes[191] = RGFW_F13;
+    _RGFW->keycodes[192] = RGFW_F14;
+    _RGFW->keycodes[193] = RGFW_F15;
+    _RGFW->keycodes[194] = RGFW_F16;
+    _RGFW->keycodes[195] = RGFW_F17;
+    _RGFW->keycodes[196] = RGFW_F18;
+    _RGFW->keycodes[197] = RGFW_F19;
+    _RGFW->keycodes[198] = RGFW_F20;
+    _RGFW->keycodes[199] = RGFW_F21;
+    _RGFW->keycodes[200] = RGFW_F22;
+    _RGFW->keycodes[201] = RGFW_F23;
+    _RGFW->keycodes[202] = RGFW_F24;
+    _RGFW->keycodes[203] = RGFW_F25;
+	_RGFW->keycodes[142] = RGFW_kpEqual;
+	_RGFW->keycodes[161] = RGFW_world1; /* non-US key #1 */
+    _RGFW->keycodes[162] = RGFW_world2; /* non-US key #2 */
 }
 
 i32 RGFW_initPlatform(void) {
 	#if defined(_POSIX_MONOTONIC_CLOCK)
 	struct timespec ts;
-	RGFW_MEMZERO(&ts, sizeof(struct timespec));
+	RGFW_MEMSET(&ts, 0, sizeof(struct timespec));
 
 	if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
 		_RGFW->clock = CLOCK_MONOTONIC;
@@ -6037,7 +5963,7 @@ i32 RGFW_initPlatform(void) {
 		return 0;
 	} else {
 		#ifdef RGFW_X11
-			RGFW_debugCallback(RGFW_typeWarning, RGFW_warningWayland,  "Falling back to X11");
+			RGFW_sendDebugInfo(RGFW_typeWarning, RGFW_warningWayland,  "Falling back to X11");
 			RGFW_useWayland(0);
 		#else
 			return ret;
@@ -6076,62 +6002,6 @@ size_t RGFW_unix_stringlen(const char* name) {
 	return i;
 }
 
-RGFWDEF void RGFW_unix_parseURI(RGFW_window* win, char* data);
-void RGFW_unix_parseURI(RGFW_window* win, char* data) {
-	const char* prefix = (const char*)"file://";
-	char* line;
-	while ((line = (char*)RGFW_strtok(data, "\r\n"))) {
-		data = NULL;
-
-		if (line[0] == '#')
-			continue;
-
-		char* l;
-		for (l = line; 1; l++) {
-			if ((l - line) > 7)
-				break;
-			else if (*l != prefix[(l - line)])
-				break;
-			else if (*l == '\0' && prefix[(l - line)] == '\0') {
-				line += 7;
-				while (*line != '/')
-					line++;
-				break;
-			} else if (*l == '\0')
-				break;
-		}
-
-		size_t len = RGFW_unix_stringlen(line);
-		char* path = (char*)RGFW_ALLOC(len + 1);
-
-		size_t index = 0;
-		while (*line) {
-			if (line[0] == '%' && line[1] && line[2]) {
-				char digits[3] = {0};
-				digits[0] = line[1];
-				digits[1] = line[2];
-				digits[2] = '\0';
-				path[index] = (char) RGFW_STRTOL(digits, NULL, 16);
-				line += 2;
-			} else {
-				if (index >= len) {
-					break;
-				}
-
-				path[index] = *line;
-			}
-
-			index++;
-			line++;
-		}
-
-		path[len] = '\0';
-		RGFW_dataDropCallback(win, (const char*)path, len + 1, RGFW_dataFile);
-		RGFW_FREE(path);
-	}
-}
-
-
 #endif /* end of wayland or X11 defines */
 
 
@@ -6359,7 +6229,7 @@ RGFW_bool RGFW_window_createSurfacePtr(RGFW_window* win, u8* data, i32 w, i32 h,
 
 	XWindowAttributes attrs;
 	if (XGetWindowAttributes(_RGFW->display, win->src.window, &attrs) == 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errBuffer, "Failed to get window attributes.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errBuffer, "Failed to get window attributes.");
 		return RGFW_FALSE;
 	}
 
@@ -6370,7 +6240,7 @@ RGFW_bool RGFW_window_createSurfacePtr(RGFW_window* win, u8* data, i32 w, i32 h,
 	surface->native.format = RGFW_XImage_getFormat(surface->native.bitmap);
 
 	if (surface->native.bitmap == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errBuffer,  "Failed to create XImage.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errBuffer,  "Failed to create XImage.");
 		return RGFW_FALSE;
 	}
 
@@ -6425,17 +6295,7 @@ void RGFW_FUNC(RGFW_window_setBorder) (RGFW_window* win, RGFW_bool border) {
 }
 
 void RGFW_FUNC(RGFW_window_setRawMouseModePlatform) (RGFW_window* win, RGFW_bool state) {
-	RGFW_UNUSED(win);
-	unsigned char mask[XIMaskLen(XI_RawMotion)];
-	RGFW_MEMZERO(mask, sizeof(mask));
-	if (state) XISetMask(mask, XI_RawMotion);
-
-	XIEventMask em;
-	em.deviceid = XIAllMasterDevices;
-	em.mask_len = sizeof(mask);
-	em.mask = mask;
-
-	XISelectEvents(_RGFW->display, XDefaultRootWindow(_RGFW->display), &em, 1);
+	RGFW_UNUSED(win); RGFW_UNUSED(state);
 }
 
 void RGFW_FUNC(RGFW_window_captureMousePlatform) (RGFW_window* win, RGFW_bool state) {
@@ -6460,7 +6320,7 @@ void RGFW_window_getVisual(XVisualInfo* visual, RGFW_bool transparent) {
 	if (transparent) {
 		XMatchVisualInfo(_RGFW->display, DefaultScreen(_RGFW->display), 32, TrueColor, visual); /*!< for RGBA backgrounds */
 		if (visual->depth != 32)
-			RGFW_debugCallback(RGFW_typeWarning, RGFW_warningOpenGL, "Failed to load a 32-bit depth.");
+			RGFW_sendDebugInfo(RGFW_typeWarning, RGFW_warningOpenGL, "Failed to load a 32-bit depth.");
 	}
 }
 
@@ -6474,7 +6334,7 @@ int RGFW_XErrorHandler(Display* display, XErrorEvent* ev) {
              errorText,
              ev->error_code, ev->request_code, ev->minor_code, ev->serial);
 
-    RGFW_debugCallback(RGFW_typeError, RGFW_errX11, buf);
+    RGFW_sendDebugInfo(RGFW_typeError, RGFW_errX11, buf);
     _RGFW->x11Error = ev;
     return 0;
 }
@@ -6485,7 +6345,7 @@ void RGFW_XCreateWindow (XVisualInfo visual, const char* name, RGFW_windowFlags
 
 	/* make X window attrubutes */
 	XSetWindowAttributes swa;
-    RGFW_MEMZERO(&swa, sizeof(swa));
+    RGFW_MEMSET(&swa, 0, sizeof(swa));
 
 	win->src.parent = DefaultRootWindow(_RGFW->display);
 
@@ -6538,6 +6398,9 @@ void RGFW_XCreateWindow (XVisualInfo visual, const char* name, RGFW_windowFlags
 
 	XSetWMHints(_RGFW->display, win->src.window, &hints);
 
+	if (flags & RGFW_windowScaleToMonitor)
+		RGFW_window_scaleToMonitor(win);
+
 	XSelectInput(_RGFW->display, (Drawable) win->src.window, event_mask); /*!< tell X11 what events we want */
 
 	/* make it so the user can't close the window until the program does */
@@ -6690,71 +6553,71 @@ RGFW_key RGFW_FUNC(RGFW_physicalToMappedKey) (RGFW_key key) {
     }
 
     switch (sym) {
-        case XK_F1:  return RGFW_keyF1;
-        case XK_F2:  return RGFW_keyF2;
-        case XK_F3:  return RGFW_keyF3;
-        case XK_F4:  return RGFW_keyF4;
-        case XK_F5:  return RGFW_keyF5;
-        case XK_F6:  return RGFW_keyF6;
-        case XK_F7:  return RGFW_keyF7;
-        case XK_F8:  return RGFW_keyF8;
-        case XK_F9:  return RGFW_keyF9;
-        case XK_F10: return RGFW_keyF10;
-        case XK_F11: return RGFW_keyF11;
-        case XK_F12: return RGFW_keyF12;
-        case XK_F13: return RGFW_keyF13;
-        case XK_F14: return RGFW_keyF14;
-        case XK_F15: return RGFW_keyF15;
-        case XK_F16: return RGFW_keyF16;
-        case XK_F17: return RGFW_keyF17;
-        case XK_F18: return RGFW_keyF18;
-        case XK_F19: return RGFW_keyF19;
-        case XK_F20: return RGFW_keyF20;
-        case XK_F21: return RGFW_keyF21;
-        case XK_F22: return RGFW_keyF22;
-        case XK_F23: return RGFW_keyF23;
-        case XK_F24: return RGFW_keyF24;
-        case XK_F25: return RGFW_keyF25;
-        case XK_Shift_L:   return RGFW_keyShiftL;
-        case XK_Shift_R:   return RGFW_keyShiftR;
-        case XK_Control_L: return RGFW_keyControlL;
-        case XK_Control_R: return RGFW_keyControlR;
-        case XK_Alt_L:     return RGFW_keyAltL;
-        case XK_Alt_R:     return RGFW_keyAltR;
-        case XK_Super_L:   return RGFW_keySuperL;
-        case XK_Super_R:   return RGFW_keySuperR;
-        case XK_Caps_Lock: return RGFW_keyCapsLock;
-        case XK_Num_Lock:  return RGFW_keyNumLock;
-        case XK_Scroll_Lock:return RGFW_keyScrollLock;
-        case XK_Up:        return RGFW_keyUp;
-        case XK_Down:      return RGFW_keyDown;
-        case XK_Left:      return RGFW_keyLeft;
-        case XK_Right:     return RGFW_keyRight;
-        case XK_Home:      return RGFW_keyHome;
-        case XK_End:       return RGFW_keyEnd;
-        case XK_Page_Up:   return RGFW_keyPageUp;
-        case XK_Page_Down: return RGFW_keyPageDown;
-        case XK_Insert:    return RGFW_keyInsert;
-        case XK_Menu:      return RGFW_keyMenu;
-        case XK_KP_Add:      return RGFW_keyPadPlus;
-        case XK_KP_Subtract: return RGFW_keyPadMinus;
-        case XK_KP_Multiply: return RGFW_keyPadMultiply;
-        case XK_KP_Divide:   return RGFW_keyPadSlash;
-        case XK_KP_Equal:    return RGFW_keyPadEqual;
-        case XK_KP_Enter:    return RGFW_keyPadReturn;
-        case XK_KP_Decimal:  return RGFW_keyPadPeriod;
-        case XK_KP_0: return RGFW_keyPad0;
-        case XK_KP_1: return RGFW_keyPad1;
-        case XK_KP_2: return RGFW_keyPad2;
-        case XK_KP_3: return RGFW_keyPad3;
-        case XK_KP_4: return RGFW_keyPad4;
-        case XK_KP_5: return RGFW_keyPad5;
-        case XK_KP_6: return RGFW_keyPad6;
-        case XK_KP_7: return RGFW_keyPad7;
-        case XK_KP_8: return RGFW_keyPad8;
-        case XK_KP_9: return RGFW_keyPad9;
-        case XK_Print: return RGFW_keyPrintScreen;
-        case XK_Pause: return RGFW_keyPause;
+        case XK_F1:  return RGFW_F1;
+        case XK_F2:  return RGFW_F2;
+        case XK_F3:  return RGFW_F3;
+        case XK_F4:  return RGFW_F4;
+        case XK_F5:  return RGFW_F5;
+        case XK_F6:  return RGFW_F6;
+        case XK_F7:  return RGFW_F7;
+        case XK_F8:  return RGFW_F8;
+        case XK_F9:  return RGFW_F9;
+        case XK_F10: return RGFW_F10;
+        case XK_F11: return RGFW_F11;
+        case XK_F12: return RGFW_F12;
+        case XK_F13: return RGFW_F13;
+        case XK_F14: return RGFW_F14;
+        case XK_F15: return RGFW_F15;
+        case XK_F16: return RGFW_F16;
+        case XK_F17: return RGFW_F17;
+        case XK_F18: return RGFW_F18;
+        case XK_F19: return RGFW_F19;
+        case XK_F20: return RGFW_F20;
+        case XK_F21: return RGFW_F21;
+        case XK_F22: return RGFW_F22;
+        case XK_F23: return RGFW_F23;
+        case XK_F24: return RGFW_F24;
+        case XK_F25: return RGFW_F25;
+        case XK_Shift_L:   return RGFW_shiftL;
+        case XK_Shift_R:   return RGFW_shiftR;
+        case XK_Control_L: return RGFW_controlL;
+        case XK_Control_R: return RGFW_controlR;
+        case XK_Alt_L:     return RGFW_altL;
+        case XK_Alt_R:     return RGFW_altR;
+        case XK_Super_L:   return RGFW_superL;
+        case XK_Super_R:   return RGFW_superR;
+        case XK_Caps_Lock: return RGFW_capsLock;
+        case XK_Num_Lock:  return RGFW_numLock;
+        case XK_Scroll_Lock:return RGFW_scrollLock;
+        case XK_Up:        return RGFW_up;
+        case XK_Down:      return RGFW_down;
+        case XK_Left:      return RGFW_left;
+        case XK_Right:     return RGFW_right;
+        case XK_Home:      return RGFW_home;
+        case XK_End:       return RGFW_end;
+        case XK_Page_Up:   return RGFW_pageUp;
+        case XK_Page_Down: return RGFW_pageDown;
+        case XK_Insert:    return RGFW_insert;
+        case XK_Menu:      return RGFW_menu;
+        case XK_KP_Add:      return RGFW_kpPlus;
+        case XK_KP_Subtract: return RGFW_kpMinus;
+        case XK_KP_Multiply: return RGFW_kpMultiply;
+        case XK_KP_Divide:   return RGFW_kpSlash;
+        case XK_KP_Equal:    return RGFW_kpEqual;
+        case XK_KP_Enter:    return RGFW_kpReturn;
+        case XK_KP_Decimal:  return RGFW_kpPeriod;
+        case XK_KP_0: return RGFW_kp0;
+        case XK_KP_1: return RGFW_kp1;
+        case XK_KP_2: return RGFW_kp2;
+        case XK_KP_3: return RGFW_kp3;
+        case XK_KP_4: return RGFW_kp4;
+        case XK_KP_5: return RGFW_kp5;
+        case XK_KP_6: return RGFW_kp6;
+        case XK_KP_7: return RGFW_kp7;
+        case XK_KP_8: return RGFW_kp8;
+        case XK_KP_9: return RGFW_kp9;
+        case XK_Print: return RGFW_printScreen;
+        case XK_Pause: return RGFW_pause;
         default: break;
     }
 
@@ -6777,9 +6640,15 @@ void RGFW_XHandleEvent(void) {
 	RGFW_LOAD_ATOM(WM_STATE);
 	RGFW_LOAD_ATOM(_NET_WM_STATE);
 
+	/* xdnd data */
+	static Window source = 0;
+	static long version = 0;
+	static i32 format = 0;
+
 	static float deltaX = 0.0f;
 	static float deltaY = 0.0f;
 
+	XEvent reply = { ClientMessage };
 	XEvent E;
 
 	XNextEvent(_RGFW->display, &E);
@@ -6789,10 +6658,12 @@ void RGFW_XHandleEvent(void) {
 		deltaY = 0.0f;
 	}
 
+#ifndef RGFW_NO_XRANDR
 	if (E.type == _RGFW->xrandrEventBase + RRNotify) {
 		RGFW_pollMonitors();
 		return;
 	}
+#endif
 
 	switch (E.type) {
 		case SelectionRequest:
@@ -6819,7 +6690,6 @@ void RGFW_XHandleEvent(void) {
 
 					_RGFW->vectorX = (float)deltaX;
 					_RGFW->vectorY = (float)deltaY;
-					RGFW_rawMotionCallback(_RGFW->root, _RGFW->vectorX, _RGFW->vectorY);
 				}
 				default: break;
 			}
@@ -6865,7 +6735,7 @@ void RGFW_XHandleEvent(void) {
 
 			XkbStateRec state;
 			XkbGetState(_RGFW->display, XkbUseCoreKbd, &state);
-			RGFW_keyUpdateKeyMods(win, (state.locked_mods & LockMask), (state.locked_mods & Mod2Mask), (state.locked_mods & Mod3Mask));
+			RGFW_updateKeyMods(win, (state.locked_mods & LockMask), (state.locked_mods & Mod2Mask), (state.locked_mods & Mod3Mask));
 
 			if (win->src.ic && XFilterEvent(&E, None) == False) {
 				char buffer[100];
@@ -6914,9 +6784,9 @@ void RGFW_XHandleEvent(void) {
 
 			XkbStateRec state;
 			XkbGetState(_RGFW->display, XkbUseCoreKbd, &state);
-			RGFW_keyUpdateKeyMods(win, (state.locked_mods & LockMask), (state.locked_mods & Mod2Mask), (state.locked_mods & Mod3Mask));
+			RGFW_updateKeyMods(win, (state.locked_mods & LockMask), (state.locked_mods & Mod2Mask), (state.locked_mods & Mod3Mask));
 
-			RGFW_keyCallback(win, value, win->internal.mod, RGFW_FALSE, RGFW_FALSE);
+			RGFW_keyCallback(win, value, win->internal.mod, keyRepeat, RGFW_FALSE);
 			break;
 		}
 		case ButtonPress: {
@@ -6967,11 +6837,11 @@ void RGFW_XHandleEvent(void) {
 			break;
 		}
 		case MotionNotify:
-			RGFW_mouseMotionCallback(win, E.xmotion.x, E.xmotion.y);
+			RGFW_mousePosCallback(win, E.xmotion.x, E.xmotion.y, _RGFW->vectorX, _RGFW->vectorY);
 			break;
 
 		case Expose: {
-			RGFW_windowRefreshCallback(win, E.xexpose.x, E.xexpose.y, E.xexpose.width, E.xexpose.height);
+			RGFW_windowRefreshCallback(win);
 
 #ifdef RGFW_ADVANCED_SMOOTH_RESIZE
 			XSyncValue value;
@@ -7003,12 +6873,12 @@ void RGFW_XHandleEvent(void) {
 			RGFW_LOAD_ATOM(WM_DELETE_WINDOW);
 			/* if the client closed the window */
 			if (E.xclient.data.l[0] == (long)WM_DELETE_WINDOW) {
-				RGFW_windowCloseCallback(win);
+				RGFW_windowQuitCallback(win);
 				break;
 			}
 #ifdef RGFW_ADVANCED_SMOOTH_RESIZE
 			if (E.xclient.message_type == WM_PROTOCOLS && (Atom)E.xclient.data.l[0] == _NET_WM_SYNC_REQUEST) {
-				RGFW_windowRefreshCallback(win, 0, 0, win->w, win->h);
+				RGFW_windowRefreshCallback(win);
 				win->src.counter_value = 0;
 				win->src.counter_value |= E.xclient.data.l[2];
 				win->src.counter_value |= (E.xclient.data.l[3] << 32);
@@ -7019,29 +6889,37 @@ void RGFW_XHandleEvent(void) {
 				break;
 			}
 #endif
-			if ((win->internal.flags & RGFW_windowAllowDND) == 0 || _RGFW->x11Version > RGFW_XDND_VERSION) {
+			if ((win->internal.flags & RGFW_windowAllowDND) == 0)
 				return;
-			}
 
 			i32 dragX = 0;
 			i32 dragY = 0;
 
+			reply.xclient.window = source;
+			reply.xclient.format = 32;
+			reply.xclient.data.l[0] = (long)win->src.window;
+			reply.xclient.data.l[1] = 0;
+			reply.xclient.data.l[2] = None;
+
 			if (E.xclient.message_type == XdndEnter) {
+				if (version > 5)
+					break;
+
 				unsigned long count;
 				Atom* formats;
-				Atom real_formats[3];
+				Atom real_formats[6];
 				Bool list = E.xclient.data.l[1] & 1;
 
-				_RGFW->x11Source = (Window)E.xclient.data.l[0];
-				_RGFW->x11Version = E.xclient.data.l[1] >> 24;
-				_RGFW->x11Format = None;
+				source = (unsigned long int)E.xclient.data.l[0];
+				version = E.xclient.data.l[1] >> 24;
+				format = None;
 				if (list) {
 					Atom actualType;
 					i32 actualFormat;
 					unsigned long bytesAfter;
 
 					XGetWindowProperty(
-						_RGFW->display, _RGFW->x11Source, XdndTypeList,
+						_RGFW->display, source, XdndTypeList,
 						0, LONG_MAX, False, 4,
 						&actualType, &actualFormat, &count, &bytesAfter, (u8**)&formats
 					);
@@ -7049,7 +6927,7 @@ void RGFW_XHandleEvent(void) {
 					count = 0;
 
 					size_t i;
-					for (i = 2; i < (2 + 3); i++) {
+					for (i = 2; i < 5; i++) {
 						if (E.xclient.data.l[i] != None) {
 							real_formats[count] = (unsigned long int)E.xclient.data.l[i];
 							count += 1;
@@ -7064,26 +6942,28 @@ void RGFW_XHandleEvent(void) {
 
 				size_t i;
 				for (i = 0; i < count; i++) {
-					if (formats[i] == XtextUriList)  _RGFW->x11TransferType  = RGFW_dataFile;
-					else if (formats[i] == XtextPlain) _RGFW->x11TransferType  = RGFW_dataText;
-					else continue;
-
-					_RGFW->x11Format = (int)formats[i];
-					break;
+					if (formats[i] == XtextUriList || formats[i] == XtextPlain) {
+						format = (int)formats[i];
+						break;
+					}
 				}
 
-				if (list && formats) {
+				if (list) {
 					XFree(formats);
 				}
 
+				break;
+			}
 
-				RGFW_dataDragCallback(win, _RGFW->x11TransferType , RGFW_dndActionEnter, dragX, dragY);
-			} else if (E.xclient.message_type == XdndPosition) {
+			if (E.xclient.message_type == XdndPosition) {
 				const i32 xabs = (E.xclient.data.l[2] >> 16) & 0xffff;
 				const i32 yabs = (E.xclient.data.l[2]) & 0xffff;
 				Window dummy;
 				i32 xpos, ypos;
 
+				if (version > 5)
+					break;
+
 				XTranslateCoordinates(
 					_RGFW->display, XDefaultRootWindow(_RGFW->display), win->src.window,
 					xabs, yabs, &xpos, &ypos, &dummy
@@ -7092,50 +6972,42 @@ void RGFW_XHandleEvent(void) {
 				dragX = xpos;
 				dragY = ypos;
 
-				RGFW_mouseMotionCallback(win, xpos, ypos);
-                XEvent reply = { ClientMessage };
-				reply.xclient.window = _RGFW->x11Source;
-                reply.xclient.message_type = XdndStatus;
-                reply.xclient.format = 32;
-				reply.xclient.data.l[0] = (long)win->src.window;
-                reply.xclient.data.l[2] = 0;
-                reply.xclient.data.l[3] = 0;
+				reply.xclient.window = source;
+				reply.xclient.message_type = XdndStatus;
 
-				if (_RGFW->x11Format) {
+				if (format) {
 					reply.xclient.data.l[1] = 1;
-					if (_RGFW->x11Version >= 2)
+					if (version >= 2)
 						reply.xclient.data.l[4] = (long)XdndActionCopy;
 				}
 
-				XSendEvent(_RGFW->display, _RGFW->x11Source, False, NoEventMask, &reply);
+				XSendEvent(_RGFW->display, source, False, NoEventMask, &reply);
 				XFlush(_RGFW->display);
-
-
-				RGFW_dataDragCallback(win, _RGFW->x11TransferType, RGFW_dndActionMove, dragX, dragY);
-			} else if (E.xclient.message_type == XdndLeave) {
-				RGFW_dataDragCallback(win, _RGFW->x11TransferType, RGFW_dndActionExit, dragX, dragY);
-			} else if (E.xclient.message_type == XdndDrop) {
-				if (_RGFW->x11Format) {
-					Time time = (_RGFW->x11Version >= 1)
-						? (Time)E.xclient.data.l[2]
-						: CurrentTime;
-					XConvertSelection(
-						_RGFW->display, XdndSelection, (Atom)_RGFW->x11Format,
-						XdndSelection, win->src.window, time
-					);
-				} else if (_RGFW->x11Version >= 2) {
-                    XEvent reply = { ClientMessage };
-                    reply.xclient.window = _RGFW->x11Source;
-                    reply.xclient.message_type = XdndFinished;
-                    reply.xclient.format = 32;
-                    reply.xclient.data.l[0] = (long)win->src.window;
-                    reply.xclient.data.l[1] = 0;
-                    reply.xclient.data.l[2] = None;
-
-					XSendEvent(_RGFW->display, _RGFW->x11Source, False, NoEventMask, &reply);
-					XFlush(_RGFW->display);
-				}
+				break;
 			}
+			if (E.xclient.message_type != XdndDrop)
+				break;
+
+			if (version > 5)
+				break;
+
+			if (format) {
+				Time time = (version >= 1)
+					? (Time)E.xclient.data.l[2]
+					: CurrentTime;
+
+				XConvertSelection(
+					_RGFW->display, XdndSelection, (Atom)format,
+					XdndSelection, win->src.window, time
+				);
+			} else if (version >= 2) {
+				XEvent new_reply = { ClientMessage };
+
+				XSendEvent(_RGFW->display, source, False, NoEventMask, &new_reply);
+				XFlush(_RGFW->display);
+			}
+
+			RGFW_dataDragCallback(win, dragX, dragY);
 		} break;
 		case SelectionNotify: {
 			/* this is only for checking for xdnd drops */
@@ -7150,33 +7022,96 @@ void RGFW_XHandleEvent(void) {
 
 			XGetWindowProperty(_RGFW->display, E.xselection.requestor, E.xselection.property, 0, LONG_MAX, False, E.xselection.target, &actualType, &actualFormat, &result, &bytesAfter, (u8**) &data);
 
-			if (result != 0) {
-				RGFW_unix_parseURI(win, data);
+			if (result == 0)
+				break;
 
-				if (data)
-					XFree(data);
+			const char* prefix = (const char*)"file://";
+
+			char* line;
+
+			size_t count = 0;
+			char** files = _RGFW->files;
+
+			while ((line = (char*)RGFW_strtok(data, "\r\n"))) {
+				data = NULL;
+
+				if (line[0] == '#')
+					continue;
+
+				char* l;
+				for (l = line; 1; l++) {
+					if ((l - line) > 7)
+						break;
+					else if (*l != prefix[(l - line)])
+						break;
+					else if (*l == '\0' && prefix[(l - line)] == '\0') {
+						line += 7;
+						while (*line != '/')
+							line++;
+						break;
+					} else if (*l == '\0')
+						break;
+				}
+
+				count++;
+
+				size_t len = RGFW_unix_stringlen(line);
+				char* path = (char*)RGFW_ALLOC(len + 1);
+
+				size_t index = 0;
+				while (*line) {
+					if (line[0] == '%' && line[1] && line[2]) {
+						char digits[3] = {0};
+                        digits[0] = line[1];
+                        digits[1] = line[2];
+                        digits[2] = '\0';
+						path[index] = (char) RGFW_STRTOL(digits, NULL, 16);
+						line += 2;
+					} else {
+						if (index >= len) {
+							break;
+						}
+
+						path[index] = *line;
+					}
+
+					index++;
+					line++;
+				}
+
+				path[len] = '\0';
+				size_t cnt = RGFW_MIN(len + 1, RGFW_MAX_PATH);
+				if (cnt == RGFW_MAX_PATH) {
+					path[cnt] = '\0';
+				}
+
+				RGFW_MEMCPY(files[count - 1], path, cnt);
+				RGFW_FREE(path);
 			}
 
-			if (_RGFW->x11Version >= 2) {
-				XEvent reply = { ClientMessage };
-				reply.xclient.window = _RGFW->x11Source;
-				reply.xclient.message_type = XdndFinished;
-				reply.xclient.format = 32;
-				reply.xclient.data.l[0] = (long)win->src.window;
-				reply.xclient.data.l[1] = (long int)result;
-				reply.xclient.data.l[2] = (long int)XdndActionCopy;
-				XSendEvent(_RGFW->display, _RGFW->x11Source, False, NoEventMask, &reply);
+			RGFW_dataDropCallback(win, files, count);
+			if (data)
+				XFree(data);
+
+			if (version >= 2) {
+				XEvent new_reply = { ClientMessage };
+				new_reply.xclient.window = source;
+				new_reply.xclient.message_type = XdndFinished;
+				new_reply.xclient.format = 32;
+				new_reply.xclient.data.l[1] = (long int)result;
+				new_reply.xclient.data.l[2] = (long int)XdndActionCopy;
+				XSendEvent(_RGFW->display, source, False, NoEventMask, &new_reply);
 				XFlush(_RGFW->display);
 			}
 			break;
 		}
 		case FocusIn:
             if (win->src.ic) XSetICFocus(win->src.ic);
-			RGFW_windowFocusCallback(win, 1);
+			RGFW_focusCallback(win, 1);
 			break;
 		case FocusOut:
             if (win->src.ic) XUnsetICFocus(win->src.ic);
-			RGFW_windowFocusCallback(win, 0);
+			RGFW_focusCallback(win, 0);
 			break;
 		case EnterNotify: {
 			RGFW_mouseNotifyCallback(win, E.xcrossing.x, E.xcrossing.y, RGFW_TRUE);
@@ -7227,16 +7162,6 @@ void RGFW_XHandleEvent(void) {
 	XFlush(_RGFW->display);
 }
 
-RGFW_bool RGFW_FUNC(RGFW_window_fetchSize) (RGFW_window* win, i32* w, i32* h) {
-    XWindowAttributes attribs;
-    XGetWindowAttributes(_RGFW->display, win->src.window, &attribs);
-
-    win->w = attribs.width;
-    win->h = attribs.height;
-
-	return RGFW_window_getSize(win, w, h);
-}
-
 void RGFW_FUNC(RGFW_pollEvents) (void) {
 	RGFW_resetPrevState();
 
@@ -7300,7 +7225,7 @@ void RGFW_FUNC(RGFW_window_setMinSize) (RGFW_window* win, i32 w, i32 h) {
 
     long flags;
 	XSizeHints hints;
-    RGFW_MEMZERO(&hints, sizeof(XSizeHints));
+    RGFW_MEMSET(&hints, 0, sizeof(XSizeHints));
 
 	XGetWMNormalHints(_RGFW->display, win->src.window, &hints, &flags);
 
@@ -7318,7 +7243,7 @@ void RGFW_FUNC(RGFW_window_setMaxSize) (RGFW_window* win, i32 w, i32 h) {
 
     long flags;
 	XSizeHints hints;
-    RGFW_MEMZERO(&hints, sizeof(XSizeHints));
+    RGFW_MEMSET(&hints, 0, sizeof(XSizeHints));
 
 	XGetWMNormalHints(_RGFW->display, win->src.window, &hints, &flags);
 
@@ -7359,7 +7284,6 @@ void RGFW_FUNC(RGFW_window_maximize) (RGFW_window* win) {
 	win->internal.oldH = win->h;
 
     RGFW_toggleXMaximized(win, 1);
-	RGFW_window_fetchSize(win, NULL, NULL);
     return;
 }
 
@@ -7534,7 +7458,7 @@ RGFW_bool RGFW_FUNC(RGFW_window_setIconEx) (RGFW_window* win, u8* data_src, i32
 	unsigned long* data = (unsigned long*) RGFW_ALLOC((u32)count * sizeof(unsigned long));
     RGFW_ASSERT(data != NULL);
 
-	RGFW_MEMZERO(data, (u32)count * sizeof(unsigned long));
+	RGFW_MEMSET(data, 0, (u32)count * sizeof(unsigned long));
     data[0] = (unsigned long)w;
 	data[1] = (unsigned long)h;
 
@@ -7570,7 +7494,61 @@ RGFW_bool RGFW_FUNC(RGFW_window_setIconEx) (RGFW_window* win, u8* data_src, i32
 	return RGFW_BOOL(res);
 }
 
-RGFW_mouse* RGFW_FUNC(RGFW_createMouseStandard) (RGFW_mouseIcon mouse) {
+RGFW_mouse* RGFW_FUNC(RGFW_loadMouse) (u8* data, i32 w, i32 h, RGFW_format format) {
+    RGFW_ASSERT(data);
+#ifndef RGFW_NO_X11_CURSOR
+	RGFW_init();
+    XcursorImage* native = XcursorImageCreate((i32)w, (i32)h);
+	native->xhot = 0;
+	native->yhot = 0;
+	RGFW_MEMSET(native->pixels, 0, (u32)(w * h * 4));
+	RGFW_copyImageData((u8*)native->pixels, w, h, RGFW_formatBGRA8, data, format, NULL);
+
+	Cursor cursor = XcursorImageLoadCursor(_RGFW->display, native);
+	XcursorImageDestroy(native);
+
+	return (void*)cursor;
+#else
+	RGFW_UNUSED(data); RGFW_UNUSED(w); RGFW_UNUSED(h); RGFW_UNUSED(format);
+	return NULL;
+#endif
+}
+
+void RGFW_FUNC(RGFW_window_setMouse)(RGFW_window* win, RGFW_mouse* mouse) {
+	RGFW_ASSERT(win && mouse);
+	XDefineCursor(_RGFW->display, win->src.window, (Cursor)mouse);
+}
+
+void RGFW_FUNC(RGFW_freeMouse)(RGFW_mouse* mouse) {
+	RGFW_ASSERT(mouse);
+	XFreeCursor(_RGFW->display, (Cursor)mouse);
+}
+
+void RGFW_FUNC(RGFW_window_moveMouse)(RGFW_window* win, i32 x, i32 y) {
+	RGFW_ASSERT(win != NULL);
+
+	XEvent event;
+	XQueryPointer(_RGFW->display, DefaultRootWindow(_RGFW->display),
+		&event.xbutton.root, &event.xbutton.window,
+		&event.xbutton.x_root, &event.xbutton.y_root,
+		&event.xbutton.x, &event.xbutton.y,
+		&event.xbutton.state);
+
+	win->internal.lastMouseX = x - win->x;
+	win->internal.lastMouseY = y - win->y;
+	if (event.xbutton.x == x && event.xbutton.y == y)
+		return;
+
+	XWarpPointer(_RGFW->display, None, win->src.window, 0, 0, 0, 0, (int) x - win->x, (int) y - win->y);
+}
+
+RGFW_bool RGFW_FUNC(RGFW_window_setMouseDefault) (RGFW_window* win) {
+	return RGFW_window_setMouseStandard(win, RGFW_mouseArrow);
+}
+
+RGFW_bool RGFW_FUNC(RGFW_window_setMouseStandard) (RGFW_window* win, u8 mouse) {
+	RGFW_ASSERT(win != NULL);
+
 	u32 mouseIcon = 0;
 
     switch (mouse) {
@@ -7595,62 +7573,15 @@ RGFW_mouse* RGFW_FUNC(RGFW_createMouseStandard) (RGFW_mouseIcon mouse) {
 		case RGFW_mouseResizeAll: mouseIcon = XC_fleur; break;
         case RGFW_mouseNotAllowed: mouseIcon = XC_pirate; break;
         case RGFW_mousePointingHand: mouseIcon = XC_hand2; break;
-		default: return NULL;
+		default: return RGFW_FALSE;
 	}
 
 	Cursor cursor = XCreateFontCursor(_RGFW->display, mouseIcon);
-	return (RGFW_mouse*)cursor;
-}
-
-RGFW_mouse* RGFW_FUNC(RGFW_createMouse) (u8* data, i32 w, i32 h, RGFW_format format) {
-    RGFW_ASSERT(data);
-#ifndef RGFW_NO_X11_CURSOR
-	RGFW_init();
-    XcursorImage* native = XcursorImageCreate((i32)w, (i32)h);
-	native->xhot = 0;
-	native->yhot = 0;
-	RGFW_MEMZERO(native->pixels, (u32)(w * h * 4));
-	RGFW_copyImageData((u8*)native->pixels, w, h, RGFW_formatBGRA8, data, format, NULL);
-
-	Cursor cursor = XcursorImageLoadCursor(_RGFW->display, native);
-	XcursorImageDestroy(native);
-
-	return (void*)cursor;
-#else
-	RGFW_UNUSED(data); RGFW_UNUSED(w); RGFW_UNUSED(h); RGFW_UNUSED(format);
-	return NULL;
-#endif
-}
-
-RGFW_bool RGFW_FUNC(RGFW_window_setMousePlatform)(RGFW_window* win, RGFW_mouse* mouse) {
-	RGFW_ASSERT(win && mouse);
-	XDefineCursor(_RGFW->display, win->src.window, (Cursor)mouse);
+	XDefineCursor(_RGFW->display, win->src.window, (Cursor) cursor);
+	XFreeCursor(_RGFW->display, (Cursor) cursor);
 	return RGFW_TRUE;
 }
 
-void RGFW_FUNC(RGFW_freeMouse)(RGFW_mouse* mouse) {
-	RGFW_ASSERT(mouse);
-	XFreeCursor(_RGFW->display, (Cursor)mouse);
-}
-
-void RGFW_FUNC(RGFW_window_moveMouse)(RGFW_window* win, i32 x, i32 y) {
-	RGFW_ASSERT(win != NULL);
-
-	XEvent event;
-	XQueryPointer(_RGFW->display, DefaultRootWindow(_RGFW->display),
-		&event.xbutton.root, &event.xbutton.window,
-		&event.xbutton.x_root, &event.xbutton.y_root,
-		&event.xbutton.x, &event.xbutton.y,
-		&event.xbutton.state);
-
-	win->internal.lastMouseX = x - win->x;
-	win->internal.lastMouseY = y - win->y;
-	if (event.xbutton.x == x && event.xbutton.y == y)
-		return;
-
-	XWarpPointer(_RGFW->display, None, win->src.window, 0, 0, 0, 0, (int) x - win->x, (int) y - win->y);
-}
-
 void RGFW_FUNC(RGFW_window_hide)(RGFW_window* win) {
 	win->internal.flags |= (u32)RGFW_windowHide;
 	XUnmapWindow(_RGFW->display, win->src.window);
@@ -7776,7 +7707,7 @@ void RGFW_FUNC(RGFW_writeClipboard)(const char* text, u32 textLen) {
     /* request ownership of the clipboard section and request to convert it, this means its our job to convert it */
 	XSetSelectionOwner(_RGFW->display, CLIPBOARD, _RGFW->helperWindow, CurrentTime);
 	if (XGetSelectionOwner(_RGFW->display, CLIPBOARD) != _RGFW->helperWindow) {
-    	RGFW_debugCallback(RGFW_typeError, RGFW_errClipboard,  "X11 failed to become owner of clipboard selection");
+    	RGFW_sendDebugInfo(RGFW_typeError, RGFW_errClipboard,  "X11 failed to become owner of clipboard selection");
 		return;
 	}
 
@@ -7868,18 +7799,20 @@ void RGFW_XGetSystemContentDPI(float* dpi) {
 	if (dpi == NULL) return;
 	float dpiOutput = 96.0f;
 
-	char* rms = XResourceManagerString(_RGFW->display);
-	if (rms == NULL) return;
+	#ifndef RGFW_NO_XRANDR
+		char* rms = XResourceManagerString(_RGFW->display);
+		if (rms == NULL) return;
 
-	XrmDatabase db = XrmGetStringDatabase(rms);
-	if (db == NULL) return;
+		XrmDatabase db = XrmGetStringDatabase(rms);
+		if (db == NULL) return;
 
-	XrmValue value;
-	char* type = NULL;
+		XrmValue value;
+		char* type = NULL;
 
-	if (XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value) && type && RGFW_STRNCMP(type, "String", 7) == 0)
-		dpiOutput = (float)RGFW_ATOF(value.addr);
-	XrmDestroyDatabase(db);
+		if (XrmGetResource(db, "Xft.dpi", "Xft.Dpi", &type, &value) && type && RGFW_STRNCMP(type, "String", 7) == 0)
+			dpiOutput = (float)RGFW_ATOF(value.addr);
+		XrmDestroyDatabase(db);
+	#endif
 
 	if (dpi) *dpi = dpiOutput;
 }
@@ -7972,9 +7905,7 @@ void RGFW_FUNC(RGFW_pollMonitors) (void) {
 		RGFW_monitor monitor;
 
 		XRROutputInfo* info = XRRGetOutputInfo(_RGFW->display, res, res->outputs[i]);
-		if (info == NULL) continue;
-		if (info->connection != RR_Connected || info->crtc == None) {
-			XRRFreeOutputInfo(info);
+		if (info == NULL || info->connection != RR_Connected || info->crtc == None) {
 			continue;
 		}
 
@@ -8124,6 +8055,7 @@ size_t RGFW_FUNC(RGFW_monitor_getModesPtr) (RGFW_monitor* monitor, RGFW_monitorM
 
 size_t RGFW_FUNC(RGFW_monitor_getGammaRampPtr) (RGFW_monitor* monitor, RGFW_gammaRamp* ramp) {
 	RGFW_UNUSED(monitor); RGFW_UNUSED(ramp);
+#ifndef RGFW_NO_XRANDR
 	size_t size = (size_t)XRRGetCrtcGammaSize(_RGFW->display, monitor->node->crtc);
 	XRRCrtcGamma* gamma = XRRGetCrtcGamma(_RGFW->display, monitor->node->crtc);
 
@@ -8135,14 +8067,18 @@ size_t RGFW_FUNC(RGFW_monitor_getGammaRampPtr) (RGFW_monitor* monitor, RGFW_gamm
 
 	XRRFreeGamma(gamma);
 	return size;
+#endif
+
+	return 0;
 }
 
 RGFW_bool RGFW_FUNC(RGFW_monitor_setGammaRamp) (RGFW_monitor* monitor, RGFW_gammaRamp* ramp) {
 	RGFW_UNUSED(monitor); RGFW_UNUSED(ramp);
 
+#ifndef RGFW_NO_XRANDR
 	size_t size = (size_t)XRRGetCrtcGammaSize(_RGFW->display, monitor->node->crtc);
 	if (size != ramp->count) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errX11, "X11: Gamma ramp size must match current ramp size");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errX11, "X11: Gamma ramp size must match current ramp size");
 		return RGFW_FALSE;
 	}
 
@@ -8156,6 +8092,8 @@ RGFW_bool RGFW_FUNC(RGFW_monitor_setGammaRamp) (RGFW_monitor* monitor, RGFW_gamm
 	XRRFreeGamma(gamma);
 
 	return RGFW_TRUE;
+#endif
+	return RGFW_FALSE;
 }
 
 RGFW_bool RGFW_FUNC(RGFW_monitor_setMode)(RGFW_monitor* mon, RGFW_monitorMode* mode) {
@@ -8174,6 +8112,7 @@ RGFW_bool RGFW_FUNC(RGFW_monitor_setMode)(RGFW_monitor* mon, RGFW_monitorMode* m
 }
 
 RGFW_bool RGFW_FUNC(RGFW_monitor_requestMode)(RGFW_monitor* mon, RGFW_monitorMode* mode, RGFW_modeRequest request) {
+	#ifndef RGFW_NO_XRANDR
     RGFW_init();
 
 	RGFW_bool output = RGFW_FALSE;
@@ -8210,6 +8149,8 @@ RGFW_bool RGFW_FUNC(RGFW_monitor_requestMode)(RGFW_monitor* mon, RGFW_monitorMod
 	XRRFreeCrtcInfo(ci);
     XRRFreeScreenResources(res);
 	return output;
+#endif
+	return RGFW_FALSE;
 }
 
 RGFW_monitor* RGFW_FUNC(RGFW_window_getMonitor) (RGFW_window* win) {
@@ -8294,7 +8235,7 @@ RGFW_bool RGFW_FUNC(RGFW_window_createContextPtr_OpenGL) (RGFW_window* win, RGFW
 	i32 best_samples = 0;
 
 	if (fbcount == 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to find any valid GLX visual configs.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to find any valid GLX visual configs.");
 		return 0;
 	}
 
@@ -8323,7 +8264,7 @@ RGFW_bool RGFW_FUNC(RGFW_window_createContextPtr_OpenGL) (RGFW_window* win, RGFW
 	}
 
 	if (best_fbc == -1) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to get a valid GLX visual.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to get a valid GLX visual.");
 		return 0;
 	}
 
@@ -8331,10 +8272,10 @@ RGFW_bool RGFW_FUNC(RGFW_window_createContextPtr_OpenGL) (RGFW_window* win, RGFW
 	bestFbc = fbc[best_fbc];
 	XVisualInfo* vi = glXGetVisualFromFBConfig(_RGFW->display, bestFbc);
 	if (vi->depth != 32 && transparent)
-		RGFW_debugCallback(RGFW_typeWarning, RGFW_warningOpenGL,  "Failed to to find a matching visual with a 32-bit depth.");
+		RGFW_sendDebugInfo(RGFW_typeWarning, RGFW_warningOpenGL,  "Failed to to find a matching visual with a 32-bit depth.");
 
 	if (best_samples < hints->samples)
-		RGFW_debugCallback(RGFW_typeWarning, RGFW_warningOpenGL, "Failed to load a matching sample count.");
+		RGFW_sendDebugInfo(RGFW_typeWarning, RGFW_warningOpenGL, "Failed to load a matching sample count.");
 
 	XFree(fbc);
 	visual = *vi;
@@ -8400,13 +8341,13 @@ RGFW_bool RGFW_FUNC(RGFW_window_createContextPtr_OpenGL) (RGFW_window* win, RGFW
 	}
 
 	if (glXCreateContextAttribsARB == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to load proc address 'glXCreateContextAttribsARB', loading a generic OpenGL context.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to load proc address 'glXCreateContextAttribsARB', loading a generic OpenGL context.");
 			win->src.ctx.native->ctx = glXCreateContext(_RGFW->display, &visual, ctx, True);
 	} else {
 		_RGFW->x11Error = NULL;
 		win->src.ctx.native->ctx = glXCreateContextAttribsARB(_RGFW->display, bestFbc, ctx, True, context_attribs);
 		if (_RGFW->x11Error || win->src.ctx.native->ctx == NULL) {
-			RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create an OpenGL context with AttribsARB, loading a generic OpenGL context.");
+			RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create an OpenGL context with AttribsARB, loading a generic OpenGL context.");
 			win->src.ctx.native->ctx = glXCreateContext(_RGFW->display, &visual, ctx, True);
 		}
 	}
@@ -8418,7 +8359,7 @@ RGFW_bool RGFW_FUNC(RGFW_window_createContextPtr_OpenGL) (RGFW_window* win, RGFW
 	#endif
 
 	glXMakeCurrent(_RGFW->display, (Drawable)win->src.ctx.native->window, (GLXContext)win->src.ctx.native->ctx);
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
 
 	RGFW_window_swapInterval_OpenGL(win, 0);
 
@@ -8434,7 +8375,7 @@ void RGFW_FUNC(RGFW_window_deleteContextPtr_OpenGL) (RGFW_window* win, RGFW_glCo
 
 	glXDestroyContext(_RGFW->display, ctx->ctx);
 	win->src.ctx.native = NULL;
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL,  "OpenGL context freed.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL,  "OpenGL context freed.");
 }
 
 RGFW_bool RGFW_FUNC(RGFW_extensionSupportedPlatform_OpenGL)(const char * extension, size_t len) {
@@ -8474,9 +8415,9 @@ void RGFW_FUNC(RGFW_window_swapInterval_OpenGL) (RGFW_window* win, i32 swapInter
 			}
 
 			if (pfn2 != NULL) {
-				RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext,  "Failed to load swap interval function, fallingback to the native swapinterval function");
+				RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext,  "Failed to load swap interval function, fallingback to the native swapinterval function");
 			} else {
-				RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext,  "Failed to load swap interval function");
+				RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext,  "Failed to load swap interval function");
 			}
 		}
 	}
@@ -8539,14 +8480,13 @@ i32 RGFW_initPlatform_X11(void) {
 	_RGFW->context = XUniqueContext();
 
 	XSetWindowAttributes wa;
-    RGFW_MEMZERO(&wa, sizeof(wa));
+    RGFW_MEMSET(&wa, 0, sizeof(wa));
     wa.event_mask = PropertyChangeMask;
     _RGFW->helperWindow = XCreateWindow(_RGFW->display, XDefaultRootWindow(_RGFW->display), 0, 0, 1, 1, 0, 0,
                                         InputOnly, DefaultVisual(_RGFW->display, DefaultScreen(_RGFW->display)), CWEventMask, &wa);
 
     u8 RGFW_blk[] = { 0, 0, 0, 0 };
-	_RGFW->hiddenMouse = RGFW_createMouse(RGFW_blk, 1, 1, RGFW_formatRGBA8);
-
+	_RGFW->hiddenMouse = RGFW_loadMouse(RGFW_blk, 1, 1, RGFW_formatRGBA8);
 	_RGFW->clipboard = NULL;
 
     XkbComponentNamesRec rec;
@@ -8557,7 +8497,7 @@ i32 RGFW_initPlatform_X11(void) {
 
     XkbGetNames(_RGFW->display, XkbKeyNamesMask, desc);
 
-    RGFW_MEMZERO(&rec, sizeof(rec));
+    RGFW_MEMSET(&rec, 0, sizeof(rec));
     char evdev[] = "evdev";
     rec.keycodes = evdev;
     evdesc = XkbGetKeyboardByName(_RGFW->display, XkbUseCoreKbd, &rec, XkbGBN_KeyNamesMask, XkbGBN_KeyNamesMask, False);
@@ -8583,10 +8523,23 @@ i32 RGFW_initPlatform_X11(void) {
 	XSetLocaleModifiers("");
 	XRegisterIMInstantiateCallback(_RGFW->display, NULL, NULL, NULL, RGFW_x11_imInitCallback, NULL);
 
+	unsigned char mask[XIMaskLen(XI_RawMotion)];
+	RGFW_MEMSET(mask, 0, sizeof(mask));
+	XISetMask(mask, XI_RawMotion);
+
+	XIEventMask em;
+	em.deviceid = XIAllMasterDevices;
+	em.mask_len = sizeof(mask);
+	em.mask = mask;
+
+	XISelectEvents(_RGFW->display, XDefaultRootWindow(_RGFW->display), &em, 1);
+
+#ifndef RGFW_NO_XRANDR
 	i32 errorBase;
 	if (XRRQueryExtension(_RGFW->display, &_RGFW->xrandrEventBase, &errorBase)) {
         XRRSelectInput(_RGFW->display, RootWindow(_RGFW->display, DefaultScreen(_RGFW->display)), RROutputChangeNotifyMask);
 	}
+#endif
 
 	return 0;
 }
@@ -8714,13 +8667,13 @@ struct wl_surface* RGFW_window_getWindow_Wayland(RGFW_window* win) { return win-
 
 
 /* wayland global garbage (wayland bad, X11 is fine (ish) (not really)) */
-#include "xdg-shell.h"
-#include "xdg-toplevel-icon-v1.h"
-#include "xdg-decoration-unstable-v1.h"
-#include "relative-pointer-unstable-v1.h"
-#include "pointer-constraints-unstable-v1.h"
-#include "xdg-output-unstable-v1.h"
-#include "pointer-warp-v1.h"
+#include "xdg-shell-client-protocol.h"
+#include "xdg-toplevel-icon-v1-client-protocol.h"
+#include "xdg-decoration-unstable-v1-client-protocol.h"
+#include "relative-pointer-unstable-v1-client-protocol.h"
+#include "pointer-constraints-unstable-v1-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+#include "pointer-warp-v1-client-protocol.h"
 
 void RGFW_toggleWaylandMaximized(RGFW_window* win, RGFW_bool maximized);
 
@@ -8817,7 +8770,7 @@ static void RGFW_wl_xdg_toplevel_close_handler(void* data, struct xdg_toplevel *
 	RGFW_window* win = (RGFW_window*)data;
 
 	if (!win->internal.shouldClose) {
-		RGFW_windowCloseCallback(win);
+		RGFW_windowQuitCallback(win);
 	}
 }
 
@@ -8851,7 +8804,7 @@ static void RGFW_wl_relative_pointer_motion(void *data, struct zwp_relative_poin
 
 	float vecX =  (float)wl_fixed_to_double(dx);
 	float vecY = (float)wl_fixed_to_double(dy);
-	RGFW_rawMotionCallback(win, vecX, vecY);
+	RGFW_mousePosCallback(win, win->internal.lastMouseX, win->internal.lastMouseY, vecX, vecY);
 }
 
 static void RGFW_wl_pointer_locked(void *data, struct zwp_locked_pointer_v1 *zwp_locked_pointer_v1) {
@@ -8897,6 +8850,7 @@ static void RGFW_wl_pointer_leave(void* data, struct wl_pointer *pointer, u32 se
 
 static void RGFW_wl_pointer_motion(void* data, struct wl_pointer *pointer, u32 time, wl_fixed_t x, wl_fixed_t y) {
 	RGFW_UNUSED(pointer); RGFW_UNUSED(time);
+
 	RGFW_info* RGFW = (RGFW_info*)data;
 	RGFW_ASSERT(RGFW->mouseOwner != NULL);
 
@@ -8904,8 +8858,10 @@ static void RGFW_wl_pointer_motion(void* data, struct wl_pointer *pointer, u32 t
 
 	i32 convertedX = (i32)wl_fixed_to_double(x);
 	i32 convertedY = (i32)wl_fixed_to_double(y);
+	float newVecX = (float)(convertedX - win->internal.lastMouseX);
+	float newVecY = (float)(convertedY - win->internal.lastMouseY);
 
-	RGFW_mouseMotionCallback(win, convertedX, convertedY);
+	RGFW_mousePosCallback(win, convertedX, convertedY, newVecX, newVecY);
 }
 
 static void RGFW_wl_pointer_button(void* data, struct wl_pointer *pointer, u32 serial, u32 time, u32 button, u32 state) {
@@ -8991,7 +8947,7 @@ static void RGFW_wl_keyboard_enter(void* data, struct wl_keyboard *keyboard, u32
 	/* pressed this flag is not set since there is no event to listen for */
 	if (win->src.minimized == RGFW_TRUE) win->src.minimized = RGFW_FALSE;
 
-	RGFW_windowFocusCallback(win, RGFW_TRUE);
+	RGFW_focusCallback(win, RGFW_TRUE);
 }
 
 static void RGFW_wl_keyboard_leave(void* data, struct wl_keyboard *keyboard, u32 serial, struct wl_surface *surface) {
@@ -9002,7 +8958,7 @@ static void RGFW_wl_keyboard_leave(void* data, struct wl_keyboard *keyboard, u32
 	if (RGFW->kbOwner == win)
 		RGFW->kbOwner = NULL;
 
-	RGFW_windowFocusCallback(win, RGFW_FALSE);
+	RGFW_focusCallback(win, RGFW_FALSE);
 }
 
 static xkb_keysym_t RGFW_wl_composeSymbol(RGFW_info* RGFW, xkb_keysym_t sym) {
@@ -9022,19 +8978,8 @@ static xkb_keysym_t RGFW_wl_composeSymbol(RGFW_info* RGFW, xkb_keysym_t sym) {
     }
 }
 
-static void RGFW_wl_send_key_event(u32 key) {
-	const xkb_keysym_t* keysyms;
-	if (xkb_state_key_get_syms(_RGFW->xkb_state, key + 8, &keysyms) == 1) {
-		xkb_keysym_t keysym = RGFW_wl_composeSymbol(_RGFW, keysyms[0]);
-		u32 codepoint = xkb_keysym_to_utf32(keysym);
-		if (codepoint != 0) {
-			RGFW_keyCharCallback(_RGFW->kbOwner, codepoint);
-		}
-	}
-}
-
 static void RGFW_wl_keyboard_key(void* data, struct wl_keyboard *keyboard, u32 serial, u32 time, u32 key, u32 state) {
-	RGFW_UNUSED(keyboard); RGFW_UNUSED(serial);
+	RGFW_UNUSED(keyboard); RGFW_UNUSED(serial); RGFW_UNUSED(time);
 
 	RGFW_info* RGFW = (RGFW_info*)data;
 	if (RGFW->kbOwner == NULL) return;
@@ -9042,22 +8987,17 @@ static void RGFW_wl_keyboard_key(void* data, struct wl_keyboard *keyboard, u32 s
 	RGFW_window *RGFW_key_win = RGFW->kbOwner;
 	RGFW_key RGFWkey = RGFW_apiKeyToRGFW(key + 8);
 
-	RGFW_keyUpdateKeyMods(RGFW_key_win, RGFW_BOOL(xkb_keymap_mod_get_index(RGFW->keymap, "Lock")), RGFW_BOOL(xkb_keymap_mod_get_index(RGFW->keymap, "Mod2")), RGFW_BOOL(xkb_keymap_mod_get_index(RGFW->keymap, "ScrollLock")));
-	RGFW_keyCallback(RGFW_key_win, (u8)RGFWkey, RGFW_key_win->internal.mod, RGFW_isKeyDown((u8)RGFWkey) && RGFW_BOOL(state), RGFW_BOOL(state));
+	RGFW_updateKeyMods(RGFW_key_win, RGFW_BOOL(xkb_keymap_mod_get_index(RGFW->keymap, "Lock")), RGFW_BOOL(xkb_keymap_mod_get_index(RGFW->keymap, "Mod2")), RGFW_BOOL(xkb_keymap_mod_get_index(RGFW->keymap, "ScrollLock")));
+	RGFW_keyCallback(RGFW_key_win, (u8)RGFWkey, RGFW_key_win->internal.mod, RGFW_window_isKeyDown(RGFW_key_win, (u8)RGFWkey), RGFW_BOOL(state));
 
-	/* [comment by Kala Telo (@kala-telo) and edited by Riley Mabb (@ColleagueRiley)]
-		we send the event at the moment we receive it, and
-		repeated key presses will be handled by RGFW_pollEvents
-		if the compositor doesn't support proxy (seat?) version
-		of at least 4, it won't initialize wl_repeat_info_rate,
-		and by spec, rate of 0 means disabled, thus repeating
-		keys are disabled by being zero-initialized
-	*/
-	RGFW->last_key = state ? key : 0;
-	RGFW->last_key_time = time + (u32)_RGFW->wl_repeat_info_delay;
-	if (state) {
-		RGFW_wl_send_key_event(_RGFW->last_key);
-	}
+	const xkb_keysym_t* keysyms;
+    if (xkb_state_key_get_syms(RGFW->xkb_state, key + 8, &keysyms) == 1) {
+		xkb_keysym_t keysym = RGFW_wl_composeSymbol(RGFW, keysyms[0]);
+		u32 codepoint = xkb_keysym_to_utf32(keysym);
+		if (codepoint != 0) {
+			RGFW_keyCharCallback(RGFW_key_win, codepoint);
+        }
+    }
 }
 
 static void RGFW_wl_keyboard_modifiers(void* data, struct wl_keyboard *keyboard, u32 serial, u32 mods_depressed, u32 mods_latched, u32 mods_locked, u32 group) {
@@ -9066,17 +9006,10 @@ static void RGFW_wl_keyboard_modifiers(void* data, struct wl_keyboard *keyboard,
 	xkb_state_update_mask(RGFW->xkb_state, mods_depressed, mods_latched, mods_locked, 0, 0, group);
 }
 
-static void RGFW_wl_keyboard_repeat_info(void* data, struct wl_keyboard *keyboard, i32 rate, i32 delay) {
-	RGFW_UNUSED(data);
-	RGFW_UNUSED(keyboard);
-	_RGFW->wl_repeat_info_rate = rate;
-	_RGFW->wl_repeat_info_delay = delay;
-}
-
 static void RGFW_wl_seat_capabilities(void* data, struct wl_seat *seat, u32 capabilities) {
 	RGFW_info* RGFW = (RGFW_info*)data;
     static struct wl_pointer_listener pointer_listener;
-	RGFW_MEMZERO(&pointer_listener, sizeof(pointer_listener));
+	RGFW_MEMSET(&pointer_listener, 0, sizeof(pointer_listener));
 	pointer_listener.enter = &RGFW_wl_pointer_enter;
 	pointer_listener.leave = &RGFW_wl_pointer_leave;
 	pointer_listener.motion = &RGFW_wl_pointer_motion;
@@ -9084,13 +9017,12 @@ static void RGFW_wl_seat_capabilities(void* data, struct wl_seat *seat, u32 capa
 	pointer_listener.axis = &RGFW_wl_pointer_axis;
 
 	static struct wl_keyboard_listener keyboard_listener;
-	RGFW_MEMZERO(&keyboard_listener, sizeof(keyboard_listener));
+	RGFW_MEMSET(&keyboard_listener, 0, sizeof(keyboard_listener));
 	keyboard_listener.keymap = &RGFW_wl_keyboard_keymap;
 	keyboard_listener.enter = &RGFW_wl_keyboard_enter;
 	keyboard_listener.leave = &RGFW_wl_keyboard_leave;
 	keyboard_listener.key = &RGFW_wl_keyboard_key;
 	keyboard_listener.modifiers = &RGFW_wl_keyboard_modifiers;
-	keyboard_listener.repeat_info = &RGFW_wl_keyboard_repeat_info;
 
     if ((capabilities & WL_SEAT_CAPABILITY_POINTER) && !RGFW->wl_pointer) {
 		RGFW->wl_pointer = wl_seat_get_pointer(seat);
@@ -9222,7 +9154,7 @@ static void RGFW_wl_output_handle_done(void* data, struct wl_output* output) {
 }
 
 static void RGFW_wl_create_outputs(struct wl_registry *const registry, u32 id) {
-	struct wl_output *output = wl_registry_bind(registry, id, &wl_output_interface, wl_proxy_get_version((struct wl_proxy*)_RGFW->seat));
+	struct wl_output *output = wl_registry_bind(registry, id, &wl_output_interface, wl_display_get_version(_RGFW->wl_display) < 4 ? 3 : 4);
 	RGFW_monitorNode* node;
 	RGFW_monitor mon;
 
@@ -9230,7 +9162,7 @@ static void RGFW_wl_create_outputs(struct wl_registry *const registry, u32 id) {
 
 	char RGFW_mon_default_name[10];
 
-	RGFW_SNPRINTF(RGFW_mon_default_name, sizeof(RGFW_mon_default_name), "monitor-%zu", _RGFW->monitors.count);
+	RGFW_SNPRINTF(RGFW_mon_default_name, sizeof(RGFW_mon_default_name), "monitor-%li", _RGFW->monitors.count);
 	RGFW_STRNCPY(mon.name, RGFW_mon_default_name, sizeof(mon.name) - 1);
 	mon.name[sizeof(mon.name) - 1] = '\0';
 
@@ -9284,6 +9216,9 @@ static void RGFW_wl_surface_enter(void *data, struct wl_surface *wl_surface, str
 	if (node == NULL) return;
 
 	win->src.active_monitor = node;
+
+	if (win->internal.flags & RGFW_windowScaleToMonitor)
+		RGFW_window_scaleToMonitor(win);
 }
 
 static void RGFW_wl_data_source_send(void *data, struct wl_data_source *wl_data_source, const char *mime_type, i32 fd) {
@@ -9340,9 +9275,6 @@ static void RGFW_wl_data_device_selection(void *data, struct wl_data_device *wl_
 
 	ssize_t n = read(pfds[0], buf, sizeof(buf));
 
-	if (_RGFW->clipboard) {
-		RGFW_FREE(_RGFW->clipboard);
-	}
 	_RGFW->clipboard = (char*)RGFW_ALLOC((size_t)n);
 	RGFW_ASSERT(_RGFW->clipboard != NULL);
 	RGFW_STRNCPY(_RGFW->clipboard, buf, (size_t)n);
@@ -9379,7 +9311,7 @@ static void RGFW_wl_global_registry_handler(void* data, struct wl_registry *regi
         RGFW->shm = wl_registry_bind(registry, id, &wl_shm_interface, 1);
         wl_shm_add_listener(RGFW->shm, &shm_listener, RGFW);
 	} else if (RGFW_STRNCMP(interface,"wl_seat", 8) == 0) {
-		RGFW->seat = wl_registry_bind(registry, id, &wl_seat_interface, version < 4 ? 3 : 4);
+		RGFW->seat = wl_registry_bind(registry, id, &wl_seat_interface, 1);
 		wl_seat_add_listener(RGFW->seat, &seat_listener, RGFW);
 	} else if (RGFW_STRNCMP(interface, zxdg_output_manager_v1_interface.name, 255) == 0) {
 		RGFW->xdg_output_manager = wl_registry_bind(registry, id, &zxdg_output_manager_v1_interface, 1);
@@ -9476,7 +9408,7 @@ static int RGFW_wl_create_shm_file(off_t size) {
 i32 RGFW_initPlatform_Wayland(void) {
 	_RGFW->wl_display = wl_display_connect(NULL);
 	if (_RGFW->wl_display == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errWayland,  "Failed to load Wayland display");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errWayland,  "Failed to load Wayland display");
 		return -1;
 	}
 
@@ -9492,8 +9424,8 @@ i32 RGFW_initPlatform_Wayland(void) {
 	wl_display_roundtrip(_RGFW->wl_display); /* bind to globals */
 
 	if (_RGFW->compositor == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errWayland, "Can't find compositor.");
-		return -1;
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errWayland, "Can't find compositor.");
+		return 1;
 	}
 
 	if (_RGFW->wl_cursor_theme == NULL) {
@@ -9502,7 +9434,7 @@ i32 RGFW_initPlatform_Wayland(void) {
 	}
 
 	 u8 RGFW_blk[] = { 0, 0, 0, 0 };
-	_RGFW->hiddenMouse = RGFW_createMouse(RGFW_blk, 1, 1, RGFW_formatRGBA8);
+	_RGFW->hiddenMouse = RGFW_loadMouse(RGFW_blk, 1, 1, RGFW_formatRGBA8);
 
 	static const struct xdg_wm_base_listener xdg_wm_base_listener = {
 		.ping = RGFW_wl_xdg_wm_base_ping_handler,
@@ -9616,12 +9548,12 @@ RGFW_bool RGFW_FUNC(RGFW_createSurfacePtr) (u8* data, i32 w, i32 h, RGFW_format
 	surface->w = w;
 	surface->h = h;
 	surface->format = format;
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoBuffer,  "Creating a 4 channel buffer");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoBuffer,  "Creating a 4 channel buffer");
 
 	u32 size = (u32)(surface->w * surface->h * 4);
 	int fd = RGFW_wl_create_shm_file(size);
 	if (fd < 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errBuffer, "Failed to create a buffer.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errBuffer, "Failed to create a buffer.");
 		return RGFW_FALSE;
 	}
 
@@ -9629,7 +9561,7 @@ RGFW_bool RGFW_FUNC(RGFW_createSurfacePtr) (u8* data, i32 w, i32 h, RGFW_format
 
 	surface->native.buffer = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 	if (surface->native.buffer == MAP_FAILED) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errBuffer, "mmap failed.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errBuffer, "mmap failed.");
 		return RGFW_FALSE;
 	}
 
@@ -9649,16 +9581,15 @@ void RGFW_FUNC(RGFW_window_blitSurface) (RGFW_window* win, RGFW_surface* surface
 	wl_surface_commit(win->src.surface);
 
 	wl_buffer_destroy(surface->native.wl_buffer);
-
-	surface->native.wl_buffer = NULL;
 }
 
 void RGFW_FUNC(RGFW_surface_freePtr) (RGFW_surface* surface) {
 	RGFW_ASSERT(surface != NULL);
 
-	if (surface->native.pool) wl_shm_pool_destroy(surface->native.pool);
-	if (surface->native.fd) close(surface->native.fd);
-	if (surface->native.buffer) munmap(surface->native.buffer, (size_t)(surface->w * surface->h * 4));
+	wl_shm_pool_destroy(surface->native.pool);
+	close(surface->native.fd);
+
+	munmap(surface->native.buffer, (size_t)(surface->w * surface->h * 4));
 }
 
 void RGFW_FUNC(RGFW_window_setBorder) (RGFW_window* win, RGFW_bool border) {
@@ -9718,7 +9649,7 @@ void RGFW_FUNC(RGFW_window_captureMousePlatform) (RGFW_window* win, RGFW_bool st
 }
 
 RGFW_window* RGFW_FUNC(RGFW_createWindowPlatform) (const char* name, RGFW_windowFlags flags, RGFW_window* win) {
-	RGFW_debugCallback(RGFW_typeWarning, RGFW_warningWayland, "RGFW Wayland support is experimental");
+	RGFW_sendDebugInfo(RGFW_typeWarning, RGFW_warningWayland, "RGFW Wayland support is experimental");
 
 	static const struct xdg_surface_listener xdg_surface_listener = {
 		.configure = RGFW_wl_xdg_surface_configure_handler,
@@ -9844,81 +9775,77 @@ RGFW_key RGFW_FUNC(RGFW_physicalToMappedKey)(RGFW_key key) {
     }
 
     switch (sym) {
-        case XKB_KEY_F1:  return RGFW_keyF1;
-        case XKB_KEY_F2:  return RGFW_keyF2;
-        case XKB_KEY_F3:  return RGFW_keyF3;
-        case XKB_KEY_F4:  return RGFW_keyF4;
-        case XKB_KEY_F5:  return RGFW_keyF5;
-        case XKB_KEY_F6:  return RGFW_keyF6;
-        case XKB_KEY_F7:  return RGFW_keyF7;
-        case XKB_KEY_F8:  return RGFW_keyF8;
-        case XKB_KEY_F9:  return RGFW_keyF9;
-        case XKB_KEY_F10: return RGFW_keyF10;
-        case XKB_KEY_F11: return RGFW_keyF11;
-        case XKB_KEY_F12: return RGFW_keyF12;
-        case XKB_KEY_F13: return RGFW_keyF13;
-        case XKB_KEY_F14: return RGFW_keyF14;
-        case XKB_KEY_F15: return RGFW_keyF15;
-        case XKB_KEY_F16: return RGFW_keyF16;
-        case XKB_KEY_F17: return RGFW_keyF17;
-        case XKB_KEY_F18: return RGFW_keyF18;
-        case XKB_KEY_F19: return RGFW_keyF19;
-        case XKB_KEY_F20: return RGFW_keyF20;
-        case XKB_KEY_F21: return RGFW_keyF21;
-        case XKB_KEY_F22: return RGFW_keyF22;
-        case XKB_KEY_F23: return RGFW_keyF23;
-        case XKB_KEY_F24: return RGFW_keyF24;
-        case XKB_KEY_F25: return RGFW_keyF25;
-        case XKB_KEY_Shift_L:   return RGFW_keyShiftL;
-        case XKB_KEY_Shift_R:   return RGFW_keyShiftR;
-        case XKB_KEY_Control_L: return RGFW_keyControlL;
-        case XKB_KEY_Control_R: return RGFW_keyControlR;
-        case XKB_KEY_Alt_L:     return RGFW_keyAltL;
-        case XKB_KEY_Alt_R:     return RGFW_keyAltR;
-        case XKB_KEY_Super_L:   return RGFW_keySuperL;
-        case XKB_KEY_Super_R:   return RGFW_keySuperR;
-        case XKB_KEY_Caps_Lock: return RGFW_keyCapsLock;
-        case XKB_KEY_Num_Lock:  return RGFW_keyNumLock;
-        case XKB_KEY_Scroll_Lock:return RGFW_keyScrollLock;
-        case XKB_KEY_Up:        return RGFW_keyUp;
-        case XKB_KEY_Down:      return RGFW_keyDown;
-        case XKB_KEY_Left:      return RGFW_keyLeft;
-        case XKB_KEY_Right:     return RGFW_keyRight;
-        case XKB_KEY_Home:      return RGFW_keyHome;
-        case XKB_KEY_End:       return RGFW_keyEnd;
-        case XKB_KEY_Page_Up:   return RGFW_keyPageUp;
-        case XKB_KEY_Page_Down: return RGFW_keyPageDown;
-        case XKB_KEY_Insert:    return RGFW_keyInsert;
-        case XKB_KEY_Menu:      return RGFW_keyMenu;
-        case XKB_KEY_KP_Add:      return RGFW_keyPadPlus;
-        case XKB_KEY_KP_Subtract: return RGFW_keyPadMinus;
-        case XKB_KEY_KP_Multiply: return RGFW_keyPadMultiply;
-        case XKB_KEY_KP_Divide:   return RGFW_keyPadSlash;
-        case XKB_KEY_KP_Equal:    return RGFW_keyPadEqual;
-        case XKB_KEY_KP_Enter:    return RGFW_keyPadReturn;
-        case XKB_KEY_KP_Decimal:  return RGFW_keyPadPeriod;
-        case XKB_KEY_KP_0: return RGFW_keyPad0;
-        case XKB_KEY_KP_1: return RGFW_keyPad1;
-        case XKB_KEY_KP_2: return RGFW_keyPad2;
-        case XKB_KEY_KP_3: return RGFW_keyPad3;
-        case XKB_KEY_KP_4: return RGFW_keyPad4;
-        case XKB_KEY_KP_5: return RGFW_keyPad5;
-        case XKB_KEY_KP_6: return RGFW_keyPad6;
-        case XKB_KEY_KP_7: return RGFW_keyPad7;
-        case XKB_KEY_KP_8: return RGFW_keyPad8;
-        case XKB_KEY_KP_9: return RGFW_keyPad9;
-        case XKB_KEY_Print: return RGFW_keyPrintScreen;
-        case XKB_KEY_Pause: return RGFW_keyPause;
+        case XKB_KEY_F1:  return RGFW_F1;
+        case XKB_KEY_F2:  return RGFW_F2;
+        case XKB_KEY_F3:  return RGFW_F3;
+        case XKB_KEY_F4:  return RGFW_F4;
+        case XKB_KEY_F5:  return RGFW_F5;
+        case XKB_KEY_F6:  return RGFW_F6;
+        case XKB_KEY_F7:  return RGFW_F7;
+        case XKB_KEY_F8:  return RGFW_F8;
+        case XKB_KEY_F9:  return RGFW_F9;
+        case XKB_KEY_F10: return RGFW_F10;
+        case XKB_KEY_F11: return RGFW_F11;
+        case XKB_KEY_F12: return RGFW_F12;
+        case XKB_KEY_F13: return RGFW_F13;
+        case XKB_KEY_F14: return RGFW_F14;
+        case XKB_KEY_F15: return RGFW_F15;
+        case XKB_KEY_F16: return RGFW_F16;
+        case XKB_KEY_F17: return RGFW_F17;
+        case XKB_KEY_F18: return RGFW_F18;
+        case XKB_KEY_F19: return RGFW_F19;
+        case XKB_KEY_F20: return RGFW_F20;
+        case XKB_KEY_F21: return RGFW_F21;
+        case XKB_KEY_F22: return RGFW_F22;
+        case XKB_KEY_F23: return RGFW_F23;
+        case XKB_KEY_F24: return RGFW_F24;
+        case XKB_KEY_F25: return RGFW_F25;
+        case XKB_KEY_Shift_L:   return RGFW_shiftL;
+        case XKB_KEY_Shift_R:   return RGFW_shiftR;
+        case XKB_KEY_Control_L: return RGFW_controlL;
+        case XKB_KEY_Control_R: return RGFW_controlR;
+        case XKB_KEY_Alt_L:     return RGFW_altL;
+        case XKB_KEY_Alt_R:     return RGFW_altR;
+        case XKB_KEY_Super_L:   return RGFW_superL;
+        case XKB_KEY_Super_R:   return RGFW_superR;
+        case XKB_KEY_Caps_Lock: return RGFW_capsLock;
+        case XKB_KEY_Num_Lock:  return RGFW_numLock;
+        case XKB_KEY_Scroll_Lock:return RGFW_scrollLock;
+        case XKB_KEY_Up:        return RGFW_up;
+        case XKB_KEY_Down:      return RGFW_down;
+        case XKB_KEY_Left:      return RGFW_left;
+        case XKB_KEY_Right:     return RGFW_right;
+        case XKB_KEY_Home:      return RGFW_home;
+        case XKB_KEY_End:       return RGFW_end;
+        case XKB_KEY_Page_Up:   return RGFW_pageUp;
+        case XKB_KEY_Page_Down: return RGFW_pageDown;
+        case XKB_KEY_Insert:    return RGFW_insert;
+        case XKB_KEY_Menu:      return RGFW_menu;
+        case XKB_KEY_KP_Add:      return RGFW_kpPlus;
+        case XKB_KEY_KP_Subtract: return RGFW_kpMinus;
+        case XKB_KEY_KP_Multiply: return RGFW_kpMultiply;
+        case XKB_KEY_KP_Divide:   return RGFW_kpSlash;
+        case XKB_KEY_KP_Equal:    return RGFW_kpEqual;
+        case XKB_KEY_KP_Enter:    return RGFW_kpReturn;
+        case XKB_KEY_KP_Decimal:  return RGFW_kpPeriod;
+        case XKB_KEY_KP_0: return RGFW_kp0;
+        case XKB_KEY_KP_1: return RGFW_kp1;
+        case XKB_KEY_KP_2: return RGFW_kp2;
+        case XKB_KEY_KP_3: return RGFW_kp3;
+        case XKB_KEY_KP_4: return RGFW_kp4;
+        case XKB_KEY_KP_5: return RGFW_kp5;
+        case XKB_KEY_KP_6: return RGFW_kp6;
+        case XKB_KEY_KP_7: return RGFW_kp7;
+        case XKB_KEY_KP_8: return RGFW_kp8;
+        case XKB_KEY_KP_9: return RGFW_kp9;
+        case XKB_KEY_Print: return RGFW_printScreen;
+        case XKB_KEY_Pause: return RGFW_pause;
         default: break;
     }
 
     return RGFW_keyNULL;
 }
 
-RGFW_bool RGFW_FUNC(RGFW_window_fetchSize) (RGFW_window* win, i32* w, i32* h) {
-	return RGFW_window_getSize(win, w, h);
-}
-
 void RGFW_FUNC(RGFW_pollEvents) (void) {
 	RGFW_resetPrevState();
 
@@ -9934,42 +9861,13 @@ void RGFW_FUNC(RGFW_pollEvents) (void) {
 			return;
 		}
 	}
-	if (_RGFW->wl_repeat_info_rate != 0 && _RGFW->last_key) {
-		u32 now = (u32)(RGFW_linux_getTimeNS() / 1000000);
-		if (now > _RGFW->last_key_time) {
-			RGFW_wl_send_key_event(_RGFW->last_key);
-			_RGFW->last_key_time = now + 1000 / (u32)_RGFW->wl_repeat_info_rate;
-		}
-	}
 
 	/* read the events; if empty this reads from the */
 	/* wayland file descriptor */
-	struct pollfd fds;
-	memset(&fds, 0, sizeof(fds));
-    fds.fd = wl_display_get_fd(_RGFW->wl_display);
-    fds.events = POLLIN;
-    fds.revents = 0;
-
-    while (1) {
-        while (wl_display_prepare_read(_RGFW->wl_display) != 0) {
-            if (wl_display_dispatch_pending(_RGFW->wl_display) > 0)
-                return;
-        }
-
-        if (poll(&fds, 1, 0) == 0) {
-            wl_display_cancel_read(_RGFW->wl_display);
-            return;
-        }
-
-        if (fds.revents & POLLIN) {
-            wl_display_read_events(_RGFW->wl_display);
-            if (wl_display_dispatch_pending(_RGFW->wl_display) > 0) {
-				return;
-			}
-		} else {
-            wl_display_cancel_read(_RGFW->wl_display);
-		}
+	if (wl_display_dispatch(_RGFW->wl_display) == -1) {
+		return;
 	}
+
 }
 
 void RGFW_FUNC(RGFW_window_move) (RGFW_window* win, i32 x, i32 y) {
@@ -10025,7 +9923,6 @@ void RGFW_FUNC(RGFW_window_maximize) (RGFW_window* win) {
 	win->internal.oldW = win->w;
 	win->internal.oldH = win->h;
     RGFW_toggleWaylandMaximized(win, 1);
-	RGFW_window_fetchSize(win, NULL, NULL);
     return;
 }
 
@@ -10133,7 +10030,50 @@ RGFW_bool RGFW_FUNC(RGFW_window_setIconEx) (RGFW_window* win, u8* data, i32 w, i
 	return RGFW_TRUE;
 }
 
-RGFW_mouse* RGFW_FUNC(RGFW_createMouseStandard) (RGFW_mouseIcon mouse) {
+RGFW_mouse* RGFW_FUNC(RGFW_loadMouse)(u8* data, i32 w, i32 h, RGFW_format format) {
+
+    RGFW_surface *mouse_surface = RGFW_createSurface(data, w, h, format);
+
+	if (mouse_surface == NULL) return NULL;
+
+	RGFW_copyImageData(mouse_surface->native.buffer, RGFW_MIN(w, mouse_surface->w), RGFW_MIN(h, mouse_surface->h), mouse_surface->native.format, mouse_surface->data, mouse_surface->format, NULL);
+
+	return (void*) mouse_surface;
+}
+
+void RGFW_FUNC(RGFW_window_setMouse)(RGFW_window* win, RGFW_mouse* mouse) {
+	RGFW_ASSERT(win); RGFW_ASSERT(mouse);
+	RGFW_surface *mouse_surface = (RGFW_surface*)mouse;
+
+	win->src.using_custom_cursor = RGFW_TRUE;
+
+	struct wl_buffer *mouse_buffer = mouse_surface->native.wl_buffer;
+
+	wl_surface_attach(win->src.custom_cursor_surface, mouse_buffer, 0, 0);
+	wl_surface_damage(win->src.custom_cursor_surface, 0, 0, mouse_surface->w, mouse_surface->h);
+	wl_surface_commit(win->src.custom_cursor_surface);
+
+}
+
+void RGFW_FUNC(RGFW_freeMouse)(RGFW_mouse* mouse) {
+	if (mouse != NULL) {
+		RGFW_surface_free((RGFW_surface*)mouse);
+	}
+}
+
+void RGFW_FUNC(RGFW_window_moveMouse)(RGFW_window* win, i32 x, i32 y) {
+	if (_RGFW->wp_pointer_warp != NULL) {
+		wp_pointer_warp_v1_warp_pointer(_RGFW->wp_pointer_warp, win->src.surface, _RGFW->wl_pointer, wl_fixed_from_int(x), wl_fixed_from_int(y), _RGFW->mouse_enter_serial);
+	}
+}
+
+RGFW_bool RGFW_FUNC(RGFW_window_setMouseDefault)(RGFW_window* win) {
+	return RGFW_window_setMouseStandard(win, RGFW_mouseArrow);
+}
+
+RGFW_bool RGFW_FUNC(RGFW_window_setMouseStandard)(RGFW_window* win, u8 mouse) {
+	RGFW_ASSERT(win != NULL);
+
 	char* cursorName = NULL;
 	switch (mouse) {
 		case RGFW_mouseNormal:       cursorName = (char*)"left_ptr"; break;
@@ -10157,66 +10097,23 @@ RGFW_mouse* RGFW_FUNC(RGFW_createMouseStandard) (RGFW_mouseIcon mouse) {
 		case RGFW_mouseNotAllowed:   cursorName = (char*)"not-allowed"; break;
 		case RGFW_mouseWait:         cursorName = (char*)"watch"; break;
 		case RGFW_mouseProgress:     cursorName = (char*)"watch"; break;
-		default:                     return NULL;
+		default:                     return RGFW_FALSE;
 	}
 
+	win->src.using_custom_cursor = RGFW_FALSE;
+
 	struct wl_cursor* wlcursor = wl_cursor_theme_get_cursor(_RGFW->wl_cursor_theme, cursorName);
 	if (wlcursor == NULL)
-		return NULL;
+		return RGFW_FALSE;
 	struct wl_cursor_image* cursor_image = wlcursor->images[0];
 	struct wl_buffer* cursor_buffer = wl_cursor_image_get_buffer(cursor_image);
-
-	RGFW_surface* surface = RGFW_ALLOC(sizeof(RGFW_surface));
-	RGFW_MEMZERO(surface, sizeof(RGFW_surface));
-	surface->w = (i32)cursor_image->width;
-	surface->h = (i32)cursor_image->height;
-	surface->native.wl_buffer = cursor_buffer;
-
-	return (RGFW_mouse*)surface;
-}
-
-RGFW_mouse* RGFW_FUNC(RGFW_createMouse)(u8* data, i32 w, i32 h, RGFW_format format) {
-    RGFW_surface* surface = RGFW_createSurface(data, w, h, format);
-	if (surface == NULL) return NULL;
-
-	surface->native.wl_buffer = wl_shm_pool_create_buffer(surface->native.pool, 0, surface->w, surface->h, (i32)surface->w * 4, WL_SHM_FORMAT_ARGB8888);
-
-	RGFW_copyImageData(surface->native.buffer, RGFW_MIN(w, surface->w), RGFW_MIN(h, surface->h), surface->native.format, surface->data, surface->format, NULL);
-
-	return (RGFW_mouse*)surface;
-}
-
-RGFW_bool RGFW_FUNC(RGFW_window_setMousePlatform)(RGFW_window* win, RGFW_mouse* mouse) {
-	RGFW_ASSERT(win); RGFW_ASSERT(mouse);
-	RGFW_surface* surface = (RGFW_surface*)mouse;
-
-	win->src.using_custom_cursor = RGFW_TRUE;
-
-	wl_surface_attach(win->src.custom_cursor_surface, surface->native.wl_buffer, 0, 0);
-	wl_surface_damage(win->src.custom_cursor_surface, 0, 0, surface->w, surface->h);
-	wl_surface_commit(win->src.custom_cursor_surface);
-
+	wl_pointer_set_cursor(_RGFW->wl_pointer, _RGFW->mouse_enter_serial, _RGFW->cursor_surface, (i32)cursor_image->hotspot_x, (i32)cursor_image->hotspot_y);
+	wl_surface_attach(_RGFW->cursor_surface, cursor_buffer, 0, 0);
+	wl_surface_damage(_RGFW->cursor_surface, 0, 0, (i32)cursor_image->width, (i32)cursor_image->height);
+	wl_surface_commit(_RGFW->cursor_surface);
 	return RGFW_TRUE;
 }
 
-void RGFW_FUNC(RGFW_freeMouse)(RGFW_mouse* mouse) {
-	if (mouse != NULL) {
-		RGFW_surface* surface = (RGFW_surface*)mouse;
-
-		if (surface->native.buffer && surface->native.wl_buffer) {
-			wl_buffer_destroy(surface->native.wl_buffer);
-		}
-
-		RGFW_surface_free(surface);
-	}
-}
-
-void RGFW_FUNC(RGFW_window_moveMouse)(RGFW_window* win, i32 x, i32 y) {
-	if (_RGFW->wp_pointer_warp != NULL) {
-		wp_pointer_warp_v1_warp_pointer(_RGFW->wp_pointer_warp, win->src.surface, _RGFW->wl_pointer, wl_fixed_from_int(x), wl_fixed_from_int(y), _RGFW->mouse_enter_serial);
-	}
-}
-
 void RGFW_FUNC(RGFW_window_hide) (RGFW_window* win) {
 	wl_surface_attach(win->src.surface, NULL, 0, 0);
 	wl_surface_commit(win->src.surface);
@@ -10237,7 +10134,6 @@ void RGFW_FUNC(RGFW_window_flash) (RGFW_window* win, RGFW_flashRequest request)
 }
 
 RGFW_ssize_t RGFW_FUNC(RGFW_readClipboardPtr) (char* str, size_t strCapacity) {
-
 	RGFW_UNUSED(strCapacity);
 
 	if (str != NULL)
@@ -10276,7 +10172,7 @@ void RGFW_FUNC(RGFW_writeClipboard) (const char* text, u32 textLen) {
 
 	// basic error checking
 	if (win->src.data_source == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errClipboard, "Could not create clipboard data source");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errClipboard, "Could not create clipboard data source");
 		return;
 	}
 	wl_data_source_offer(win->src.data_source , "text/plain;charset=utf-8");
@@ -10393,7 +10289,7 @@ void RGFW_FUNC(RGFW_window_swapInterval_OpenGL) (RGFW_window* win, i32 swapInter
 
 void RGFW_FUNC(RGFW_window_closePlatform)(RGFW_window* win) {
 	RGFW_ASSERT(win != NULL);
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoWindow, "a window was freed");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoWindow, "a window was freed");
 	#ifdef RGFW_LIBDECOR
 		if (win->src.decorContext)
 			libdecor_unref(win->src.decorContext);
@@ -10609,7 +10505,6 @@ void RGFW_win32_makeWindowTransparent(RGFW_window* win) {
 RGFWDEF RGFW_bool RGFW_win32_getDarkModeState(void);
 RGFW_bool RGFW_win32_getDarkModeState(void) {
 	u32 lightMode = 1;
-#if (_WIN32_WINNT >= 0x0600)
 	DWORD len = sizeof(lightMode);
 
 	RegGetValueW(
@@ -10617,7 +10512,6 @@ RGFW_bool RGFW_win32_getDarkModeState(void) {
 		L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
 		L"AppsUseLightTheme", RRF_RT_REG_DWORD, NULL, &lightMode, &len
 	);
-#endif
 
 	return (lightMode == 0);
 }
@@ -10648,11 +10542,11 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
             break;
 		case WM_CLOSE:
 		case WM_QUIT:
-			RGFW_windowCloseCallback(win);
+			RGFW_windowQuitCallback(win);
 			return 0;
 		case WM_ACTIVATE: {
 			RGFW_bool inFocus = RGFW_BOOL(LOWORD(wParam) != WA_INACTIVE);
-			RGFW_windowFocusCallback(win, inFocus);
+			RGFW_focusCallback(win, inFocus);
 
 			return DefWindowProcW(hWnd, message, wParam, lParam);
 		}
@@ -10732,15 +10626,10 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			return DefWindowProcW(hWnd, message, wParam, lParam);
 		}
 		case WM_PAINT: {
-			RECT rect;
-			if (GetUpdateRect(hWnd, &rect, FALSE)) {
-				RGFW_windowRefreshCallback(win, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
-			} else {
-				PAINTSTRUCT ps;
-				BeginPaint(hWnd, &ps);
-				RGFW_windowRefreshCallback(win, 0, 0, win->w, win->h);
-				EndPaint(hWnd, &ps);
-			}
+            PAINTSTRUCT ps;
+            BeginPaint(hWnd, &ps);
+            RGFW_windowRefreshCallback(win);
+            EndPaint(hWnd, &ps);
 
             return DefWindowProcW(hWnd, message, wParam, lParam);
 		}
@@ -10770,7 +10659,7 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			break;
 		}
         case WM_TIMER:
-			RGFW_windowRefreshCallback(win, 0, 0, win->w, win->h);
+			RGFW_windowRefreshCallback(win);
 			break;
 
 		case WM_NCLBUTTONDOWN: {
@@ -10838,12 +10727,14 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 			if (wParam == VK_CONTROL) {
 				if (HIWORD(lParam) & KF_EXTENDED)
-					value = RGFW_keyControlR;
-				else value = RGFW_keyControlL;
+					value = RGFW_controlR;
+				else value = RGFW_controlL;
 			}
 
-			RGFW_keyUpdateKeyMods(win, (GetKeyState(VK_CAPITAL) & 0x0001), (GetKeyState(VK_NUMLOCK) & 0x0001), (GetKeyState(VK_SCROLL) & 0x0001));
-			RGFW_keyCallback(win, value, win->internal.mod, RGFW_FALSE, RGFW_FALSE);
+			RGFW_bool repeat = ((lParam & 0x40000000) != 0) || RGFW_window_isKeyDown(win, value);
+
+			RGFW_updateKeyMods(win, (GetKeyState(VK_CAPITAL) & 0x0001), (GetKeyState(VK_NUMLOCK) & 0x0001), (GetKeyState(VK_SCROLL) & 0x0001));
+			RGFW_keyCallback(win, value, win->internal.mod, repeat, RGFW_FALSE);
 			break;
 		}
 		case WM_SYSKEYDOWN: case WM_KEYDOWN: {
@@ -10862,13 +10753,13 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			RGFW_key value = (u8)RGFW_apiKeyToRGFW((u32) scancode);
 			if (wParam == VK_CONTROL) {
 				if (HIWORD(lParam) & KF_EXTENDED)
-					value = RGFW_keyControlR;
-				else value = RGFW_keyControlL;
+					value = RGFW_controlR;
+				else value = RGFW_controlL;
 			}
 
-			RGFW_bool repeat = RGFW_isKeyDown(value);
+			RGFW_bool repeat = ((lParam & 0x40000000) != 0) || RGFW_window_isKeyDown(win, value);
 
-			RGFW_keyUpdateKeyMods(win, (GetKeyState(VK_CAPITAL) & 0x0001), (GetKeyState(VK_NUMLOCK) & 0x0001), (GetKeyState(VK_SCROLL) & 0x0001));
+			RGFW_updateKeyMods(win, (GetKeyState(VK_CAPITAL) & 0x0001), (GetKeyState(VK_NUMLOCK) & 0x0001), (GetKeyState(VK_SCROLL) & 0x0001));
 			RGFW_keyCallback(win, value, win->internal.mod, repeat, 1);
 			break;
 		}
@@ -10877,7 +10768,11 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				RGFW_mouseNotifyCallback(win, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), RGFW_TRUE);
 			}
 
-			RGFW_mouseMotionCallback(win, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+			if ((win->internal.rawMouse) || _RGFW->rawMouse) {
+				return DefWindowProcW(hWnd, message, wParam, lParam);
+			}
+
+			RGFW_mousePosCallback(win, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), _RGFW->vectorX, _RGFW->vectorY);
 			break;
 		}
 		case WM_INPUT: {
@@ -10919,7 +10814,7 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				vecY = (float)(raw.data.mouse.lLastY);
 			}
 
-			RGFW_rawMotionCallback(win, vecX, vecY);
+			RGFW_mousePosCallback(win, win->internal.lastMouseX, win->internal.lastMouseY, vecX, vecY);
 			break;
 		}
 		case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: case WM_MBUTTONDOWN: case WM_XBUTTONDOWN: {
@@ -10958,9 +10853,10 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 			/* Move the mouse to the position of the drop */
 			DragQueryPoint(drop, &pt);
-			RGFW_dataDragCallback(win, RGFW_dataFile, RGFW_dndActionMove, pt.x, pt.y);
+			RGFW_dataDragCallback(win, pt.x, pt.y);
 
 			if (!(win->internal.enabledEvents & RGFW_dataDrop)) return DefWindowProcW(hWnd, message, wParam, lParam);
+			char** files = _RGFW->files;
 			size_t count = DragQueryFileW(drop, 0xffffffff, NULL, 0);
 
 			u32 i;
@@ -10969,20 +10865,20 @@ LRESULT CALLBACK WndProcW(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				if (length == 0)
 					continue;
 
-				WCHAR* buffer = (WCHAR*)RGFW_ALLOC(sizeof(WCHAR) * (length + 1));
-				char* cbuffer = (char*)RGFW_ALLOC(length + 1);
+				WCHAR buffer[RGFW_MAX_PATH * 2];
+				if (length > (RGFW_MAX_PATH * 2) - 1)
+					length = RGFW_MAX_PATH * 2;
 
 				DragQueryFileW(drop, i, buffer, length + 1);
 
-				RGFW_createUTF8FromWideStringWin32(buffer, cbuffer, length);
+				RGFW_createUTF8FromWideStringWin32(buffer, files[i], RGFW_MAX_PATH);
 
-				RGFW_dataDropCallback(win, cbuffer, length + 1, RGFW_dataFile);
-				RGFW_FREE(buffer);
-				RGFW_FREE(cbuffer);
+				files[i][RGFW_MAX_PATH - 1] = '\0';
 			}
 
 			DragFinish(drop);
 
+			RGFW_dataDropCallback(win, files, count);
 			break;
 		}
 		default: break;
@@ -11037,10 +10933,10 @@ RGFW_bool RGFW_createSurfacePtr(u8* data, i32 w, i32 h, RGFW_format format, RGFW
 		(void**) &surface->native.bitmapBits,
 		NULL, (DWORD) 0);
 
-	surface->native.format = (format >= RGFW_formatRGBA8) ? (RGFW_format) RGFW_formatBGRA8 : (RGFW_format) RGFW_formatBGR8;
+	surface->native.format = (format >= RGFW_formatRGBA8) ? RGFW_formatBGRA8 : RGFW_formatBGR8;
 
 	if (surface->native.bitmap == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errBuffer,  "Failed to create DIB section.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errBuffer,  "Failed to create DIB section.");
 		return RGFW_FALSE;
 	}
 
@@ -11090,7 +10986,7 @@ int RGFW_window_createSwapChain_DirectX(RGFW_window* win, IDXGIFactory* pFactory
     RGFW_ASSERT(win && pFactory && pDevice && swapchain);
 
     static DXGI_SWAP_CHAIN_DESC swapChainDesc;
-	RGFW_MEMZERO(&swapChainDesc, sizeof(swapChainDesc));
+	RGFW_MEMSET(&swapChainDesc, 0, sizeof(swapChainDesc));
     swapChainDesc.BufferCount = 2;
     swapChainDesc.BufferDesc.Width = win->w;
     swapChainDesc.BufferDesc.Height = win->h;
@@ -11104,7 +11000,7 @@ int RGFW_window_createSwapChain_DirectX(RGFW_window* win, IDXGIFactory* pFactory
 
     HRESULT hr = pFactory->lpVtbl->CreateSwapChain(pFactory, (IUnknown*)pDevice, &swapChainDesc, swapchain);
     if (FAILED(hr)) {
-        RGFW_debugCallback(RGFW_typeError, RGFW_errDirectXContext,  "Failed to create DirectX swap chain!");
+        RGFW_sendDebugInfo(RGFW_typeError, RGFW_errDirectXContext,  "Failed to create DirectX swap chain!");
         return -2;
     }
 
@@ -11114,124 +11010,124 @@ int RGFW_window_createSwapChain_DirectX(RGFW_window* win, IDXGIFactory* pFactory
 
 /* we're doing it with magic numbers because some keys are missing  */
 void RGFW_initKeycodesPlatform(void) {
-	_RGFW->keycodes[0x00B] = RGFW_key0;
-	_RGFW->keycodes[0x002] = RGFW_key1;
-	_RGFW->keycodes[0x003] = RGFW_key2;
-	_RGFW->keycodes[0x004] = RGFW_key3;
-	_RGFW->keycodes[0x005] = RGFW_key4;
-	_RGFW->keycodes[0x006] = RGFW_key5;
-	_RGFW->keycodes[0x007] = RGFW_key6;
-	_RGFW->keycodes[0x008] = RGFW_key7;
-	_RGFW->keycodes[0x009] = RGFW_key8;
-	_RGFW->keycodes[0x00A] = RGFW_key9;
-	_RGFW->keycodes[0x01E] = RGFW_keyA;
-	_RGFW->keycodes[0x030] = RGFW_keyB;
-	_RGFW->keycodes[0x02E] = RGFW_keyC;
-	_RGFW->keycodes[0x020] = RGFW_keyD;
-	_RGFW->keycodes[0x012] = RGFW_keyE;
-	_RGFW->keycodes[0x021] = RGFW_keyF;
-	_RGFW->keycodes[0x022] = RGFW_keyG;
-	_RGFW->keycodes[0x023] = RGFW_keyH;
-	_RGFW->keycodes[0x017] = RGFW_keyI;
-	_RGFW->keycodes[0x024] = RGFW_keyJ;
-	_RGFW->keycodes[0x025] = RGFW_keyK;
-	_RGFW->keycodes[0x026] = RGFW_keyL;
-	_RGFW->keycodes[0x032] = RGFW_keyM;
-	_RGFW->keycodes[0x031] = RGFW_keyN;
-	_RGFW->keycodes[0x018] = RGFW_keyO;
-	_RGFW->keycodes[0x019] = RGFW_keyP;
-	_RGFW->keycodes[0x010] = RGFW_keyQ;
-	_RGFW->keycodes[0x013] = RGFW_keyR;
-	_RGFW->keycodes[0x01F] = RGFW_keyS;
-	_RGFW->keycodes[0x014] = RGFW_keyT;
-	_RGFW->keycodes[0x016] = RGFW_keyU;
-	_RGFW->keycodes[0x02F] = RGFW_keyV;
-	_RGFW->keycodes[0x011] = RGFW_keyW;
-	_RGFW->keycodes[0x02D] = RGFW_keyX;
-	_RGFW->keycodes[0x015] = RGFW_keyY;
-	_RGFW->keycodes[0x02C] = RGFW_keyZ;
-	_RGFW->keycodes[0x028] = RGFW_keyApostrophe;
-	_RGFW->keycodes[0x02B] = RGFW_keyBackSlash;
-	_RGFW->keycodes[0x033] = RGFW_keyComma;
-	_RGFW->keycodes[0x00D] = RGFW_keyEquals;
-	_RGFW->keycodes[0x029] = RGFW_keyBacktick;
-	_RGFW->keycodes[0x01A] = RGFW_keyBracket;
-	_RGFW->keycodes[0x00C] = RGFW_keyMinus;
-	_RGFW->keycodes[0x034] = RGFW_keyPeriod;
-	_RGFW->keycodes[0x01B] = RGFW_keyCloseBracket;
-	_RGFW->keycodes[0x027] = RGFW_keySemicolon;
-	_RGFW->keycodes[0x035] = RGFW_keySlash;
-	_RGFW->keycodes[0x056] = RGFW_keyWorld2;
-	_RGFW->keycodes[0x00E] = RGFW_keyBackSpace;
-	_RGFW->keycodes[0x153] = RGFW_keyDelete;
-	_RGFW->keycodes[0x14F] = RGFW_keyEnd;
-	_RGFW->keycodes[0x01C] = RGFW_keyEnter;
-	_RGFW->keycodes[0x001] = RGFW_keyEscape;
-	_RGFW->keycodes[0x147] = RGFW_keyHome;
-	_RGFW->keycodes[0x152] = RGFW_keyInsert;
-	_RGFW->keycodes[0x15D] = RGFW_keyMenu;
-	_RGFW->keycodes[0x151] = RGFW_keyPageDown;
-	_RGFW->keycodes[0x149] = RGFW_keyPageUp;
-	_RGFW->keycodes[0x045] = RGFW_keyPause;
-	_RGFW->keycodes[0x039] = RGFW_keySpace;
-	_RGFW->keycodes[0x00F] = RGFW_keyTab;
-	_RGFW->keycodes[0x03A] = RGFW_keyCapsLock;
-	_RGFW->keycodes[0x145] = RGFW_keyNumLock;
-	_RGFW->keycodes[0x046] = RGFW_keyScrollLock;
-	_RGFW->keycodes[0x03B] = RGFW_keyF1;
-	_RGFW->keycodes[0x03C] = RGFW_keyF2;
-	_RGFW->keycodes[0x03D] = RGFW_keyF3;
-	_RGFW->keycodes[0x03E] = RGFW_keyF4;
-	_RGFW->keycodes[0x03F] = RGFW_keyF5;
-	_RGFW->keycodes[0x040] = RGFW_keyF6;
-	_RGFW->keycodes[0x041] = RGFW_keyF7;
-	_RGFW->keycodes[0x042] = RGFW_keyF8;
-	_RGFW->keycodes[0x043] = RGFW_keyF9;
-	_RGFW->keycodes[0x044] = RGFW_keyF10;
-	_RGFW->keycodes[0x057] = RGFW_keyF11;
-	_RGFW->keycodes[0x058] = RGFW_keyF12;
-	_RGFW->keycodes[0x064] = RGFW_keyF13;
-	_RGFW->keycodes[0x065] = RGFW_keyF14;
-	_RGFW->keycodes[0x066] = RGFW_keyF15;
-	_RGFW->keycodes[0x067] = RGFW_keyF16;
-	_RGFW->keycodes[0x068] = RGFW_keyF17;
-	_RGFW->keycodes[0x069] = RGFW_keyF18;
-	_RGFW->keycodes[0x06A] = RGFW_keyF19;
-	_RGFW->keycodes[0x06B] = RGFW_keyF20;
-	_RGFW->keycodes[0x06C] = RGFW_keyF21;
-	_RGFW->keycodes[0x06D] = RGFW_keyF22;
-	_RGFW->keycodes[0x06E] = RGFW_keyF23;
-	_RGFW->keycodes[0x076] = RGFW_keyF24;
-	_RGFW->keycodes[0x038] = RGFW_keyAltL;
-	_RGFW->keycodes[0x01D] = RGFW_keyControlL;
-	_RGFW->keycodes[0x02A] = RGFW_keyShiftL;
-	_RGFW->keycodes[0x15B] = RGFW_keySuperL;
-	_RGFW->keycodes[0x137] = RGFW_keyPrintScreen;
-	_RGFW->keycodes[0x138] = RGFW_keyAltR;
-	_RGFW->keycodes[0x11D] = RGFW_keyControlR;
-	_RGFW->keycodes[0x036] = RGFW_keyShiftR;
-	_RGFW->keycodes[0x15C] = RGFW_keySuperR;
-	_RGFW->keycodes[0x150] = RGFW_keyDown;
-	_RGFW->keycodes[0x14B] = RGFW_keyLeft;
-	_RGFW->keycodes[0x14D] = RGFW_keyRight;
-	_RGFW->keycodes[0x148] = RGFW_keyUp;
-	_RGFW->keycodes[0x052] = RGFW_keyPad0;
-	_RGFW->keycodes[0x04F] = RGFW_keyPad1;
-	_RGFW->keycodes[0x050] = RGFW_keyPad2;
-	_RGFW->keycodes[0x051] = RGFW_keyPad3;
-	_RGFW->keycodes[0x04B] = RGFW_keyPad4;
-	_RGFW->keycodes[0x04C] = RGFW_keyPad5;
-	_RGFW->keycodes[0x04D] = RGFW_keyPad6;
-	_RGFW->keycodes[0x047] = RGFW_keyPad7;
-	_RGFW->keycodes[0x048] = RGFW_keyPad8;
-	_RGFW->keycodes[0x049] = RGFW_keyPad9;
-	_RGFW->keycodes[0x04E] = RGFW_keyPadPlus;
-	_RGFW->keycodes[0x053] = RGFW_keyPadPeriod;
-	_RGFW->keycodes[0x135] = RGFW_keyPadSlash;
-	_RGFW->keycodes[0x11C] = RGFW_keyPadReturn;
-	_RGFW->keycodes[0x059] = RGFW_keyPadEqual;
-	_RGFW->keycodes[0x037] = RGFW_keyPadMultiply;
-	_RGFW->keycodes[0x04A] = RGFW_keyPadMinus;
+	_RGFW->keycodes[0x00B] = RGFW_0;
+	_RGFW->keycodes[0x002] = RGFW_1;
+	_RGFW->keycodes[0x003] = RGFW_2;
+	_RGFW->keycodes[0x004] = RGFW_3;
+	_RGFW->keycodes[0x005] = RGFW_4;
+	_RGFW->keycodes[0x006] = RGFW_5;
+	_RGFW->keycodes[0x007] = RGFW_6;
+	_RGFW->keycodes[0x008] = RGFW_7;
+	_RGFW->keycodes[0x009] = RGFW_8;
+	_RGFW->keycodes[0x00A] = RGFW_9;
+	_RGFW->keycodes[0x01E] = RGFW_a;
+	_RGFW->keycodes[0x030] = RGFW_b;
+	_RGFW->keycodes[0x02E] = RGFW_c;
+	_RGFW->keycodes[0x020] = RGFW_d;
+	_RGFW->keycodes[0x012] = RGFW_e;
+	_RGFW->keycodes[0x021] = RGFW_f;
+	_RGFW->keycodes[0x022] = RGFW_g;
+	_RGFW->keycodes[0x023] = RGFW_h;
+	_RGFW->keycodes[0x017] = RGFW_i;
+	_RGFW->keycodes[0x024] = RGFW_j;
+	_RGFW->keycodes[0x025] = RGFW_k;
+	_RGFW->keycodes[0x026] = RGFW_l;
+	_RGFW->keycodes[0x032] = RGFW_m;
+	_RGFW->keycodes[0x031] = RGFW_n;
+	_RGFW->keycodes[0x018] = RGFW_o;
+	_RGFW->keycodes[0x019] = RGFW_p;
+	_RGFW->keycodes[0x010] = RGFW_q;
+	_RGFW->keycodes[0x013] = RGFW_r;
+	_RGFW->keycodes[0x01F] = RGFW_s;
+	_RGFW->keycodes[0x014] = RGFW_t;
+	_RGFW->keycodes[0x016] = RGFW_u;
+	_RGFW->keycodes[0x02F] = RGFW_v;
+	_RGFW->keycodes[0x011] = RGFW_w;
+	_RGFW->keycodes[0x02D] = RGFW_x;
+	_RGFW->keycodes[0x015] = RGFW_y;
+	_RGFW->keycodes[0x02C] = RGFW_z;
+	_RGFW->keycodes[0x028] = RGFW_apostrophe;
+	_RGFW->keycodes[0x02B] = RGFW_backSlash;
+	_RGFW->keycodes[0x033] = RGFW_comma;
+	_RGFW->keycodes[0x00D] = RGFW_equals;
+	_RGFW->keycodes[0x029] = RGFW_backtick;
+	_RGFW->keycodes[0x01A] = RGFW_bracket;
+	_RGFW->keycodes[0x00C] = RGFW_minus;
+	_RGFW->keycodes[0x034] = RGFW_period;
+	_RGFW->keycodes[0x01B] = RGFW_closeBracket;
+	_RGFW->keycodes[0x027] = RGFW_semicolon;
+	_RGFW->keycodes[0x035] = RGFW_slash;
+	_RGFW->keycodes[0x056] = RGFW_world2;
+	_RGFW->keycodes[0x00E] = RGFW_backSpace;
+	_RGFW->keycodes[0x153] = RGFW_delete;
+	_RGFW->keycodes[0x14F] = RGFW_end;
+	_RGFW->keycodes[0x01C] = RGFW_enter;
+	_RGFW->keycodes[0x001] = RGFW_escape;
+	_RGFW->keycodes[0x147] = RGFW_home;
+	_RGFW->keycodes[0x152] = RGFW_insert;
+	_RGFW->keycodes[0x15D] = RGFW_menu;
+	_RGFW->keycodes[0x151] = RGFW_pageDown;
+	_RGFW->keycodes[0x149] = RGFW_pageUp;
+	_RGFW->keycodes[0x045] = RGFW_pause;
+	_RGFW->keycodes[0x039] = RGFW_space;
+	_RGFW->keycodes[0x00F] = RGFW_tab;
+	_RGFW->keycodes[0x03A] = RGFW_capsLock;
+	_RGFW->keycodes[0x145] = RGFW_numLock;
+	_RGFW->keycodes[0x046] = RGFW_scrollLock;
+	_RGFW->keycodes[0x03B] = RGFW_F1;
+	_RGFW->keycodes[0x03C] = RGFW_F2;
+	_RGFW->keycodes[0x03D] = RGFW_F3;
+	_RGFW->keycodes[0x03E] = RGFW_F4;
+	_RGFW->keycodes[0x03F] = RGFW_F5;
+	_RGFW->keycodes[0x040] = RGFW_F6;
+	_RGFW->keycodes[0x041] = RGFW_F7;
+	_RGFW->keycodes[0x042] = RGFW_F8;
+	_RGFW->keycodes[0x043] = RGFW_F9;
+	_RGFW->keycodes[0x044] = RGFW_F10;
+	_RGFW->keycodes[0x057] = RGFW_F11;
+	_RGFW->keycodes[0x058] = RGFW_F12;
+	_RGFW->keycodes[0x064] = RGFW_F13;
+	_RGFW->keycodes[0x065] = RGFW_F14;
+	_RGFW->keycodes[0x066] = RGFW_F15;
+	_RGFW->keycodes[0x067] = RGFW_F16;
+	_RGFW->keycodes[0x068] = RGFW_F17;
+	_RGFW->keycodes[0x069] = RGFW_F18;
+	_RGFW->keycodes[0x06A] = RGFW_F19;
+	_RGFW->keycodes[0x06B] = RGFW_F20;
+	_RGFW->keycodes[0x06C] = RGFW_F21;
+	_RGFW->keycodes[0x06D] = RGFW_F22;
+	_RGFW->keycodes[0x06E] = RGFW_F23;
+	_RGFW->keycodes[0x076] = RGFW_F24;
+	_RGFW->keycodes[0x038] = RGFW_altL;
+	_RGFW->keycodes[0x01D] = RGFW_controlL;
+	_RGFW->keycodes[0x02A] = RGFW_shiftL;
+	_RGFW->keycodes[0x15B] = RGFW_superL;
+	_RGFW->keycodes[0x137] = RGFW_printScreen;
+	_RGFW->keycodes[0x138] = RGFW_altR;
+	_RGFW->keycodes[0x11D] = RGFW_controlR;
+	_RGFW->keycodes[0x036] = RGFW_shiftR;
+	_RGFW->keycodes[0x15C] = RGFW_superR;
+	_RGFW->keycodes[0x150] = RGFW_down;
+	_RGFW->keycodes[0x14B] = RGFW_left;
+	_RGFW->keycodes[0x14D] = RGFW_right;
+	_RGFW->keycodes[0x148] = RGFW_up;
+	_RGFW->keycodes[0x052] = RGFW_kp0;
+	_RGFW->keycodes[0x04F] = RGFW_kp1;
+	_RGFW->keycodes[0x050] = RGFW_kp2;
+	_RGFW->keycodes[0x051] = RGFW_kp3;
+	_RGFW->keycodes[0x04B] = RGFW_kp4;
+	_RGFW->keycodes[0x04C] = RGFW_kp5;
+	_RGFW->keycodes[0x04D] = RGFW_kp6;
+	_RGFW->keycodes[0x047] = RGFW_kp7;
+	_RGFW->keycodes[0x048] = RGFW_kp8;
+	_RGFW->keycodes[0x049] = RGFW_kp9;
+	_RGFW->keycodes[0x04E] = RGFW_kpPlus;
+	_RGFW->keycodes[0x053] = RGFW_kpPeriod;
+	_RGFW->keycodes[0x135] = RGFW_kpSlash;
+	_RGFW->keycodes[0x11C] = RGFW_kpReturn;
+	_RGFW->keycodes[0x059] = RGFW_kpEqual;
+	_RGFW->keycodes[0x037] = RGFW_kpMultiply;
+	_RGFW->keycodes[0x04A] = RGFW_kpMinus;
 }
 
 
@@ -11269,8 +11165,8 @@ i32 RGFW_initPlatform(void) {
 	#endif
 
 	u8 RGFW_blk[] = { 0, 0, 0, 0 };
-	_RGFW->hiddenMouse = RGFW_createMouse(RGFW_blk, 1, 1, RGFW_formatRGBA8);
-    return 0;
+	_RGFW->hiddenMouse = RGFW_loadMouse(RGFW_blk, 1, 1, RGFW_formatRGBA8);
+    return 1;
 }
 
 RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags, RGFW_window* win) {
@@ -11311,6 +11207,8 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 
 	DWORD window_style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 
+	RECT windowRect, clientRect;
+
 	if (!(flags & RGFW_windowNoBorder)) {
 		window_style |= WS_CAPTION | WS_SYSMENU | WS_BORDER | WS_MINIMIZEBOX;
 
@@ -11323,6 +11221,9 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 	MultiByteToWideChar(CP_UTF8, 0, name, -1, wide_name, 255);
 	HWND dummyWin = CreateWindowW(Class.lpszClassName, (wchar_t*)wide_name, window_style, win->x, win->y, win->w, win->h, 0, 0, inh, 0);
 
+	GetWindowRect(dummyWin, &windowRect);
+	GetClientRect(dummyWin, &clientRect);
+
 #ifdef RGFW_OPENGL
 	RGFW_win32_loadOpenGLFuncs(dummyWin);
 #endif
@@ -11351,29 +11252,23 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 
 void RGFW_window_setBorder(RGFW_window* win, RGFW_bool border) {
 	RGFW_setBit(&win->internal.flags, RGFW_windowNoBorder, !border);
-
-	RECT rect;
-    GetClientRect(win->src.window, &rect);
-
 	LONG style = GetWindowLong(win->src.window, GWL_STYLE);
-	style |= (LONG)RGFW_winapi_window_getStyle(win, win->internal.flags);
 
 	if (border == 0) {
-		style &= ~WS_OVERLAPPEDWINDOW;
-	} else {
-		if (win->internal.flags & RGFW_windowNoResize) style &= ~WS_MAXIMIZEBOX;
-		style |= WS_OVERLAPPEDWINDOW;
+		SetWindowLong(win->src.window, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW);
+		SetWindowPos(
+			win->src.window, HWND_TOP, 0, 0, 0, 0,
+			SWP_NOZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE
+		);
+	}
+	else {
+		if (win->internal.flags & RGFW_windowNoResize) style &= ~WS_MAXIMIZEBOX;
+		SetWindowLong(win->src.window, GWL_STYLE, style | WS_OVERLAPPEDWINDOW);
+		SetWindowPos(
+			win->src.window, HWND_TOP, 0, 0, 0, 0,
+			SWP_NOZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE
+		);
 	}
-
-	DWORD exStyle = RGFW_winapi_window_getExStyle(win, win->internal.flags);
-	ClientToScreen(win->src.window, (POINT*) &rect.left);
-    ClientToScreen(win->src.window, (POINT*) &rect.right);
-
-	AdjustWindowRectEx(&rect, (DWORD)style, FALSE, exStyle);
-	SetWindowLong(win->src.window, GWL_STYLE, style);
-
-    SetWindowLongW(win->src.window, GWL_STYLE, style);
-    SetWindowPos(win->src.window, HWND_TOP, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_FRAMECHANGED | SWP_NOACTIVATE | SWP_NOZORDER);
 }
 
 void RGFW_window_setDND(RGFW_window* win, RGFW_bool allow) {
@@ -11422,18 +11317,15 @@ void RGFW_window_raise(RGFW_window* win) {
 void RGFW_window_setFullscreen(RGFW_window* win, RGFW_bool fullscreen) {
 	RGFW_ASSERT(win != NULL);
 
-	RGFW_monitor* mon  = RGFW_window_getMonitor(win);
-
 	if (fullscreen == RGFW_FALSE) {
-		RGFW_monitor_setMode(mon, &win->internal.oldMode);
-
 		RGFW_window_setBorder(win, 1);
 
 		RECT rect = { 0, 0, win->internal.oldW, win->internal.oldH};
 		DWORD style = RGFW_winapi_window_getStyle(win, win->internal.flags);
 		DWORD exStyle = RGFW_winapi_window_getExStyle(win, win->internal.flags);
 		AdjustWindowRectEx(&rect, style, FALSE, exStyle);
-		SetWindowPos(win->src.window, HWND_TOP, win->internal.oldX, win->internal.oldY, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
+		SetWindowPos(win->src.window, HWND_TOP, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOZORDER);
+
 
 		win->internal.flags &= ~(u32)RGFW_windowFullscreen;
 		win->x  = win->internal.oldX;
@@ -11447,17 +11339,17 @@ void RGFW_window_setFullscreen(RGFW_window* win, RGFW_bool fullscreen) {
 	win->internal.oldY = win->y;
 	win->internal.oldW = win->w;
 	win->internal.oldH = win->h;
-	win->internal.oldMode = mon->mode;
 	win->internal.flags |= RGFW_windowFullscreen;
 
-	RGFW_window_setBorder(win, 0);
+	RGFW_monitor* mon  = RGFW_window_getMonitor(win);
+
+	RGFW_window_setBorder(win, 0);
+	RGFW_monitor_scaleToWindow(mon, win);
+
+    SetWindowPos(win->src.window, HWND_TOPMOST, (i32)mon->x, (i32)mon->y, (i32)mon->mode.w, (i32)mon->mode.h, SWP_NOOWNERZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
 
-    SetWindowPos(win->src.window, HWND_TOPMOST, (i32)mon->x, (i32)mon->y, 0, 0, SWP_NOOWNERZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOSIZE);
 	win->x = mon->x;
 	win->y = mon->y;
-
-	RGFW_monitor_scaleToWindow(mon, win);
-    SetWindowPos(win->src.window, HWND_TOPMOST, 0, 0, (i32)mon->mode.w, (i32)mon->mode.h, SWP_NOOWNERZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOMOVE);
 	win->w = mon->mode.w;
 	win->h = mon->mode.h;
 }
@@ -11466,7 +11358,6 @@ void RGFW_window_maximize(RGFW_window* win) {
 	RGFW_ASSERT(win != NULL);
 	RGFW_window_hide(win);
 	ShowWindow(win->src.window, SW_MAXIMIZE);
-	RGFW_window_fetchSize(win, NULL, NULL);
 }
 
 void RGFW_window_minimize(RGFW_window* win) {
@@ -11517,85 +11408,75 @@ RGFW_key RGFW_physicalToMappedKey(RGFW_key key) {
 	}
 
     switch (vk) {
-        case VK_F1:  return RGFW_keyF1;
-        case VK_F2:  return RGFW_keyF2;
-        case VK_F3:  return RGFW_keyF3;
-        case VK_F4:  return RGFW_keyF4;
-        case VK_F5:  return RGFW_keyF5;
-        case VK_F6:  return RGFW_keyF6;
-        case VK_F7:  return RGFW_keyF7;
-        case VK_F8:  return RGFW_keyF8;
-        case VK_F9:  return RGFW_keyF9;
-        case VK_F10: return RGFW_keyF10;
-        case VK_F11: return RGFW_keyF11;
-        case VK_F12: return RGFW_keyF12;
-        case VK_F13: return RGFW_keyF13;
-        case VK_F14: return RGFW_keyF14;
-        case VK_F15: return RGFW_keyF15;
-        case VK_F16: return RGFW_keyF16;
-        case VK_F17: return RGFW_keyF17;
-        case VK_F18: return RGFW_keyF18;
-        case VK_F19: return RGFW_keyF19;
-        case VK_F20: return RGFW_keyF20;
-        case VK_F21: return RGFW_keyF21;
-        case VK_F22: return RGFW_keyF22;
-        case VK_F23: return RGFW_keyF23;
-        case VK_F24: return RGFW_keyF24;
-        case VK_LSHIFT:   return RGFW_keyShiftL;
-        case VK_RSHIFT:   return RGFW_keyShiftR;
-        case VK_LCONTROL: return RGFW_keyControlL;
-        case VK_RCONTROL: return RGFW_keyControlR;
-        case VK_LMENU:    return RGFW_keyAltL;
-        case VK_RMENU:    return RGFW_keyAltR;
-        case VK_LWIN:     return RGFW_keySuperL;
-        case VK_RWIN:     return RGFW_keySuperR;
-        case VK_CAPITAL:  return RGFW_keyCapsLock;
-        case VK_NUMLOCK:  return RGFW_keyNumLock;
-        case VK_SCROLL:   return RGFW_keyScrollLock;
-        case VK_UP:       return RGFW_keyUp;
-        case VK_DOWN:     return RGFW_keyDown;
-        case VK_LEFT:     return RGFW_keyLeft;
-        case VK_RIGHT:    return RGFW_keyRight;
-        case VK_HOME:     return RGFW_keyHome;
-        case VK_END:      return RGFW_keyEnd;
-        case VK_PRIOR:    return RGFW_keyPageUp;
-        case VK_NEXT:     return RGFW_keyPageDown;
-        case VK_INSERT:   return RGFW_keyInsert;
-        case VK_APPS:     return RGFW_keyMenu;
-        case VK_ADD:      return RGFW_keyPadPlus;
-        case VK_SUBTRACT: return RGFW_keyPadMinus;
-        case VK_MULTIPLY: return RGFW_keyPadMultiply;
-        case VK_DIVIDE:   return RGFW_keyPadSlash;
-        case VK_RETURN:   return RGFW_keyPadReturn;
-        case VK_DECIMAL:  return RGFW_keyPadPeriod;
-        case VK_NUMPAD0: return RGFW_keyPad0;
-        case VK_NUMPAD1: return RGFW_keyPad1;
-        case VK_NUMPAD2: return RGFW_keyPad2;
-        case VK_NUMPAD3: return RGFW_keyPad3;
-        case VK_NUMPAD4: return RGFW_keyPad4;
-        case VK_NUMPAD5: return RGFW_keyPad5;
-        case VK_NUMPAD6: return RGFW_keyPad6;
-        case VK_NUMPAD7: return RGFW_keyPad7;
-        case VK_NUMPAD8: return RGFW_keyPad8;
-        case VK_NUMPAD9: return RGFW_keyPad9;
-        case VK_SNAPSHOT: return RGFW_keyPrintScreen;
-        case VK_PAUSE:    return RGFW_keyPause;
+        case VK_F1:  return RGFW_F1;
+        case VK_F2:  return RGFW_F2;
+        case VK_F3:  return RGFW_F3;
+        case VK_F4:  return RGFW_F4;
+        case VK_F5:  return RGFW_F5;
+        case VK_F6:  return RGFW_F6;
+        case VK_F7:  return RGFW_F7;
+        case VK_F8:  return RGFW_F8;
+        case VK_F9:  return RGFW_F9;
+        case VK_F10: return RGFW_F10;
+        case VK_F11: return RGFW_F11;
+        case VK_F12: return RGFW_F12;
+        case VK_F13: return RGFW_F13;
+        case VK_F14: return RGFW_F14;
+        case VK_F15: return RGFW_F15;
+        case VK_F16: return RGFW_F16;
+        case VK_F17: return RGFW_F17;
+        case VK_F18: return RGFW_F18;
+        case VK_F19: return RGFW_F19;
+        case VK_F20: return RGFW_F20;
+        case VK_F21: return RGFW_F21;
+        case VK_F22: return RGFW_F22;
+        case VK_F23: return RGFW_F23;
+        case VK_F24: return RGFW_F24;
+        case VK_LSHIFT:   return RGFW_shiftL;
+        case VK_RSHIFT:   return RGFW_shiftR;
+        case VK_LCONTROL: return RGFW_controlL;
+        case VK_RCONTROL: return RGFW_controlR;
+        case VK_LMENU:    return RGFW_altL;
+        case VK_RMENU:    return RGFW_altR;
+        case VK_LWIN:     return RGFW_superL;
+        case VK_RWIN:     return RGFW_superR;
+        case VK_CAPITAL:  return RGFW_capsLock;
+        case VK_NUMLOCK:  return RGFW_numLock;
+        case VK_SCROLL:   return RGFW_scrollLock;
+        case VK_UP:       return RGFW_up;
+        case VK_DOWN:     return RGFW_down;
+        case VK_LEFT:     return RGFW_left;
+        case VK_RIGHT:    return RGFW_right;
+        case VK_HOME:     return RGFW_home;
+        case VK_END:      return RGFW_end;
+        case VK_PRIOR:    return RGFW_pageUp;
+        case VK_NEXT:     return RGFW_pageDown;
+        case VK_INSERT:   return RGFW_insert;
+        case VK_APPS:     return RGFW_menu;
+        case VK_ADD:      return RGFW_kpPlus;
+        case VK_SUBTRACT: return RGFW_kpMinus;
+        case VK_MULTIPLY: return RGFW_kpMultiply;
+        case VK_DIVIDE:   return RGFW_kpSlash;
+        case VK_RETURN:   return RGFW_kpReturn;
+        case VK_DECIMAL:  return RGFW_kpPeriod;
+        case VK_NUMPAD0: return RGFW_kp0;
+        case VK_NUMPAD1: return RGFW_kp1;
+        case VK_NUMPAD2: return RGFW_kp2;
+        case VK_NUMPAD3: return RGFW_kp3;
+        case VK_NUMPAD4: return RGFW_kp4;
+        case VK_NUMPAD5: return RGFW_kp5;
+        case VK_NUMPAD6: return RGFW_kp6;
+        case VK_NUMPAD7: return RGFW_kp7;
+        case VK_NUMPAD8: return RGFW_kp8;
+        case VK_NUMPAD9: return RGFW_kp9;
+        case VK_SNAPSHOT: return RGFW_printScreen;
+        case VK_PAUSE:    return RGFW_pause;
         default: return RGFW_keyNULL;
     }
 
     return RGFW_keyNULL;
 }
 
-RGFW_bool RGFW_window_fetchSize(RGFW_window* win, i32* w, i32* h) {
-    RECT area;
-    GetClientRect(win->src.window, &area);
-
-    win->w = area.right;
-    win->h = area.bottom;
-
-	return RGFW_window_getSize(win, w, h);
-}
-
 void RGFW_pollEvents(void) {
 	RGFW_resetPrevState();
     MSG msg;
@@ -11666,7 +11547,7 @@ size_t RGFW_monitor_getGammaRampPtr(RGFW_monitor* monitor, RGFW_gammaRamp* ramp)
 RGFW_bool RGFW_monitor_setGammaRamp(RGFW_monitor* monitor, RGFW_gammaRamp* ramp) {
     WORD values[3][256];
     if (ramp->count != 256) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errX11, "Win32: Gamma ramp size must be 256");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errX11, "Win32: Gamma ramp size must be 256");
         return RGFW_FALSE;
     }
 
@@ -11731,10 +11612,6 @@ size_t RGFW_monitor_getModesPtr(RGFW_monitor* monitor, RGFW_monitorMode** modes)
 		if (!EnumDisplaySettingsW(monitor->node->adapterName, modeIndex, &dm))
 			break;
 
-		if (ChangeDisplaySettingsExW(monitor->node->adapterName, &dm, NULL, CDS_TEST, NULL) != DISP_CHANGE_SUCCESSFUL) {
-			continue;
-		}
-
 		modeIndex++;
 
 		if (dm.dmBitsPerPel < 15)
@@ -11799,9 +11676,9 @@ void RGFW_win32_createMonitor(DISPLAY_DEVICEW* adapter, DISPLAY_DEVICEW* dd) {
 	node->mon.y = monitorInfo.rcMonitor.top;
 
 	HDC hdc = CreateDCW(monitorInfo.szDevice, NULL, NULL, NULL);
-
+	/* get pixels per inch */
 	float dpiX = (float)GetDeviceCaps(hdc, LOGPIXELSX);
-	float dpiY = (float)GetDeviceCaps(hdc, LOGPIXELSY);
+	float dpiY = (float)GetDeviceCaps(hdc, LOGPIXELSX);
 
 	node->mon.scaleX = dpiX / 96.0f;
 	node->mon.scaleY = dpiY / 96.0f;
@@ -11930,16 +11807,14 @@ RGFW_bool RGFW_monitor_setMode(RGFW_monitor* mon, RGFW_monitorMode* mode) {
 	dm.dmBitsPerPel = (DWORD)(mode->red + mode->green + mode->blue);
 
 	if (ChangeDisplaySettingsExW(mon->node->adapterName, &dm, NULL, CDS_TEST, NULL) == DISP_CHANGE_SUCCESSFUL) {
-		if (ChangeDisplaySettingsExW(mon->node->adapterName, &dm, NULL, CDS_UPDATEREGISTRY, NULL) == DISP_CHANGE_SUCCESSFUL) {
-			RGFW_win32_getMode(&dm, &mon->mode);
+		if (ChangeDisplaySettingsExW(mon->node->adapterName, &dm, NULL, CDS_UPDATEREGISTRY, NULL) == DISP_CHANGE_SUCCESSFUL)
 			return RGFW_TRUE;
-		}
 		return RGFW_FALSE;
 	} else return RGFW_FALSE;
 }
 
 RGFW_bool RGFW_monitor_requestMode(RGFW_monitor* mon, RGFW_monitorMode* mode, RGFW_modeRequest request) {
-HMONITOR src = mon->node->hMonitor;
+    HMONITOR src = mon->node->hMonitor;
 
 	MONITORINFOEX  monitorInfo;
 	monitorInfo.cbSize = sizeof(MONITORINFOEX);
@@ -11949,15 +11824,7 @@ HMONITOR src = mon->node->hMonitor;
 	ZeroMemory(&dm, sizeof(dm));
 	dm.dmSize = sizeof(dm);
 
-	DWORD index = 0;
-
-	for (;;) {
-		if (EnumDisplaySettingsW(mon->node->adapterName, index, &dm) == 0) {
-			break;
-		}
-
-		index += 1;
-
+	if (EnumDisplaySettingsW(mon->node->adapterName, ENUM_CURRENT_SETTINGS, &dm)) {
 		if (request & RGFW_monitorScale) {
 			dm.dmFields |= DM_PELSWIDTH | DM_PELSHEIGHT;
 			dm.dmPelsWidth = (u32)mode->w;
@@ -11980,7 +11847,7 @@ HMONITOR src = mon->node->hMonitor;
 				return RGFW_TRUE;
 			}
 			return RGFW_FALSE;
-		}
+		} else return RGFW_FALSE;
 	}
 
 	return RGFW_FALSE;
@@ -12023,8 +11890,29 @@ HICON RGFW_loadHandleImage(u8* data, i32 w, i32 h, RGFW_format format, BOOL icon
 
 	return handle;
 }
+RGFW_mouse* RGFW_loadMouse(u8* data, i32 w, i32 h, RGFW_format format) {
+	HCURSOR cursor = (HCURSOR) RGFW_loadHandleImage(data, w, h, format, FALSE);
+	return cursor;
+}
+
+void RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse) {
+	RGFW_ASSERT(win && mouse);
+	SetClassLongPtrA(win->src.window, GCLP_HCURSOR, (LPARAM) mouse);
+	SetCursor((HCURSOR)mouse);
+}
+
+void RGFW_freeMouse(RGFW_mouse* mouse) {
+	RGFW_ASSERT(mouse);
+	DestroyCursor((HCURSOR)mouse);
+}
+
+RGFW_bool RGFW_window_setMouseDefault(RGFW_window* win) {
+	return RGFW_window_setMouseStandard(win, RGFW_mouseArrow);
+}
+
+RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, u8 mouse) {
+	RGFW_ASSERT(win != NULL);
 
-RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon mouse) {
 	u32 mouseIcon = 0;
 
     switch (mouse) {
@@ -12049,29 +11937,14 @@ RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon mouse) {
 		case RGFW_mouseResizeS: mouseIcon = OCR_SIZENS; break;
 		case RGFW_mouseResizeSW: mouseIcon = OCR_SIZENESW; break;
 		case RGFW_mouseResizeW: mouseIcon = OCR_SIZEWE; break;
-		default: return NULL;
+		default: return RGFW_FALSE;
     }
 
 	char* icon = MAKEINTRESOURCEA(mouseIcon);
-	return LoadCursorA(NULL, icon);
-}
 
-RGFW_mouse* RGFW_createMouse(u8* data, i32 w, i32 h, RGFW_format format) {
-	HCURSOR cursor = (HCURSOR) RGFW_loadHandleImage(data, w, h, format, FALSE);
-	return cursor;
-}
-
-RGFW_bool RGFW_window_setMousePlatform(RGFW_window* win, RGFW_mouse* mouse) {
-	RGFW_ASSERT(win && mouse);
-	SetClassLongPtrA(win->src.window, GCLP_HCURSOR, (LPARAM) mouse);
-	SetCursor((HCURSOR)mouse);
-
-	return RGFW_FALSE;
-}
-
-void RGFW_freeMouse(RGFW_mouse* mouse) {
-	RGFW_ASSERT(mouse);
-	DestroyCursor((HCURSOR)mouse);
+	SetClassLongPtrA(win->src.window, GCLP_HCURSOR, (LPARAM) LoadCursorA(NULL, icon));
+	SetCursor(LoadCursorA(NULL, icon));
+	return RGFW_TRUE;
 }
 
 void RGFW_window_hide(RGFW_window* win) {
@@ -12089,7 +11962,7 @@ void RGFW_window_flash(RGFW_window* win, RGFW_flashRequest request) {
 	}
 
 	FLASHWINFO desc;
-	RGFW_MEMZERO(&desc, sizeof(desc));
+	RGFW_MEMSET(&desc, 0, sizeof(desc));
 
     desc.cbSize = sizeof(desc);
     desc.hwnd = win->src.window;
@@ -12152,10 +12025,12 @@ void RGFW_window_resize(RGFW_window* win, i32 w, i32 h) {
 
 	win->w = w;
 	win->h = h;
+
 	RECT rect = { 0, 0, w, h};
 	DWORD style = RGFW_winapi_window_getStyle(win, win->internal.flags);
 	DWORD exStyle = RGFW_winapi_window_getExStyle(win, win->internal.flags);
 	AdjustWindowRectEx(&rect, style, FALSE, exStyle);
+
 	SetWindowPos(win->src.window, HWND_TOP, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOZORDER);
 }
 
@@ -12341,7 +12216,7 @@ void RGFW_win32_loadOpenGLFuncs(HWND dummyWin) {
 
     wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)(RGFW_proc)wglGetProcAddress("wglSwapIntervalEXT");
     if (wglSwapIntervalEXT == NULL) {
-        RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext,  "Failed to load swap interval function");
+        RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext,  "Failed to load swap interval function");
     }
 
 	wglMakeCurrent(dummy_dc, cur);
@@ -12455,14 +12330,14 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 		UINT num_formats;
 		wglChoosePixelFormatARB(win->src.hdc, pixel_format_attribs, 0, 1, &new_pixel_format, &num_formats);
 		if (!num_formats)
-			RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create a pixel format for WGL");
+			RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create a pixel format for WGL");
 		else pixel_format = new_pixel_format;
 	}
 
 	PIXELFORMATDESCRIPTOR suggested;
 	if (!DescribePixelFormat(win->src.hdc, pixel_format, sizeof(suggested), &suggested) ||
 		!SetPixelFormat(win->src.hdc, pixel_format, &pfd))
-			RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to set the WGL pixel format");
+			RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to set the WGL pixel format");
 
 	if (wglCreateContextAttribsARB != NULL) {
 		/* create OpenGL/WGL context for the specified version */
@@ -12512,7 +12387,7 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 	}
 
 	if (wglCreateContextAttribsARB == NULL || win->src.ctx.native->ctx == NULL) { /* fall back to a default context (probably OpenGL 2 or something) */
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create an accelerated OpenGL Context.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create an accelerated OpenGL Context.");
 		win->src.ctx.native->ctx = wglCreateContext(win->src.hdc);
 	}
 
@@ -12524,14 +12399,14 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 	}
 
 	wglMakeCurrent(win->src.hdc, win->src.ctx.native->ctx);
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
 	return RGFW_TRUE;
 }
 
 void RGFW_window_deleteContextPtr_OpenGL(RGFW_window* win, RGFW_glContext* ctx) {
 	wglDeleteContext((HGLRC) ctx->ctx); /*!< delete OpenGL context */
 	win->src.ctx.native->ctx = NULL;
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context freed.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context freed.");
 }
 
 void RGFW_window_makeCurrentContext_OpenGL(RGFW_window* win) {
@@ -12551,7 +12426,7 @@ void RGFW_window_swapBuffers_OpenGL(RGFW_window* win) {
 void RGFW_window_swapInterval_OpenGL(RGFW_window* win, i32 swapInterval) {
 	RGFW_ASSERT(win != NULL);
     if (wglSwapIntervalEXT == NULL || wglSwapIntervalEXT(swapInterval) == FALSE)
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to set swap interval");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to set swap interval");
 }
 #endif
 
@@ -12932,16 +12807,7 @@ NSInteger NSPasteBoard_declareTypes(id pasteboard, NSPasteboardType* newTypes, s
 static id RGFW__osxCustomInitWithRGFWWindow(id self, SEL _cmd, RGFW_window* win) {
 	RGFW_UNUSED(_cmd);
     struct objc_super s = { self, class_getSuperclass(object_getClass(self)) };
-
-    CGRect rect;
-    rect.origin.x = 0;
-    rect.origin.y = 0;
-    rect.size.width = (double)win->w;
-    rect.size.height = (double)win->h;
-
-    self = ((id (*)(struct objc_super*, SEL, CGRect))objc_msgSendSuper)(
-        &s, sel_registerName("initWithFrame:"), rect
-    );
+    self = ((id (*)(struct objc_super*, SEL))objc_msgSendSuper)(&s, sel_registerName("init"));
 
     if (self != nil) {
         object_setInstanceVariable(self, "RGFW_window", win);
@@ -12979,7 +12845,7 @@ static u32 RGFW_OnClose(id self) {
 	object_getInstanceVariable(self, (const char*)"RGFW_window", (void**)&win);
 	if (win == NULL) return true;
 
-	RGFW_windowCloseCallback(win);
+	RGFW_windowQuitCallback(win);
 	return false;
 }
 
@@ -12988,28 +12854,22 @@ static bool RGFW__osxAcceptsFirstResponder(void) { return true; }
 static bool RGFW__osxPerformKeyEquivalent(id event) { RGFW_UNUSED(event); return true; }
 
 static NSDragOperation RGFW__osxDraggingEntered(id self, SEL sel, id sender) {
-	RGFW_UNUSED(sel);
+	RGFW_UNUSED(sender); RGFW_UNUSED(self); RGFW_UNUSED(sel);
 
-	RGFW_window* win = NULL;
-	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
-	if (win == NULL)
-		return 0;
-
-	NSPoint p = ((NSPoint(*)(id, SEL)) objc_msgSend)(sender, sel_registerName("draggingLocation"));
-	RGFW_dataDragCallback(win, RGFW_dataFile, RGFW_dndActionEnter, (i32) p.x, (i32) (win->h - p.y));
 	return NSDragOperationCopy;
 }
 static NSDragOperation RGFW__osxDraggingUpdated(id self, SEL sel, id sender) {
 	RGFW_UNUSED(sel);
 
 	RGFW_window* win = NULL;
+
 	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
 	if (win == NULL)
 		return 0;
 	if (!(win->internal.enabledEvents & RGFW_dataDragFlag)) return NSDragOperationCopy;
 
 	NSPoint p = ((NSPoint(*)(id, SEL)) objc_msgSend)(sender, sel_registerName("draggingLocation"));
-	RGFW_dataDragCallback(win, RGFW_dataFile, RGFW_dndActionMove, (i32) p.x, (i32) (win->h - p.y));
+	RGFW_dataDragCallback(win, (i32) p.x, (i32) (win->h - p.y));
 	return NSDragOperationCopy;
 }
 static bool RGFW__osxPrepareForDragOperation(id self) {
@@ -13025,22 +12885,12 @@ static bool RGFW__osxPrepareForDragOperation(id self) {
 	return true;
 }
 
-static void RGFW__osxDraggingEnded(id self, SEL sel, id sender) {
-	RGFW_UNUSED(sel);
-
-	RGFW_window* win = NULL;
-	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
-	if (win == NULL)
-		return;
-	if (!(win->internal.enabledEvents & RGFW_dataDragFlag)) return;
-
-	NSPoint p = ((NSPoint(*)(id, SEL)) objc_msgSend)(sender, sel_registerName("draggingLocation"));
-	RGFW_dataDragCallback(win, RGFW_dataFile, RGFW_dndActionExit, (i32) p.x, (i32) (win->h - p.y));
-	return;
-}
+void RGFW__osxDraggingEnded(id self, SEL sel, id sender);
+void RGFW__osxDraggingEnded(id self, SEL sel, id sender) { RGFW_UNUSED(sender); RGFW_UNUSED(self); RGFW_UNUSED(sel);  return; }
 
 static bool RGFW__osxPerformDragOperation(id self, SEL sel, id sender) {
 	RGFW_UNUSED(sender); RGFW_UNUSED(self); RGFW_UNUSED(sel);
+
 	RGFW_window* win = NULL;
 	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
 	if (win == NULL || (!(win->internal.enabledEvents & RGFW_dataDropFlag)))
@@ -13058,7 +12908,7 @@ static bool RGFW__osxPerformDragOperation(id self, SEL sel, id sender) {
 
 	/* Check if the pasteboard contains file URLs */
 	if (objc_msgSend_id_bool(types, sel_registerName("containsObject:"), fileURLsType) == 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errClipboard, "No files found on the pasteboard.");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errClipboard, "No files found on the pasteboard.");
 		return 0;
 	}
 
@@ -13068,15 +12918,18 @@ static bool RGFW__osxPerformDragOperation(id self, SEL sel, id sender) {
 	if (count == 0)
 		return 0;
 
+	char** files = (char**)(void*)_RGFW->files;
+
 	u32 i;
     for (i = 0; i < (u32)count; i++) {
 		id fileURL = objc_msgSend_arr(fileURLs, sel_registerName("objectAtIndex:"), i);
 		const char *filePath = ((const char* (*)(id, SEL))objc_msgSend)(fileURL, sel_registerName("UTF8String"));
-		int string_count = ((int (*)(id, SEL))objc_msgSend)(fileURL, sel_registerName("count"));
-
-		RGFW_dataDropCallback(win, filePath, (size_t)string_count + 1, RGFW_dataFile);
+		RGFW_STRNCPY(files[i], filePath, RGFW_MAX_PATH - 1);
+		files[i][RGFW_MAX_PATH - 1] = '\0';
 	}
 
+	RGFW_dataDropCallback(win, files, (size_t)count);
+
 	return false;
 }
 
@@ -13185,7 +13038,7 @@ static void RGFW__osxWindowBecameKey(id self, SEL sel) {
 	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
 	if (win == NULL) return;
 
-	RGFW_windowFocusCallback(win, RGFW_TRUE);
+	RGFW_focusCallback(win, RGFW_TRUE);
 }
 
 static void RGFW__osxWindowResignKey(id self, SEL sel) {
@@ -13194,7 +13047,7 @@ static void RGFW__osxWindowResignKey(id self, SEL sel) {
 	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
 	if (win == NULL) return;
 
-	RGFW_windowFocusCallback(win, RGFW_FALSE);
+	RGFW_focusCallback(win, RGFW_FALSE);
 }
 
 static void RGFW__osxDidWindowResize(id self, SEL _cmd, id notification) {
@@ -13256,7 +13109,7 @@ static void RGFW__osxUpdateLayer(id self, SEL _cmd) {
 	RGFW_window* win = NULL;
 	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
 	if (win == NULL) return;
-	RGFW_windowRefreshCallback(win, 0, 0, win->w, win->h);
+	RGFW_windowRefreshCallback(win);
 }
 
 static void RGFW__osxDrawRect(id self, SEL _cmd, CGRect rect) {
@@ -13265,9 +13118,7 @@ static void RGFW__osxDrawRect(id self, SEL _cmd, CGRect rect) {
 	object_getInstanceVariable(self, "RGFW_window", (void**)&win);
 	if (win == NULL) return;
 
-	float y = RGFW_cocoaYTransform((float)(rect.size.height - 1));
-
-	RGFW_windowRefreshCallback(win, (i32)rect.origin.x, (i32)y, (i32)rect.size.width, (i32)rect.size.height);
+	RGFW_windowRefreshCallback(win);
 }
 
 static void RGFW__osxMouseEntered(id self, SEL _cmd, id event) {
@@ -13298,7 +13149,7 @@ static void RGFW__osxKeyDown(id self, SEL _cmd, id event) {
     u32 key = (u16)((u32(*)(id, SEL))objc_msgSend)(event, sel_registerName("keyCode"));
 
 	RGFW_key value = (u8)RGFW_apiKeyToRGFW(key);
-	RGFW_bool repeat = RGFW_isKeyDown(value);
+	RGFW_bool repeat = RGFW_window_isKeyPressed(win, value);
 
     RGFW_keyCallback(win, value, win->internal.mod, repeat, 1);
 
@@ -13320,8 +13171,9 @@ static void RGFW__osxKeyUp(id self, SEL _cmd, id event) {
     u32 key = (u16)((u32(*)(id, SEL))objc_msgSend)(event, sel_registerName("keyCode"));
 
     RGFW_key value = (u8)RGFW_apiKeyToRGFW(key);
+    RGFW_bool repeat = RGFW_window_isKeyDown(win, (u8)value);
 
-    RGFW_keyCallback(win, value, win->internal.mod, RGFW_FALSE, 0);
+    RGFW_keyCallback(win, value, win->internal.mod, repeat, 0);
 }
 
 static void RGFW__osxFlagsChanged(id self, SEL _cmd, id event) {
@@ -13334,7 +13186,7 @@ static void RGFW__osxFlagsChanged(id self, SEL _cmd, id event) {
 	RGFW_bool pressed = RGFW_FALSE;
 
     u32 flags = (u32)((u32(*)(id, SEL))objc_msgSend)(event, sel_registerName("modifierFlags"));
-    RGFW_keyUpdateKeyModsEx(win,
+    RGFW_updateKeyModsEx(win,
                           ((u32)(flags & NSEventModifierFlagCapsLock) % 255),
                           ((flags & NSEventModifierFlagNumericPad) % 255),
                           ((flags & NSEventModifierFlagControl) % 255),
@@ -13343,27 +13195,28 @@ static void RGFW__osxFlagsChanged(id self, SEL _cmd, id event) {
                           ((flags & NSEventModifierFlagCommand) % 255), 0);
     u8 i;
     for (i = 0; i < 9; i++)
-        _RGFW->keyboard[i + RGFW_keyCapsLock].prev = _RGFW->keyboard[i + RGFW_keyCapsLock].current;
+        _RGFW->keyboard[i + RGFW_capsLock].prev = _RGFW->keyboard[i + RGFW_capsLock].current;
 
     for (i = 0; i < 5; i++) {
         u32 shift = (1 << (i + 16));
-        RGFW_key key = i + RGFW_keyCapsLock;
-        if ((flags & shift) && !RGFW_isKeyDown((u8)key)) {
+        RGFW_key key = i + RGFW_capsLock;
+        if ((flags & shift) && !RGFW_window_isKeyDown(win, (u8)key)) {
 			pressed = RGFW_TRUE;
             value = (u8)key;
             break;
         }
-        if (!(flags & shift) && RGFW_isKeyDown((u8)key)) {
+        if (!(flags & shift) && RGFW_window_isKeyDown(win, (u8)key)) {
 			pressed = RGFW_FALSE;
             value = (u8)key;
             break;
         }
     }
 
-	RGFW_keyCallback(win, value, win->internal.mod, RGFW_isKeyDown(value) && pressed, pressed);
+	RGFW_bool repeat = RGFW_window_isKeyDown(win, (u8)value);
+	RGFW_keyCallback(win, value, win->internal.mod, repeat, pressed);
 
-	if (value != RGFW_keyCapsLock) {
-		RGFW_keyCallback(win, value + 4, win->internal.mod, RGFW_isKeyDown(value + 4) && pressed, pressed);
+	if (value != RGFW_capsLock) {
+		RGFW_keyCallback(win, value + 4, win->internal.mod, repeat, pressed);
 	}
 
 }
@@ -13379,8 +13232,7 @@ static void RGFW__osxMouseMoved(id self, SEL _cmd, id event) {
 	CGFloat vecX = ((CGFloat(*)(id, SEL))abi_objc_msgSend_fpret)(event, sel_registerName("deltaX"));
     CGFloat vecY = ((CGFloat(*)(id, SEL))abi_objc_msgSend_fpret)(event, sel_registerName("deltaY"));
 
-    RGFW_mouseMotionCallback(win, (i32)p.x, (i32)(win->h - p.y));
-	RGFW_rawMotionCallback(win, (float)vecX, (float)vecY);
+    RGFW_mousePosCallback(win, (i32)p.x, (i32)(win->h - p.y), (float)vecX, (float)vecY);
 }
 
 static void RGFW__osxMouseDown(id self, SEL _cmd, id event) {
@@ -13493,117 +13345,117 @@ void* RGFW_getLayer_OSX(void) {
 void* RGFW_window_getWindow_OSX(RGFW_window* win) { return win->src.window; }
 
 void RGFW_initKeycodesPlatform(void) {
-	_RGFW->keycodes[0x1D] = RGFW_key0;
-	_RGFW->keycodes[0x12] = RGFW_key1;
-	_RGFW->keycodes[0x13] = RGFW_key2;
-	_RGFW->keycodes[0x14] = RGFW_key3;
-	_RGFW->keycodes[0x15] = RGFW_key4;
-	_RGFW->keycodes[0x17] = RGFW_key5;
-	_RGFW->keycodes[0x16] = RGFW_key6;
-	_RGFW->keycodes[0x1A] = RGFW_key7;
-	_RGFW->keycodes[0x1C] = RGFW_key8;
-	_RGFW->keycodes[0x19] = RGFW_key9;
-	_RGFW->keycodes[0x00] = RGFW_keyA;
-	_RGFW->keycodes[0x0B] = RGFW_keyB;
-	_RGFW->keycodes[0x08] = RGFW_keyC;
-	_RGFW->keycodes[0x02] = RGFW_keyD;
-	_RGFW->keycodes[0x0E] = RGFW_keyE;
-	_RGFW->keycodes[0x03] = RGFW_keyF;
-	_RGFW->keycodes[0x05] = RGFW_keyG;
-	_RGFW->keycodes[0x04] = RGFW_keyH;
-	_RGFW->keycodes[0x22] = RGFW_keyI;
-	_RGFW->keycodes[0x26] = RGFW_keyJ;
-	_RGFW->keycodes[0x28] = RGFW_keyK;
-	_RGFW->keycodes[0x25] = RGFW_keyL;
-	_RGFW->keycodes[0x2E] = RGFW_keyM;
-	_RGFW->keycodes[0x2D] = RGFW_keyN;
-	_RGFW->keycodes[0x1F] = RGFW_keyO;
-	_RGFW->keycodes[0x23] = RGFW_keyP;
-	_RGFW->keycodes[0x0C] = RGFW_keyQ;
-	_RGFW->keycodes[0x0F] = RGFW_keyR;
-	_RGFW->keycodes[0x01] = RGFW_keyS;
-	_RGFW->keycodes[0x11] = RGFW_keyT;
-	_RGFW->keycodes[0x20] = RGFW_keyU;
-	_RGFW->keycodes[0x09] = RGFW_keyV;
-	_RGFW->keycodes[0x0D] = RGFW_keyW;
-	_RGFW->keycodes[0x07] = RGFW_keyX;
-	_RGFW->keycodes[0x10] = RGFW_keyY;
-	_RGFW->keycodes[0x06] = RGFW_keyZ;
-	_RGFW->keycodes[0x27] = RGFW_keyApostrophe;
-	_RGFW->keycodes[0x2A] = RGFW_keyBackSlash;
-	_RGFW->keycodes[0x2B] = RGFW_keyComma;
-	_RGFW->keycodes[0x18] = RGFW_keyEquals;
-	_RGFW->keycodes[0x32] = RGFW_keyBacktick;
-	_RGFW->keycodes[0x21] = RGFW_keyBracket;
-	_RGFW->keycodes[0x1B] = RGFW_keyMinus;
-	_RGFW->keycodes[0x2F] = RGFW_keyPeriod;
-	_RGFW->keycodes[0x1E] = RGFW_keyCloseBracket;
-	_RGFW->keycodes[0x29] = RGFW_keySemicolon;
-	_RGFW->keycodes[0x2C] = RGFW_keySlash;
-	_RGFW->keycodes[0x0A] = RGFW_keyWorld1;
-	_RGFW->keycodes[0x33] = RGFW_keyBackSpace;
-	_RGFW->keycodes[0x39] = RGFW_keyCapsLock;
-	_RGFW->keycodes[0x75] = RGFW_keyDelete;
-	_RGFW->keycodes[0x7D] = RGFW_keyDown;
-	_RGFW->keycodes[0x77] = RGFW_keyEnd;
-	_RGFW->keycodes[0x24] = RGFW_keyEnter;
-	_RGFW->keycodes[0x35] = RGFW_keyEscape;
-	_RGFW->keycodes[0x7A] = RGFW_keyF1;
-	_RGFW->keycodes[0x78] = RGFW_keyF2;
-	_RGFW->keycodes[0x63] = RGFW_keyF3;
-	_RGFW->keycodes[0x76] = RGFW_keyF4;
-	_RGFW->keycodes[0x60] = RGFW_keyF5;
-	_RGFW->keycodes[0x61] = RGFW_keyF6;
-	_RGFW->keycodes[0x62] = RGFW_keyF7;
-	_RGFW->keycodes[0x64] = RGFW_keyF8;
-	_RGFW->keycodes[0x65] = RGFW_keyF9;
-	_RGFW->keycodes[0x6D] = RGFW_keyF10;
-	_RGFW->keycodes[0x67] = RGFW_keyF11;
-	_RGFW->keycodes[0x6F] = RGFW_keyF12;
-	_RGFW->keycodes[0x69] = RGFW_keyPrintScreen;
-	_RGFW->keycodes[0x6B] = RGFW_keyF14;
-	_RGFW->keycodes[0x71] = RGFW_keyF15;
-	_RGFW->keycodes[0x6A] = RGFW_keyF16;
-	_RGFW->keycodes[0x40] = RGFW_keyF17;
-	_RGFW->keycodes[0x4F] = RGFW_keyF18;
-	_RGFW->keycodes[0x50] = RGFW_keyF19;
-	_RGFW->keycodes[0x5A] = RGFW_keyF20;
-	_RGFW->keycodes[0x73] = RGFW_keyHome;
-	_RGFW->keycodes[0x72] = RGFW_keyInsert;
-	_RGFW->keycodes[0x7B] = RGFW_keyLeft;
-	_RGFW->keycodes[0x3A] = RGFW_keyAltL;
-	_RGFW->keycodes[0x3B] = RGFW_keyControlL;
-	_RGFW->keycodes[0x38] = RGFW_keyShiftL;
-	_RGFW->keycodes[0x37] = RGFW_keySuperL;
-	_RGFW->keycodes[0x6E] = RGFW_keyMenu;
-	_RGFW->keycodes[0x47] = RGFW_keyNumLock;
-	_RGFW->keycodes[0x79] = RGFW_keyPageDown;
-	_RGFW->keycodes[0x74] = RGFW_keyPageUp;
-	_RGFW->keycodes[0x7C] = RGFW_keyRight;
-	_RGFW->keycodes[0x3D] = RGFW_keyAltR;
-	_RGFW->keycodes[0x3E] = RGFW_keyControlR;
-	_RGFW->keycodes[0x3C] = RGFW_keyShiftR;
-	_RGFW->keycodes[0x36] = RGFW_keySuperR;
-	_RGFW->keycodes[0x31] = RGFW_keySpace;
-	_RGFW->keycodes[0x30] = RGFW_keyTab;
-	_RGFW->keycodes[0x7E] = RGFW_keyUp;
-	_RGFW->keycodes[0x52] = RGFW_keyPad0;
-	_RGFW->keycodes[0x53] = RGFW_keyPad1;
-	_RGFW->keycodes[0x54] = RGFW_keyPad2;
-	_RGFW->keycodes[0x55] = RGFW_keyPad3;
-	_RGFW->keycodes[0x56] = RGFW_keyPad4;
-	_RGFW->keycodes[0x57] = RGFW_keyPad5;
-	_RGFW->keycodes[0x58] = RGFW_keyPad6;
-	_RGFW->keycodes[0x59] = RGFW_keyPad7;
-	_RGFW->keycodes[0x5B] = RGFW_keyPad8;
-	_RGFW->keycodes[0x5C] = RGFW_keyPad9;
-	_RGFW->keycodes[0x45] = RGFW_keyPadSlash;
-	_RGFW->keycodes[0x41] = RGFW_keyPadPeriod;
-	_RGFW->keycodes[0x4B] = RGFW_keyPadSlash;
-	_RGFW->keycodes[0x4C] = RGFW_keyPadReturn;
-	_RGFW->keycodes[0x51] = RGFW_keyPadEqual;
-	_RGFW->keycodes[0x43] = RGFW_keyPadMultiply;
-	_RGFW->keycodes[0x4E] = RGFW_keyPadMinus;
+	_RGFW->keycodes[0x1D] = RGFW_0;
+	_RGFW->keycodes[0x12] = RGFW_1;
+	_RGFW->keycodes[0x13] = RGFW_2;
+	_RGFW->keycodes[0x14] = RGFW_3;
+	_RGFW->keycodes[0x15] = RGFW_4;
+	_RGFW->keycodes[0x17] = RGFW_5;
+	_RGFW->keycodes[0x16] = RGFW_6;
+	_RGFW->keycodes[0x1A] = RGFW_7;
+	_RGFW->keycodes[0x1C] = RGFW_8;
+	_RGFW->keycodes[0x19] = RGFW_9;
+	_RGFW->keycodes[0x00] = RGFW_a;
+	_RGFW->keycodes[0x0B] = RGFW_b;
+	_RGFW->keycodes[0x08] = RGFW_c;
+	_RGFW->keycodes[0x02] = RGFW_d;
+	_RGFW->keycodes[0x0E] = RGFW_e;
+	_RGFW->keycodes[0x03] = RGFW_f;
+	_RGFW->keycodes[0x05] = RGFW_g;
+	_RGFW->keycodes[0x04] = RGFW_h;
+	_RGFW->keycodes[0x22] = RGFW_i;
+	_RGFW->keycodes[0x26] = RGFW_j;
+	_RGFW->keycodes[0x28] = RGFW_k;
+	_RGFW->keycodes[0x25] = RGFW_l;
+	_RGFW->keycodes[0x2E] = RGFW_m;
+	_RGFW->keycodes[0x2D] = RGFW_n;
+	_RGFW->keycodes[0x1F] = RGFW_o;
+	_RGFW->keycodes[0x23] = RGFW_p;
+	_RGFW->keycodes[0x0C] = RGFW_q;
+	_RGFW->keycodes[0x0F] = RGFW_r;
+	_RGFW->keycodes[0x01] = RGFW_s;
+	_RGFW->keycodes[0x11] = RGFW_t;
+	_RGFW->keycodes[0x20] = RGFW_u;
+	_RGFW->keycodes[0x09] = RGFW_v;
+	_RGFW->keycodes[0x0D] = RGFW_w;
+	_RGFW->keycodes[0x07] = RGFW_x;
+	_RGFW->keycodes[0x10] = RGFW_y;
+	_RGFW->keycodes[0x06] = RGFW_z;
+	_RGFW->keycodes[0x27] = RGFW_apostrophe;
+	_RGFW->keycodes[0x2A] = RGFW_backSlash;
+	_RGFW->keycodes[0x2B] = RGFW_comma;
+	_RGFW->keycodes[0x18] = RGFW_equals;
+	_RGFW->keycodes[0x32] = RGFW_backtick;
+	_RGFW->keycodes[0x21] = RGFW_bracket;
+	_RGFW->keycodes[0x1B] = RGFW_minus;
+	_RGFW->keycodes[0x2F] = RGFW_period;
+	_RGFW->keycodes[0x1E] = RGFW_closeBracket;
+	_RGFW->keycodes[0x29] = RGFW_semicolon;
+	_RGFW->keycodes[0x2C] = RGFW_slash;
+	_RGFW->keycodes[0x0A] = RGFW_world1;
+	_RGFW->keycodes[0x33] = RGFW_backSpace;
+	_RGFW->keycodes[0x39] = RGFW_capsLock;
+	_RGFW->keycodes[0x75] = RGFW_delete;
+	_RGFW->keycodes[0x7D] = RGFW_down;
+	_RGFW->keycodes[0x77] = RGFW_end;
+	_RGFW->keycodes[0x24] = RGFW_enter;
+	_RGFW->keycodes[0x35] = RGFW_escape;
+	_RGFW->keycodes[0x7A] = RGFW_F1;
+	_RGFW->keycodes[0x78] = RGFW_F2;
+	_RGFW->keycodes[0x63] = RGFW_F3;
+	_RGFW->keycodes[0x76] = RGFW_F4;
+	_RGFW->keycodes[0x60] = RGFW_F5;
+	_RGFW->keycodes[0x61] = RGFW_F6;
+	_RGFW->keycodes[0x62] = RGFW_F7;
+	_RGFW->keycodes[0x64] = RGFW_F8;
+	_RGFW->keycodes[0x65] = RGFW_F9;
+	_RGFW->keycodes[0x6D] = RGFW_F10;
+	_RGFW->keycodes[0x67] = RGFW_F11;
+	_RGFW->keycodes[0x6F] = RGFW_F12;
+	_RGFW->keycodes[0x69] = RGFW_printScreen;
+	_RGFW->keycodes[0x6B] = RGFW_F14;
+	_RGFW->keycodes[0x71] = RGFW_F15;
+	_RGFW->keycodes[0x6A] = RGFW_F16;
+	_RGFW->keycodes[0x40] = RGFW_F17;
+	_RGFW->keycodes[0x4F] = RGFW_F18;
+	_RGFW->keycodes[0x50] = RGFW_F19;
+	_RGFW->keycodes[0x5A] = RGFW_F20;
+	_RGFW->keycodes[0x73] = RGFW_home;
+	_RGFW->keycodes[0x72] = RGFW_insert;
+	_RGFW->keycodes[0x7B] = RGFW_left;
+	_RGFW->keycodes[0x3A] = RGFW_altL;
+	_RGFW->keycodes[0x3B] = RGFW_controlL;
+	_RGFW->keycodes[0x38] = RGFW_shiftL;
+	_RGFW->keycodes[0x37] = RGFW_superL;
+	_RGFW->keycodes[0x6E] = RGFW_menu;
+	_RGFW->keycodes[0x47] = RGFW_numLock;
+	_RGFW->keycodes[0x79] = RGFW_pageDown;
+	_RGFW->keycodes[0x74] = RGFW_pageUp;
+	_RGFW->keycodes[0x7C] = RGFW_right;
+	_RGFW->keycodes[0x3D] = RGFW_altR;
+	_RGFW->keycodes[0x3E] = RGFW_controlR;
+	_RGFW->keycodes[0x3C] = RGFW_shiftR;
+	_RGFW->keycodes[0x36] = RGFW_superR;
+	_RGFW->keycodes[0x31] = RGFW_space;
+	_RGFW->keycodes[0x30] = RGFW_tab;
+	_RGFW->keycodes[0x7E] = RGFW_up;
+	_RGFW->keycodes[0x52] = RGFW_kp0;
+	_RGFW->keycodes[0x53] = RGFW_kp1;
+	_RGFW->keycodes[0x54] = RGFW_kp2;
+	_RGFW->keycodes[0x55] = RGFW_kp3;
+	_RGFW->keycodes[0x56] = RGFW_kp4;
+	_RGFW->keycodes[0x57] = RGFW_kp5;
+	_RGFW->keycodes[0x58] = RGFW_kp6;
+	_RGFW->keycodes[0x59] = RGFW_kp7;
+	_RGFW->keycodes[0x5B] = RGFW_kp8;
+	_RGFW->keycodes[0x5C] = RGFW_kp9;
+	_RGFW->keycodes[0x45] = RGFW_kpSlash;
+	_RGFW->keycodes[0x41] = RGFW_kpPeriod;
+	_RGFW->keycodes[0x4B] = RGFW_kpSlash;
+	_RGFW->keycodes[0x4C] = RGFW_kpReturn;
+	_RGFW->keycodes[0x51] = RGFW_kpEqual;
+	_RGFW->keycodes[0x43] = RGFW_kpMultiply;
+	_RGFW->keycodes[0x4E] = RGFW_kpMinus;
 }
 
 i32 RGFW_initPlatform(void) {
@@ -13881,15 +13733,6 @@ RGFW_key RGFW_physicalToMappedKey(RGFW_key key) {
 	return key;
 }
 
-RGFW_bool RGFW_window_fetchSize(RGFW_window* win, i32* w, i32* h) {
-	NSRect content = ((NSRect(*)(id, SEL))abi_objc_msgSend_stret)((id)win->src.view, sel_registerName("frame"));
-
-	win->w = (i32)content.size.width;
-	win->h = (i32)content.size.height;
-
-	return RGFW_window_getSize(win, w, h);
-}
-
 void RGFW_pollEvents(void) {
 	RGFW_resetPrevState();
 
@@ -14003,7 +13846,6 @@ void RGFW_window_maximize(RGFW_window* win) {
 
 	win->internal.flags |= RGFW_windowMaximize;
 	objc_msgSend_void_SEL(win->src.window, sel_registerName("zoom:"), NULL);
-	RGFW_window_fetchSize(win, NULL, NULL);
 }
 
 void RGFW_window_minimize(RGFW_window* win) {
@@ -14114,40 +13956,10 @@ id NSCursor_arrowStr(const char* str);
 id NSCursor_arrowStr(const char* str) {
 	void* nclass = objc_getClass("NSCursor");
 	SEL func = sel_registerName(str);
-	id mouse = (id) objc_msgSend_id(nclass, func);
-	NSRetain(mouse);
-	return mouse;
+	return (id) objc_msgSend_id(nclass, func);
 }
 
-RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon mouse) {
-	switch (mouse) {
-        case RGFW_mouseNormal: return NSCursor_arrowStr("arrowCursor");
-        case RGFW_mouseArrow: return NSCursor_arrowStr("arrowCursor");
-        case RGFW_mouseIbeam: return NSCursor_arrowStr("IBeamCursor");
-        case RGFW_mouseCrosshair: return NSCursor_arrowStr("crosshairCursor");
-        case RGFW_mousePointingHand: return NSCursor_arrowStr("pointingHandCursor");
-        case RGFW_mouseResizeEW: return NSCursor_arrowStr("resizeLeftRightCursor");
-        case RGFW_mouseResizeE: return NSCursor_arrowStr("resizeLeftRightCursor");
-        case RGFW_mouseResizeW: return NSCursor_arrowStr("resizeLeftRightCursor");
-        case RGFW_mouseResizeNS: return NSCursor_arrowStr("resizeUpDownCursor");
-        case RGFW_mouseResizeN: return NSCursor_arrowStr("resizeUpDownCursor");
-        case RGFW_mouseResizeS: return NSCursor_arrowStr("resizeUpDownCursor");
-        case RGFW_mouseResizeNWSE: return NSCursor_arrowStr("_windowResizeNorthWestSouthEastCursor");
-        case RGFW_mouseResizeNW: return NSCursor_arrowStr("_windowResizeNorthWestSouthEastCursor");
-        case RGFW_mouseResizeSE: return NSCursor_arrowStr("_windowResizeNorthWestSouthEastCursor");
-        case RGFW_mouseResizeNESW: return NSCursor_arrowStr("_windowResizeNorthEastSouthWestCursor");
-        case RGFW_mouseResizeNE: return NSCursor_arrowStr("_windowResizeNorthEastSouthWestCursor");
-        case RGFW_mouseResizeSW: return NSCursor_arrowStr("_windowResizeNorthEastSouthWestCursor");
-        case RGFW_mouseResizeAll: return NSCursor_arrowStr("openHandCursor");
-        case RGFW_mouseNotAllowed: return NSCursor_arrowStr("operationNotAllowedCursor");
-        case RGFW_mouseWait: return NSCursor_arrowStr("arrowCursor");
-        case RGFW_mouseProgress: return NSCursor_arrowStr("arrowCursor");
-        default: return NULL;
-    }
-	return NULL;
-}
-
-RGFW_mouse* RGFW_createMouse(u8* data, i32 w, i32 h, RGFW_format format) {
+RGFW_mouse* RGFW_loadMouse(u8* data, i32 w, i32 h, RGFW_format format) {
 	id pool = objc_msgSend_class(objc_getClass("NSAutoreleasePool"), sel_registerName("alloc"));
 	pool = objc_msgSend_id(pool, sel_registerName("init"));
 
@@ -14176,12 +13988,11 @@ RGFW_mouse* RGFW_createMouse(u8* data, i32 w, i32 h, RGFW_format format) {
 	return (void*)cursor;
 }
 
-RGFW_bool RGFW_window_setMousePlatform(RGFW_window* win, RGFW_mouse* mouse) {
+void RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse) {
 	RGFW_ASSERT(win != NULL); RGFW_ASSERT(mouse);
 	CGDisplayShowCursor(kCGDirectMainDisplay);
 	objc_msgSend_void((id)mouse, sel_registerName("set"));
 	win->src.mouse = mouse;
-	return RGFW_TRUE;
 }
 
 void RGFW_freeMouse(RGFW_mouse* mouse) {
@@ -14189,12 +14000,57 @@ void RGFW_freeMouse(RGFW_mouse* mouse) {
 	NSRelease((id)mouse);
 }
 
+RGFW_bool RGFW_window_setMouseDefault(RGFW_window* win) {
+	return RGFW_window_setMouseStandard(win, RGFW_mouseArrow);
+}
+
 void RGFW_window_showMouse(RGFW_window* win, RGFW_bool show) {
 	RGFW_window_showMouseFlags(win, show);
 	if (show)   CGDisplayShowCursor(kCGDirectMainDisplay);
 	else        CGDisplayHideCursor(kCGDirectMainDisplay);
 }
 
+RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, u8 stdMouse) {
+	const char* cursorSelectorStr;
+	switch (stdMouse) {
+        case RGFW_mouseNormal:    cursorSelectorStr = "arrowCursor"; break;
+        case RGFW_mouseArrow: cursorSelectorStr = "arrowCursor"; break;
+        case RGFW_mouseIbeam: cursorSelectorStr = "IBeamCursor"; break;
+        case RGFW_mouseCrosshair: cursorSelectorStr = "crosshairCursor"; break;
+        case RGFW_mousePointingHand: cursorSelectorStr = "pointingHandCursor"; break;
+        case RGFW_mouseResizeEW: cursorSelectorStr = "resizeLeftRightCursor"; break;
+        case RGFW_mouseResizeE: cursorSelectorStr = "resizeLeftRightCursor"; break;
+        case RGFW_mouseResizeW: cursorSelectorStr = "resizeLeftRightCursor"; break;
+        case RGFW_mouseResizeNS: cursorSelectorStr = "resizeUpDownCursor"; break;
+        case RGFW_mouseResizeN: cursorSelectorStr = "resizeUpDownCursor"; break;
+        case RGFW_mouseResizeS: cursorSelectorStr = "resizeUpDownCursor"; break;
+        case RGFW_mouseResizeNWSE: cursorSelectorStr = "_windowResizeNorthWestSouthEastCursor"; break;
+        case RGFW_mouseResizeNW: cursorSelectorStr = "_windowResizeNorthWestSouthEastCursor"; break;
+        case RGFW_mouseResizeSE: cursorSelectorStr = "_windowResizeNorthWestSouthEastCursor"; break;
+        case RGFW_mouseResizeNESW: cursorSelectorStr = "_windowResizeNorthEastSouthWestCursor"; break;
+        case RGFW_mouseResizeNE: cursorSelectorStr = "_windowResizeNorthEastSouthWestCursor"; break;
+        case RGFW_mouseResizeSW: cursorSelectorStr = "_windowResizeNorthEastSouthWestCursor"; break;
+        case RGFW_mouseResizeAll: cursorSelectorStr = "openHandCursor"; break;
+        case RGFW_mouseNotAllowed: cursorSelectorStr = "operationNotAllowedCursor"; break;
+        case RGFW_mouseWait: cursorSelectorStr = "arrowCursor"; break;
+        case RGFW_mouseProgress: cursorSelectorStr = "arrowCursor"; break;
+        default:
+            return RGFW_FALSE;
+    }
+
+	id mouse = NSCursor_arrowStr(cursorSelectorStr);
+
+	if (mouse == NULL)
+		return RGFW_FALSE;
+
+	RGFW_UNUSED(win);
+	CGDisplayShowCursor(kCGDirectMainDisplay);
+	objc_msgSend_void(mouse, sel_registerName("set"));
+	win->src.mouse = mouse;
+
+	return RGFW_TRUE;
+}
+
 void RGFW_window_setRawMouseModePlatform(RGFW_window* win, RGFW_bool state) {
 	RGFW_UNUSED(win); RGFW_UNUSED(state);
 }
@@ -14308,17 +14164,14 @@ float RGFW_osx_getRefreshRate(CGDirectDisplayID display, CGDisplayModeRef mode)
 }
 
 void RGFW_pollMonitors(void) {
+	static CGDirectDisplayID displays[RGFW_MAX_MONITORS];
 	u32 count;
 
-	if (CGGetActiveDisplayList(0, NULL, &count) != kCGErrorSuccess) {
-		return;
-	}
-
-	CGDirectDisplayID* displays = (CGDirectDisplayID*)RGFW_ALLOC(sizeof(CGDirectDisplayID) * count);
-	if (CGGetActiveDisplayList(count, displays, &count) != kCGErrorSuccess) {
+	if (CGGetActiveDisplayList(RGFW_MAX_MONITORS, displays, &count) != kCGErrorSuccess) {
 		return;
 	}
 
+	if (count > RGFW_MAX_MONITORS) count = RGFW_MAX_MONITORS;
 
 	for (RGFW_monitorNode* node = _RGFW->monitors.list.head; node; node = node->next) {
 		node->disconnected = RGFW_TRUE;
@@ -14390,8 +14243,6 @@ void RGFW_pollMonitors(void) {
 		RGFW_monitorCallback(_RGFW->root, &node->mon, RGFW_TRUE);
 	}
 
-	RGFW_FREE(displays);
-
 	RGFW_monitors_refresh();
 }
 
@@ -14537,11 +14388,6 @@ RGFW_monitor* RGFW_window_getMonitor(RGFW_window* win) {
 		}
 	}
 
-    if (node == NULL) {
-		node = _RGFW->monitors.primary ? _RGFW->monitors.primary : _RGFW->monitors.list.head;
-	}
-
-	if (node == NULL) return NULL;
 	return &node->mon;
 }
 
@@ -14653,7 +14499,7 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 
 	void* format = (void*) ((id(*)(id, SEL, const u32*))objc_msgSend) (NSAlloc((id)objc_getClass("NSOpenGLPixelFormat")), sel_registerName("initWithAttributes:"), (u32*)attribs);
 	if (format == NULL) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to load pixel format for OpenGL");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "Failed to load pixel format for OpenGL");
 
 		assert(render_type_index + 3 < (sizeof(attribs) / sizeof(attribs[0])));
 		attribs[render_type_index] = NSOpenGLPFARendererID;
@@ -14662,9 +14508,9 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 
 		format = (void*) ((id(*)(id, SEL, const u32*))objc_msgSend) (NSAlloc((id)objc_getClass("NSOpenGLPixelFormat")), sel_registerName("initWithAttributes:"), (u32*)attribs);
 		if (format == NULL)
-			RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "and loading software rendering OpenGL failed");
+			RGFW_sendDebugInfo(RGFW_typeError, RGFW_errOpenGLContext, "and loading software rendering OpenGL failed");
 		else
-			RGFW_debugCallback(RGFW_typeWarning, RGFW_warningOpenGL, "Switching to software rendering");
+			RGFW_sendDebugInfo(RGFW_typeWarning, RGFW_warningOpenGL, "Switching to software rendering");
 	}
 
 	/* the pixel format can be passed directly to OpenGL context creation to create a context
@@ -14702,7 +14548,7 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 
 	RGFW_window_swapInterval_OpenGL(win, 0);
 
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
 	return RGFW_TRUE;
 }
 
@@ -14712,7 +14558,7 @@ void RGFW_window_deleteContextPtr_OpenGL(RGFW_window* win, RGFW_glContext* ctx)
 
 	objc_msgSend_void(ctx->ctx, sel_registerName("release"));
 	win->src.ctx.native->ctx = NULL;
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context freed.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context freed.");
 }
 
 void RGFW_window_makeCurrentContext_OpenGL(RGFW_window* win) {
@@ -14773,7 +14619,7 @@ VkResult RGFW_window_createSurface_Vulkan(RGFW_window* win, VkInstance instance,
 
     id nsView = (id)win->src.view;
     if (!nsView) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errMetal, "NSView is NULL for macOS window");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errMetal, "NSView is NULL for macOS window");
         return -1;
     }
 
@@ -14792,12 +14638,12 @@ VkResult RGFW_window_createSurface_Vulkan(RGFW_window* win, VkInstance instance,
 	VkMetalSurfaceCreateInfoEXT macos;
 	macos.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
 	macos.slayer = metalLayer;
-	RGFW_MEMZERO(&macos, sizeof(macos));
+	RGFW_MEMSET(&macos, 0, sizeof(macos));
     result = vkCreateMacOSSurfaceMVK(instance, &macos, NULL, surface);
 */
 
 	VkMacOSSurfaceCreateInfoMVK macos;
-	RGFW_MEMZERO(&macos, sizeof(macos));
+	RGFW_MEMSET(&macos, 0, sizeof(macos));
 	macos.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
 	macos.pView = nsView;
 
@@ -14814,7 +14660,7 @@ WGPUSurface RGFW_window_createSurface_WebGPU(RGFW_window* window, WGPUInstance i
 	WGPUSurfaceDescriptor surfaceDesc = {0};
     id* nsView = (id*)window->src.view;
     if (!nsView) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errMetal, "NSView is NULL for macOS window");
+		RGFW_sendDebugInfo(RGFW_typeError, RGFW_errMetal, "NSView is NULL for macOS window");
         return NULL;
     }
 
@@ -14900,21 +14746,20 @@ EM_BOOL Emscripten_on_fullscreenchange(int eventType, const EmscriptenFullscreen
 EM_BOOL Emscripten_on_focusin(int eventType, const EmscriptenFocusEvent* E, void* userData) {
 	RGFW_UNUSED(eventType); RGFW_UNUSED(userData); RGFW_UNUSED(E);
 
-	RGFW_windowFocusCallback(_RGFW->root, 1);
+	RGFW_focusCallback(_RGFW->root, 1);
     return EM_TRUE;
 }
 
 EM_BOOL Emscripten_on_focusout(int eventType, const EmscriptenFocusEvent* E, void* userData) {
 	RGFW_UNUSED(eventType); RGFW_UNUSED(userData); RGFW_UNUSED(E);
 
-	RGFW_windowFocusCallback(_RGFW->root, 0);
+	RGFW_focusCallback(_RGFW->root, 0);
     return EM_TRUE;
 }
 
 EM_BOOL Emscripten_on_mousemove(int eventType, const EmscriptenMouseEvent* E, void* userData) {
 	RGFW_UNUSED(eventType); RGFW_UNUSED(userData);
-	RGFW_mouseMotionCallback(_RGFW->root, E->targetX, E->targetY);
-	RGFW_rawMotionCallback(_RGFW->root, E->movementX, E->movementY);
+	RGFW_mousePosCallback(_RGFW->root, E->targetX, E->targetY, E->movementX, E->movementY);
     return EM_TRUE;
 }
 
@@ -14955,8 +14800,7 @@ EM_BOOL Emscripten_on_touchstart(int eventType, const EmscriptenTouchEvent* E, v
 
     size_t i;
     for (i = 0; i < (size_t)E->numTouches; i++) {
-        RGFW_mouseMotionCallback(_RGFW->root, E->touches[i].targetX, E->touches[i].targetY);
-		RGFW_rawMotionCallback(_RGFW->root, 0, 0);
+        RGFW_mousePosCallback(_RGFW->root, E->touches[i].targetX, E->touches[i].targetY, 0, 0);
 	    RGFW_mouseButtonCallback(_RGFW->root, RGFW_mouseLeft, 1);
     }
 
@@ -14966,12 +14810,11 @@ EM_BOOL Emscripten_on_touchstart(int eventType, const EmscriptenTouchEvent* E, v
 EM_BOOL Emscripten_on_touchmove(int eventType, const EmscriptenTouchEvent* E, void* userData) {
 	RGFW_UNUSED(eventType); RGFW_UNUSED(userData);
 
-	if (!(_RGFW->root->internal.enabledEvents & RGFW_mouseMotionFlag)) return EM_TRUE;
+	if (!(_RGFW->root->internal.enabledEvents & RGFW_mousePosChangedFlag)) return EM_TRUE;
 
     size_t i;
     for (i = 0; i < (size_t)E->numTouches; i++) {
-        RGFW_mouseMotionCallback(_RGFW->root, E->touches[i].targetX, E->touches[i].targetY);
-		RGFW_rawMotionCallback(_RGFW->root, 0, 0);
+        RGFW_mousePosCallback(_RGFW->root, E->touches[i].targetX, E->touches[i].targetY, 0, 0);
     }
     return EM_TRUE;
 }
@@ -14983,8 +14826,7 @@ EM_BOOL Emscripten_on_touchend(int eventType, const EmscriptenTouchEvent* E, voi
 
     size_t i;
     for (i = 0; i < (size_t)E->numTouches; i++) {
-		RGFW_mouseMotionCallback(_RGFW->root, E->touches[i].targetX, E->touches[i].targetY);
-		RGFW_rawMotionCallback(_RGFW->root, 0, 0);
+		RGFW_mousePosCallback(_RGFW->root, E->touches[i].targetX, E->touches[i].targetY, 0, 0);
 		RGFW_mouseButtonCallback(_RGFW->root, RGFW_mouseLeft, 0);
     }
 	return EM_TRUE;
@@ -15002,22 +14844,20 @@ void EMSCRIPTEN_KEEPALIVE RGFW_handleKeyEvent(char* code, u32 codepoint, RGFW_bo
 
 	u32 physicalKey = RGFW_WASMPhysicalToRGFW(hash);
 
-	RGFW_keyCallback(_RGFW->root, physicalKey, _RGFW->root->internal.mod,  RGFW_isKeyDown((u8)physicalKey) && press, press);
+	RGFW_keyCallback(_RGFW->root, physicalKey, _RGFW->root->internal.mod,  RGFW_window_isKeyDown(_RGFW->root, (u8)physicalKey), press);
 	if (press) {
 ;		RGFW_keyCharCallback(_RGFW->root, codepoint);
 	}
 }
 
 void EMSCRIPTEN_KEEPALIVE RGFW_handleKeyMods(RGFW_bool capital, RGFW_bool numlock, RGFW_bool control, RGFW_bool alt, RGFW_bool shift, RGFW_bool super, RGFW_bool scroll) {
-	RGFW_keyUpdateKeyModsEx(_RGFW->root, capital, numlock, control, alt, shift, super, scroll);
+	RGFW_updateKeyModsEx(_RGFW->root, capital, numlock, control, alt, shift, super, scroll);
 }
 
-void EMSCRIPTEN_KEEPALIVE Emscripten_onDrop(char* file, size_t size) {
-	RGFW_dataDropCallback(_RGFW->root, file, size, RGFW_dataFile);
+void EMSCRIPTEN_KEEPALIVE Emscripten_onDrop(size_t count) {
+	RGFW_dataDropCallback(_RGFW->root, _RGFW->files, count);
 }
 
-void EMSCRIPTEN_KEEPALIVE RGFW_webFree(void* ptr) { free(ptr); }
-
 void RGFW_stopCheckEvents(void) {
 	_RGFW->stopCheckEvents_bool = RGFW_TRUE;
 }
@@ -15044,6 +14884,14 @@ void RGFW_window_blitSurface(RGFW_window* win, RGFW_surface* surface) {
 
 void RGFW_surface_freePtr(RGFW_surface* surface) { }
 
+void EMSCRIPTEN_KEEPALIVE RGFW_makeSetValue(size_t index, char* file) {
+	/* This seems like a terrible idea, don't replicate this unless you hate yourself or the OS */
+	/* TODO: find a better way to do this
+	*/
+	RGFW_STRNCPY((char*)_RGFW->files[index], file, RGFW_MAX_PATH - 1);
+	_RGFW->files[index][RGFW_MAX_PATH - 1] = '\0';
+}
+
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <errno.h>
@@ -15061,148 +14909,117 @@ void EMSCRIPTEN_KEEPALIVE RGFW_writeFile(const char *path, const char *data, siz
 }
 
 void RGFW_initKeycodesPlatform(void) {
-	_RGFW->keycodes[DOM_VK_BACK_QUOTE] = RGFW_keyBacktick;
-	_RGFW->keycodes[DOM_VK_0] = RGFW_key0;
-	_RGFW->keycodes[DOM_VK_1] = RGFW_key1;
-	_RGFW->keycodes[DOM_VK_2] = RGFW_key2;
-	_RGFW->keycodes[DOM_VK_3] = RGFW_key3;
-	_RGFW->keycodes[DOM_VK_4] = RGFW_key4;
-	_RGFW->keycodes[DOM_VK_5] = RGFW_key5;
-	_RGFW->keycodes[DOM_VK_6] = RGFW_key6;
-	_RGFW->keycodes[DOM_VK_7] = RGFW_key7;
-	_RGFW->keycodes[DOM_VK_8] = RGFW_key8;
-	_RGFW->keycodes[DOM_VK_9] = RGFW_key9;
-	_RGFW->keycodes[DOM_VK_SPACE] = RGFW_keySpace;
-	_RGFW->keycodes[DOM_VK_A] = RGFW_keyA;
-	_RGFW->keycodes[DOM_VK_B] = RGFW_keyB;
-	_RGFW->keycodes[DOM_VK_C] = RGFW_keyC;
-	_RGFW->keycodes[DOM_VK_D] = RGFW_keyD;
-	_RGFW->keycodes[DOM_VK_E] = RGFW_keyE;
-	_RGFW->keycodes[DOM_VK_F] = RGFW_keyF;
-	_RGFW->keycodes[DOM_VK_G] = RGFW_keyG;
-	_RGFW->keycodes[DOM_VK_H] = RGFW_keyH;
-	_RGFW->keycodes[DOM_VK_I] = RGFW_keyI;
-	_RGFW->keycodes[DOM_VK_J] = RGFW_keyJ;
-	_RGFW->keycodes[DOM_VK_K] = RGFW_keyK;
-	_RGFW->keycodes[DOM_VK_L] = RGFW_keyL;
-	_RGFW->keycodes[DOM_VK_M] = RGFW_keyM;
-	_RGFW->keycodes[DOM_VK_N] = RGFW_keyN;
-	_RGFW->keycodes[DOM_VK_O] = RGFW_keyO;
-	_RGFW->keycodes[DOM_VK_P] = RGFW_keyP;
-	_RGFW->keycodes[DOM_VK_Q] = RGFW_keyQ;
-	_RGFW->keycodes[DOM_VK_R] = RGFW_keyR;
-	_RGFW->keycodes[DOM_VK_S] = RGFW_keyS;
-	_RGFW->keycodes[DOM_VK_T] = RGFW_keyT;
-	_RGFW->keycodes[DOM_VK_U] = RGFW_keyU;
-	_RGFW->keycodes[DOM_VK_V] = RGFW_keyV;
-	_RGFW->keycodes[DOM_VK_W] = RGFW_keyW;
-	_RGFW->keycodes[DOM_VK_X] = RGFW_keyX;
-	_RGFW->keycodes[DOM_VK_Y] = RGFW_keyY;
-	_RGFW->keycodes[DOM_VK_Z] = RGFW_keyZ;
-	_RGFW->keycodes[DOM_VK_PERIOD] = RGFW_keyPeriod;
-	_RGFW->keycodes[DOM_VK_COMMA] = RGFW_keyComma;
-	_RGFW->keycodes[DOM_VK_SLASH] = RGFW_keySlash;
-	_RGFW->keycodes[DOM_VK_OPEN_BRACKET] = RGFW_keyBracket;
-	_RGFW->keycodes[DOM_VK_CLOSE_BRACKET] = RGFW_keyCloseBracket;
-	_RGFW->keycodes[DOM_VK_SEMICOLON] = RGFW_keySemicolon;
-	_RGFW->keycodes[DOM_VK_QUOTE] = RGFW_keyApostrophe;
-	_RGFW->keycodes[DOM_VK_BACK_SLASH] = RGFW_keyBackSlash;
-	_RGFW->keycodes[DOM_VK_RETURN] = RGFW_keyReturn;
-	_RGFW->keycodes[DOM_VK_DELETE] = RGFW_keyDelete;
-	_RGFW->keycodes[DOM_VK_NUM_LOCK] = RGFW_keyNumLock;
-	_RGFW->keycodes[DOM_VK_DIVIDE] = RGFW_keyPadSlash;
-	_RGFW->keycodes[DOM_VK_MULTIPLY] = RGFW_keyPadMultiply;
-	_RGFW->keycodes[DOM_VK_SUBTRACT] = RGFW_keyPadMinus;
-	_RGFW->keycodes[DOM_VK_NUMPAD1] = RGFW_keyPad1;
-	_RGFW->keycodes[DOM_VK_NUMPAD2] = RGFW_keyPad2;
-	_RGFW->keycodes[DOM_VK_NUMPAD3] = RGFW_keyPad3;
-	_RGFW->keycodes[DOM_VK_NUMPAD4] = RGFW_keyPad4;
-	_RGFW->keycodes[DOM_VK_NUMPAD5] = RGFW_keyPad5;
-	_RGFW->keycodes[DOM_VK_NUMPAD6] = RGFW_keyPad6;
-	_RGFW->keycodes[DOM_VK_NUMPAD9] = RGFW_keyPad9;
-	_RGFW->keycodes[DOM_VK_NUMPAD0] = RGFW_keyPad0;
-	_RGFW->keycodes[DOM_VK_DECIMAL] = RGFW_keyPadPeriod;
-	_RGFW->keycodes[DOM_VK_RETURN] = RGFW_keyPadReturn;
-	_RGFW->keycodes[DOM_VK_HYPHEN_MINUS] = RGFW_keyMinus;
-	_RGFW->keycodes[DOM_VK_EQUALS] = RGFW_keyEquals;
-	_RGFW->keycodes[DOM_VK_BACK_SPACE] = RGFW_keyBackSpace;
-	_RGFW->keycodes[DOM_VK_TAB] = RGFW_keyTab;
-	_RGFW->keycodes[DOM_VK_CAPS_LOCK] = RGFW_keyCapsLock;
-	_RGFW->keycodes[DOM_VK_SHIFT] = RGFW_keyShiftL;
-	_RGFW->keycodes[DOM_VK_CONTROL] = RGFW_keyControlL;
-	_RGFW->keycodes[DOM_VK_ALT] = RGFW_keyAltL;
-	_RGFW->keycodes[DOM_VK_META] = RGFW_keySuperL;
-	_RGFW->keycodes[DOM_VK_F1] = RGFW_keyF1;
-	_RGFW->keycodes[DOM_VK_F2] = RGFW_keyF2;
-	_RGFW->keycodes[DOM_VK_F3] = RGFW_keyF3;
-	_RGFW->keycodes[DOM_VK_F4] = RGFW_keyF4;
-	_RGFW->keycodes[DOM_VK_F5] = RGFW_keyF5;
-	_RGFW->keycodes[DOM_VK_F6] = RGFW_keyF6;
-	_RGFW->keycodes[DOM_VK_F7] = RGFW_keyF7;
-	_RGFW->keycodes[DOM_VK_F8] = RGFW_keyF8;
-	_RGFW->keycodes[DOM_VK_F9] = RGFW_keyF9;
-	_RGFW->keycodes[DOM_VK_F10] = RGFW_keyF10;
-	_RGFW->keycodes[DOM_VK_F11] = RGFW_keyF11;
-	_RGFW->keycodes[DOM_VK_F12] = RGFW_keyF12;
-	_RGFW->keycodes[DOM_VK_UP] = RGFW_keyUp;
-	_RGFW->keycodes[DOM_VK_DOWN] = RGFW_keyDown;
-	_RGFW->keycodes[DOM_VK_LEFT] = RGFW_keyLeft;
-	_RGFW->keycodes[DOM_VK_RIGHT] = RGFW_keyRight;
-	_RGFW->keycodes[DOM_VK_INSERT] = RGFW_keyInsert;
-	_RGFW->keycodes[DOM_VK_END] = RGFW_keyEnd;
-	_RGFW->keycodes[DOM_VK_PAGE_UP] = RGFW_keyPageUp;
-	_RGFW->keycodes[DOM_VK_PAGE_DOWN] = RGFW_keyPageDown;
-	_RGFW->keycodes[DOM_VK_ESCAPE] = RGFW_keyEscape;
-	_RGFW->keycodes[DOM_VK_HOME] = RGFW_keyHome;
-	_RGFW->keycodes[DOM_VK_SCROLL_LOCK] = RGFW_keyScrollLock;
-	_RGFW->keycodes[DOM_VK_PRINTSCREEN] = RGFW_keyPrintScreen;
-	_RGFW->keycodes[DOM_VK_PAUSE] = RGFW_keyPause;
-	_RGFW->keycodes[DOM_VK_F13]  = RGFW_keyF13;
-	_RGFW->keycodes[DOM_VK_F14]  = RGFW_keyF14;
-	_RGFW->keycodes[DOM_VK_F15]  = RGFW_keyF15;
-	_RGFW->keycodes[DOM_VK_F16]  = RGFW_keyF16;
-	_RGFW->keycodes[DOM_VK_F17]  = RGFW_keyF17;
-	_RGFW->keycodes[DOM_VK_F18]  = RGFW_keyF18;
-	_RGFW->keycodes[DOM_VK_F19]  = RGFW_keyF19;
-	_RGFW->keycodes[DOM_VK_F20]  = RGFW_keyF20;
-	_RGFW->keycodes[DOM_VK_F21]  = RGFW_keyF21;
-	_RGFW->keycodes[DOM_VK_F22]  = RGFW_keyF22;
-	_RGFW->keycodes[DOM_VK_F23]  = RGFW_keyF23;
-	_RGFW->keycodes[DOM_VK_F24]  = RGFW_keyF24;
+	_RGFW->keycodes[DOM_VK_BACK_QUOTE] = RGFW_backtick;
+	_RGFW->keycodes[DOM_VK_0] = RGFW_0;
+	_RGFW->keycodes[DOM_VK_1] = RGFW_1;
+	_RGFW->keycodes[DOM_VK_2] = RGFW_2;
+	_RGFW->keycodes[DOM_VK_3] = RGFW_3;
+	_RGFW->keycodes[DOM_VK_4] = RGFW_4;
+	_RGFW->keycodes[DOM_VK_5] = RGFW_5;
+	_RGFW->keycodes[DOM_VK_6] = RGFW_6;
+	_RGFW->keycodes[DOM_VK_7] = RGFW_7;
+	_RGFW->keycodes[DOM_VK_8] = RGFW_8;
+	_RGFW->keycodes[DOM_VK_9] = RGFW_9;
+	_RGFW->keycodes[DOM_VK_SPACE] = RGFW_space;
+	_RGFW->keycodes[DOM_VK_A] = RGFW_a;
+	_RGFW->keycodes[DOM_VK_B] = RGFW_b;
+	_RGFW->keycodes[DOM_VK_C] = RGFW_c;
+	_RGFW->keycodes[DOM_VK_D] = RGFW_d;
+	_RGFW->keycodes[DOM_VK_E] = RGFW_e;
+	_RGFW->keycodes[DOM_VK_F] = RGFW_f;
+	_RGFW->keycodes[DOM_VK_G] = RGFW_g;
+	_RGFW->keycodes[DOM_VK_H] = RGFW_h;
+	_RGFW->keycodes[DOM_VK_I] = RGFW_i;
+	_RGFW->keycodes[DOM_VK_J] = RGFW_j;
+	_RGFW->keycodes[DOM_VK_K] = RGFW_k;
+	_RGFW->keycodes[DOM_VK_L] = RGFW_l;
+	_RGFW->keycodes[DOM_VK_M] = RGFW_m;
+	_RGFW->keycodes[DOM_VK_N] = RGFW_n;
+	_RGFW->keycodes[DOM_VK_O] = RGFW_o;
+	_RGFW->keycodes[DOM_VK_P] = RGFW_p;
+	_RGFW->keycodes[DOM_VK_Q] = RGFW_q;
+	_RGFW->keycodes[DOM_VK_R] = RGFW_r;
+	_RGFW->keycodes[DOM_VK_S] = RGFW_s;
+	_RGFW->keycodes[DOM_VK_T] = RGFW_t;
+	_RGFW->keycodes[DOM_VK_U] = RGFW_u;
+	_RGFW->keycodes[DOM_VK_V] = RGFW_v;
+	_RGFW->keycodes[DOM_VK_W] = RGFW_w;
+	_RGFW->keycodes[DOM_VK_X] = RGFW_x;
+	_RGFW->keycodes[DOM_VK_Y] = RGFW_y;
+	_RGFW->keycodes[DOM_VK_Z] = RGFW_z;
+	_RGFW->keycodes[DOM_VK_PERIOD] = RGFW_period;
+	_RGFW->keycodes[DOM_VK_COMMA] = RGFW_comma;
+	_RGFW->keycodes[DOM_VK_SLASH] = RGFW_slash;
+	_RGFW->keycodes[DOM_VK_OPEN_BRACKET] = RGFW_bracket;
+	_RGFW->keycodes[DOM_VK_CLOSE_BRACKET] = RGFW_closeBracket;
+	_RGFW->keycodes[DOM_VK_SEMICOLON] = RGFW_semicolon;
+	_RGFW->keycodes[DOM_VK_QUOTE] = RGFW_apostrophe;
+	_RGFW->keycodes[DOM_VK_BACK_SLASH] = RGFW_backSlash;
+	_RGFW->keycodes[DOM_VK_RETURN] = RGFW_return;
+	_RGFW->keycodes[DOM_VK_DELETE] = RGFW_delete;
+	_RGFW->keycodes[DOM_VK_NUM_LOCK] = RGFW_numLock;
+	_RGFW->keycodes[DOM_VK_DIVIDE] = RGFW_kpSlash;
+	_RGFW->keycodes[DOM_VK_MULTIPLY] = RGFW_kpMultiply;
+	_RGFW->keycodes[DOM_VK_SUBTRACT] = RGFW_kpMinus;
+	_RGFW->keycodes[DOM_VK_NUMPAD1] = RGFW_kp1;
+	_RGFW->keycodes[DOM_VK_NUMPAD2] = RGFW_kp2;
+	_RGFW->keycodes[DOM_VK_NUMPAD3] = RGFW_kp3;
+	_RGFW->keycodes[DOM_VK_NUMPAD4] = RGFW_kp4;
+	_RGFW->keycodes[DOM_VK_NUMPAD5] = RGFW_kp5;
+	_RGFW->keycodes[DOM_VK_NUMPAD6] = RGFW_kp6;
+	_RGFW->keycodes[DOM_VK_NUMPAD9] = RGFW_kp9;
+	_RGFW->keycodes[DOM_VK_NUMPAD0] = RGFW_kp0;
+	_RGFW->keycodes[DOM_VK_DECIMAL] = RGFW_kpPeriod;
+	_RGFW->keycodes[DOM_VK_RETURN] = RGFW_kpReturn;
+	_RGFW->keycodes[DOM_VK_HYPHEN_MINUS] = RGFW_minus;
+	_RGFW->keycodes[DOM_VK_EQUALS] = RGFW_equals;
+	_RGFW->keycodes[DOM_VK_BACK_SPACE] = RGFW_backSpace;
+	_RGFW->keycodes[DOM_VK_TAB] = RGFW_tab;
+	_RGFW->keycodes[DOM_VK_CAPS_LOCK] = RGFW_capsLock;
+	_RGFW->keycodes[DOM_VK_SHIFT] = RGFW_shiftL;
+	_RGFW->keycodes[DOM_VK_CONTROL] = RGFW_controlL;
+	_RGFW->keycodes[DOM_VK_ALT] = RGFW_altL;
+	_RGFW->keycodes[DOM_VK_META] = RGFW_superL;
+	_RGFW->keycodes[DOM_VK_F1] = RGFW_F1;
+	_RGFW->keycodes[DOM_VK_F2] = RGFW_F2;
+	_RGFW->keycodes[DOM_VK_F3] = RGFW_F3;
+	_RGFW->keycodes[DOM_VK_F4] = RGFW_F4;
+	_RGFW->keycodes[DOM_VK_F5] = RGFW_F5;
+	_RGFW->keycodes[DOM_VK_F6] = RGFW_F6;
+	_RGFW->keycodes[DOM_VK_F7] = RGFW_F7;
+	_RGFW->keycodes[DOM_VK_F8] = RGFW_F8;
+	_RGFW->keycodes[DOM_VK_F9] = RGFW_F9;
+	_RGFW->keycodes[DOM_VK_F10] = RGFW_F10;
+	_RGFW->keycodes[DOM_VK_F11] = RGFW_F11;
+	_RGFW->keycodes[DOM_VK_F12] = RGFW_F12;
+	_RGFW->keycodes[DOM_VK_UP] = RGFW_up;
+	_RGFW->keycodes[DOM_VK_DOWN] = RGFW_down;
+	_RGFW->keycodes[DOM_VK_LEFT] = RGFW_left;
+	_RGFW->keycodes[DOM_VK_RIGHT] = RGFW_right;
+	_RGFW->keycodes[DOM_VK_INSERT] = RGFW_insert;
+	_RGFW->keycodes[DOM_VK_END] = RGFW_end;
+	_RGFW->keycodes[DOM_VK_PAGE_UP] = RGFW_pageUp;
+	_RGFW->keycodes[DOM_VK_PAGE_DOWN] = RGFW_pageDown;
+	_RGFW->keycodes[DOM_VK_ESCAPE] = RGFW_escape;
+	_RGFW->keycodes[DOM_VK_HOME] = RGFW_home;
+	_RGFW->keycodes[DOM_VK_SCROLL_LOCK] = RGFW_scrollLock;
+	_RGFW->keycodes[DOM_VK_PRINTSCREEN] = RGFW_printScreen;
+	_RGFW->keycodes[DOM_VK_PAUSE] = RGFW_pause;
+	_RGFW->keycodes[DOM_VK_F13]  = RGFW_F13;
+	_RGFW->keycodes[DOM_VK_F14]  = RGFW_F14;
+	_RGFW->keycodes[DOM_VK_F15]  = RGFW_F15;
+	_RGFW->keycodes[DOM_VK_F16]  = RGFW_F16;
+	_RGFW->keycodes[DOM_VK_F17]  = RGFW_F17;
+	_RGFW->keycodes[DOM_VK_F18]  = RGFW_F18;
+	_RGFW->keycodes[DOM_VK_F19]  = RGFW_F19;
+	_RGFW->keycodes[DOM_VK_F20]  = RGFW_F20;
+	_RGFW->keycodes[DOM_VK_F21]  = RGFW_F21;
+	_RGFW->keycodes[DOM_VK_F22]  = RGFW_F22;
+	_RGFW->keycodes[DOM_VK_F23]  = RGFW_F23;
+	_RGFW->keycodes[DOM_VK_F24]  = RGFW_F24;
 }
 
-i32 RGFW_initPlatform(void) {
-	RGFW_monitorNode* node = NULL;
-	RGFW_monitor monitor;
-
-	monitor.name[0] = '\0';
-
-	monitor.x = 0;
-	monitor.y = 0;
-
-	monitor.pixelRatio = EM_ASM_DOUBLE({return window.devicePixelRatio || 1;});
-	monitor.mode.w = EM_ASM_INT({return window.innerWidth || 0;});
-	monitor.mode.h = EM_ASM_INT({return window.innerHeight || 0;});
-
-	monitor.physW = (float)RGFW_ROUND((float)monitor.mode.w * monitor.pixelRatio);
-	monitor.physH = (float)RGFW_ROUND((float)monitor.mode.h * monitor.pixelRatio);
-
-	float dpi = 96.0f * monitor.pixelRatio;
-	monitor.scaleX = dpi / 96.0f;
-	monitor.scaleY = dpi / 96.0f;
-
-	RGFW_splitBPP(32, &monitor.mode);
-
-	monitor.mode.refreshRate = 0;
-
-	node = RGFW_monitors_add(&monitor);
-	if (node != NULL) {
-		_RGFW->monitors.primary = node;
-		RGFW_monitorCallback(_RGFW->root, &node->mon, RGFW_TRUE);
-	}
-
-	return 0;
-}
+i32 RGFW_initPlatform(void) { return 0; }
 
 RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags, RGFW_window* win) {
 	emscripten_set_canvas_element_size("#canvas", win->w, win->h);
@@ -15238,7 +15055,7 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 				}
 
 				Module._RGFW_handleKeyEvent(code, codepoint, 1);
-				Module._RGFW_webFree(code);
+				_free(code);
 			},
 		true);
 		window.addEventListener("keyup",
@@ -15246,7 +15063,7 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 				var code = stringToNewUTF8(event.code);
 				Module._RGFW_handleKeyMods(event.getModifierState("CapsLock"), event.getModifierState("NumLock"), event.getModifierState("Control"), event.getModifierState("Alt"), event.getModifierState("Shift"), event.getModifierState("Meta"), event.getModifierState("ScrollLock"));
 				Module._RGFW_handleKeyEvent(code, 0, 0);
-				Module._RGFW_webFree(code);
+				_free(code);
 			},
 		true);
 	});
@@ -15258,6 +15075,7 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
             if (e.dataTransfer.file < 0)
 				return;
 
+			var filenamesArray = [];
 			var count = e.dataTransfer.files.length;
 
 			/* Read and save the files to emscripten's files */
@@ -15282,12 +15100,19 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 				};
 
 				reader.readAsArrayBuffer(file);
+				/* This works weird on modern OpenGL */
 				var filename = stringToNewUTF8(path);
 
-				Module._Emscripten_onDrop(filename, path.length + 1);
-				free(filename);
+				filenamesArray.push(filename);
+
+				Module._RGFW_makeSetValue(i, filename);
 			}
 
+			Module._Emscripten_onDrop(count);
+
+			for (var i = 0; i < count; i++) {
+				_free(filenamesArray[i]);
+			}
         }, true);
 
         canvas.addEventListener('dragover', function(e) { e.preventDefault(); return false; }, true);
@@ -15300,18 +15125,9 @@ RGFW_key RGFW_physicalToMappedKey(RGFW_key key) {
 	return key;
 }
 
-RGFW_bool RGFW_window_fetchSize(RGFW_window* win, i32* w, i32* h) {
-	return RGFW_window_getSize(win, w, h);
-}
-
 void RGFW_pollEvents(void) {
-	static int using_asyncify = -1;
-	if (using_asyncify == -1) using_asyncify = EM_ASM_INT({ return 'Asyncify' in Module; });
-
 	RGFW_resetPrevState();
-	if (using_asyncify) {
-		emscripten_sleep(0);
-	}
+	emscripten_sleep(0);
 }
 
 void RGFW_window_resize(RGFW_window* win, i32 w, i32 h) {
@@ -15319,7 +15135,16 @@ void RGFW_window_resize(RGFW_window* win, i32 w, i32 h) {
 	emscripten_set_canvas_element_size("#canvas", w, h);
 }
 
-RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon mouse) {
+/* NOTE: I don't know if this is possible */
+void RGFW_window_moveMouse(RGFW_window* win, i32 x, i32 y) { RGFW_UNUSED(win); RGFW_UNUSED(x); RGFW_UNUSED(y); }
+/* this one might be possible but it looks iffy */
+RGFW_mouse* RGFW_loadMouse(u8* data, i32 w, i32 h, RGFW_format format) { RGFW_UNUSED(data); RGFW_UNUSED(w); RGFW_UNUSED(h); RGFW_UNUSED(format); return NULL; }
+
+void RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse) { RGFW_UNUSED(win); RGFW_UNUSED(mouse); }
+void RGFW_freeMouse(RGFW_mouse* mouse) { RGFW_UNUSED(mouse); }
+
+RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, u8 mouse) {
+	RGFW_UNUSED(win);
 	char* cursorName = NULL;
 
 	switch (mouse) {
@@ -15344,25 +15169,16 @@ RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon mouse) {
 		case RGFW_mouseNotAllowed:   cursorName = (char*)"not-allowed"; break;
 		case RGFW_mouseWait:         cursorName = (char*)"wait"; break;
 		case RGFW_mouseProgress:     cursorName = (char*)"progress"; break;
-		default:                     return NULL;
+		default:                     return RGFW_FALSE;
 	}
 
-	return (RGFW_mouse*)cursorName;
-}
-
-/* NOTE: I don't know if this is possible */
-void RGFW_window_moveMouse(RGFW_window* win, i32 x, i32 y) { RGFW_UNUSED(win); RGFW_UNUSED(x); RGFW_UNUSED(y); }
-/* this one might be possible but it looks iffy */
-RGFW_mouse* RGFW_createMouse(u8* data, i32 w, i32 h, RGFW_format format) { RGFW_UNUSED(data); RGFW_UNUSED(w); RGFW_UNUSED(h); RGFW_UNUSED(format); return NULL; }
-
-RGFW_bool RGFW_window_setMousePlatform(RGFW_window* win, RGFW_mouse* mouse) {
-	RGFW_ASSERT(win != NULL);
-	RGFW_ASSERT(mouse != NULL);
-
-	EM_ASM( { document.getElementById("canvas").style.cursor = UTF8ToString($0); }, (char*)mouse);
+	EM_ASM( { document.getElementById("canvas").style.cursor = UTF8ToString($0); }, cursorName);
 	return RGFW_TRUE;
 }
-void RGFW_freeMouse(RGFW_mouse* mouse) { RGFW_UNUSED(mouse); }
+
+RGFW_bool RGFW_window_setMouseDefault(RGFW_window* win) {
+	return RGFW_window_setMouseStandard(win, RGFW_mouseNormal);
+}
 
 void RGFW_window_showMouse(RGFW_window* win, RGFW_bool show) {
 	RGFW_window_showMouseFlags(win, show);
@@ -15416,7 +15232,6 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 	win->src.gfxType = RGFW_gfxNativeOpenGL;
 
 	EmscriptenWebGLContextAttributes attrs;
-	emscripten_webgl_init_context_attributes(&attrs);
 	attrs.alpha = hints->alpha;
 	attrs.depth = hints->depth;
 	attrs.stencil = hints->stencil;
@@ -15430,41 +15245,19 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 		attrs.renderViaOffscreenBackBuffer = hints->auxBuffers;
 
 	attrs.failIfMajorPerformanceCaveat = EM_FALSE;
+	attrs.majorVersion = (hints->major == 0) ? 1 : hints->major;
+	attrs.minorVersion = hints->minor;
 
 	attrs.enableExtensionsByDefault = EM_TRUE;
-
-	if (hints->profile == RGFW_glWeb) {
-		attrs.majorVersion = (hints->major == 0) ? 1 : hints->major;
-		attrs.minorVersion = hints->minor;
-	} else {
-		attrs.majorVersion = (hints->major == 0) ? 1 : ( (hints->major > 1) ? hints->major - 1 : hints->major );
-		attrs.minorVersion = hints->minor;
-	}
-
 	attrs.explicitSwapControl = EM_TRUE;
+
+	emscripten_webgl_init_context_attributes(&attrs);
 	win->src.ctx.native->ctx = emscripten_webgl_create_context("#canvas", &attrs);
-
-	if (win->src.ctx.native->ctx == 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_warningOpenGL, "WebGL: Failed to create an OpenGL Context with explicit swap control.");
-		attrs.explicitSwapControl = EM_FALSE;
-		win->src.ctx.native->ctx = emscripten_webgl_create_context("#canvas", &attrs);
-	}
-
-	if (win->src.ctx.native->ctx == 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create an OpenGL Context with the requested attributes, falling back to defaults.");
-		win->src.ctx.native->ctx = emscripten_webgl_create_context("#canvas", &attrs);
-	}
-
-	if (win->src.ctx.native->ctx == 0) {
-		RGFW_debugCallback(RGFW_typeError, RGFW_errOpenGLContext, "Failed to create an OpenGL Context.");
-		return RGFW_FALSE;
-	}
-
 	emscripten_webgl_make_context_current(win->src.ctx.native->ctx);
 
 	#ifdef LEGACY_GL_EMULATION
 	EM_ASM("Module.useWebGL = true; GLImmediate.init();");
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context initalized.");
     #endif
 
 	RGFW_window_swapInterval_OpenGL(win, 0);
@@ -15475,7 +15268,7 @@ RGFW_bool RGFW_window_createContextPtr_OpenGL(RGFW_window* win, RGFW_glContext*
 void RGFW_window_deleteContextPtr_OpenGL(RGFW_window* win, RGFW_glContext* ctx) {
 	emscripten_webgl_destroy_context(ctx->ctx);
 	win->src.ctx.native->ctx = 0;
-	RGFW_debugCallback(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context freed.");
+	RGFW_sendDebugInfo(RGFW_typeInfo, RGFW_infoOpenGL, "OpenGL context freed.");
 }
 
 void RGFW_window_makeCurrentContext_OpenGL(RGFW_window* win) {
@@ -15550,7 +15343,6 @@ void RGFW_window_maximize(RGFW_window* win) {
 	}
 
 	RGFW_window_move(win, 0, 0);
-	RGFW_window_fetchSize(win, NULL, NULL);
 }
 
 void RGFW_window_setFullscreen(RGFW_window* win, RGFW_bool fullscreen) {
@@ -15587,87 +15379,87 @@ WGPUSurface RGFW_window_createSurface_WebGPU(RGFW_window* window, WGPUInstance i
 
 RGFW_key RGFW_WASMPhysicalToRGFW(u32 hash) {
 	switch(hash) {             /* 0x0000 */
-		case 0x67243A2DU /* Escape             */: return RGFW_keyEscape;               /* 0x0001 */
-		case 0x67251058U /* Digit0             */: return RGFW_key0;                    /* 0x0002 */
-		case 0x67251059U /* Digit1             */: return RGFW_key1;                    /* 0x0003 */
-		case 0x6725105AU /* Digit2             */: return RGFW_key2;                    /* 0x0004 */
-		case 0x6725105BU /* Digit3             */: return RGFW_key3;                    /* 0x0005 */
-		case 0x6725105CU /* Digit4             */: return RGFW_key4;                    /* 0x0006 */
-		case 0x6725105DU /* Digit5             */: return RGFW_key5;                    /* 0x0007 */
-		case 0x6725105EU /* Digit6             */: return RGFW_key6;                    /* 0x0008 */
-		case 0x6725105FU /* Digit7             */: return RGFW_key7;                    /* 0x0009 */
-		case 0x67251050U /* Digit8             */: return RGFW_key8;                    /* 0x000A */
-		case 0x67251051U /* Digit9             */: return RGFW_key9;                    /* 0x000B */
-		case 0x92E14DD3U /* Minus              */: return RGFW_keyMinus;                /* 0x000C */
-		case 0x92E1FBACU /* Equal              */: return RGFW_keyEquals;                /* 0x000D */
-		case 0x36BF1CB5U /* Backspace          */: return RGFW_keyBackSpace;            /* 0x000E */
-		case 0x7B8E51E2U  /* Tab                */: return RGFW_keyTab;                  /* 0x000F */
-		case 0x2C595B51U /* KeyQ               */: return RGFW_keyQ;                    /* 0x0010 */
-		case 0x2C595B57U /* KeyW               */: return RGFW_keyW;                    /* 0x0011 */
-		case 0x2C595B45U /* KeyE               */: return RGFW_keyE;                    /* 0x0012 */
-		case 0x2C595B52U /* KeyR               */: return RGFW_keyR;                    /* 0x0013 */
-		case 0x2C595B54U /* KeyT               */: return RGFW_keyT;                    /* 0x0014 */
-		case 0x2C595B59U /* KeyY               */: return RGFW_keyY;                    /* 0x0015 */
-		case 0x2C595B55U /* KeyU               */: return RGFW_keyU;                    /* 0x0016 */
-		case 0x2C595B4FU /* KeyO               */: return RGFW_keyO;                    /* 0x0018 */
-		case 0x2C595B50U /* KeyP               */: return RGFW_keyP;                    /* 0x0019 */
-		case 0x45D8158CU /* BracketLeft        */: return RGFW_keyCloseBracket;         /* 0x001A */
-		case 0xDEEABF7CU /* BracketRight       */: return RGFW_keyBracket;        /* 0x001B */
-		case 0x92E1C5D2U /* Enter              */: return RGFW_keyReturn;                /* 0x001C */
-		case 0xE058958CU /* ControlLeft        */: return RGFW_keyControlL;         /* 0x001D */
-		case 0x2C595B41U /* KeyA               */: return RGFW_keyA;                    /* 0x001E */
-		case 0x2C595B53U /* KeyS               */: return RGFW_keyS;                    /* 0x001F */
-		case 0x2C595B44U /* KeyD               */: return RGFW_keyD;                    /* 0x0020 */
-		case 0x2C595B46U /* KeyF               */: return RGFW_keyF;                    /* 0x0021 */
-		case 0x2C595B47U /* KeyG               */: return RGFW_keyG;                    /* 0x0022 */
-		case 0x2C595B48U /* KeyH               */: return RGFW_keyH;                    /* 0x0023 */
-		case 0x2C595B4AU /* KeyJ               */: return RGFW_keyJ;                    /* 0x0024 */
-		case 0x2C595B4BU /* KeyK               */: return RGFW_keyK;                    /* 0x0025 */
-		case 0x2C595B4CU /* KeyL               */: return RGFW_keyL;                    /* 0x0026 */
-		case 0x2707219EU /* Semicolon          */: return RGFW_keySemicolon;            /* 0x0027 */
-		case 0x92E0B58DU /* Quote              */: return RGFW_keyApostrophe;                /* 0x0028 */
-		case 0x36BF358DU /* Backquote          */: return RGFW_keyBacktick;            /* 0x0029 */
-		case 0x26B1958CU /* ShiftLeft          */: return RGFW_keyShiftL;           /* 0x002A */
-		case 0x36BF2438U /* Backslash          */: return RGFW_keyBackSlash;            /* 0x002B */
-		case 0x2C595B5AU /* KeyZ               */: return RGFW_keyZ;                    /* 0x002C */
-		case 0x2C595B58U /* KeyX               */: return RGFW_keyX;                    /* 0x002D */
-		case 0x2C595B43U /* KeyC               */: return RGFW_keyC;                    /* 0x002E */
-		case 0x2C595B56U /* KeyV               */: return RGFW_keyV;                    /* 0x002F */
-		case 0x2C595B42U /* KeyB               */: return RGFW_keyB;                    /* 0x0030 */
-		case 0x2C595B4EU /* KeyN               */: return RGFW_keyN;                    /* 0x0031 */
-		case 0x2C595B4DU /* KeyM               */: return RGFW_keyM;                    /* 0x0032 */
-		case 0x92E1A1C1U /* Comma              */: return RGFW_keyComma;                /* 0x0033 */
-		case 0x672FFAD4U /* Period             */: return RGFW_keyPeriod;               /* 0x0034 */
-		case 0x92E0A438U /* Slash              */: return RGFW_keySlash;                /* 0x0035 */
-		case 0xC5A6BF7CU /* ShiftRight         */: return RGFW_keyShiftR;
-		case 0x5D64DA91U /* NumpadMultiply     */: return RGFW_keyPadMultiply;
-		case 0xC914958CU /* AltLeft            */: return RGFW_keyAltL;             /* 0x0038 */
-		case 0x92E09CB5U /* Space              */: return RGFW_keySpace;                /* 0x0039 */
-		case 0xB8FAE73BU  /* CapsLock           */: return RGFW_keyCapsLock;            /* 0x003A */
-		case 0x7174B789U /* F1                 */: return RGFW_keyF1;                   /* 0x003B */
-		case 0x7174B78AU /* F2                 */: return RGFW_keyF2;                   /* 0x003C */
-		case 0x7174B78BU /* F3                 */: return RGFW_keyF3;                   /* 0x003D */
-		case 0x7174B78CU /* F4                 */: return RGFW_keyF4;                   /* 0x003E */
-		case 0x7174B78DU /* F5                 */: return RGFW_keyF5;                   /* 0x003F */
-		case 0x7174B78EU /* F6                 */: return RGFW_keyF6;                   /* 0x0040 */
-		case 0x7174B78FU /* F7                 */: return RGFW_keyF7;                   /* 0x0041 */
-		case 0x7174B780U /* F8                 */: return RGFW_keyF8;                   /* 0x0042 */
-		case 0x7174B781U /* F9                 */: return RGFW_keyF9;                   /* 0x0043 */
-		case 0x7B8E57B0U  /* F10                */: return RGFW_keyF10;                  /* 0x0044 */
-		case 0xC925FCDFU /* Numpad7            */: return RGFW_keyPadMultiply;             /* 0x0047 */
-		case 0xC925FCD0U /* Numpad8            */: return RGFW_keyPad8;             /* 0x0048 */
-		case 0xC925FCD1U /* Numpad9            */: return RGFW_keyPad9;             /* 0x0049 */
-		case 0x5EA3E8A4U /* NumpadSubtract     */: return RGFW_keyMinus;      /* 0x004A */
-		case 0xC925FCDCU /* Numpad4            */: return RGFW_keyPad4;             /* 0x004B */
-		case 0xC925FCDDU /* Numpad5            */: return RGFW_keyPad5;             /* 0x004C */
-		case 0xC925FCDEU /* Numpad6            */: return RGFW_keyPad6;             /* 0x004D */
-		case 0xC925FCD9U /* Numpad1            */: return RGFW_keyPad1;             /* 0x004F */
-		case 0xC925FCDAU /* Numpad2            */: return RGFW_keyPad2;             /* 0x0050 */
-		case 0xC925FCDBU /* Numpad3            */: return RGFW_keyPad3;             /* 0x0051 */
-		case 0xC925FCD8U /* Numpad0            */: return RGFW_keyPad0;             /* 0x0052 */
-		case 0x95852DACU /* NumpadDecimal      */: return RGFW_keyPeriod;       /* 0x0053 */
-		case 0x7B8E57B1U  /* F11                */: return RGFW_keyF11;                  /* 0x0057 */
-		case 0x7B8E57B2U  /* F12                */: return RGFW_keyF12;                  /* 0x0058 */
+		case 0x67243A2DU /* Escape             */: return RGFW_escape;               /* 0x0001 */
+		case 0x67251058U /* Digit0             */: return RGFW_0;                    /* 0x0002 */
+		case 0x67251059U /* Digit1             */: return RGFW_1;                    /* 0x0003 */
+		case 0x6725105AU /* Digit2             */: return RGFW_2;                    /* 0x0004 */
+		case 0x6725105BU /* Digit3             */: return RGFW_3;                    /* 0x0005 */
+		case 0x6725105CU /* Digit4             */: return RGFW_4;                    /* 0x0006 */
+		case 0x6725105DU /* Digit5             */: return RGFW_5;                    /* 0x0007 */
+		case 0x6725105EU /* Digit6             */: return RGFW_6;                    /* 0x0008 */
+		case 0x6725105FU /* Digit7             */: return RGFW_7;                    /* 0x0009 */
+		case 0x67251050U /* Digit8             */: return RGFW_8;                    /* 0x000A */
+		case 0x67251051U /* Digit9             */: return RGFW_9;                    /* 0x000B */
+		case 0x92E14DD3U /* Minus              */: return RGFW_minus;                /* 0x000C */
+		case 0x92E1FBACU /* Equal              */: return RGFW_equals;                /* 0x000D */
+		case 0x36BF1CB5U /* Backspace          */: return RGFW_backSpace;            /* 0x000E */
+		case 0x7B8E51E2U  /* Tab                */: return RGFW_tab;                  /* 0x000F */
+		case 0x2C595B51U /* KeyQ               */: return RGFW_q;                    /* 0x0010 */
+		case 0x2C595B57U /* KeyW               */: return RGFW_w;                    /* 0x0011 */
+		case 0x2C595B45U /* KeyE               */: return RGFW_e;                    /* 0x0012 */
+		case 0x2C595B52U /* KeyR               */: return RGFW_r;                    /* 0x0013 */
+		case 0x2C595B54U /* KeyT               */: return RGFW_t;                    /* 0x0014 */
+		case 0x2C595B59U /* KeyY               */: return RGFW_y;                    /* 0x0015 */
+		case 0x2C595B55U /* KeyU               */: return RGFW_u;                    /* 0x0016 */
+		case 0x2C595B4FU /* KeyO               */: return RGFW_o;                    /* 0x0018 */
+		case 0x2C595B50U /* KeyP               */: return RGFW_p;                    /* 0x0019 */
+		case 0x45D8158CU /* BracketLeft        */: return RGFW_closeBracket;         /* 0x001A */
+		case 0xDEEABF7CU /* BracketRight       */: return RGFW_bracket;        /* 0x001B */
+		case 0x92E1C5D2U /* Enter              */: return RGFW_return;                /* 0x001C */
+		case 0xE058958CU /* ControlLeft        */: return RGFW_controlL;         /* 0x001D */
+		case 0x2C595B41U /* KeyA               */: return RGFW_a;                    /* 0x001E */
+		case 0x2C595B53U /* KeyS               */: return RGFW_s;                    /* 0x001F */
+		case 0x2C595B44U /* KeyD               */: return RGFW_d;                    /* 0x0020 */
+		case 0x2C595B46U /* KeyF               */: return RGFW_f;                    /* 0x0021 */
+		case 0x2C595B47U /* KeyG               */: return RGFW_g;                    /* 0x0022 */
+		case 0x2C595B48U /* KeyH               */: return RGFW_h;                    /* 0x0023 */
+		case 0x2C595B4AU /* KeyJ               */: return RGFW_j;                    /* 0x0024 */
+		case 0x2C595B4BU /* KeyK               */: return RGFW_k;                    /* 0x0025 */
+		case 0x2C595B4CU /* KeyL               */: return RGFW_l;                    /* 0x0026 */
+		case 0x2707219EU /* Semicolon          */: return RGFW_semicolon;            /* 0x0027 */
+		case 0x92E0B58DU /* Quote              */: return RGFW_apostrophe;                /* 0x0028 */
+		case 0x36BF358DU /* Backquote          */: return RGFW_backtick;            /* 0x0029 */
+		case 0x26B1958CU /* ShiftLeft          */: return RGFW_shiftL;           /* 0x002A */
+		case 0x36BF2438U /* Backslash          */: return RGFW_backSlash;            /* 0x002B */
+		case 0x2C595B5AU /* KeyZ               */: return RGFW_z;                    /* 0x002C */
+		case 0x2C595B58U /* KeyX               */: return RGFW_x;                    /* 0x002D */
+		case 0x2C595B43U /* KeyC               */: return RGFW_c;                    /* 0x002E */
+		case 0x2C595B56U /* KeyV               */: return RGFW_v;                    /* 0x002F */
+		case 0x2C595B42U /* KeyB               */: return RGFW_b;                    /* 0x0030 */
+		case 0x2C595B4EU /* KeyN               */: return RGFW_n;                    /* 0x0031 */
+		case 0x2C595B4DU /* KeyM               */: return RGFW_m;                    /* 0x0032 */
+		case 0x92E1A1C1U /* Comma              */: return RGFW_comma;                /* 0x0033 */
+		case 0x672FFAD4U /* Period             */: return RGFW_period;               /* 0x0034 */
+		case 0x92E0A438U /* Slash              */: return RGFW_slash;                /* 0x0035 */
+		case 0xC5A6BF7CU /* ShiftRight         */: return RGFW_shiftR;
+		case 0x5D64DA91U /* NumpadMultiply     */: return RGFW_kpMultiply;
+		case 0xC914958CU /* AltLeft            */: return RGFW_altL;             /* 0x0038 */
+		case 0x92E09CB5U /* Space              */: return RGFW_space;                /* 0x0039 */
+		case 0xB8FAE73BU  /* CapsLock           */: return RGFW_capsLock;            /* 0x003A */
+		case 0x7174B789U /* F1                 */: return RGFW_F1;                   /* 0x003B */
+		case 0x7174B78AU /* F2                 */: return RGFW_F2;                   /* 0x003C */
+		case 0x7174B78BU /* F3                 */: return RGFW_F3;                   /* 0x003D */
+		case 0x7174B78CU /* F4                 */: return RGFW_F4;                   /* 0x003E */
+		case 0x7174B78DU /* F5                 */: return RGFW_F5;                   /* 0x003F */
+		case 0x7174B78EU /* F6                 */: return RGFW_F6;                   /* 0x0040 */
+		case 0x7174B78FU /* F7                 */: return RGFW_F7;                   /* 0x0041 */
+		case 0x7174B780U /* F8                 */: return RGFW_F8;                   /* 0x0042 */
+		case 0x7174B781U /* F9                 */: return RGFW_F9;                   /* 0x0043 */
+		case 0x7B8E57B0U  /* F10                */: return RGFW_F10;                  /* 0x0044 */
+		case 0xC925FCDFU /* Numpad7            */: return RGFW_kpMultiply;             /* 0x0047 */
+		case 0xC925FCD0U /* Numpad8            */: return RGFW_kp8;             /* 0x0048 */
+		case 0xC925FCD1U /* Numpad9            */: return RGFW_kp9;             /* 0x0049 */
+		case 0x5EA3E8A4U /* NumpadSubtract     */: return RGFW_minus;      /* 0x004A */
+		case 0xC925FCDCU /* Numpad4            */: return RGFW_kp4;             /* 0x004B */
+		case 0xC925FCDDU /* Numpad5            */: return RGFW_kp5;             /* 0x004C */
+		case 0xC925FCDEU /* Numpad6            */: return RGFW_kp6;             /* 0x004D */
+		case 0xC925FCD9U /* Numpad1            */: return RGFW_kp1;             /* 0x004F */
+		case 0xC925FCDAU /* Numpad2            */: return RGFW_kp2;             /* 0x0050 */
+		case 0xC925FCDBU /* Numpad3            */: return RGFW_kp3;             /* 0x0051 */
+		case 0xC925FCD8U /* Numpad0            */: return RGFW_kp0;             /* 0x0052 */
+		case 0x95852DACU /* NumpadDecimal      */: return RGFW_period;       /* 0x0053 */
+		case 0x7B8E57B1U  /* F11                */: return RGFW_F11;                  /* 0x0057 */
+		case 0x7B8E57B2U  /* F12                */: return RGFW_F12;                  /* 0x0058 */
 		case 0x7B8E57B3U /* F13                */: return DOM_PK_F13;                  /* 0x0064 */
 		case 0x7B8E57B4U /* F14                */: return DOM_PK_F14;                  /* 0x0065 */
 		case 0x7B8E57B5U /* F15                */: return DOM_PK_F15;                  /* 0x0066 */
@@ -15679,21 +15471,21 @@ RGFW_key RGFW_WASMPhysicalToRGFW(u32 hash) {
 		case 0x7B8E57A9U /* F21                */: return DOM_PK_F21;                  /* 0x006C */
 		case 0x7B8E57AAU /* F22                */: return DOM_PK_F22;                  /* 0x006D */
 		case 0x7B8E57ABU /* F23                */: return DOM_PK_F23;                  /* 0x006E */
-		case 0x7393FBACU /* NumpadEqual        */: return RGFW_keyPadReturn;
-		case 0xB88EBF7CU  /* AltRight           */: return RGFW_keyAltR;            /* 0xE038 */
-		case 0xC925873BU /* NumLock            */: return RGFW_keyNumLock;             /* 0xE045 */
-		case 0x2C595F45U /* Home               */: return RGFW_keyHome;                 /* 0xE047 */
-		case 0xC91BB690U /* ArrowUp            */: return RGFW_keyUp;             /* 0xE048 */
-		case 0x672F9210U /* PageUp             */: return RGFW_keyPageUp;              /* 0xE049 */
-		case 0x3799258CU /* ArrowLeft          */: return RGFW_keyLeft;           /* 0xE04B */
-		case 0x4CE33F7CU /* ArrowRight         */: return RGFW_keyRight;          /* 0xE04D */
-		case 0x7B8E55DCU  /* End                */: return RGFW_keyEnd;                  /* 0xE04F */
-		case 0x3799379EU /* ArrowDown          */: return RGFW_keyDown;           /* 0xE050 */
-		case 0xBA90179EU /* PageDown           */: return RGFW_keyPageDown;            /* 0xE051 */
-		case 0x6723CB2CU /* Insert             */: return RGFW_keyInsert;               /* 0xE052 */
-		case 0x6725C50DU /* Delete             */: return RGFW_keyDelete;               /* 0xE053 */
-		case 0x6723658CU /* OSLeft             */: return RGFW_keySuperL;              /* 0xE05B */
-		case 0x39643F7CU /* MetaRight          */: return RGFW_keySuperR;           /* 0xE05C */
+		case 0x7393FBACU /* NumpadEqual        */: return RGFW_kpReturn;
+		case 0xB88EBF7CU  /* AltRight           */: return RGFW_altR;            /* 0xE038 */
+		case 0xC925873BU /* NumLock            */: return RGFW_numLock;             /* 0xE045 */
+		case 0x2C595F45U /* Home               */: return RGFW_home;                 /* 0xE047 */
+		case 0xC91BB690U /* ArrowUp            */: return RGFW_up;             /* 0xE048 */
+		case 0x672F9210U /* PageUp             */: return RGFW_pageUp;              /* 0xE049 */
+		case 0x3799258CU /* ArrowLeft          */: return RGFW_left;           /* 0xE04B */
+		case 0x4CE33F7CU /* ArrowRight         */: return RGFW_right;          /* 0xE04D */
+		case 0x7B8E55DCU  /* End                */: return RGFW_end;                  /* 0xE04F */
+		case 0x3799379EU /* ArrowDown          */: return RGFW_down;           /* 0xE050 */
+		case 0xBA90179EU /* PageDown           */: return RGFW_pageDown;            /* 0xE051 */
+		case 0x6723CB2CU /* Insert             */: return RGFW_insert;               /* 0xE052 */
+		case 0x6725C50DU /* Delete             */: return RGFW_delete;               /* 0xE053 */
+		case 0x6723658CU /* OSLeft             */: return RGFW_superL;              /* 0xE05B */
+		case 0x39643F7CU /* MetaRight          */: return RGFW_superR;           /* 0xE05C */
 		case 0x380B9C8CU /* NumpadAdd          */: return DOM_PK_NUMPAD_ADD;           /* 0x004E */
 		default: return DOM_PK_UNKNOWN;
 	}
@@ -15701,13 +15493,7 @@ RGFW_key RGFW_WASMPhysicalToRGFW(u32 hash) {
 	return 0;
 }
 
-RGFW_monitor* RGFW_window_getMonitor(RGFW_window* win) {
-	RGFW_UNUSED(win);
-	return RGFW_getPrimaryMonitor();
-}
-
 /* unsupported functions */
-void RGFW_pollMonitors(void) { }
 void RGFW_window_focus(RGFW_window* win) { RGFW_UNUSED(win); }
 void RGFW_window_raise(RGFW_window* win) { RGFW_UNUSED(win); }
 RGFW_bool RGFW_monitor_requestMode(RGFW_monitor* mon, RGFW_monitorMode* mode, RGFW_modeRequest request) { RGFW_UNUSED(mon); RGFW_UNUSED(mode); RGFW_UNUSED(request); return RGFW_FALSE; }
@@ -15716,6 +15502,7 @@ size_t RGFW_monitor_getGammaRampPtr(RGFW_monitor* monitor, RGFW_gammaRamp* ramp)
 RGFW_bool RGFW_monitor_setGammaRamp(RGFW_monitor* monitor, RGFW_gammaRamp* ramp) { RGFW_UNUSED(monitor); RGFW_UNUSED(ramp); return RGFW_FALSE; }
 size_t RGFW_monitor_getModesPtr(RGFW_monitor* mon, RGFW_monitorMode** modes) { RGFW_UNUSED(mon); RGFW_UNUSED(modes); return 0; }
 RGFW_bool RGFW_monitor_setMode(RGFW_monitor* mon, RGFW_monitorMode* mode) { RGFW_UNUSED(mon); RGFW_UNUSED(mode); return RGFW_FALSE; }
+void RGFW_pollMonitors(void) { }
 void RGFW_window_move(RGFW_window* win, i32 x, i32 y) { RGFW_UNUSED(win);  RGFW_UNUSED(x); RGFW_UNUSED(y);  }
 void RGFW_window_setAspectRatio(RGFW_window* win, i32 w, i32 h) { RGFW_UNUSED(win);  RGFW_UNUSED(w); RGFW_UNUSED(h);  }
 void RGFW_window_setMinSize(RGFW_window* win, i32 w, i32 h) { RGFW_UNUSED(win); RGFW_UNUSED(w); RGFW_UNUSED(h);  }
@@ -15732,6 +15519,7 @@ RGFW_bool RGFW_window_isHidden(RGFW_window* win) { RGFW_UNUSED(win); return RGFW
 RGFW_bool RGFW_window_isMinimized(RGFW_window* win) { RGFW_UNUSED(win); return RGFW_FALSE; }
 RGFW_bool RGFW_window_isMaximized(RGFW_window* win) { RGFW_UNUSED(win); return RGFW_FALSE; }
 RGFW_bool RGFW_window_isFloating(RGFW_window* win) { RGFW_UNUSED(win); return RGFW_FALSE; }
+RGFW_monitor* RGFW_window_getMonitor(RGFW_window* win) { RGFW_UNUSED(win); return NULL; }
 void RGFW_waitForEvent(i32 waitMS) { RGFW_UNUSED(waitMS); }
 #endif
 
@@ -15745,7 +15533,6 @@ typedef RGFW_window* (*RGFW_createWindowPlatform_ptr)(const char* name, RGFW_win
 typedef RGFW_bool (*RGFW_getMouse_ptr)(i32* x, i32* y);
 typedef RGFW_key (*RGFW_physicalToMappedKey_ptr)(RGFW_key key);
 typedef void (*RGFW_pollEvents_ptr)(void);
-typedef RGFW_bool (*RGFW_window_fetchSize_ptr)(RGFW_window* win, i32* w, i32* h);
 typedef void (*RGFW_pollMonitors_ptr)(void);
 typedef void (*RGFW_window_move_ptr)(RGFW_window* win, i32 x, i32 y);
 typedef void (*RGFW_window_resize_ptr)(RGFW_window* win, i32 w, i32 h);
@@ -15764,10 +15551,11 @@ typedef RGFW_bool (*RGFW_window_isFloating_ptr)(RGFW_window* win);
 typedef void (*RGFW_window_setName_ptr)(RGFW_window* win, const char* name);
 typedef void (*RGFW_window_setMousePassthrough_ptr)(RGFW_window* win, RGFW_bool passthrough);
 typedef RGFW_bool (*RGFW_window_setIconEx_ptr)(RGFW_window* win, u8* data, i32 w, i32 h, RGFW_format format, u8 type);
-typedef RGFW_mouse* (*RGFW_createMouse_ptr)(u8* data, i32 w, i32 h, RGFW_format format);
-typedef RGFW_mouse* (*RGFW_createMouseStandard_ptr)(RGFW_mouseIcon icons);
-typedef RGFW_bool (*RGFW_window_setMousePlatform_ptr)(RGFW_window* win, RGFW_mouse* mouse);
+typedef RGFW_mouse* (*RGFW_loadMouse_ptr)(u8* data, i32 w, i32 h, RGFW_format format);
+typedef void (*RGFW_window_setMouse_ptr)(RGFW_window* win, RGFW_mouse* mouse);
 typedef void (*RGFW_window_moveMouse_ptr)(RGFW_window* win, i32 x, i32 y);
+typedef RGFW_bool (*RGFW_window_setMouseDefault_ptr)(RGFW_window* win);
+typedef RGFW_bool (*RGFW_window_setMouseStandard_ptr)(RGFW_window* win, u8 mouse);
 typedef void (*RGFW_window_hide_ptr)(RGFW_window* win);
 typedef void (*RGFW_window_show_ptr)(RGFW_window* win);
 typedef void (*RGFW_window_flash_ptr)(RGFW_window* win, RGFW_flashRequest request);
@@ -15819,8 +15607,7 @@ typedef struct RGFW_FunctionPointers {
     RGFW_createWindowPlatform_ptr createWindowPlatform;
     RGFW_getMouse_ptr getGlobalMouse;
 	RGFW_physicalToMappedKey_ptr physicalToMappedKey;
-    RGFW_window_fetchSize_ptr window_fetchSize;
-	RGFW_pollEvents_ptr pollEvents;
+    RGFW_pollEvents_ptr pollEvents;
     RGFW_pollMonitors_ptr pollMonitors;
     RGFW_window_move_ptr window_move;
     RGFW_window_resize_ptr window_resize;
@@ -15839,10 +15626,11 @@ typedef struct RGFW_FunctionPointers {
     RGFW_window_setName_ptr window_setName;
     RGFW_window_setMousePassthrough_ptr window_setMousePassthrough;
     RGFW_window_setIconEx_ptr window_setIconEx;
-    RGFW_createMouse_ptr createMouse;
-    RGFW_createMouseStandard_ptr createMouseStandard;
-    RGFW_window_setMousePlatform_ptr window_setMousePlatform;
+    RGFW_loadMouse_ptr loadMouse;
+    RGFW_window_setMouse_ptr window_setMouse;
     RGFW_window_moveMouse_ptr window_moveMouse;
+    RGFW_window_setMouseDefault_ptr window_setMouseDefault;
+    RGFW_window_setMouseStandard_ptr window_setMouseStandard;
     RGFW_window_hide_ptr window_hide;
     RGFW_window_show_ptr window_show;
     RGFW_window_flash_ptr window_flash;
@@ -15888,7 +15676,6 @@ RGFW_window* RGFW_createWindowPlatform(const char* name, RGFW_windowFlags flags,
 RGFW_bool RGFW_getGlobalMouse(i32* x, i32* y) { return RGFW_api.getGlobalMouse(x, y); }
 RGFW_key RGFW_physicalToMappedKey(RGFW_key key) { return RGFW_api.physicalToMappedKey(key); }
 void RGFW_pollEvents(void) { RGFW_api.pollEvents(); }
-RGFW_bool RGFW_window_fetchSize(RGFW_window* win, i32* w, i32* h) { return RGFW_api.window_fetchSize(win, w, h); }
 void RGFW_pollMonitors(void) { RGFW_api.pollMonitors(); }
 void RGFW_window_move(RGFW_window* win, i32 x, i32 y) { RGFW_api.window_move(win, x, y); }
 void RGFW_window_resize(RGFW_window* win, i32 w, i32 h) { RGFW_api.window_resize(win, w, h); }
@@ -15911,10 +15698,11 @@ void RGFW_window_setMousePassthrough(RGFW_window* win, RGFW_bool passthrough) {
 #endif
 
 RGFW_bool RGFW_window_setIconEx(RGFW_window* win, u8* data, i32 w, i32 h, RGFW_format format, u8 type) { return RGFW_api.window_setIconEx(win, data, w, h, format, type); }
-RGFW_mouse* RGFW_createMouse(u8* data, i32 w, i32 h, RGFW_format format) { return RGFW_api.createMouse(data, w, h, format); }
-RGFW_mouse* RGFW_createMouseStandard(RGFW_mouseIcon icon) { return RGFW_api.createMouseStandard(icon); }
-RGFW_bool RGFW_window_setMousePlatform(RGFW_window* win, RGFW_mouse* mouse) { return RGFW_api.window_setMousePlatform(win, mouse); }
+RGFW_mouse* RGFW_loadMouse(u8* data, i32 w, i32 h, RGFW_format format) { return RGFW_api.loadMouse(data, w, h, format); }
+void RGFW_window_setMouse(RGFW_window* win, RGFW_mouse* mouse) { RGFW_api.window_setMouse(win, mouse); }
 void RGFW_window_moveMouse(RGFW_window* win, i32 x, i32 y) { RGFW_api.window_moveMouse(win, x, y); }
+RGFW_bool RGFW_window_setMouseDefault(RGFW_window* win) { return RGFW_api.window_setMouseDefault(win); }
+RGFW_bool RGFW_window_setMouseStandard(RGFW_window* win, u8 mouse) { return RGFW_api.window_setMouseStandard(win, mouse); }
 void RGFW_window_hide(RGFW_window* win) { RGFW_api.window_hide(win); }
 void RGFW_window_show(RGFW_window* win) { RGFW_api.window_show(win); }
 void RGFW_window_flash(RGFW_window* win, RGFW_flashRequest request) { RGFW_api.window_flash(win, request); }
@@ -15967,7 +15755,6 @@ void RGFW_load_X11(void) {
     RGFW_api.getGlobalMouse = RGFW_getGlobalMouse_X11;
     RGFW_api.physicalToMappedKey = RGFW_physicalToMappedKey_X11;
     RGFW_api.pollEvents = RGFW_pollEvents_X11;
-    RGFW_api.window_fetchSize = RGFW_window_fetchSize_X11;
     RGFW_api.pollMonitors = RGFW_pollMonitors_X11;
     RGFW_api.window_move = RGFW_window_move_X11;
     RGFW_api.window_resize = RGFW_window_resize_X11;
@@ -15988,10 +15775,11 @@ void RGFW_load_X11(void) {
     RGFW_api.window_setMousePassthrough = RGFW_window_setMousePassthrough_X11;
 #endif
     RGFW_api.window_setIconEx = RGFW_window_setIconEx_X11;
-    RGFW_api.createMouse = RGFW_createMouse_X11;
-	RGFW_api.createMouseStandard = RGFW_createMouseStandard_X11;
-    RGFW_api.window_setMousePlatform = RGFW_window_setMousePlatform_X11;
+    RGFW_api.loadMouse = RGFW_loadMouse_X11;
+    RGFW_api.window_setMouse = RGFW_window_setMouse_X11;
     RGFW_api.window_moveMouse = RGFW_window_moveMouse_X11;
+    RGFW_api.window_setMouseDefault = RGFW_window_setMouseDefault_X11;
+    RGFW_api.window_setMouseStandard = RGFW_window_setMouseStandard_X11;
     RGFW_api.window_hide = RGFW_window_hide_X11;
     RGFW_api.window_show = RGFW_window_show_X11;
     RGFW_api.window_flash = RGFW_window_flash_X11;
@@ -16035,7 +15823,6 @@ void RGFW_load_Wayland(void) {
     RGFW_api.getGlobalMouse = RGFW_getGlobalMouse_Wayland;
     RGFW_api.physicalToMappedKey = RGFW_physicalToMappedKey_Wayland;
     RGFW_api.pollEvents = RGFW_pollEvents_Wayland;
-    RGFW_api.window_fetchSize = RGFW_window_fetchSize_Wayland;
     RGFW_api.pollMonitors = RGFW_pollMonitors_Wayland;
     RGFW_api.window_move = RGFW_window_move_Wayland;
     RGFW_api.window_resize = RGFW_window_resize_Wayland;
@@ -16056,10 +15843,11 @@ void RGFW_load_Wayland(void) {
     RGFW_api.window_setMousePassthrough = RGFW_window_setMousePassthrough_Wayland;
 #endif
     RGFW_api.window_setIconEx = RGFW_window_setIconEx_Wayland;
-    RGFW_api.createMouse = RGFW_createMouse_Wayland;
-	RGFW_api.createMouseStandard = RGFW_createMouseStandard_Wayland;
-    RGFW_api.window_setMousePlatform = RGFW_window_setMousePlatform_Wayland;
+	RGFW_api.loadMouse = RGFW_loadMouse_Wayland;
+    RGFW_api.window_setMouse = RGFW_window_setMouse_Wayland;
     RGFW_api.window_moveMouse = RGFW_window_moveMouse_Wayland;
+    RGFW_api.window_setMouseDefault = RGFW_window_setMouseDefault_Wayland;
+    RGFW_api.window_setMouseStandard = RGFW_window_setMouseStandard_Wayland;
     RGFW_api.window_hide = RGFW_window_hide_Wayland;
     RGFW_api.window_show = RGFW_window_show_Wayland;
     RGFW_api.window_flash = RGFW_window_flash_X11;
diff --git a/src/libraries/raylib/raylib/src/external/dr_flac.h b/src/libraries/raylib/raylib/src/external/dr_flac.h
index 72bc6b7..2891194 100644
--- a/src/libraries/raylib/raylib/src/external/dr_flac.h
+++ b/src/libraries/raylib/raylib/src/external/dr_flac.h
@@ -1,6 +1,6 @@
 /*
 FLAC audio decoder. Choice of public domain or MIT-0. See license statements at the end of this file.
-dr_flac - v0.13.4 - TBD
+dr_flac - v0.13.3 - 2026-01-17
 
 David Reid - mackron@gmail.com
 
@@ -126,7 +126,7 @@ extern "C" {
 
 #define DRFLAC_VERSION_MAJOR     0
 #define DRFLAC_VERSION_MINOR     13
-#define DRFLAC_VERSION_REVISION  4
+#define DRFLAC_VERSION_REVISION  3
 #define DRFLAC_VERSION_STRING    DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MAJOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MINOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_REVISION)
 
 #include <stddef.h> /* For size_t. */
@@ -1547,8 +1547,6 @@ static DRFLAC_INLINE drflac_bool32 drflac_has_sse41(void)
 #define DRFLAC_ZERO_OBJECT(p)               DRFLAC_ZERO_MEMORY((p), sizeof(*(p)))
 #endif
 
-#define DRFLAC_MIN(a, b)                    (((a) < (b)) ? (a) : (b))
-
 #define DRFLAC_MAX_SIMD_VECTOR_SIZE                     64  /* 64 for AVX-512 in the future. */
 
 /* Result Codes */
@@ -5982,6 +5980,8 @@ static drflac_bool32 drflac__seek_to_pcm_frame__binary_search_internal(drflac* p
                     break;  /* Failed to seek to FLAC frame. */
                 }
             } else {
+                const float approxCompressionRatio = (drflac_int64)(lastSuccessfulSeekOffset - pFlac->firstFLACFramePosInBytes) / ((drflac_int64)(pcmRangeLo * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+
                 if (pcmRangeLo > pcmFrameIndex) {
                     /* We seeked too far forward. We need to move our target byte backward and try again. */
                     byteRangeHi = lastSuccessfulSeekOffset;
@@ -6004,14 +6004,12 @@ static drflac_bool32 drflac__seek_to_pcm_frame__binary_search_internal(drflac* p
                             break;  /* Failed to seek to FLAC frame. */
                         }
                     } else {
-                        const double approxCompressionRatio = (drflac_int64)(lastSuccessfulSeekOffset - pFlac->firstFLACFramePosInBytes) / ((drflac_int64)(pcmRangeLo * pFlac->channels * pFlac->bitsPerSample)/8.0);
-
                         byteRangeLo = lastSuccessfulSeekOffset;
                         if (byteRangeHi < byteRangeLo) {
                             byteRangeHi = byteRangeLo;
                         }
 
-                        targetByte = lastSuccessfulSeekOffset + (drflac_uint64)(((drflac_int64)((pcmFrameIndex-pcmRangeLo) * pFlac->channels * pFlac->bitsPerSample)/8.0) * approxCompressionRatio);
+                        targetByte = lastSuccessfulSeekOffset + (drflac_uint64)(((drflac_int64)((pcmFrameIndex-pcmRangeLo) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * approxCompressionRatio);
                         if (targetByte > byteRangeHi) {
                             targetByte = byteRangeHi;
                         }
@@ -6404,7 +6402,7 @@ static void* drflac__realloc_from_callbacks(void* p, size_t szNew, size_t szOld,
         }
 
         if (p != NULL) {
-            DRFLAC_COPY_MEMORY(p2, p, DRFLAC_MIN(szNew, szOld));
+            DRFLAC_COPY_MEMORY(p2, p, szOld);
             pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
         }
 
@@ -6432,22 +6430,11 @@ static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, d
     We want to keep track of the byte position in the stream of the seektable. At the time of calling this function we know that
     we'll be sitting on byte 42.
     */
-    drflac_uint64 runningFilePos   = 42;
-    drflac_uint64 seektablePos     = 0;
-    drflac_uint32 seektableSize    = 0;
-    drflac_int64  fileSize         = 0;
-    drflac_bool32 hasKnownFileSize = DRFLAC_FALSE;
+    drflac_uint64 runningFilePos = 42;
+    drflac_uint64 seektablePos   = 0;
+    drflac_uint32 seektableSize  = 0;
 
-    /* We'll be doing some memory allocations here against untrusted data. We'll do a basic validation check that they don't exceed the size of the file. */
-    if (onTell != NULL && onSeek != NULL) {
-        if (onSeek(pUserData, 0, DRFLAC_SEEK_END)) {
-            if (onTell(pUserData, &fileSize)) {
-                hasKnownFileSize = DRFLAC_TRUE;
-            }
-
-            onSeek(pUserData, runningFilePos, DRFLAC_SEEK_SET);
-        }
-    }
+    (void)onTell;
 
     for (;;) {
         drflac_metadata metadata;
@@ -6457,11 +6444,6 @@ static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, d
         if (drflac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize) == DRFLAC_FALSE) {
             return DRFLAC_FALSE;
         }
-
-        if (hasKnownFileSize && (blockSize > ((drflac_uint64)fileSize - runningFilePos))) {
-            return DRFLAC_FALSE;    /* Block size exceeds the size of the file. */
-        }
-
         runningFilePos += 4;
 
         metadata.type = blockType;
@@ -6577,7 +6559,7 @@ static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, d
                         drflac__free_from_callbacks(pRawData, pAllocationCallbacks);
                         return DRFLAC_FALSE;
                     }
-                    metadata.data.vorbis_comment.vendor       = pRunningData;                                   pRunningData += metadata.data.vorbis_comment.vendorLength;
+                    metadata.data.vorbis_comment.vendor       = pRunningData;                                            pRunningData += metadata.data.vorbis_comment.vendorLength;
                     metadata.data.vorbis_comment.commentCount = drflac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
 
                     /* Need space for 'commentCount' comments after the block, which at minimum is a drflac_uint32 per comment */
@@ -6765,18 +6747,13 @@ static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, d
                     blockSizeRemaining -= 4;
                     metadata.data.picture.mimeLength = drflac__be2host_32(metadata.data.picture.mimeLength);
 
-                    if (blockSizeRemaining < metadata.data.picture.mimeLength) {
-                        result = DRFLAC_FALSE;
-                        goto done_flac;
-                    }
-
                     pMime = (char*)drflac__malloc_from_callbacks(metadata.data.picture.mimeLength + 1, pAllocationCallbacks); /* +1 for null terminator. */
                     if (pMime == NULL) {
                         result = DRFLAC_FALSE;
                         goto done_flac;
                     }
 
-                    if (onRead(pUserData, pMime, metadata.data.picture.mimeLength) != metadata.data.picture.mimeLength) {
+                    if (blockSizeRemaining < metadata.data.picture.mimeLength || onRead(pUserData, pMime, metadata.data.picture.mimeLength) != metadata.data.picture.mimeLength) {
                         result = DRFLAC_FALSE;
                         goto done_flac;
                     }
@@ -6792,18 +6769,13 @@ static drflac_bool32 drflac__read_and_decode_metadata(drflac_read_proc onRead, d
                     blockSizeRemaining -= 4;
                     metadata.data.picture.descriptionLength = drflac__be2host_32(metadata.data.picture.descriptionLength);
 
-                    if (blockSizeRemaining < metadata.data.picture.descriptionLength) {
-                        result = DRFLAC_FALSE;
-                        goto done_flac;
-                    }
-
                     pDescription = (char*)drflac__malloc_from_callbacks(metadata.data.picture.descriptionLength + 1, pAllocationCallbacks); /* +1 for null terminator. */
                     if (pDescription == NULL) {
                         result = DRFLAC_FALSE;
                         goto done_flac;
                     }
 
-                    if (onRead(pUserData, pDescription, metadata.data.picture.descriptionLength) != metadata.data.picture.descriptionLength) {
+                    if (blockSizeRemaining < metadata.data.picture.descriptionLength || onRead(pUserData, pDescription, metadata.data.picture.descriptionLength) != metadata.data.picture.descriptionLength) {
                         result = DRFLAC_FALSE;
                         goto done_flac;
                     }
@@ -8122,17 +8094,11 @@ static drflac* drflac_open_with_metadata_private(drflac_read_proc onRead, drflac
             return NULL;
         }
 
-        if ((0xFFFFFFFF - (seekpointCount * sizeof(drflac_seekpoint))) < allocationSize) {
-        #ifndef DR_FLAC_NO_OGG
-            drflac__free_from_callbacks(pOggbs, &allocationCallbacks);
-        #endif
-            return NULL;
-        }
-
         allocationSize += seekpointCount * sizeof(drflac_seekpoint);
     }
 
-    pFlac = (drflac*)drflac__malloc_from_callbacks((size_t)allocationSize, &allocationCallbacks);
+
+    pFlac = (drflac*)drflac__malloc_from_callbacks(allocationSize, &allocationCallbacks);
     if (pFlac == NULL) {
     #ifndef DR_FLAC_NO_OGG
         drflac__free_from_callbacks(pOggbs, &allocationCallbacks);
@@ -12203,10 +12169,6 @@ DRFLAC_API drflac_bool32 drflac_next_cuesheet_track(drflac_cuesheet_track_iterat
 /*
 REVISION HISTORY
 ================
-v0.13.4 - TBD
-  - Add a bounds check when allocating memory during metadata processing.
-  - Fix a possible overflow error when parsing picture metadata.
-
 v0.13.3 - 2026-01-17
   - Fix a compiler compatibility issue with some inlined assembly.
   - Fix a compilation warning.
diff --git a/src/libraries/raylib/raylib/src/external/dr_mp3.h b/src/libraries/raylib/raylib/src/external/dr_mp3.h
index a458d86..c0969c4 100644
--- a/src/libraries/raylib/raylib/src/external/dr_mp3.h
+++ b/src/libraries/raylib/raylib/src/external/dr_mp3.h
@@ -3188,10 +3188,6 @@ static drmp3_bool32 drmp3_init_internal(drmp3* pMP3, drmp3_read_proc onRead, drm
                 pTagDataBeg = pFirstFrameData + DRMP3_HDR_SIZE + (bs.pos/8);
                 pTagData    = pTagDataBeg;
 
-                if (firstFrameInfo.frame_bytes - (size_t)(pTagData - pFirstFrameData) < 8) {
-                    goto done_xing_info;    /* Frame too small for a Xing/Info tag. */
-                }
-
                 /* Check for both "Xing" and "Info" identifiers. */
                 isXing = (pTagData[0] == 'X' && pTagData[1] == 'i' && pTagData[2] == 'n' && pTagData[3] == 'g');
                 isInfo = (pTagData[0] == 'I' && pTagData[1] == 'n' && pTagData[2] == 'f' && pTagData[3] == 'o');
@@ -3203,60 +3199,42 @@ static drmp3_bool32 drmp3_init_internal(drmp3* pMP3, drmp3_read_proc onRead, drm
                     pTagData += 8;  /* Skip past the ID and flags. */
 
                     if (flags & 0x01) { /* FRAMES flag. */
-                        if (firstFrameInfo.frame_bytes - (size_t)(pTagData - pFirstFrameData) < 4) {
-                            goto done_xing_info;    /* Invalid Xing/Info tag. */
-                        }
-
                         detectedMP3FrameCount = (drmp3_uint32)pTagData[0] << 24 | (drmp3_uint32)pTagData[1] << 16 | (drmp3_uint32)pTagData[2] << 8 | (drmp3_uint32)pTagData[3];
                         pTagData += 4;
                     }
 
                     if (flags & 0x02) { /* BYTES flag. */
-                        if (firstFrameInfo.frame_bytes - (size_t)(pTagData - pFirstFrameData) < 4) {
-                            goto done_xing_info;    /* Invalid Xing/Info tag. */
-                        }
-
                         bytes  = (drmp3_uint32)pTagData[0] << 24 | (drmp3_uint32)pTagData[1] << 16 | (drmp3_uint32)pTagData[2] << 8 | (drmp3_uint32)pTagData[3];
                         (void)bytes;    /* <-- Just to silence a warning about `bytes` being assigned but unused. Want to leave this here in case I want to make use of it later. */
                         pTagData += 4;
                     }
 
                     if (flags & 0x04) { /* TOC flag. */
-                        if (firstFrameInfo.frame_bytes - (size_t)(pTagData - pFirstFrameData) < 100) {
-                            goto done_xing_info;    /* Invalid Xing/Info tag. */
-                        }
-
                         /* TODO: Extract and bind seek points. */
                         pTagData += 100;
                     }
 
                     if (flags & 0x08) { /* SCALE flag. */
-                        if (firstFrameInfo.frame_bytes - (size_t)(pTagData - pFirstFrameData) < 4) {
-                            goto done_xing_info;    /* Invalid Xing/Info tag. */
-                        }
-                        
                         pTagData += 4;
                     }
 
                     /* At this point we're done with the Xing/Info header. Now we can look at the LAME data. */
                     if (pTagData[0]) {
-                        int delayInPCMFrames;
-                        int paddingInPCMFrames;
-
-                        if (firstFrameInfo.frame_bytes - (size_t)(pTagData - pFirstFrameData) < 36) {
-                            goto done_xing_info;    /* Invalid Xing/Info tag. */
-                        }
-
                         pTagData += 21;
 
-                        delayInPCMFrames   = (( (drmp3_uint32)pTagData[0]        << 4) | ((drmp3_uint32)pTagData[1] >> 4)) + (528 + 1);
-                        paddingInPCMFrames = ((((drmp3_uint32)pTagData[1] & 0xF) << 8) | ((drmp3_uint32)pTagData[2]     )) - (528 + 1);
-                        if (paddingInPCMFrames < 0) {
-                            paddingInPCMFrames = 0; /* Padding cannot be negative. Probably a malformed file. Ignore. */
+                        if (pTagData - pFirstFrameData + 14 < firstFrameInfo.frame_bytes) {
+                            int delayInPCMFrames;
+                            int paddingInPCMFrames;
+
+                            delayInPCMFrames   = (( (drmp3_uint32)pTagData[0]        << 4) | ((drmp3_uint32)pTagData[1] >> 4)) + (528 + 1);
+                            paddingInPCMFrames = ((((drmp3_uint32)pTagData[1] & 0xF) << 8) | ((drmp3_uint32)pTagData[2]     )) - (528 + 1);
+                            if (paddingInPCMFrames < 0) {
+                                paddingInPCMFrames = 0; /* Padding cannot be negative. Probably a malformed file. Ignore. */
+                            }
+                            
+                            pMP3->delayInPCMFrames   = (drmp3_uint32)delayInPCMFrames;
+                            pMP3->paddingInPCMFrames = (drmp3_uint32)paddingInPCMFrames;
                         }
-                        
-                        pMP3->delayInPCMFrames   = (drmp3_uint32)delayInPCMFrames;
-                        pMP3->paddingInPCMFrames = (drmp3_uint32)paddingInPCMFrames;
                     }
 
                     /*
@@ -3295,8 +3273,6 @@ static drmp3_bool32 drmp3_init_internal(drmp3* pMP3, drmp3_read_proc onRead, drm
                     */
                     drmp3dec_init(&pMP3->decoder);
                 }
-
-                done_xing_info:;
             } else {
                 /* Failed to read the side info. */
             }
@@ -3309,7 +3285,7 @@ static drmp3_bool32 drmp3_init_internal(drmp3* pMP3, drmp3_read_proc onRead, drm
     }
 
     if (detectedMP3FrameCount != 0xFFFFFFFF) {
-        pMP3->totalPCMFrameCount = (drmp3_uint64)detectedMP3FrameCount * firstFramePCMFrameCount;
+        pMP3->totalPCMFrameCount = detectedMP3FrameCount * firstFramePCMFrameCount;
     }
 
     pMP3->channels   = pMP3->mp3FrameChannels;
@@ -4271,7 +4247,7 @@ DRMP3_API drmp3_uint64 drmp3_read_pcm_frames_f32(drmp3* pMP3, drmp3_uint64 frame
 #else
     /* Slow path. Convert from s16 to f32. */
     {
-        drmp3_int16 pTempS16[1152*2];   /* MP3 frames have a maximum per-channel sample count of 1152. Times 2 to account for stereo. */
+        drmp3_int16 pTempS16[8192];
         drmp3_uint64 totalPCMFramesRead = 0;
 
         while (totalPCMFramesRead < framesToRead) {
@@ -4308,7 +4284,7 @@ DRMP3_API drmp3_uint64 drmp3_read_pcm_frames_s16(drmp3* pMP3, drmp3_uint64 frame
 #else
     /* Slow path. Convert from f32 to s16. */
     {
-        float pTempF32[1152*2];   /* MP3 frames have a maximum per-channel sample count of 1152. Times 2 to account for stereo. */
+        float pTempF32[4096];
         drmp3_uint64 totalPCMFramesRead = 0;
 
         while (totalPCMFramesRead < framesToRead) {
@@ -4796,7 +4772,7 @@ static float* drmp3__full_read_and_close_f32(drmp3* pMP3, drmp3_config* pConfig,
     drmp3_uint64 totalFramesRead = 0;
     drmp3_uint64 framesCapacity = 0;
     float* pFrames = NULL;
-    float temp[1152*2];   /* MP3 frames have a maximum per-channel sample count of 1152. Times 2 to account for stereo. */
+    float temp[4096];
 
     DRMP3_ASSERT(pMP3 != NULL);
 
@@ -4865,7 +4841,7 @@ static drmp3_int16* drmp3__full_read_and_close_s16(drmp3* pMP3, drmp3_config* pC
     drmp3_uint64 totalFramesRead = 0;
     drmp3_uint64 framesCapacity = 0;
     drmp3_int16* pFrames = NULL;
-    drmp3_int16 temp[1152*2];   /* MP3 frames have a maximum per-channel sample count of 1152. Times 2 to account for stereo. */
+    drmp3_int16 temp[4096];
 
     DRMP3_ASSERT(pMP3 != NULL);
 
@@ -5034,9 +5010,6 @@ DIFFERENCES BETWEEN minimp3 AND dr_mp3
 REVISION HISTORY
 ================
 v0.7.4 - TBD
-  - Fix an overflow error with "Xing" and "Info" tag parsing.
-  - Add some validation checks for "Xing" and "Info" tag parsing.
-  - Reduce size of some stack allocations.
   - Improvements to SIMD detection.
 
 v0.7.3 - 2026-01-17
diff --git a/src/libraries/raylib/raylib/src/external/dr_wav.h b/src/libraries/raylib/raylib/src/external/dr_wav.h
index a18bc04..c7bd89f 100644
--- a/src/libraries/raylib/raylib/src/external/dr_wav.h
+++ b/src/libraries/raylib/raylib/src/external/dr_wav.h
@@ -1,6 +1,6 @@
 /*
 WAV audio loader and writer. Choice of public domain or MIT-0. See license statements at the end of this file.
-dr_wav - v0.14.6 - TBD
+dr_wav - v0.14.5 - 2026-03-03
 
 David Reid - mackron@gmail.com
 
@@ -147,7 +147,7 @@ extern "C" {
 
 #define DRWAV_VERSION_MAJOR     0
 #define DRWAV_VERSION_MINOR     14
-#define DRWAV_VERSION_REVISION  6
+#define DRWAV_VERSION_REVISION  5
 #define DRWAV_VERSION_STRING    DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
 
 #include <stddef.h> /* For size_t. */
@@ -1971,15 +1971,7 @@ DRWAV_PRIVATE drwav_result drwav__read_chunk_header(drwav_read_proc onRead, void
             return DRWAV_INVALID_FILE;
         }
 
-        pHeaderOut->sizeInBytes = drwav_bytes_to_u64(sizeInBytes);
-
-        /* Subtract 24 from the size because with w64 the reported chunk size includes the size of the header itself. */
-        if (pHeaderOut->sizeInBytes >= 24) {
-            pHeaderOut->sizeInBytes -= 24;
-        } else {
-            return DRWAV_INVALID_FILE;
-        }
-
+        pHeaderOut->sizeInBytes = drwav_bytes_to_u64(sizeInBytes) - 24;    /* <-- Subtract 24 because w64 includes the size of the header. */
         pHeaderOut->paddingSize = drwav__chunk_padding_size_w64(pHeaderOut->sizeInBytes);
         *pRunningBytesReadOut += 24;
     } else {
@@ -2209,7 +2201,7 @@ DRWAV_PRIVATE drwav_uint64 drwav__read_smpl_to_metadata_obj(drwav__metadata_pars
         so it's consistent with how we do it in the first stage.
         */
         loopCount = drwav_bytes_to_u32(smplHeaderData + 28);
-        calculatedLoopCount = (drwav_uint32)((pChunkHeader->sizeInBytes - DRWAV_SMPL_BYTES) / DRWAV_SMPL_LOOP_BYTES);
+        calculatedLoopCount = (pChunkHeader->sizeInBytes - DRWAV_SMPL_BYTES) / DRWAV_SMPL_LOOP_BYTES;
         if (loopCount != calculatedLoopCount) {
             return totalBytesRead;
         }
@@ -2588,10 +2580,8 @@ DRWAV_PRIVATE drwav_uint64 drwav__read_bext_to_metadata_obj(drwav__metadata_pars
                 pMetadata->data.bext.pCodingHistory = (char*)drwav__metadata_get_memory(pParser, extraBytes + 1, 1);
                 DRWAV_ASSERT(pMetadata->data.bext.pCodingHistory != NULL);
 
-                pMetadata->data.bext.codingHistorySize = (drwav_uint32)drwav__metadata_parser_read(pParser, pMetadata->data.bext.pCodingHistory, extraBytes, NULL);
-                pMetadata->data.bext.pCodingHistory[pMetadata->data.bext.codingHistorySize] = '\0'; /* <-- Explicit null terminator in case of a badly formed file. */
-                
-                bytesRead += pMetadata->data.bext.codingHistorySize;
+                bytesRead += drwav__metadata_parser_read(pParser, pMetadata->data.bext.pCodingHistory, extraBytes, NULL);
+                pMetadata->data.bext.codingHistorySize = (drwav_uint32)drwav__strlen(pMetadata->data.bext.pCodingHistory);
             } else {
                 pMetadata->data.bext.pCodingHistory    = NULL;
                 pMetadata->data.bext.codingHistorySize = 0;
@@ -2765,10 +2755,10 @@ DRWAV_PRIVATE drwav_uint64 drwav__metadata_process_chunk(drwav__metadata_parser*
                 bytesJustRead = drwav__metadata_parser_read(pParser, buffer, sizeof(buffer), &bytesRead);
                 if (bytesJustRead == sizeof(buffer)) {
                     drwav_uint32 loopCount = drwav_bytes_to_u32(buffer);
-                    drwav_uint32 calculatedLoopCount;
+                    drwav_uint64 calculatedLoopCount;
 
                     /* The loop count must be validated against the size of the chunk. */
-                    calculatedLoopCount = (drwav_uint32)((pChunkHeader->sizeInBytes - DRWAV_SMPL_BYTES) / DRWAV_SMPL_LOOP_BYTES);
+                    calculatedLoopCount = (pChunkHeader->sizeInBytes - DRWAV_SMPL_BYTES) / DRWAV_SMPL_LOOP_BYTES;
                     if (calculatedLoopCount == loopCount) {
                         bytesJustRead = drwav__metadata_parser_read(pParser, buffer, sizeof(buffer), &bytesRead);
                         if (bytesJustRead == sizeof(buffer)) {
@@ -2870,9 +2860,7 @@ DRWAV_PRIVATE drwav_uint64 drwav__metadata_process_chunk(drwav__metadata_parser*
                     return bytesRead;
                 }
                 allocSizeNeeded += drwav__strlen(buffer) + 1;
-
-                /* Coding history. */
-                allocSizeNeeded += (size_t)pChunkHeader->sizeInBytes - DRWAV_BEXT_BYTES + 1;
+                allocSizeNeeded += (size_t)pChunkHeader->sizeInBytes - DRWAV_BEXT_BYTES + 1; /* Coding history. */
 
                 drwav__metadata_request_extra_memory_for_stage_2(pParser, allocSizeNeeded, 1);
 
@@ -3333,10 +3321,6 @@ DRWAV_PRIVATE drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc on
             ((pWav->container == drwav_container_w64) && drwav_guid_equal(header.id.guid, drwavGUID_W64_FMT))) {
             drwav_uint8 fmtData[16];
 
-            if (header.sizeInBytes < sizeof(fmtData)) {
-                return DRWAV_FALSE; /* Invalid fmt chunk. */
-            }
-
             foundChunk_fmt = DRWAV_TRUE;
 
             if (pWav->onRead(pWav->pUserData, fmtData, sizeof(fmtData)) != sizeof(fmtData)) {
@@ -3849,11 +3833,6 @@ DRWAV_PRIVATE drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc on
 
             /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */
             totalBlockHeaderSizeInBytes = blockCount * (6*fmt.channels);
-            if (totalBlockHeaderSizeInBytes >= dataChunkSize) {  /* <-- We'll be subtracting totalBlockHeaderSizeInBytes from dataChunkSize next so it must be validated. */
-                drwav_free(pWav->pMetadata, &pWav->allocationCallbacks);
-                return DRWAV_FALSE; /* Invalid file. */
-            }
-
             pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
         }
         if (pWav->translatedFormatTag == DR_WAVE_FORMAT_DVI_ADPCM) {
@@ -3867,11 +3846,6 @@ DRWAV_PRIVATE drwav_bool32 drwav_init__internal(drwav* pWav, drwav_chunk_proc on
 
             /* We decode two samples per byte. There will be blockCount headers in the data chunk. This is enough to know how to calculate the total PCM frame count. */
             totalBlockHeaderSizeInBytes = blockCount * (4*fmt.channels);
-            if (totalBlockHeaderSizeInBytes >= dataChunkSize) {  /* <-- We'll be subtracting totalBlockHeaderSizeInBytes from dataChunkSize next so it must be validated. */
-                drwav_free(pWav->pMetadata, &pWav->allocationCallbacks);
-                return DRWAV_FALSE; /* Invalid file. */
-            }
-
             pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
 
             /* The header includes a decoded sample for each channel which acts as the initial predictor sample. */
@@ -6751,10 +6725,6 @@ DRWAV_PRIVATE void drwav__pcm_to_s16(drwav_int16* pOut, const drwav_uint8* pIn,
             shift  += 8;
         }
 
-        if (!drwav__is_little_endian()) {
-            sample = drwav__bswap64(sample);
-        }
-
         pIn += j;
         *pOut++ = (drwav_int16)((drwav_int64)sample >> 48);
     }
@@ -7196,10 +7166,6 @@ DRWAV_PRIVATE void drwav__pcm_to_f32(float* pOut, const drwav_uint8* pIn, size_t
             shift  += 8;
         }
 
-        if (!drwav__is_little_endian()) {
-            sample = drwav__bswap64(sample);
-        }
-
         pIn += j;
         *pOut++ = (float)((drwav_int64)sample / 9223372036854775807.0);
     }
@@ -7684,10 +7650,6 @@ DRWAV_PRIVATE void drwav__pcm_to_s32(drwav_int32* pOut, const drwav_uint8* pIn,
             shift  += 8;
         }
 
-        if (!drwav__is_little_endian()) {
-            sample = drwav__bswap64(sample);
-        }
-
         pIn += j;
         *pOut++ = (drwav_int32)((drwav_int64)sample >> 32);
     }
@@ -8595,13 +8557,6 @@ DRWAV_API drwav_bool32 drwav_fourcc_equal(const drwav_uint8* a, const char* b)
 /*
 REVISION HISTORY
 ================
-v0.14.6 - TBD
-  - Fix an error when loading files with a malformed "bext" chunk.
-  - Fix an error when loading files with a malformed "fmt" chunk.
-  - Fix an underflow error with badly formed ADPCM encoded files.
-  - Fix an underflow error with badly formed W64 files.
-  - Fix an error when converting from >32 bit samples to s16/f32/s32 on big-endian architectures.
-
 v0.14.5 - 2026-03-03
   - Fix a crash when loading files with a malformed "smpl" chunk.
   - Fix a signed overflow bug with the MS-ADPCM decoder.
diff --git a/src/libraries/raylib/raylib/src/external/fix_win32_compatibility.h b/src/libraries/raylib/raylib/src/external/fix_win32_compatibility.h
index 2874230..e103766 100644
--- a/src/libraries/raylib/raylib/src/external/fix_win32_compatibility.h
+++ b/src/libraries/raylib/raylib/src/external/fix_win32_compatibility.h
@@ -2,7 +2,7 @@
 *
 *   fix_win32_compatibility.h   Utility to help include windows.h with raylib projects
 *
-*   Usage: #include "fix_win32_compatibility.h" any library that uses windows.h
+*   Useage: #include "fix_win32_compatibility.h" any library that uses windows.h
 *                                     order is critical, this must be done before raylib
 *
 *   LICENSE: MIT
@@ -32,7 +32,7 @@
 #pragma once
 
 // move the windows functions to new names
-// note that you can't call these functions or structures from your code, but you should not need to
+// note that you can't call these functions or structures from your code, but you should not neeed to
 #define CloseWindow CloseWindowWin32
 #define Rectangle RectangleWin32
 #define ShowCursor ShowCursorWin32
@@ -46,9 +46,8 @@
 // include windows
 #define WIN32_LEAN_AND_MEAN 
 #include <windows.h>
-#include <playsoundapi.h>
 
-// remove all our redefinitions so that raylib can define them properly
+// remove all our redfintions so that raylib can define them properly
 #undef CloseWindow
 #undef Rectangle
 #undef ShowCursor
diff --git a/src/libraries/raylib/raylib/src/external/glfw/CMake/GenerateMappings.cmake b/src/libraries/raylib/raylib/src/external/glfw/CMake/GenerateMappings.cmake
index 9a95df6..c8c9e23 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/CMake/GenerateMappings.cmake
+++ b/src/libraries/raylib/raylib/src/external/glfw/CMake/GenerateMappings.cmake
@@ -1,8 +1,6 @@
 # Usage:
 # cmake -P GenerateMappings.cmake <path/to/mappings.h.in> <path/to/mappings.h>
 
-cmake_policy(VERSION 3.16)
-
 set(source_url "https://raw.githubusercontent.com/gabomdq/SDL_GameControllerDB/master/gamecontrollerdb.txt")
 set(source_path "${CMAKE_CURRENT_BINARY_DIR}/gamecontrollerdb.txt")
 set(template_path "${CMAKE_ARGV3}")
@@ -24,24 +22,24 @@ if (status_code)
 endif()
 
 file(STRINGS "${source_path}" lines)
-list(FILTER lines INCLUDE REGEX "^[0-9a-fA-F]")
-
-foreach(line IN LISTS lines)
-    if (line MATCHES "platform:Windows")
-        if (GLFW_WIN32_MAPPINGS)
-            string(APPEND GLFW_WIN32_MAPPINGS "\n")
+foreach(line ${lines})
+    if (line MATCHES "^[0-9a-fA-F]")
+        if (line MATCHES "platform:Windows")
+            if (GLFW_WIN32_MAPPINGS)
+                string(APPEND GLFW_WIN32_MAPPINGS "\n")
+            endif()
+            string(APPEND GLFW_WIN32_MAPPINGS "\"${line}\",")
+        elseif (line MATCHES "platform:Mac OS X")
+            if (GLFW_COCOA_MAPPINGS)
+                string(APPEND GLFW_COCOA_MAPPINGS "\n")
+            endif()
+            string(APPEND GLFW_COCOA_MAPPINGS "\"${line}\",")
+        elseif (line MATCHES "platform:Linux")
+            if (GLFW_LINUX_MAPPINGS)
+                string(APPEND GLFW_LINUX_MAPPINGS "\n")
+            endif()
+            string(APPEND GLFW_LINUX_MAPPINGS "\"${line}\",")
         endif()
-        string(APPEND GLFW_WIN32_MAPPINGS "\"${line}\",")
-    elseif (line MATCHES "platform:Mac OS X")
-        if (GLFW_COCOA_MAPPINGS)
-            string(APPEND GLFW_COCOA_MAPPINGS "\n")
-        endif()
-        string(APPEND GLFW_COCOA_MAPPINGS "\"${line}\",")
-    elseif (line MATCHES "platform:Linux")
-        if (GLFW_LINUX_MAPPINGS)
-            string(APPEND GLFW_LINUX_MAPPINGS "\n")
-        endif()
-        string(APPEND GLFW_LINUX_MAPPINGS "\"${line}\",")
     endif()
 endforeach()
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/CMakeLists.txt b/src/libraries/raylib/raylib/src/external/glfw/CMakeLists.txt
index cbc12be..a3cb1fe 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/CMakeLists.txt
+++ b/src/libraries/raylib/raylib/src/external/glfw/CMakeLists.txt
@@ -1,6 +1,14 @@
-cmake_minimum_required(VERSION 3.16...3.28 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.4...3.28 FATAL_ERROR)
 
-project(GLFW VERSION 3.5.1 LANGUAGES C HOMEPAGE_URL "https://www.glfw.org/")
+project(GLFW VERSION 3.4.0 LANGUAGES C)
+
+if (POLICY CMP0069)
+    cmake_policy(SET CMP0069 NEW)
+endif()
+
+if (POLICY CMP0077)
+    cmake_policy(SET CMP0077 NEW)
+endif()
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
@@ -38,7 +46,11 @@ set(GLFW_LIBRARY_TYPE "${GLFW_LIBRARY_TYPE}" CACHE STRING
     "Library type override for GLFW (SHARED, STATIC, OBJECT, or empty to follow BUILD_SHARED_LIBS)")
 
 if (GLFW_LIBRARY_TYPE)
-    string(COMPARE EQUAL "${GLFW_LIBRARY_TYPE}" "SHARED" GLFW_BUILD_SHARED_LIBRARY)
+    if (GLFW_LIBRARY_TYPE STREQUAL "SHARED")
+        set(GLFW_BUILD_SHARED_LIBRARY TRUE)
+    else()
+        set(GLFW_BUILD_SHARED_LIBRARY FALSE)
+    endif()
 else()
     set(GLFW_BUILD_SHARED_LIBRARY ${BUILD_SHARED_LIBS})
 endif()
@@ -68,7 +80,24 @@ endif()
 # This is here because it also applies to tests and examples
 #--------------------------------------------------------------------
 if (MSVC AND NOT USE_MSVC_RUNTIME_LIBRARY_DLL)
-    set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    if (CMAKE_VERSION VERSION_LESS 3.15)
+        foreach (flag CMAKE_C_FLAGS
+                      CMAKE_C_FLAGS_DEBUG
+                      CMAKE_C_FLAGS_RELEASE
+                      CMAKE_C_FLAGS_MINSIZEREL
+                      CMAKE_C_FLAGS_RELWITHDEBINFO)
+
+            if (flag MATCHES "/MD")
+                string(REGEX REPLACE "/MD" "/MT" ${flag} "${${flag}}")
+            endif()
+            if (flag MATCHES "/MDd")
+                string(REGEX REPLACE "/MDd" "/MTd" ${flag} "${${flag}}")
+            endif()
+
+        endforeach()
+    else()
+        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
+    endif()
 endif()
 
 #--------------------------------------------------------------------
diff --git a/src/libraries/raylib/raylib/src/external/glfw/CONTRIBUTORS.md b/src/libraries/raylib/raylib/src/external/glfw/CONTRIBUTORS.md
index 8a495a1..c4c74ad 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/CONTRIBUTORS.md
+++ b/src/libraries/raylib/raylib/src/external/glfw/CONTRIBUTORS.md
@@ -6,12 +6,10 @@ excludes other invaluable contributions like language bindings and text and
 video tutorials.
 
  - Bobyshev Alexander
- - Alzathar
  - Laurent Aphecetche
  - Matt Arsenault
  - Takuro Ashie
  - ashishgamedev
- - avagordon01
  - David Avedissian
  - Luca Bacci
  - Keith Bauer
@@ -25,7 +23,6 @@ video tutorials.
  - Denis Bernard
  - BiBi
  - Doug Binks
- - bitb4ker
  - blanco
  - Waris Boonyasiriwat
  - Kyle Brenneman
@@ -36,7 +33,6 @@ video tutorials.
  - Nicolas Caramelli
  - David Carlier
  - Arturo Castro
- - Jose Luis Cercós Pita
  - Chi-kwan Chan
  - Victor Chernyakin
  - TheChocolateOre
@@ -52,15 +48,11 @@ video tutorials.
  - Andrew Corrigan
  - Bailey Cosier
  - Noel Cower
- - James Cowgill
  - CuriouserThing
  - Bill Currie
  - Jason Daly
  - danhambleton
- - danijel1023
  - Jarrod Davis
- - Aaron Day
- - decce
  - Olivier Delannoy
  - Paul R. Deppe
  - Michael Dickens
@@ -73,18 +65,14 @@ video tutorials.
  - Robin Eklind
  - Jan Ekström
  - Siavash Eliasi
- - er-azh
- - Jan Hendrik Farr
  - Ahmad Fatoum
  - Nikita Fediuchin
  - Felipe Ferreira
  - Michael Fogleman
- - Folling
  - forworldm
  - Jason Francis
  - Gerald Franz
  - Mário Freitas
- - Friz64
  - GeO4d
  - Marcus Geelnard
  - Gegy
@@ -100,7 +88,6 @@ video tutorials.
  - Andrew Gutekanst
  - Stephen Gutekanst
  - Jonathan Hale
- - halx99
  - Daniel Hauser
  - hdf89shfdfs
  - Moritz Heinemann
@@ -131,7 +118,6 @@ video tutorials.
  - Josh Kilmer
  - Byunghoon Kim
  - Cameron King
- - knokko
  - Peter Knut
  - Christoph Kubisch
  - Yuri Kunde Schlesner
@@ -167,10 +153,8 @@ video tutorials.
  - Bryce Mehring
  - Jonathan Mercier
  - Marcel Metz
- - Lucas Michaudel
  - Liam Middlebrook
  - mightgoyardstill
- - Mihail
  - Ave Milia
  - Icyllis Milica
  - Jonathan Miller
@@ -184,7 +168,6 @@ video tutorials.
  - Jon Morton
  - Pierre Moulon
  - Martins Mozeiko
- - Tomáš Mráz
  - Pascal Muetschard
  - James Murphy
  - Julian Møller
@@ -231,7 +214,6 @@ video tutorials.
  - Philip Rideout
  - Eddie Ringle
  - Max Risuhin
- - road2react
  - Joe Roback
  - Jorge Rodriguez
  - Jari Ronkainen
@@ -239,13 +221,12 @@ video tutorials.
  - Ed Ropple
  - Aleksey Rybalkin
  - Mikko Rytkönen
- - saikyun
  - Riku Salminen
  - Yoshinori Sano
  - Brandon Schaefer
  - Sebastian Schuberth
  - Scr3amer
- - Jan Schürkamp
+ - Jan Schuerkamp
  - Christian Sdunek
  - Matt Sealey
  - Steve Sexton
@@ -294,12 +275,10 @@ video tutorials.
  - Corentin Wallez
  - Torsten Walluhn
  - Patrick Walton
- - Ivor Wanders
  - Jim Wang
  - Xo Wang
  - Andre Weissflog
  - Jay Weisskopf
- - Drew Weymouth
  - Frank Wille
  - Andy Williams
  - Joel Winarske
diff --git a/src/libraries/raylib/raylib/src/external/glfw/README.md b/src/libraries/raylib/raylib/src/external/glfw/README.md
index c37d1de..c5501ff 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/README.md
+++ b/src/libraries/raylib/raylib/src/external/glfw/README.md
@@ -1,198 +1,18 @@
-# GLFW
+# GLFW (modified for raylib)
 
-[![Build status](https://github.com/glfw/glfw/actions/workflows/build.yml/badge.svg)](https://github.com/glfw/glfw/actions)
-[![Build status](https://ci.appveyor.com/api/projects/status/0kf0ct9831i5l6sp/branch/master?svg=true)](https://ci.appveyor.com/project/elmindreda/glfw)
+This directory contains a modification of GLFW, whose official website and
+upstream repository are https://glfw.org and https://github.com/glfw/glfw,
+respectively.
 
-## Introduction
+In this modification, some static functions sharing the same name in different
+platforms have been renamed so all of GLFW's source files can be combined into
+one (as done by ``rglfw.c``). Also, the Null platform, which is not used by
+raylib, has been disabled. The renamed functions are:
 
-GLFW is an Open Source, multi-platform library for OpenGL, OpenGL ES and Vulkan
-application development.  It provides a simple, platform-independent API for
-creating windows, contexts and surfaces, reading input, handling events, etc.
-
-GLFW is written primarily in C99, with parts of macOS support being written in
-Objective-C.
-
-GLFW supports Windows, macOS and Linux, and also works on many other Unix-like
-systems.  On Linux both Wayland and X11 are supported.
-
-GLFW is licensed under the [zlib/libpng
-license](https://www.glfw.org/license.html).
-
-You can [download](https://www.glfw.org/download.html) the latest stable release
-as source or Windows and macOS binaries.  There are [release
-tags](https://github.com/glfw/glfw/releases) with source and binary archives
-attached for every version since 3.0.
-
-The [documentation](https://www.glfw.org/docs/latest/) is available online and is
-also included in source and binary archives, except those generated
-automatically by Github.  The documentation contains guides, a tutorial and the
-API reference.  The [release
-notes](https://www.glfw.org/docs/latest/news.html) list the new features,
-caveats and deprecations in the latest release.  The [version
-history](https://www.glfw.org/changelog.html) lists every user-visible change
-for every release.
-
-GLFW exists because of the contributions of [many people](CONTRIBUTORS.md)
-around the world, whether by reporting bugs, providing community support, adding
-features, reviewing or testing code, debugging, proofreading docs, suggesting
-features or fixing bugs.
-
-
-## System requirements
-
-GLFW supports Windows 7 and later and macOS 10.11 and later.  On GNOME Wayland,
-window decorations will be very basic unless the
-[libdecor](https://gitlab.freedesktop.org/libdecor/libdecor) package is
-installed.  Linux and other Unix-like systems running X11 are supported even
-without a desktop environment or modern extensions, although some features
-require a clipboard manager or a modern window manager.
-
-See the [compatibility guide](https://www.glfw.org/docs/latest/compat.html)
-for more detailed information.
-
-
-## Compiling GLFW
-
-GLFW supports compilation with Visual C++ (2013 and later), GCC and Clang.  Both
-Clang-CL and MinGW-w64 are supported.  Other C99 compilers will likely also
-work, but this is not regularly tested.
-
-There are [pre-compiled binaries](https://www.glfw.org/download.html)
-available for Windows and macOS.
-
-GLFW itself needs only CMake and the headers and libraries for your operating
-system and window system.  No other SDKs are required.
-
-See the [compilation guide](https://www.glfw.org/docs/latest/compile.html) for
-more information about compiling GLFW and the exact dependencies required for
-each window system.
-
-The examples and test programs depend on a number of tiny libraries.  These are
-bundled in the `deps/` directory.  The repository has no submodules.
-
- - [getopt\_port](https://github.com/kimgr/getopt_port/) for examples
-   with command-line options
- - [TinyCThread](https://github.com/tinycthread/tinycthread) for threaded
-   examples
- - [glad2](https://github.com/Dav1dde/glad) for loading OpenGL and Vulkan
-   functions
- - [linmath.h](https://github.com/datenwolf/linmath.h) for linear algebra in
-   examples
- - [Nuklear](https://github.com/Immediate-Mode-UI/Nuklear) for test and example UI
- - [stb\_image\_write](https://github.com/nothings/stb) for writing images to disk
-
-The documentation is generated with [Doxygen](https://doxygen.org/) when the
-library is built, provided CMake could find a sufficiently new version of it
-during configuration.
-
-
-## Using GLFW
-
-See the [HTML documentation](https://www.glfw.org/docs/latest/) for a tutorial,
-guides and the API reference.
-
-
-## Contributing to GLFW
-
-See the [contribution
-guide](https://github.com/glfw/glfw/blob/master/docs/CONTRIBUTING.md) for
-more information.
-
-The `master` branch is the stable integration branch and _should_ always compile
-and run on all supported platforms.  Details of a newly added feature,
-including the public API, may change until it has been included in a release.
-
-The `latest` branch is equivalent to the [highest numbered](https://semver.org/)
-release, although it may not always point to the same commit as the tag for that
-release.
-
-The `ci` branch is used to trigger continuous integration jobs for code under
-testing and should never be relied on for any purpose.
-
-
-## Reporting bugs
-
-Bugs are reported to our [issue tracker](https://github.com/glfw/glfw/issues).
-Please check the [contribution
-guide](https://github.com/glfw/glfw/blob/master/docs/CONTRIBUTING.md) for
-information on what to include when reporting a bug.
-
-
-## Changelog since 3.5
-
-None.
-
-## Changelog since 3.4
-
- - Added `GLFW_UNLIMITED_MOUSE_BUTTONS` input mode that allows mouse buttons beyond
-   the limit of the mouse button tokens to be reported (#2423)
- - Added `glfwGetEGLConfig` function to query the `EGLConfig` of a window (#2045)
- - Added `glfwGetGLXFBConfig` function to query the `GLXFBConfig` of a window (#1925)
- - Updated minimum CMake version to 3.16 (#2541)
- - Removed support for building with original MinGW (#2540)
- - [Win32] Removed support for Windows XP and Vista (#2505)
- - [Win32] Bugfix: Media keys were reported with a scancode of 256 (#1768,#2417,#2625)
- - [Cocoa] Added `QuartzCore` framework as link-time dependency
- - [Cocoa] Removed support for OS X 10.10 Yosemite and earlier (#2506)
- - [Cocoa] Bugfix: Cmd+Period, Ctrl+Tab and Ctrl+Esc key events were not emitted
-   (#1362,#2278)
- - [Wayland] Bugfix: The fractional scaling related objects were not destroyed
- - [Wayland] Bugfix: `glfwInit` would segfault on compositor with no seat (#2517)
- - [Wayland] Bugfix: A drag entering a non-GLFW surface could cause a segfault
- - [Wayland] Bugfix: Ignore key repeat events when no window has keyboard focus (#2727)
- - [Wayland] Bugfix: Reset key repeat timer when window destroyed (#2741,#2727)
- - [Wayland] Bugfix: Memory would leak if reading a data offer failed midway
- - [Wayland] Bugfix: Retrieved cursor position would be incorrect when hovering over
-                     fallback decorations
- - [Wayland] Bugfix: Fallback decorations would report scroll events
- - [Wayland] Bugfix: Keyboard repeat events halted when any key is released (#2568)
- - [Wayland] Bugfix: Fallback decorations would show menu at wrong position
- - [Wayland] Bugfix: The cursor was not updated when clicking through from
-   a modal to a fallback decoration
- - [Wayland] Bugfix: The cursor position was not updated when clicking through
-   from a modal to the content area
- - [Wayland] Bugfix: free modules at end of terminate function to resolve
-   potential segmentation fault (#2744)
- - [Wayland] Bugfix: Confining or disabling the cursor could segfault on
-   compositors without `pointer-constraints-unstable-v1`
- - [Wayland] Bugfix: Key repeat did not function on very old compositors
- - [Wayland] Bugfix: The `libwayland-client` library was not unloaded at termination
- - [Wayland] Bugfix: Scroll events were sent twice on some versions of GNOME (#2494)
- - [Wayland] Bugfix: Two-dimensional scroll input was emitted as separate axes
- - [Wayland] Bugfix: Mouse wheel scroll distance was incorrect on some compositors
- - [Wayland] Bugfix: `glfwSwapBuffers` would halt with nonzero swap interval when window
-   was suspended (#1350,#2582,#2640,#2719,#2723,#2800,#2827)
- - [Wayland] Bugfix: `glfwPostEmptyEvent` would leak a callback proxy (#2836)
- - [Wayland] Bugfix: `glfwHideWindow` did not always send its request immediately
- - [Wayland] Bugfix: Some event types were not always processed by `glfwPollEvents` or
-   `glfwWait*Events` (#2793,#2795)
- - [Wayland] Bugfix: Scaled framebuffer size was sometimes incorect (#2713,#2810)
- - [X11] Bugfix: Running without a WM could trigger an assert (#2593,#2601,#2631)
- - [X11] Bugfix: Occasional crash when an idle display awakes (#2766) 
- - [X11] Bugfix: Prevent BadWindow when creating small windows with a content scale
-   less than 1 (#2754)
- - [X11] Bugfix: Clamp width and height to >= 1 to prevent BadValue error and app exit
- - [X11] Bugfix: Floating windows silently became non-floating when hidden (#2276)
- - [X11] Bugfix: The `libXext` library was not unloaded at termination
- - [Linux] Bugfix: The header for `ioctl` was only implicitly included (#2778)
- - [Null] Added Vulkan 'window' surface creation via `VK_EXT_headless_surface`
- - [Null] Added EGL context creation on Mesa via `EGL_MESA_platform_surfaceless`
- - [EGL] Allowed native access on Wayland with `GLFW_CONTEXT_CREATION_API` set to
-   `GLFW_NATIVE_CONTEXT_API` (#2518)
-
-
-## Contact
-
-On [glfw.org](https://www.glfw.org/) you can find the latest version of GLFW, as
-well as news, documentation and other information about the project.
-
-If you have questions related to the use of GLFW, we have a
-[forum](https://discourse.glfw.org/).
-
-If you have a bug to report, a patch to submit or a feature you'd like to
-request, please file it in the
-[issue tracker](https://github.com/glfw/glfw/issues) on GitHub.
-
-Finally, if you're interested in helping out with the development of GLFW or
-porting it to your favorite platform, join us on the forum or GitHub.
+``
+createKeyTables()
+translateKey()
+acquireMonitor()
+releaseMonitor()
+``
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3.h b/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3.h
index dec5700..9c55ac9 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3.h
@@ -1,5 +1,5 @@
 /*************************************************************************
- * GLFW 3.5 - www.glfw.org
+ * GLFW 3.4 - www.glfw.org
  * A library for OpenGL, window and input
  *------------------------------------------------------------------------
  * Copyright (c) 2002-2006 Marcus Geelnard
@@ -291,14 +291,14 @@ extern "C" {
  *  features are added to the API but it remains backward-compatible.
  *  @ingroup init
  */
-#define GLFW_VERSION_MINOR          5
+#define GLFW_VERSION_MINOR          4
 /*! @brief The revision number of the GLFW header.
  *
  *  The revision number of the GLFW header.  This is incremented when a bug fix
  *  release is made that does not contain any API changes.
  *  @ingroup init
  */
-#define GLFW_VERSION_REVISION       1
+#define GLFW_VERSION_REVISION       0
 /*! @} */
 
 /*! @brief One.
@@ -1149,12 +1149,11 @@ extern "C" {
 #define GLFW_OPENGL_CORE_PROFILE    0x00032001
 #define GLFW_OPENGL_COMPAT_PROFILE  0x00032002
 
-#define GLFW_CURSOR                  0x00033001
-#define GLFW_STICKY_KEYS             0x00033002
-#define GLFW_STICKY_MOUSE_BUTTONS    0x00033003
-#define GLFW_LOCK_KEY_MODS           0x00033004
-#define GLFW_RAW_MOUSE_MOTION        0x00033005
-#define GLFW_UNLIMITED_MOUSE_BUTTONS 0x00033006
+#define GLFW_CURSOR                 0x00033001
+#define GLFW_STICKY_KEYS            0x00033002
+#define GLFW_STICKY_MOUSE_BUTTONS   0x00033003
+#define GLFW_LOCK_KEY_MODS          0x00033004
+#define GLFW_RAW_MOUSE_MOTION       0x00033005
 
 #define GLFW_CURSOR_NORMAL          0x00034001
 #define GLFW_CURSOR_HIDDEN          0x00034002
@@ -1228,13 +1227,13 @@ extern "C" {
  *  The top-left to bottom-right diagonal resize/move shape.  This is usually
  *  a diagonal double-headed arrow.
  *
- *  @note __macOS:__ This shape is provided by a private system API and may fail
+ *  @note @macos This shape is provided by a private system API and may fail
  *  with @ref GLFW_CURSOR_UNAVAILABLE in the future.
  *
- *  @note __Wayland:__ This shape is provided by a newer standard not supported by
+ *  @note @wayland This shape is provided by a newer standard not supported by
  *  all cursor themes.
  *
- *  @note __X11:__ This shape is provided by a newer standard not supported by all
+ *  @note @x11 This shape is provided by a newer standard not supported by all
  *  cursor themes.
  */
 #define GLFW_RESIZE_NWSE_CURSOR     0x00036007
@@ -1243,13 +1242,13 @@ extern "C" {
  *  The top-right to bottom-left diagonal resize/move shape.  This is usually
  *  a diagonal double-headed arrow.
  *
- *  @note __macOS:__ This shape is provided by a private system API and may fail
+ *  @note @macos This shape is provided by a private system API and may fail
  *  with @ref GLFW_CURSOR_UNAVAILABLE in the future.
  *
- *  @note __Wayland:__ This shape is provided by a newer standard not supported by
+ *  @note @wayland This shape is provided by a newer standard not supported by
  *  all cursor themes.
  *
- *  @note __X11:__ This shape is provided by a newer standard not supported by all
+ *  @note @x11 This shape is provided by a newer standard not supported by all
  *  cursor themes.
  */
 #define GLFW_RESIZE_NESW_CURSOR     0x00036008
@@ -1264,10 +1263,10 @@ extern "C" {
  *  The operation-not-allowed shape.  This is usually a circle with a diagonal
  *  line through it.
  *
- *  @note __Wayland:__ This shape is provided by a newer standard not supported by
+ *  @note @wayland This shape is provided by a newer standard not supported by
  *  all cursor themes.
  *
- *  @note __X11:__ This shape is provided by a newer standard not supported by all
+ *  @note @x11 This shape is provided by a newer standard not supported by all
  *  cursor themes.
  */
 #define GLFW_NOT_ALLOWED_CURSOR     0x0003600A
@@ -1344,10 +1343,6 @@ extern "C" {
 #define GLFW_PLATFORM_NULL          0x00060005
 /*! @} */
 
-/* Reserved platform define for external Emscripten ports: 0x00060006
- * See https://github.com/pongasoft/emscripten-glfw
- */
-
 #define GLFW_DONT_CARE              -1
 
 
@@ -1633,7 +1628,7 @@ typedef void (* GLFWwindowposfun)(GLFWwindow* window, int xpos, int ypos);
  *  @sa @ref glfwSetWindowSizeCallback
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -1653,7 +1648,7 @@ typedef void (* GLFWwindowsizefun)(GLFWwindow* window, int width, int height);
  *  @sa @ref glfwSetWindowCloseCallback
  *
  *  @since Added in version 2.5.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -1673,7 +1668,7 @@ typedef void (* GLFWwindowclosefun)(GLFWwindow* window);
  *  @sa @ref glfwSetWindowRefreshCallback
  *
  *  @since Added in version 2.5.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -1804,7 +1799,7 @@ typedef void (* GLFWwindowcontentscalefun)(GLFWwindow* window, float xscale, flo
  *  @sa @ref glfwSetMouseButtonCallback
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle and modifier mask parameters.
+ *  @glfw3 Added window handle and modifier mask parameters.
  *
  *  @ingroup input
  */
@@ -1895,7 +1890,7 @@ typedef void (* GLFWscrollfun)(GLFWwindow* window, double xoffset, double yoffse
  *  @sa @ref glfwSetKeyCallback
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle, scancode and modifier mask parameters.
+ *  @glfw3 Added window handle, scancode and modifier mask parameters.
  *
  *  @ingroup input
  */
@@ -1916,7 +1911,7 @@ typedef void (* GLFWkeyfun)(GLFWwindow* window, int key, int scancode, int actio
  *  @sa @ref glfwSetCharCallback
  *
  *  @since Added in version 2.4.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup input
  */
@@ -2024,7 +2019,7 @@ typedef void (* GLFWjoystickfun)(int jid, int event);
  *  @sa @ref glfwGetVideoModes
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added refresh rate member.
+ *  @glfw3 Added refresh rate member.
  *
  *  @ingroup monitor
  */
@@ -2087,7 +2082,7 @@ typedef struct GLFWgammaramp
  *  @sa @ref window_icon
  *
  *  @since Added in version 2.1.
- *  __GLFW 3:__ Removed format and bytes-per-pixel members.
+ *  @glfw3 Removed format and bytes-per-pixel members.
  *
  *  @ingroup window
  */
@@ -2187,12 +2182,12 @@ typedef struct GLFWallocator
  *  @errors Possible errors include @ref GLFW_PLATFORM_UNAVAILABLE and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __macOS:__ This function will change the current directory of the
+ *  @remark @macos This function will change the current directory of the
  *  application to the `Contents/Resources` subdirectory of the application's
  *  bundle, if present.  This can be disabled with the @ref
  *  GLFW_COCOA_CHDIR_RESOURCES init hint.
  *
- *  @remark __macOS:__ This function will create the main menu and dock icon for the
+ *  @remark @macos This function will create the main menu and dock icon for the
  *  application.  If GLFW finds a `MainMenu.nib` it is loaded and assumed to
  *  contain a menu bar.  Otherwise a minimal menu bar is created manually with
  *  common commands like Hide, Quit and About.  The About entry opens a minimal
@@ -2207,7 +2202,7 @@ typedef struct GLFWallocator
  *  to something other than `wayland` or `x11`, the regular detection mechanism
  *  will be used instead.
  *
- *  @remark __X11:__ This function will set the `LC_CTYPE` category of the
+ *  @remark @x11 This function will set the `LC_CTYPE` category of the
  *  application locale according to the current environment if that category is
  *  still "C".  This is because the "C" locale breaks Unicode text input.
  *
@@ -2683,7 +2678,7 @@ GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos,
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
- *  @remark __Win32:__ On Windows 8 and earlier the physical size is calculated from
+ *  @remark @win32 On Windows 8 and earlier the physical size is calculated from
  *  the current resolution and system DPI instead of querying the monitor EDID data.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -2717,7 +2712,7 @@ GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int*
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __Wayland:__ Fractional scaling information is not yet available for
+ *  @remark @wayland Fractional scaling information is not yet available for
  *  monitors, so this function only returns integer content scales.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -2865,7 +2860,7 @@ GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun callback);
  *  @sa @ref glfwGetVideoMode
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Changed to return an array of modes for a specific monitor.
+ *  @glfw3 Changed to return an array of modes for a specific monitor.
  *
  *  @ingroup monitor
  */
@@ -2919,8 +2914,8 @@ GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_INVALID_VALUE,
  *  @ref GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark __Wayland:__ Monitor gamma is a privileged protocol, so this function
- *  cannot be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
+ *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -2943,8 +2938,8 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref GLFW_PLATFORM_ERROR
  *  and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark __Wayland:__ Monitor gamma is a privileged protocol, so this function
- *  cannot be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE while
+ *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE while
  *  returning `NULL`.
  *
  *  @pointer_lifetime The returned structure and its arrays are allocated and
@@ -2985,10 +2980,10 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor);
  *  @remark The size of the specified gamma ramp should match the size of the
  *  current ramp for that monitor.
  *
- *  @remark __Win32:__ The gamma ramp size must be 256.
+ *  @remark @win32 The gamma ramp size must be 256.
  *
- *  @remark __Wayland:__ Monitor gamma is a privileged protocol, so this function
- *  cannot be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
+ *  @remark @wayland Gamma handling is a privileged protocol, this function
+ *  will thus never be implemented and emits @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @pointer_lifetime The specified gamma ramp is copied before this function
  *  returns.
@@ -3163,32 +3158,32 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
  *  GLFW_VERSION_UNAVAILABLE, @ref GLFW_FORMAT_UNAVAILABLE, @ref
  *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR.
  *
- *  @remark __Win32:__ Window creation will fail if the Microsoft GDI software
+ *  @remark @win32 Window creation will fail if the Microsoft GDI software
  *  OpenGL implementation is the only one available.
  *
- *  @remark __Win32:__ If the executable has an icon resource named `GLFW_ICON,` it
+ *  @remark @win32 If the executable has an icon resource named `GLFW_ICON,` it
  *  will be set as the initial icon for the window.  If no such icon is present,
  *  the `IDI_APPLICATION` icon will be used instead.  To set a different icon,
  *  see @ref glfwSetWindowIcon.
  *
- *  @remark __Win32:__ The context to share resources with must not be current on
+ *  @remark @win32 The context to share resources with must not be current on
  *  any other thread.
  *
- *  @remark __macOS:__ The OS only supports core profile contexts for OpenGL
+ *  @remark @macos The OS only supports core profile contexts for OpenGL
  *  versions 3.2 and later.  Before creating an OpenGL context of version 3.2 or
  *  later you must set the [GLFW_OPENGL_PROFILE](@ref GLFW_OPENGL_PROFILE_hint)
  *  hint accordingly.  OpenGL 3.0 and 3.1 contexts are not supported at all
  *  on macOS.
  *
- *  @remark __macOS:__ The GLFW window has no icon, as it is not a document
+ *  @remark @macos The GLFW window has no icon, as it is not a document
  *  window, but the dock icon will be the same as the application bundle's icon.
  *  For more information on bundles, see the
  *  [Bundle Programming Guide][bundle-guide] in the Mac Developer Library.
  *
  *  [bundle-guide]: https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/
  *
- *  @remark __macOS:__  The window frame will not be rendered at full resolution
- *  on Retina displays unless the
+ *  @remark @macos On OS X 10.10 and later the window frame will not be rendered
+ *  at full resolution on Retina displays unless the
  *  [GLFW_SCALE_FRAMEBUFFER](@ref GLFW_SCALE_FRAMEBUFFER_hint)
  *  hint is `GLFW_TRUE` and the `NSHighResolutionCapable` key is enabled in the
  *  application bundle's `Info.plist`.  For more information, see
@@ -3199,11 +3194,11 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
  *
  *  [hidpi-guide]: https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html
  *
- *  @remark __macOS:__ When activating frame autosaving with
+ *  @remark @macos When activating frame autosaving with
  *  [GLFW_COCOA_FRAME_NAME](@ref GLFW_COCOA_FRAME_NAME_hint), the specified
  *  window size and position may be overridden by previously saved values.
  *
- *  @remark __Wayland:__ GLFW uses [libdecor][] where available to create its window
+ *  @remark @wayland GLFW uses [libdecor][] where available to create its window
  *  decorations.  This in turn uses server-side XDG decorations where available
  *  and provides high quality client-side decorations on compositors like GNOME.
  *  If both XDG decorations and libdecor are unavailable, GLFW falls back to
@@ -3212,15 +3207,15 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value);
  *
  *  [libdecor]: https://gitlab.freedesktop.org/libdecor/libdecor
  *
- *  @remark __X11:__ Some window managers will not respect the placement of
+ *  @remark @x11 Some window managers will not respect the placement of
  *  initially hidden windows.
  *
- *  @remark __X11:__ Due to the asynchronous nature of X11, it may take a moment for
+ *  @remark @x11 Due to the asynchronous nature of X11, it may take a moment for
  *  a window to reach its requested state.  This means you may not be able to
  *  query the final size, position or other attributes directly after window
  *  creation.
  *
- *  @remark __X11:__ The class part of the `WM_CLASS` window property will by
+ *  @remark @x11 The class part of the `WM_CLASS` window property will by
  *  default be set to the window title passed to this function.  The instance
  *  part will use the contents of the `RESOURCE_NAME` environment variable, if
  *  present and not empty, or fall back to the window title.  Set the
@@ -3353,7 +3348,7 @@ GLFWAPI const char* glfwGetWindowTitle(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __macOS:__ The window title will not be updated until the next time you
+ *  @remark @macos The window title will not be updated until the next time you
  *  process events.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3362,7 +3357,7 @@ GLFWAPI const char* glfwGetWindowTitle(GLFWwindow* window);
  *  @sa @ref glfwGetWindowTitle
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -3396,14 +3391,14 @@ GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title);
  *  @pointer_lifetime The specified image data is copied before this function
  *  returns.
  *
- *  @remark __macOS:__ Regular windows do not have icons on macOS.  This function
+ *  @remark @macos Regular windows do not have icons on macOS.  This function
  *  will emit @ref GLFW_FEATURE_UNAVAILABLE.  The dock icon will be the same as
  *  the application bundle's icon.  For more information on bundles, see the
  *  [Bundle Programming Guide][bundle-guide] in the Mac Developer Library.
  *
  *  [bundle-guide]: https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/
  *
- *  @remark __Wayland:__ There is no existing protocol to change an icon, the
+ *  @remark @wayland There is no existing protocol to change an icon, the
  *  window will thus inherit the one defined in the application's desktop file.
  *  This function will emit @ref GLFW_FEATURE_UNAVAILABLE.
  *
@@ -3434,8 +3429,8 @@ GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* i
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark __Wayland:__ Window positions are not currently part of any common
- *  Wayland protocol, so this function cannot be implemented and will emit @ref
+ *  @remark @wayland There is no way for an application to retrieve the global
+ *  position of its windows.  This function will emit @ref
  *  GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3468,8 +3463,8 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark __Wayland:__ Window positions are not currently part of any common
- *  Wayland protocol, so this function cannot be implemented and will emit @ref
+ *  @remark @wayland There is no way for an application to set the global
+ *  position of its windows.  This function will emit @ref
  *  GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3478,7 +3473,7 @@ GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos);
  *  @sa @ref glfwGetWindowPos
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -3508,7 +3503,7 @@ GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos);
  *  @sa @ref glfwSetWindowSize
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -3543,7 +3538,7 @@ GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height);
  *  @remark If you set size limits and an aspect ratio that conflict, the
  *  results are undefined.
  *
- *  @remark __Wayland:__ The size limits will not be applied until the window is
+ *  @remark @wayland The size limits will not be applied until the window is
  *  actually resized, either by the user or by the compositor.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3586,7 +3581,7 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minhe
  *  @remark If you set size limits and an aspect ratio that conflict, the
  *  results are undefined.
  *
- *  @remark __Wayland:__ The aspect ratio will not be applied until the window is
+ *  @remark @wayland The aspect ratio will not be applied until the window is
  *  actually resized, either by the user or by the compositor.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3632,7 +3627,7 @@ GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom);
  *  @sa @ref glfwSetWindowMonitor
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -3782,7 +3777,7 @@ GLFWAPI float glfwGetWindowOpacity(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark __Wayland:__ There is no way to set an opacity factor for a window.
+ *  @remark @wayland There is no way to set an opacity factor for a window.
  *  This function will emit @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3811,6 +3806,10 @@ GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
+ *  @remark @wayland Once a window is iconified, @ref glfwRestoreWindow won’t
+ *  be able to restore it.  This is a design decision of the xdg-shell
+ *  protocol.
+ *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify
@@ -3818,7 +3817,7 @@ GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity);
  *  @sa @ref glfwMaximizeWindow
  *
  *  @since Added in version 2.1.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -3838,10 +3837,6 @@ GLFWAPI void glfwIconifyWindow(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __Wayland:__ Restoring a window from maximization is not currently
- *  part of any common Wayland protocol, so this function can only restore
- *  windows from maximization.
- *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify
@@ -3849,7 +3844,7 @@ GLFWAPI void glfwIconifyWindow(GLFWwindow* window);
  *  @sa @ref glfwMaximizeWindow
  *
  *  @since Added in version 2.1.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -3896,7 +3891,7 @@ GLFWAPI void glfwMaximizeWindow(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __Wayland:__ Because Wayland wants every frame of the desktop to be
+ *  @remark @wayland Because Wayland wants every frame of the desktop to be
  *  complete, this function does not immediately make the window visible.
  *  Instead it will become visible the next time the window framebuffer is
  *  updated after this call.
@@ -3959,7 +3954,7 @@ GLFWAPI void glfwHideWindow(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __Wayland:__ The compositor will likely ignore focus requests unless
+ *  @remark @wayland The compositor will likely ignore focus requests unless
  *  another window created by the same application already has input focus.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -3987,7 +3982,7 @@ GLFWAPI void glfwFocusWindow(GLFWwindow* window);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __macOS:__ Attention is requested to the application as a whole, not the
+ *  @remark @macos Attention is requested to the application as a whole, not the
  *  specific window.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -4062,8 +4057,8 @@ GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window);
  *  affected by any resizing or mode switching, although you may need to update
  *  your viewport if the framebuffer size has changed.
  *
- *  @remark __Wayland:__ Window positions are not currently part of any common
- *  Wayland protocol.  The window position arguments are ignored.
+ *  @remark @wayland The desired window position is ignored, as there is no way
+ *  for an application to set this property.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -4100,9 +4095,8 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int
  *  errors.  However, this function should not fail as long as it is passed
  *  valid arguments and the library has been [initialized](@ref intro_init).
  *
- *  @remark __Wayland:__ Checking whether a window is iconified is not currently
- *  part of any common Wayland protocol, so the @ref GLFW_ICONIFIED attribute
- *  cannot be implemented and is always `GLFW_FALSE`.
+ *  @remark @wayland The Wayland protocol provides no way to check whether a
+ *  window is iconfied, so @ref GLFW_ICONIFIED always returns `GLFW_FALSE`.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -4144,7 +4138,7 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib);
  *  @remark Calling @ref glfwGetWindowAttrib will always return the latest
  *  value, even if that value is ignored by the current mode of the window.
  *
- *  @remark __Wayland:__ The [GLFW_FLOATING](@ref GLFW_FLOATING_attrib) window attribute is
+ *  @remark @wayland The [GLFW_FLOATING](@ref GLFW_FLOATING_attrib) window attribute is
  *  not supported.  Setting this will emit @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -4224,8 +4218,8 @@ GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window);
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
- *  @remark __Wayland:__ This callback will not be called.  The Wayland protocol
- *  provides no way to be notified of when a window is moved.
+ *  @remark @wayland This callback will never be called, as there is no way for
+ *  an application to know its global position.
  *
  *  @thread_safety This function must only be called from the main thread.
  *
@@ -4263,7 +4257,7 @@ GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindow
  *  @sa @ref window_size
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter and return value.
+ *  @glfw3 Added window handle parameter and return value.
  *
  *  @ingroup window
  */
@@ -4295,7 +4289,7 @@ GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwind
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
- *  @remark __macOS:__ Selecting Quit from the application menu will trigger the
+ *  @remark @macos Selecting Quit from the application menu will trigger the
  *  close callback for all windows.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -4303,7 +4297,7 @@ GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwind
  *  @sa @ref window_close
  *
  *  @since Added in version 2.5.
- *  __GLFW 3:__ Added window handle parameter and return value.
+ *  @glfw3 Added window handle parameter and return value.
  *
  *  @ingroup window
  */
@@ -4339,7 +4333,7 @@ GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwi
  *  @sa @ref window_refresh
  *
  *  @since Added in version 2.5.
- *  __GLFW 3:__ Added window handle parameter and return value.
+ *  @glfw3 Added window handle parameter and return value.
  *
  *  @ingroup window
  */
@@ -4400,10 +4394,6 @@ GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwi
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED.
  *
- *  @remark __Wayland:__ This callback will not be called.  The Wayland protocol
- *  provides no way to be notified of when a window is iconified, and no way to
- *  check whether a window is currently iconified.
- *
  *  @thread_safety This function must only be called from the main thread.
  *
  *  @sa @ref window_iconify
@@ -4524,8 +4514,7 @@ GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow*
  *  GLFW will pass those events on to the application callbacks before
  *  returning.
  *
- *  Event processing is not required to receive joystick input.  Joystick state
- *  is polled when a joystick input or gamepad input function is called.
+ *  Event processing is not required for joystick input to work.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -4570,8 +4559,7 @@ GLFWAPI void glfwPollEvents(void);
  *  GLFW will pass those events on to the application callbacks before
  *  returning.
  *
- *  Event processing is not required to receive joystick input.  Joystick state
- *  is polled when a joystick input or gamepad input function is called.
+ *  Event processing is not required for joystick input to work.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
@@ -4618,8 +4606,7 @@ GLFWAPI void glfwWaitEvents(void);
  *  GLFW will pass those events on to the application callbacks before
  *  returning.
  *
- *  Event processing is not required to receive joystick input.  Joystick state
- *  is polled when a joystick input or gamepad input function is called.
+ *  Event processing is not required for joystick input to work.
  *
  *  @param[in] timeout The maximum amount of time, in seconds, to wait.
  *
@@ -4689,8 +4676,8 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
  *
  *  This function sets an input mode option for the specified window.  The mode
  *  must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS,
- *  @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS
- *  @ref GLFW_RAW_MOUSE_MOTION, or @ref GLFW_UNLIMITED_MOUSE_BUTTONS.
+ *  @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or
+ *  @ref GLFW_RAW_MOUSE_MOTION.
  *
  *  If the mode is `GLFW_CURSOR`, the value must be one of the following cursor
  *  modes:
@@ -4730,11 +4717,6 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode);
  *  attempting to set this will emit @ref GLFW_FEATURE_UNAVAILABLE.  Call @ref
  *  glfwRawMouseMotionSupported to check for support.
  *
- *  If the mode is `GLFW_UNLIMITED_MOUSE_BUTTONS`, the value must be either
- *  `GLFW_TRUE` to disable the mouse button limit when calling the mouse button
- *  callback, or `GLFW_FALSE` to limit the mouse buttons sent to the callback
- *  to the mouse button token values up to `GLFW_MOUSE_BUTTON_LAST`.
- *
  *  @param[in] window The window whose input mode to set.
  *  @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`,
  *  `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or
@@ -4912,7 +4894,7 @@ GLFWAPI int glfwGetKeyScancode(int key);
  *  @sa @ref input_key
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup input
  */
@@ -4929,11 +4911,8 @@ GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
  *  returns `GLFW_PRESS` the first time you call it for a mouse button that was
  *  pressed, even if that mouse button has already been released.
  *
- *  The @ref GLFW_UNLIMITED_MOUSE_BUTTONS input mode does not effect the
- *  limit on buttons which can be polled with this function.
- *
  *  @param[in] window The desired window.
- *  @param[in] button The desired [mouse button token](@ref buttons).
+ *  @param[in] button The desired [mouse button](@ref buttons).
  *  @return One of `GLFW_PRESS` or `GLFW_RELEASE`.
  *
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
@@ -4944,7 +4923,7 @@ GLFWAPI int glfwGetKey(GLFWwindow* window, int key);
  *  @sa @ref input_mouse_button
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup input
  */
@@ -5014,7 +4993,7 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_PLATFORM_ERROR and @ref GLFW_FEATURE_UNAVAILABLE (see remarks).
  *
- *  @remark __Wayland:__ This function will only work when the cursor mode is
+ *  @remark @wayland This function will only work when the cursor mode is
  *  `GLFW_CURSOR_DISABLED`, otherwise it will emit @ref GLFW_FEATURE_UNAVAILABLE.
  *
  *  @thread_safety This function must only be called from the main thread.
@@ -5212,7 +5191,7 @@ GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor);
  *  @sa @ref input_key
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter and return value.
+ *  @glfw3 Added window handle parameter and return value.
  *
  *  @ingroup input
  */
@@ -5255,7 +5234,7 @@ GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun callback);
  *  @sa @ref input_char
  *
  *  @since Added in version 2.4.
- *  __GLFW 3:__ Added window handle parameter and return value.
+ *  @glfw3 Added window handle parameter and return value.
  *
  *  @ingroup input
  */
@@ -5309,15 +5288,10 @@ GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmods
  *  is called when a mouse button is pressed or released.
  *
  *  When a window loses input focus, it will generate synthetic mouse button
- *  release events for all pressed mouse buttons with associated button tokens.
- *  You can tell these events from user-generated events by the fact that the
- *  synthetic ones are generated after the focus loss event has been processed,
- *  i.e. after the [window focus callback](@ref glfwSetWindowFocusCallback) has
- *  been called.
- *
- *  The reported `button` value can be higher than `GLFW_MOUSE_BUTTON_LAST` if
- *  the button does not have an associated [button token](@ref buttons) and the
- *  @ref GLFW_UNLIMITED_MOUSE_BUTTONS input mode is set.
+ *  release events for all pressed mouse buttons.  You can tell these events
+ *  from user-generated events by the fact that the synthetic ones are generated
+ *  after the focus loss event has been processed, i.e. after the
+ *  [window focus callback](@ref glfwSetWindowFocusCallback) has been called.
  *
  *  @param[in] window The window whose callback to set.
  *  @param[in] callback The new callback, or `NULL` to remove the currently set
@@ -5339,7 +5313,7 @@ GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmods
  *  @sa @ref input_mouse_button
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter and return value.
+ *  @glfw3 Added window handle parameter and return value.
  *
  *  @ingroup input
  */
@@ -5569,7 +5543,7 @@ GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count);
  *  @sa @ref joystick_button
  *
  *  @since Added in version 2.2.
- *  __GLFW 3:__ Changed to return a dynamic array.
+ *  @glfw3 Changed to return a dynamic array.
  *
  *  @ingroup input
  */
@@ -5933,7 +5907,7 @@ GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
  *  GLFW_PLATFORM_ERROR.
  *
- *  @remark __Win32:__ The clipboard on Windows has a single global lock for reading and
+ *  @remark @win32 The clipboard on Windows has a single global lock for reading and
  *  writing.  GLFW tries to acquire it a few times, which is almost always enough.  If it
  *  cannot acquire the lock then this function emits @ref GLFW_PLATFORM_ERROR and returns.
  *  It is safe to try this multiple times.
@@ -5966,7 +5940,7 @@ GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_FORMAT_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR.
  *
- *  @remark __Win32:__ The clipboard on Windows has a single global lock for reading and
+ *  @remark @win32 The clipboard on Windows has a single global lock for reading and
  *  writing.  GLFW tries to acquire it a few times, which is almost always enough.  If it
  *  cannot acquire the lock then this function emits @ref GLFW_PLATFORM_ERROR and returns.
  *  It is safe to try this multiple times.
@@ -6174,10 +6148,6 @@ GLFWAPI GLFWwindow* glfwGetCurrentContext(void);
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR.
  *
- *  @remark __Wayland:__ When the swap interval is greater than zero and the
- *  window is not in view, this function may take a few extra milliseconds to
- *  return.
- *
  *  @remark __EGL:__ The context of the specified window must be current on the
  *  calling thread.
  *
@@ -6187,7 +6157,7 @@ GLFWAPI GLFWwindow* glfwGetCurrentContext(void);
  *  @sa @ref glfwSwapInterval
  *
  *  @since Added in version 1.0.
- *  __GLFW 3:__ Added window handle parameter.
+ *  @glfw3 Added window handle parameter.
  *
  *  @ingroup window
  */
@@ -6454,7 +6424,7 @@ GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* p
  *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
  *  GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR.
  *
- *  @remark __macOS:__ This function currently always returns `GLFW_TRUE`, as the
+ *  @remark @macos This function currently always returns `GLFW_TRUE`, as the
  *  `VK_MVK_macos_surface` and `VK_EXT_metal_surface` extensions do not provide
  *  a `vkGetPhysicalDevice*PresentationSupport` type function.
  *
@@ -6512,15 +6482,15 @@ GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhys
  *  @ref glfwVulkanSupported and @ref glfwGetRequiredInstanceExtensions should
  *  eliminate almost all occurrences of these errors.
  *
- *  @remark __macOS:__ GLFW prefers the `VK_EXT_metal_surface` extension, with the
+ *  @remark @macos GLFW prefers the `VK_EXT_metal_surface` extension, with the
  *  `VK_MVK_macos_surface` extension as a fallback.  The name of the selected
  *  extension, if any, is included in the array returned by @ref
  *  glfwGetRequiredInstanceExtensions.
  *
- *  @remark __macOS:__ This function creates and sets a `CAMetalLayer` instance for
+ *  @remark @macos This function creates and sets a `CAMetalLayer` instance for
  *  the window content view, which is required for MoltenVK to function.
  *
- *  @remark __X11:__ By default GLFW prefers the `VK_KHR_xcb_surface` extension,
+ *  @remark @x11 By default GLFW prefers the `VK_KHR_xcb_surface` extension,
  *  with the `VK_KHR_xlib_surface` extension as a fallback.  You can make
  *  `VK_KHR_xlib_surface` the preferred extension by setting the
  *  [GLFW_X11_XCB_VULKAN_SURFACE](@ref GLFW_X11_XCB_VULKAN_SURFACE_hint) init
diff --git a/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3native.h b/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3native.h
index 8db2cfa..92f0d32 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3native.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/include/GLFW/glfw3native.h
@@ -1,5 +1,5 @@
 /*************************************************************************
- * GLFW 3.5 - www.glfw.org
+ * GLFW 3.4 - www.glfw.org
  * A library for OpenGL, window and input
  *------------------------------------------------------------------------
  * Copyright (c) 2002-2006 Marcus Geelnard
@@ -478,29 +478,6 @@ GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
  *  @ingroup native
  */
 GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window);
-
-/*! @brief Retrieves the `GLXFBConfig` of the specified window's `GLXWindow`.
- *
- *  @param[in] window The window whose `GLXWindow` to query.
- *  @param[out] config The `GLXFBConfig` of the window `GLXWindow`, if available.
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
- *  [error](@ref error_handling) occurred.
- *
- *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref
- *  GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_UNAVAILABLE.
- *
- *  @remark `GLXFBConfig` is an opaque type.  Unlike other GLFW functions, the
- *  @p config out parameter is not cleared on error, as core GLX does not define
- *  any invalid value.
- *
- *  @thread_safety This function may be called from any thread.  Access is not
- *  synchronized.
- *
- *  @since Added in version 3.5
- *
- *  @ingroup native
- */
-GLFWAPI int glfwGetGLXFBConfig(GLFWwindow* window, GLXFBConfig* config);
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
@@ -609,29 +586,6 @@ GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
  *  @ingroup native
  */
 GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
-
-/*! @brief Retrieves the `EGLConfig` of the specified window's `EGLSurface`.
- *
- *  @param[in] window The window whose `EGLSurface` to query.
- *  @param[out] config The `EGLConfig` of the window `EGLSurface`, if available.
- *  @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an
- *  [error](@ref error_handling) occurred.
- *
- *  @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref
- *  GLFW_NO_WINDOW_CONTEXT.
- *
- *  @remark `EGLConfig` is an opaque type.  Unlike other GLFW functions, the @p
- *  config out parameter is not cleared on error, as core EGL does not define
- *  any invalid value.
- *
- *  @thread_safety This function may be called from any thread.  Access is not
- *  synchronized.
- *
- *  @since Added in version 3.5.
- *
- *  @ingroup native
- */
-GLFWAPI int glfwGetEGLConfig(GLFWwindow* window, EGLConfig* config);
 #endif
 
 #if defined(GLFW_EXPOSE_NATIVE_OSMESA)
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/CMakeLists.txt b/src/libraries/raylib/raylib/src/external/glfw/src/CMakeLists.txt
index 24f099f..1057a6f 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/CMakeLists.txt
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/CMakeLists.txt
@@ -10,7 +10,7 @@ add_library(glfw ${GLFW_LIBRARY_TYPE}
 # The time, thread and module code is shared between all backends on a given OS,
 # including the null backend, which still needs those bits to be functional
 if (APPLE)
-    target_sources(glfw PRIVATE macos_time.h macos_time.c posix_thread.h
+    target_sources(glfw PRIVATE cocoa_time.h cocoa_time.c posix_thread.h
                                 posix_module.c posix_thread.c)
 elseif (WIN32)
     target_sources(glfw PRIVATE win32_time.h win32_thread.h win32_module.c
@@ -30,7 +30,6 @@ add_custom_target(update_mappings
 set_target_properties(update_mappings PROPERTIES FOLDER "GLFW3")
 
 if (GLFW_BUILD_COCOA)
-    enable_language(OBJC)
     target_compile_definitions(glfw PRIVATE _GLFW_COCOA)
     target_sources(glfw PRIVATE cocoa_platform.h cocoa_joystick.h cocoa_init.m
                                 cocoa_joystick.m cocoa_monitor.m cocoa_window.m
@@ -46,15 +45,15 @@ endif()
 
 if (GLFW_BUILD_X11)
     target_compile_definitions(glfw PRIVATE _GLFW_X11)
-    target_sources(glfw PRIVATE x11_platform.h x11_init.c
+    target_sources(glfw PRIVATE x11_platform.h xkb_unicode.h x11_init.c
                                 x11_monitor.c x11_window.c xkb_unicode.c
                                 glx_context.c)
 endif()
 
 if (GLFW_BUILD_WAYLAND)
     target_compile_definitions(glfw PRIVATE _GLFW_WAYLAND)
-    target_sources(glfw PRIVATE wl_platform.h wl_init.c
-                                wl_monitor.c wl_window.c)
+    target_sources(glfw PRIVATE wl_platform.h xkb_unicode.h wl_init.c
+                                wl_monitor.c wl_window.c xkb_unicode.c)
 endif()
 
 if (GLFW_BUILD_X11 OR GLFW_BUILD_WAYLAND)
@@ -138,6 +137,13 @@ target_include_directories(glfw PRIVATE
                            "${GLFW_BINARY_DIR}/src")
 target_link_libraries(glfw PRIVATE Threads::Threads)
 
+# Workaround for CMake not knowing about .m files before version 3.16
+if (CMAKE_VERSION VERSION_LESS "3.16" AND APPLE)
+    set_source_files_properties(cocoa_init.m cocoa_joystick.m cocoa_monitor.m
+                                cocoa_window.m nsgl_context.m PROPERTIES
+                                LANGUAGE C)
+endif()
+
 if (GLFW_BUILD_WIN32)
     list(APPEND glfw_PKG_LIBS "-lgdi32")
 endif()
@@ -145,11 +151,10 @@ endif()
 if (GLFW_BUILD_COCOA)
     target_link_libraries(glfw PRIVATE "-framework Cocoa"
                                        "-framework IOKit"
-                                       "-framework QuartzCore")
+                                       "-framework CoreFoundation")
 
-    list(APPEND glfw_PKG_LIBS "-framework Cocoa"
-                              "-framework IOKit"
-                              "-framework QuartzCore")
+    set(glfw_PKG_DEPS "")
+    set(glfw_PKG_LIBS "-framework Cocoa -framework IOKit -framework CoreFoundation")
 endif()
 
 if (GLFW_BUILD_WAYLAND)
@@ -234,11 +239,6 @@ if (UNIX AND NOT APPLE)
     endif()
 endif()
 
-if (APPLE)
-    target_link_libraries(glfw PRIVATE "-framework CoreFoundation")
-    list(APPEND glfw_PKG_LIBS "-framework CoreFoundation")
-endif()
-
 if (WIN32)
     if (GLFW_USE_HYBRID_HPG)
         target_compile_definitions(glfw PRIVATE _GLFW_USE_HYBRID_HPG)
@@ -260,6 +260,24 @@ if (GLFW_BUILD_WIN32)
     target_compile_definitions(glfw PRIVATE UNICODE _UNICODE)
 endif()
 
+# HACK: When building on MinGW, WINVER and UNICODE need to be defined before
+# the inclusion of stddef.h (by glfw3.h), which is itself included before
+# win32_platform.h.  We define them here until a saner solution can be found
+# NOTE: MinGW-w64 and Visual C++ do /not/ need this hack.
+if (MINGW)
+    target_compile_definitions(glfw PRIVATE WINVER=0x0501)
+endif()
+
+# Workaround for legacy MinGW not providing XInput and DirectInput
+if (MINGW)
+    include(CheckIncludeFile)
+    check_include_file(dinput.h DINPUT_H_FOUND)
+    check_include_file(xinput.h XINPUT_H_FOUND)
+    if (NOT DINPUT_H_FOUND OR NOT XINPUT_H_FOUND)
+        target_include_directories(glfw PRIVATE "${GLFW_SOURCE_DIR}/deps/mingw")
+    endif()
+endif()
+
 # Workaround for the MS CRT deprecating parts of the standard library
 if (MSVC OR CMAKE_C_SIMULATE_ID STREQUAL "MSVC")
     target_compile_definitions(glfw PRIVATE _CRT_SECURE_NO_WARNINGS)
@@ -273,6 +291,10 @@ endif()
 if (GLFW_BUILD_SHARED_LIBRARY)
     if (WIN32)
         if (MINGW)
+            # Remove the dependency on the shared version of libgcc
+            # NOTE: MinGW-w64 has the correct default but MinGW needs this
+            target_link_libraries(glfw PRIVATE "-static-libgcc")
+
             # Remove the lib prefix on the DLL (but not the import library)
             set_target_properties(glfw PROPERTIES PREFIX "")
 
@@ -290,34 +312,30 @@ if (GLFW_BUILD_SHARED_LIBRARY)
     if (MINGW)
         # Enable link-time exploit mitigation features enabled by default on MSVC
         include(CheckCCompilerFlag)
-        include(CMakePushCheckState)
 
         # Compatibility with data execution prevention (DEP)
-        cmake_push_check_state()
         set(CMAKE_REQUIRED_FLAGS "-Wl,--nxcompat")
         check_c_compiler_flag("" _GLFW_HAS_DEP)
         if (_GLFW_HAS_DEP)
             target_link_libraries(glfw PRIVATE "-Wl,--nxcompat")
         endif()
-        cmake_pop_check_state()
 
         # Compatibility with address space layout randomization (ASLR)
-        cmake_push_check_state()
         set(CMAKE_REQUIRED_FLAGS "-Wl,--dynamicbase")
         check_c_compiler_flag("" _GLFW_HAS_ASLR)
         if (_GLFW_HAS_ASLR)
             target_link_libraries(glfw PRIVATE "-Wl,--dynamicbase")
         endif()
-        cmake_pop_check_state()
 
         # Compatibility with 64-bit address space layout randomization (ASLR)
-        cmake_push_check_state()
         set(CMAKE_REQUIRED_FLAGS "-Wl,--high-entropy-va")
         check_c_compiler_flag("" _GLFW_HAS_64ASLR)
         if (_GLFW_HAS_64ASLR)
             target_link_libraries(glfw PRIVATE "-Wl,--high-entropy-va")
         endif()
-        cmake_pop_check_state()
+
+        # Clear flags again to avoid breaking later tests
+        set(CMAKE_REQUIRED_FLAGS)
     endif()
 
     if (UNIX)
@@ -326,8 +344,12 @@ if (GLFW_BUILD_SHARED_LIBRARY)
     endif()
 endif()
 
-list(JOIN glfw_PKG_DEPS " " deps)
-list(JOIN glfw_PKG_LIBS " " libs)
+foreach(arg ${glfw_PKG_DEPS})
+    string(APPEND deps " ${arg}")
+endforeach()
+foreach(arg ${glfw_PKG_LIBS})
+    string(APPEND libs " ${arg}")
+endforeach()
 
 set(GLFW_PKG_CONFIG_REQUIRES_PRIVATE "${deps}" CACHE INTERNAL
     "GLFW pkg-config Requires.private")
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_init.m b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_init.m
index 95d6289..f34d985 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_init.m
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_init.m
@@ -1,7 +1,8 @@
 //========================================================================
-// GLFW 3.5 Cocoa - www.glfw.org
+// GLFW 3.4 macOS (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -175,7 +176,7 @@ static void createMenuBar(void)
 
 // Create key code translation tables
 //
-static void createKeyTables(void)
+static void createKeyTablesCocoa(void)
 {
     memset(_glfw.ns.keycodes, -1, sizeof(_glfw.ns.keycodes));
     memset(_glfw.ns.scancodes, -1, sizeof(_glfw.ns.scancodes));
@@ -450,6 +451,41 @@ static GLFWbool initializeTIS(void)
 
 @end // GLFWApplicationDelegate
 
+
+//////////////////////////////////////////////////////////////////////////
+//////                       GLFW internal API                      //////
+//////////////////////////////////////////////////////////////////////////
+
+void* _glfwLoadLocalVulkanLoaderCocoa(void)
+{
+    CFBundleRef bundle = CFBundleGetMainBundle();
+    if (!bundle)
+        return NULL;
+
+    CFURLRef frameworksUrl = CFBundleCopyPrivateFrameworksURL(bundle);
+    if (!frameworksUrl)
+        return NULL;
+
+    CFURLRef loaderUrl = CFURLCreateCopyAppendingPathComponent(
+        kCFAllocatorDefault, frameworksUrl, CFSTR("libvulkan.1.dylib"), false);
+    if (!loaderUrl)
+    {
+        CFRelease(frameworksUrl);
+        return NULL;
+    }
+
+    char path[PATH_MAX];
+    void* handle = NULL;
+
+    if (CFURLGetFileSystemRepresentation(loaderUrl, true, (UInt8*) path, sizeof(path) - 1))
+        handle = _glfwPlatformLoadModule(path);
+
+    CFRelease(loaderUrl);
+    CFRelease(frameworksUrl);
+    return handle;
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
 //////////////////////////////////////////////////////////////////////////
@@ -583,7 +619,7 @@ int _glfwInitCocoa(void)
                name:NSTextInputContextKeyboardSelectionDidChangeNotification
              object:nil];
 
-    createKeyTables();
+    createKeyTablesCocoa();
 
     _glfw.ns.eventSource = CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
     if (!_glfw.ns.eventSource)
@@ -653,8 +689,6 @@ void _glfwTerminateCocoa(void)
     _glfwTerminateEGL();
     _glfwTerminateOSMesa();
 
-    memset(&_glfw.ns, 0, sizeof(_glfw.ns));
-
     } // autoreleasepool
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.h b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.h
index c3a58e2..2f46dfc 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Cocoa - www.glfw.org
+// GLFW 3.4 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.m b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.m
index bb86ad2..d5de479 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.m
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_joystick.m
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Cocoa - www.glfw.org
+// GLFW 3.4 Cocoa - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2019 Camilla Löwy <elmindreda@glfw.org>
 // Copyright (c) 2012 Torsten Walluhn <tw@mad-cad.net>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_monitor.m b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_monitor.m
index 620a8cf..a2bcc2f 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_monitor.m
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_monitor.m
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 Cocoa - www.glfw.org
+// GLFW 3.4 macOS (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -32,7 +33,6 @@
 #include <stdlib.h>
 #include <limits.h>
 #include <math.h>
-#include <assert.h>
 
 #include <IOKit/graphics/IOGraphicsLib.h>
 #include <ApplicationServices/ApplicationServices.h>
@@ -137,7 +137,7 @@ static GLFWbool modeIsGood(CGDisplayModeRef mode)
     if (flags & kDisplayModeStretchedFlag)
         return GLFW_FALSE;
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED == 101100
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
     if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
         CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
@@ -164,7 +164,7 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
     if (result.refreshRate == 0)
         result.refreshRate = (int) round(fallbackRefreshRate);
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED == 101100
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
     if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
     {
@@ -180,7 +180,7 @@ static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode,
         result.blueBits = 8;
     }
 
-#if MAC_OS_X_VERSION_MAX_ALLOWED == 101100
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
     CFRelease(format);
 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
     return result;
@@ -628,6 +628,7 @@ void _glfwSetGammaRampCocoa(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 
 GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* handle)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(kCGNullDirectDisplay);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_COCOA)
@@ -636,9 +637,6 @@ GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* handle)
         return kCGNullDirectDisplay;
     }
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     return monitor->ns.displayID;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_platform.h b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_platform.h
index 175372d..3991455 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_platform.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_platform.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Cocoa - www.glfw.org
+// GLFW 3.4 macOS - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2019 Camilla Löwy <elmindreda@glfw.org>
 //
@@ -291,6 +291,8 @@ void _glfwRestoreVideoModeCocoa(_GLFWmonitor* monitor);
 
 float _glfwTransformYCocoa(float y);
 
+void* _glfwLoadLocalVulkanLoaderCocoa(void);
+
 GLFWbool _glfwInitNSGL(void);
 void _glfwTerminateNSGL(void);
 GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_window.m b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_window.m
index 6104980..949cace 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_window.m
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/cocoa_window.m
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Cocoa - www.glfw.org
+// GLFW 3.4 macOS - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2019 Camilla Löwy <elmindreda@glfw.org>
 //
@@ -28,11 +28,8 @@
 
 #if defined(_GLFW_COCOA)
 
-#import <QuartzCore/CAMetalLayer.h>
-
 #include <float.h>
 #include <string.h>
-#include <assert.h>
 
 // HACK: This enum value is missing from framework headers on OS X 10.11 despite
 //       having been (according to documentation) added in Mac OS X 10.7
@@ -114,7 +111,7 @@ static void updateCursorMode(_GLFWwindow* window)
 
 // Make the specified window and its video mode active on its monitor
 //
-static void acquireMonitor(_GLFWwindow* window)
+static void acquireMonitorCocoa(_GLFWwindow* window)
 {
     _glfwSetVideoModeCocoa(window->monitor, &window->videoMode);
     const CGRect bounds = CGDisplayBounds(window->monitor->ns.displayID);
@@ -130,7 +127,7 @@ static void acquireMonitor(_GLFWwindow* window)
 
 // Remove the window and restore the original video mode
 //
-static void releaseMonitor(_GLFWwindow* window)
+static void releaseMonitorCocoa(_GLFWwindow* window)
 {
     if (window->monitor->window != window)
         return;
@@ -161,7 +158,7 @@ static int translateFlags(NSUInteger flags)
 
 // Translates a macOS keycode to a GLFW keycode
 //
-static int translateKey(unsigned int key)
+static int translateKeyCocoa(unsigned int key)
 {
     if (key >= sizeof(_glfw.ns.keycodes) / sizeof(_glfw.ns.keycodes[0]))
         return GLFW_KEY_UNKNOWN;
@@ -280,7 +277,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 - (void)windowDidMiniaturize:(NSNotification *)notification
 {
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorCocoa(window);
 
     _glfwInputWindowIconify(window, GLFW_TRUE);
 }
@@ -288,7 +285,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 - (void)windowDidDeminiaturize:(NSNotification *)notification
 {
     if (window->monitor)
-        acquireMonitor(window);
+        acquireMonitorCocoa(window);
 
     _glfwInputWindowIconify(window, GLFW_FALSE);
 }
@@ -312,6 +309,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (void)windowDidChangeOcclusionState:(NSNotification* )notification
 {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1090
     if ([window->ns.object respondsToSelector:@selector(occlusionState)])
     {
         if ([window->ns.object occlusionState] & NSWindowOcclusionStateVisible)
@@ -319,6 +317,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
         else
             window->ns.occluded = GLFW_TRUE;
     }
+#endif
 }
 
 @end
@@ -562,7 +561,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (void)keyDown:(NSEvent *)event
 {
-    const int key = translateKey([event keyCode]);
+    const int key = translateKeyCocoa([event keyCode]);
     const int mods = translateFlags([event modifierFlags]);
 
     _glfwInputKey(window, key, [event keyCode], GLFW_PRESS, mods);
@@ -575,7 +574,7 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
     int action;
     const unsigned int modifierFlags =
         [event modifierFlags] & NSEventModifierFlagDeviceIndependentFlagsMask;
-    const int key = translateKey([event keyCode]);
+    const int key = translateKeyCocoa([event keyCode]);
     const int mods = translateFlags(modifierFlags);
     const NSUInteger keyFlag = translateKeyToModifierFlag(key);
 
@@ -594,39 +593,11 @@ static const NSRange kEmptyRange = { NSNotFound, 0 };
 
 - (void)keyUp:(NSEvent *)event
 {
-    const int key = translateKey([event keyCode]);
+    const int key = translateKeyCocoa([event keyCode]);
     const int mods = translateFlags([event modifierFlags]);
     _glfwInputKey(window, key, [event keyCode], GLFW_RELEASE, mods);
 }
 
-- (BOOL)performKeyEquivalent:(NSEvent *)event
-{
-    // HACK: Some key combinations are consumed before reaching keyDown:
-    //       so we claim those events and emit them here
-    const int key = translateKey([event keyCode]);
-    const int mods = translateFlags([event modifierFlags]);
-
-    if (mods & GLFW_MOD_CONTROL)
-    {
-        if (key == GLFW_KEY_TAB || key == GLFW_KEY_ESCAPE)
-        {
-            _glfwInputKey(window, key, [event keyCode], GLFW_PRESS, mods);
-            return YES;
-        }
-    }
-
-    if (mods & GLFW_MOD_SUPER)
-    {
-        if (key == GLFW_KEY_PERIOD)
-        {
-            _glfwInputKey(window, key, [event keyCode], GLFW_PRESS, mods);
-            return YES;
-        }
-    }
-
-    return [super performKeyEquivalent:event];
-}
-
 - (void)scrollWheel:(NSEvent *)event
 {
     double deltaX = [event scrollingDeltaX];
@@ -912,7 +883,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
 
     [window->ns.object setContentView:window->ns.view];
     [window->ns.object makeFirstResponder:window->ns.view];
-    [window->ns.object setTitle:@(window->title)];
+    [window->ns.object setTitle:@(wndconfig->title)];
     [window->ns.object setDelegate:window->ns.delegate];
     [window->ns.object setAcceptsMouseMovedEvents:YES];
     [window->ns.object setRestorable:NO];
@@ -995,7 +966,7 @@ GLFWbool _glfwCreateWindowCocoa(_GLFWwindow* window,
     {
         _glfwShowWindowCocoa(window);
         _glfwFocusWindowCocoa(window);
-        acquireMonitor(window);
+        acquireMonitorCocoa(window);
 
         if (wndconfig->centerCursor)
             _glfwCenterCursorInContentArea(window);
@@ -1025,7 +996,7 @@ void _glfwDestroyWindowCocoa(_GLFWwindow* window)
     [window->ns.object orderOut:nil];
 
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorCocoa(window);
 
     if (window->context.destroy)
         window->context.destroy(window);
@@ -1112,7 +1083,7 @@ void _glfwSetWindowSizeCocoa(_GLFWwindow* window, int width, int height)
     if (window->monitor)
     {
         if (window->monitor->window == window)
-            acquireMonitor(window);
+            acquireMonitorCocoa(window);
     }
     else
     {
@@ -1281,7 +1252,7 @@ void _glfwSetWindowMonitorCocoa(_GLFWwindow* window,
         if (monitor)
         {
             if (monitor->window == window)
-                acquireMonitor(window);
+                acquireMonitorCocoa(window);
         }
         else
         {
@@ -1299,7 +1270,7 @@ void _glfwSetWindowMonitorCocoa(_GLFWwindow* window,
     }
 
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorCocoa(window);
 
     _glfwInputWindowMonitor(window, monitor);
 
@@ -1337,7 +1308,7 @@ void _glfwSetWindowMonitorCocoa(_GLFWwindow* window,
         [window->ns.object setLevel:NSMainMenuWindowLevel + 1];
         [window->ns.object setHasShadow:NO];
 
-        acquireMonitor(window);
+        acquireMonitorCocoa(window);
     }
     else
     {
@@ -1978,8 +1949,19 @@ VkResult _glfwCreateWindowSurfaceCocoa(VkInstance instance,
 {
     @autoreleasepool {
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101100
+    // HACK: Dynamically load Core Animation to avoid adding an extra
+    //       dependency for the majority who don't use MoltenVK
+    NSBundle* bundle = [NSBundle bundleWithPath:@"/System/Library/Frameworks/QuartzCore.framework"];
+    if (!bundle)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Cocoa: Failed to find QuartzCore.framework");
+        return VK_ERROR_EXTENSION_NOT_PRESENT;
+    }
+
     // NOTE: Create the layer here as makeBackingLayer should not return nil
-    window->ns.layer = [CAMetalLayer layer];
+    window->ns.layer = [[bundle classNamed:@"CAMetalLayer"] layer];
     if (!window->ns.layer)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -2044,6 +2026,9 @@ VkResult _glfwCreateWindowSurfaceCocoa(VkInstance instance,
     }
 
     return err;
+#else
+    return VK_ERROR_EXTENSION_NOT_PRESENT;
+#endif
 
     } // autoreleasepool
 }
@@ -2055,6 +2040,7 @@ VkResult _glfwCreateWindowSurfaceCocoa(VkInstance instance,
 
 GLFWAPI id glfwGetCocoaWindow(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(nil);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_COCOA)
@@ -2064,14 +2050,12 @@ GLFWAPI id glfwGetCocoaWindow(GLFWwindow* handle)
         return nil;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     return window->ns.object;
 }
 
 GLFWAPI id glfwGetCocoaView(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(nil);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_COCOA)
@@ -2081,9 +2065,6 @@ GLFWAPI id glfwGetCocoaView(GLFWwindow* handle)
         return nil;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     return window->ns.view;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/context.c b/src/libraries/raylib/raylib/src/external/glfw/src/context.c
index a584cb1..bcb2b51 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/context.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/context.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2016 Camilla Löwy <elmindreda@glfw.org>
@@ -195,7 +195,7 @@ const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
     {
         current = alternatives + i;
 
-        if (desired->stereo && !current->stereo)
+        if (desired->stereo > 0 && current->stereo == 0)
         {
             // Stereo is a hard constraint
             continue;
@@ -359,7 +359,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
     window->context.source = ctxconfig->source;
     window->context.client = GLFW_OPENGL_API;
 
-    previous = _glfwPlatformGetTls(&_glfw.contextSlot);
+    previous = (_GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
     glfwMakeContextCurrent((GLFWwindow*) window);
     if (_glfwPlatformGetTls(&_glfw.contextSlot) != window)
         return GLFW_FALSE;
@@ -368,12 +368,7 @@ GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
         window->context.getProcAddress("glGetIntegerv");
     window->context.GetString = (PFNGLGETSTRINGPROC)
         window->context.getProcAddress("glGetString");
-    window->context.Flush = (PFNGLFLUSHPROC)
-        window->context.getProcAddress("glFlush");
-
-    if (!window->context.GetIntegerv ||
-        !window->context.GetString ||
-        !window->context.Flush)
+    if (!window->context.GetIntegerv || !window->context.GetString)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR, "Entry point retrieval is broken");
         glfwMakeContextCurrent((GLFWwindow*) previous);
@@ -620,12 +615,12 @@ GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions
 
 GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFWwindow* window = (_GLFWwindow *) handle;
     _GLFWwindow* previous;
 
-    previous = _glfwPlatformGetTls(&_glfw.contextSlot);
+    _GLFW_REQUIRE_INIT();
+
+    previous = (_GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
 
     if (window && window->context.client == GLFW_NO_API)
     {
@@ -647,16 +642,16 @@ GLFWAPI void glfwMakeContextCurrent(GLFWwindow* handle)
 GLFWAPI GLFWwindow* glfwGetCurrentContext(void)
 {
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-    return _glfwPlatformGetTls(&_glfw.contextSlot);
+    return (GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
 }
 
 GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
+    _GLFWwindow* window = (_GLFWwindow *) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     if (window->context.client == GLFW_NO_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT,
@@ -673,7 +668,7 @@ GLFWAPI void glfwSwapInterval(int interval)
 
     _GLFW_REQUIRE_INIT();
 
-    window = _glfwPlatformGetTls(&_glfw.contextSlot);
+    window = (_GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT,
@@ -691,7 +686,7 @@ GLFWAPI int glfwExtensionSupported(const char* extension)
 
     _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
 
-    window = _glfwPlatformGetTls(&_glfw.contextSlot);
+    window = (_GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT,
@@ -757,7 +752,7 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    window = _glfwPlatformGetTls(&_glfw.contextSlot);
+    window = (_GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
     if (!window)
     {
         _glfwInputError(GLFW_NO_CURRENT_CONTEXT,
@@ -767,4 +762,3 @@ GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
 
     return window->context.getProcAddress(procname);
 }
-
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/egl_context.c b/src/libraries/raylib/raylib/src/external/glfw/src/egl_context.c
index 4d436d3..19ab3df 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/egl_context.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/egl_context.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 EGL - www.glfw.org
+// GLFW 3.4 EGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -92,7 +92,7 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
     EGLConfig* nativeConfigs;
     _GLFWfbconfig* usableConfigs;
     const _GLFWfbconfig* closest;
-    int i, nativeCount, usableCount, apiBit, surfaceTypeBit;
+    int i, nativeCount, usableCount, apiBit;
     GLFWbool wrongApiAvailable = GLFW_FALSE;
 
     if (ctxconfig->client == GLFW_OPENGL_ES_API)
@@ -105,11 +105,6 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
     else
         apiBit = EGL_OPENGL_BIT;
 
-    if (_glfw.egl.platform == EGL_PLATFORM_SURFACELESS_MESA)
-        surfaceTypeBit = EGL_PBUFFER_BIT;
-    else
-        surfaceTypeBit = EGL_WINDOW_BIT;
-
     if (fbconfig->stereo)
     {
         _glfwInputError(GLFW_FORMAT_UNAVAILABLE, "EGL: Stereo rendering not supported");
@@ -123,10 +118,10 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
         return GLFW_FALSE;
     }
 
-    nativeConfigs = _glfw_calloc(nativeCount, sizeof(EGLConfig));
+    nativeConfigs = (EGLConfig *)_glfw_calloc(nativeCount, sizeof(EGLConfig));
     eglGetConfigs(_glfw.egl.display, nativeConfigs, nativeCount, &nativeCount);
 
-    usableConfigs = _glfw_calloc(nativeCount, sizeof(_GLFWfbconfig));
+    usableConfigs = (_GLFWfbconfig *)_glfw_calloc(nativeCount, sizeof(_GLFWfbconfig));
     usableCount = 0;
 
     for (i = 0;  i < nativeCount;  i++)
@@ -138,7 +133,8 @@ static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
         if (getEGLConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) != EGL_RGB_BUFFER)
             continue;
 
-        if (!(getEGLConfigAttrib(n, EGL_SURFACE_TYPE) & surfaceTypeBit))
+        // Only consider window EGLConfigs
+        if (!(getEGLConfigAttrib(n, EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
             continue;
 
 #if defined(_GLFW_X11)
@@ -254,12 +250,6 @@ static void makeContextCurrentEGL(_GLFWwindow* window)
                             getEGLErrorString(eglGetError()));
             return;
         }
-
-#if defined(_GLFW_WAYLAND)
-        // NOTE: Disable EGL vsync so we can substitute our own that includes a timeout
-        if (_glfw.platform.platformID == GLFW_PLATFORM_WAYLAND)
-            eglSwapInterval(_glfw.egl.display, 0);
-#endif // _GLFW_WAYLAND
     }
     else
     {
@@ -293,15 +283,6 @@ static void swapBuffersEGL(_GLFWwindow* window)
         // NOTE: Swapping buffers on a hidden window on Wayland makes it visible
         if (!window->wl.visible)
             return;
-
-        // NOTE: We wait for a frame manually so we can add a timeout,
-        //       as the EGL implementation will wait indefinitely
-        if (window->wl.egl.interval > 0)
-        {
-            window->context.Flush();
-            if (!_glfwWaitForEGLFrameWayland(window))
-                return;
-        }
     }
 #endif
 
@@ -310,16 +291,6 @@ static void swapBuffersEGL(_GLFWwindow* window)
 
 static void swapIntervalEGL(int interval)
 {
-#if defined(_GLFW_WAYLAND)
-    if (_glfw.platform.platformID == GLFW_PLATFORM_WAYLAND)
-    {
-        _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
-        assert(window != NULL);
-        window->wl.egl.interval = interval;
-        return;
-    }
-#endif
-
     eglSwapInterval(_glfw.egl.display, interval);
 }
 
@@ -337,19 +308,18 @@ static int extensionSupportedEGL(const char* extension)
 
 static GLFWglproc getProcAddressEGL(const char* procname)
 {
-    const GLFWglproc proc = (GLFWglproc) eglGetProcAddress(procname);
-    if (proc)
-        return proc;
+    _GLFWwindow* window = (_GLFWwindow *)_glfwPlatformGetTls(&_glfw.contextSlot);
+    assert(window != NULL);
 
-    if (!_glfw.egl.KHR_get_all_proc_addresses)
+    if (window->context.egl.client)
     {
-        _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
-        assert(window != NULL);
-
-        return _glfwPlatformGetModuleSymbol(window->context.egl.client, procname);
+        GLFWglproc proc = (GLFWglproc)
+            _glfwPlatformGetModuleSymbol(window->context.egl.client, procname);
+        if (proc)
+            return proc;
     }
 
-    return NULL;
+    return eglGetProcAddress(procname);
 }
 
 static void destroyContextEGL(_GLFWwindow* window)
@@ -359,8 +329,11 @@ static void destroyContextEGL(_GLFWwindow* window)
     if (_glfw.platform.platformID != GLFW_PLATFORM_X11 ||
         window->context.client != GLFW_OPENGL_API)
     {
-        _glfwPlatformFreeModule(window->context.egl.client);
-        window->context.egl.client = NULL;
+        if (window->context.egl.client)
+        {
+            _glfwPlatformFreeModule(window->context.egl.client);
+            window->context.egl.client = NULL;
+        }
     }
 
     if (window->context.egl.surface)
@@ -381,6 +354,8 @@ static void destroyContextEGL(_GLFWwindow* window)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+// Initialize EGL
+//
 GLFWbool _glfwInitEGL(void)
 {
     int i;
@@ -390,10 +365,10 @@ GLFWbool _glfwInitEGL(void)
     {
 #if defined(_GLFW_EGL_LIBRARY)
         _GLFW_EGL_LIBRARY,
-#elif defined(_WIN32)
+#elif defined(_GLFW_WIN32)
         "libEGL.dll",
         "EGL.dll",
-#elif defined(__APPLE__)
+#elif defined(_GLFW_COCOA)
         "libEGL.dylib",
 #elif defined(__CYGWIN__)
         "libEGL-1.so",
@@ -445,8 +420,6 @@ GLFWbool _glfwInitEGL(void)
         _glfwPlatformGetModuleSymbol(_glfw.egl.handle, "eglDestroyContext");
     _glfw.egl.CreateWindowSurface = (PFN_eglCreateWindowSurface)
         _glfwPlatformGetModuleSymbol(_glfw.egl.handle, "eglCreateWindowSurface");
-    _glfw.egl.CreatePbufferSurface = (PFN_eglCreatePbufferSurface)
-        _glfwPlatformGetModuleSymbol(_glfw.egl.handle, "eglCreatePbufferSurface");
     _glfw.egl.MakeCurrent = (PFN_eglMakeCurrent)
         _glfwPlatformGetModuleSymbol(_glfw.egl.handle, "eglMakeCurrent");
     _glfw.egl.SwapBuffers = (PFN_eglSwapBuffers)
@@ -469,7 +442,6 @@ GLFWbool _glfwInitEGL(void)
         !_glfw.egl.DestroySurface ||
         !_glfw.egl.DestroyContext ||
         !_glfw.egl.CreateWindowSurface ||
-        !_glfw.egl.CreatePbufferSurface ||
         !_glfw.egl.MakeCurrent ||
         !_glfw.egl.SwapBuffers ||
         !_glfw.egl.SwapInterval ||
@@ -505,8 +477,6 @@ GLFWbool _glfwInitEGL(void)
             _glfwStringInExtensionString("EGL_ANGLE_platform_angle_vulkan", extensions);
         _glfw.egl.ANGLE_platform_angle_metal =
             _glfwStringInExtensionString("EGL_ANGLE_platform_angle_metal", extensions);
-        _glfw.egl.MESA_platform_surfaceless =
-            _glfwStringInExtensionString("EGL_MESA_platform_surfaceless", extensions);
     }
 
     if (_glfw.egl.EXT_platform_base)
@@ -566,6 +536,8 @@ GLFWbool _glfwInitEGL(void)
     return GLFW_TRUE;
 }
 
+// Terminate EGL
+//
 void _glfwTerminateEGL(void)
 {
     if (_glfw.egl.display)
@@ -574,8 +546,7 @@ void _glfwTerminateEGL(void)
         _glfw.egl.display = EGL_NO_DISPLAY;
     }
 
-    // Free modules only after all wayland termination functions are called
-    if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
+    if (_glfw.egl.handle)
     {
         _glfwPlatformFreeModule(_glfw.egl.handle);
         _glfw.egl.handle = NULL;
@@ -589,6 +560,8 @@ void _glfwTerminateEGL(void)
     attribs[index++] = v; \
 }
 
+// Create the OpenGL or OpenGL ES context
+//
 GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig)
@@ -675,7 +648,7 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         if (ctxconfig->noerror)
         {
             if (_glfw.egl.KHR_create_context_no_error)
-                SET_ATTRIB(EGL_CONTEXT_OPENGL_NO_ERROR_KHR, true);
+                SET_ATTRIB(EGL_CONTEXT_OPENGL_NO_ERROR_KHR, GLFW_TRUE);
         }
 
         if (mask)
@@ -735,36 +708,20 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
             SET_ATTRIB(EGL_PRESENT_OPAQUE_EXT, !fbconfig->transparent);
     }
 
-    if (_glfw.egl.platform == EGL_PLATFORM_SURFACELESS_MESA)
-    {
-        int width, height;
-        _glfw.platform.getFramebufferSize(window, &width, &height);
-
-        SET_ATTRIB(EGL_WIDTH, width);
-        SET_ATTRIB(EGL_HEIGHT, height);
-    }
-
     SET_ATTRIB(EGL_NONE, EGL_NONE);
 
     native = _glfw.platform.getEGLNativeWindow(window);
-    if (!_glfw.egl.platform || _glfw.egl.platform == EGL_PLATFORM_ANGLE_ANGLE)
+    // HACK: ANGLE does not implement eglCreatePlatformWindowSurfaceEXT
+    //       despite reporting EGL_EXT_platform_base
+    if (_glfw.egl.platform && _glfw.egl.platform != EGL_PLATFORM_ANGLE_ANGLE)
     {
-        // HACK: Also use non-platform function for ANGLE, as it does not
-        //       implement eglCreatePlatformWindowSurfaceEXT despite reporting
-        //       support for EGL_EXT_platform_base
         window->context.egl.surface =
-            eglCreateWindowSurface(_glfw.egl.display, config, native, attribs);
-    }
-    else if (_glfw.egl.platform == EGL_PLATFORM_SURFACELESS_MESA)
-    {
-        // HACK: Use a pbuffer surface as the default framebuffer
-        window->context.egl.surface =
-            eglCreatePbufferSurface(_glfw.egl.display, config, attribs);
+            eglCreatePlatformWindowSurfaceEXT(_glfw.egl.display, config, native, attribs);
     }
     else
     {
         window->context.egl.surface =
-            eglCreatePlatformWindowSurfaceEXT(_glfw.egl.display, config, native, attribs);
+            eglCreateWindowSurface(_glfw.egl.display, config, native, attribs);
     }
 
     if (window->context.egl.surface == EGL_NO_SURFACE)
@@ -786,10 +743,10 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         {
 #if defined(_GLFW_GLESV1_LIBRARY)
             _GLFW_GLESV1_LIBRARY,
-#elif defined(_WIN32)
+#elif defined(_GLFW_WIN32)
             "GLESv1_CM.dll",
             "libGLES_CM.dll",
-#elif defined(__APPLE__)
+#elif defined(_GLFW_COCOA)
             "libGLESv1_CM.dylib",
 #elif defined(__OpenBSD__) || defined(__NetBSD__)
             "libGLESv1_CM.so",
@@ -803,10 +760,10 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         {
 #if defined(_GLFW_GLESV2_LIBRARY)
             _GLFW_GLESV2_LIBRARY,
-#elif defined(_WIN32)
+#elif defined(_GLFW_WIN32)
             "GLESv2.dll",
             "libGLESv2.dll",
-#elif defined(__APPLE__)
+#elif defined(_GLFW_COCOA)
             "libGLESv2.dylib",
 #elif defined(__CYGWIN__)
             "libGLESv2-2.so",
@@ -821,8 +778,8 @@ GLFWbool _glfwCreateContextEGL(_GLFWwindow* window,
         {
 #if defined(_GLFW_OPENGL_LIBRARY)
             _GLFW_OPENGL_LIBRARY,
-#elif defined(_WIN32)
-#elif defined(__APPLE__)
+#elif defined(_GLFW_WIN32)
+#elif defined(_GLFW_COCOA)
 #elif defined(__OpenBSD__) || defined(__NetBSD__)
             "libGL.so",
 #else
@@ -926,19 +883,13 @@ GLFWAPI EGLDisplay glfwGetEGLDisplay(void)
 
 GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow *) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_CONTEXT);
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->context.source != GLFW_EGL_CONTEXT_API)
     {
-        if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND ||
-            window->context.source != GLFW_NATIVE_CONTEXT_API)
-        {
-            _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
-            return EGL_NO_CONTEXT;
-        }
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return EGL_NO_CONTEXT;
     }
 
     return window->context.egl.handle;
@@ -946,43 +897,14 @@ GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
 
 GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow *) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_SURFACE);
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->context.source != GLFW_EGL_CONTEXT_API)
     {
-        if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND ||
-            window->context.source != GLFW_NATIVE_CONTEXT_API)
-        {
-            _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
-            return EGL_NO_SURFACE;
-        }
+        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
+        return EGL_NO_SURFACE;
     }
 
     return window->context.egl.surface;
 }
-
-GLFWAPI int glfwGetEGLConfig(GLFWwindow* handle, EGLConfig* config)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-    assert(config != NULL);
-
-    if (window->context.source != GLFW_EGL_CONTEXT_API)
-    {
-        if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND ||
-            window->context.source != GLFW_NATIVE_CONTEXT_API)
-        {
-            _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
-            return GLFW_FALSE;
-        }
-    }
-
-    *config = window->context.egl.config;
-    return GLFW_TRUE;
-}
-
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/glx_context.c b/src/libraries/raylib/raylib/src/external/glfw/src/glx_context.c
index f56f674..7082682 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/glx_context.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/glx_context.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 GLX - www.glfw.org
+// GLFW 3.4 GLX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -119,7 +119,9 @@ static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
         u->accumAlphaBits = getGLXFBConfigAttrib(n, GLX_ACCUM_ALPHA_SIZE);
 
         u->auxBuffers = getGLXFBConfigAttrib(n, GLX_AUX_BUFFERS);
-        u->stereo = getGLXFBConfigAttrib(n, GLX_STEREO);
+
+        if (getGLXFBConfigAttrib(n, GLX_STEREO))
+            u->stereo = GLFW_TRUE;
 
         if (_glfw.glx.ARB_multisample)
             u->samples = getGLXFBConfigAttrib(n, GLX_SAMPLES);
@@ -251,6 +253,8 @@ static void destroyContextGLX(_GLFWwindow* window)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+// Initialize GLX
+//
 GLFWbool _glfwInitGLX(void)
 {
     const char* sonames[] =
@@ -365,7 +369,7 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXSwapIntervalEXT");
 
         if (_glfw.glx.SwapIntervalEXT)
-            _glfw.glx.EXT_swap_control = true;
+            _glfw.glx.EXT_swap_control = GLFW_TRUE;
     }
 
     if (extensionSupportedGLX("GLX_SGI_swap_control"))
@@ -374,7 +378,7 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXSwapIntervalSGI");
 
         if (_glfw.glx.SwapIntervalSGI)
-            _glfw.glx.SGI_swap_control = true;
+            _glfw.glx.SGI_swap_control = GLFW_TRUE;
     }
 
     if (extensionSupportedGLX("GLX_MESA_swap_control"))
@@ -383,17 +387,17 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXSwapIntervalMESA");
 
         if (_glfw.glx.SwapIntervalMESA)
-            _glfw.glx.MESA_swap_control = true;
+            _glfw.glx.MESA_swap_control = GLFW_TRUE;
     }
 
     if (extensionSupportedGLX("GLX_ARB_multisample"))
-        _glfw.glx.ARB_multisample = true;
+        _glfw.glx.ARB_multisample = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_ARB_framebuffer_sRGB"))
-        _glfw.glx.ARB_framebuffer_sRGB = true;
+        _glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_EXT_framebuffer_sRGB"))
-        _glfw.glx.EXT_framebuffer_sRGB = true;
+        _glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_ARB_create_context"))
     {
@@ -401,34 +405,39 @@ GLFWbool _glfwInitGLX(void)
             getProcAddressGLX("glXCreateContextAttribsARB");
 
         if (_glfw.glx.CreateContextAttribsARB)
-            _glfw.glx.ARB_create_context = true;
+            _glfw.glx.ARB_create_context = GLFW_TRUE;
     }
 
     if (extensionSupportedGLX("GLX_ARB_create_context_robustness"))
-        _glfw.glx.ARB_create_context_robustness = true;
+        _glfw.glx.ARB_create_context_robustness = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_ARB_create_context_profile"))
-        _glfw.glx.ARB_create_context_profile = true;
+        _glfw.glx.ARB_create_context_profile = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile"))
-        _glfw.glx.EXT_create_context_es2_profile = true;
+        _glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_ARB_create_context_no_error"))
-        _glfw.glx.ARB_create_context_no_error = true;
+        _glfw.glx.ARB_create_context_no_error = GLFW_TRUE;
 
     if (extensionSupportedGLX("GLX_ARB_context_flush_control"))
-        _glfw.glx.ARB_context_flush_control = true;
+        _glfw.glx.ARB_context_flush_control = GLFW_TRUE;
 
     return GLFW_TRUE;
 }
 
+// Terminate GLX
+//
 void _glfwTerminateGLX(void)
 {
     // NOTE: This function must not call any X11 functions, as it is called
     //       after XCloseDisplay (see _glfwTerminateX11 for details)
 
-    _glfwPlatformFreeModule(_glfw.glx.handle);
-    _glfw.glx.handle = NULL;
+    if (_glfw.glx.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.glx.handle);
+        _glfw.glx.handle = NULL;
+    }
 }
 
 #define SET_ATTRIB(a, v) \
@@ -438,6 +447,8 @@ void _glfwTerminateGLX(void)
     attribs[index++] = v; \
 }
 
+// Create the OpenGL or OpenGL ES context
+//
 GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig)
@@ -615,8 +626,6 @@ GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
         return GLFW_FALSE;
     }
 
-    window->context.glx.fbconfig = native;
-
     window->context.makeCurrent = makeContextCurrentGLX;
     window->context.swapBuffers = swapBuffersGLX;
     window->context.swapInterval = swapIntervalGLX;
@@ -668,6 +677,7 @@ GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
 
 GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
@@ -676,9 +686,6 @@ GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
         return NULL;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->context.source != GLFW_NATIVE_CONTEXT_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
@@ -690,6 +697,7 @@ GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
 
 GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(None);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
@@ -698,9 +706,6 @@ GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
         return None;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->context.source != GLFW_NATIVE_CONTEXT_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
@@ -710,29 +715,5 @@ GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
     return window->context.glx.window;
 }
 
-GLFWAPI int glfwGetGLXFBConfig(GLFWwindow* handle, GLXFBConfig* config)
-{
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-
-    if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
-    {
-        _glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "GLX: Platform not initialized");
-        return GLFW_FALSE;
-    }
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-    assert(config != NULL);
-
-    if (window->context.source != GLFW_NATIVE_CONTEXT_API)
-    {
-        _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
-        return GLFW_FALSE;
-    }
-
-    *config = window->context.glx.fbconfig;
-    return GLFW_TRUE;
-}
-
 #endif // _GLFW_X11
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/init.c b/src/libraries/raylib/raylib/src/external/glfw/src/init.c
index 7cd872c..532264e 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/init.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/init.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
@@ -49,18 +49,18 @@ static GLFWerrorfun _glfwErrorCallback;
 static GLFWallocator _glfwInitAllocator;
 static _GLFWinitconfig _glfwInitHints =
 {
-    .hatButtons = true,
+    .hatButtons = GLFW_TRUE,
     .angleType = GLFW_ANGLE_PLATFORM_TYPE_NONE,
     .platformID = GLFW_ANY_PLATFORM,
     .vulkanLoader = NULL,
     .ns =
     {
-        .menubar = true,
-        .chdir = true
+        .menubar = GLFW_TRUE,
+        .chdir = GLFW_TRUE
     },
     .x11 =
     {
-        .xcbVulkanSurface = true,
+        .xcbVulkanSurface = GLFW_TRUE,
     },
     .wl =
     {
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/input.c b/src/libraries/raylib/raylib/src/external/glfw/src/input.c
index b68ddef..7b3b340 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/input.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/input.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -333,8 +333,10 @@ void _glfwInputChar(_GLFWwindow* window, uint32_t codepoint, int mods, GLFWbool
 void _glfwInputScroll(_GLFWwindow* window, double xoffset, double yoffset)
 {
     assert(window != NULL);
-    assert(isfinite(xoffset));
-    assert(isfinite(yoffset));
+    assert(xoffset > -FLT_MAX);
+    assert(xoffset < FLT_MAX);
+    assert(yoffset > -FLT_MAX);
+    assert(yoffset < FLT_MAX);
 
     if (window->callbacks.scroll)
         window->callbacks.scroll((GLFWwindow*) window, xoffset, yoffset);
@@ -346,22 +348,20 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
 {
     assert(window != NULL);
     assert(button >= 0);
+    assert(button <= GLFW_MOUSE_BUTTON_LAST);
     assert(action == GLFW_PRESS || action == GLFW_RELEASE);
     assert(mods == (mods & GLFW_MOD_MASK));
 
-    if (button < 0 || (!window->disableMouseButtonLimit && button > GLFW_MOUSE_BUTTON_LAST))
+    if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
         return;
 
     if (!window->lockKeyMods)
         mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
 
-    if (button <= GLFW_MOUSE_BUTTON_LAST)
-    {
-        if (action == GLFW_RELEASE && window->stickyMouseButtons)
-            window->mouseButtons[button] = _GLFW_STICK;
-        else
-            window->mouseButtons[button] = (char) action;
-    }
+    if (action == GLFW_RELEASE && window->stickyMouseButtons)
+        window->mouseButtons[button] = _GLFW_STICK;
+    else
+        window->mouseButtons[button] = (char) action;
 
     if (window->callbacks.mouseButton)
         window->callbacks.mouseButton((GLFWwindow*) window, button, action, mods);
@@ -373,8 +373,10 @@ void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
 void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
 {
     assert(window != NULL);
-    assert(isfinite(xpos));
-    assert(isfinite(ypos));
+    assert(xpos > -FLT_MAX);
+    assert(xpos < FLT_MAX);
+    assert(ypos > -FLT_MAX);
+    assert(ypos < FLT_MAX);
 
     if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
         return;
@@ -432,7 +434,6 @@ void _glfwInputJoystickAxis(_GLFWjoystick* js, int axis, float value)
     assert(js != NULL);
     assert(axis >= 0);
     assert(axis < js->axisCount);
-    assert(isfinite(value));
 
     js->axes[axis] = value;
 }
@@ -558,11 +559,11 @@ void _glfwCenterCursorInContentArea(_GLFWwindow* window)
 
 GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(0);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
     switch (mode)
     {
         case GLFW_CURSOR:
@@ -575,8 +576,6 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
             return window->lockKeyMods;
         case GLFW_RAW_MOUSE_MOTION:
             return window->rawMouseMotion;
-        case GLFW_UNLIMITED_MOUSE_BUTTONS:
-            return window->disableMouseButtonLimit;
     }
 
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
@@ -585,11 +584,11 @@ GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
 
 GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     switch (mode)
     {
         case GLFW_CURSOR:
@@ -684,12 +683,6 @@ GLFWAPI void glfwSetInputMode(GLFWwindow* handle, int mode, int value)
             _glfw.platform.setRawMouseMotion(window, value);
             return;
         }
-
-        case GLFW_UNLIMITED_MOUSE_BUTTONS:
-        {
-            window->disableMouseButtonLimit = value ? GLFW_TRUE : GLFW_FALSE;
-            return;
-        }
     }
 
     _glfwInputError(GLFW_INVALID_ENUM, "Invalid input mode 0x%08X", mode);
@@ -741,11 +734,11 @@ GLFWAPI int glfwGetKeyScancode(int key)
 
 GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
+
     if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
     {
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
@@ -764,11 +757,11 @@ GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
 
 GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
+
     if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
     {
         _glfwInputError(GLFW_INVALID_ENUM, "Invalid mouse button %i", button);
@@ -787,6 +780,9 @@ GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
 
 GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     if (xpos)
         *xpos = 0;
     if (ypos)
@@ -794,9 +790,6 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->cursorMode == GLFW_CURSOR_DISABLED)
     {
         if (xpos)
@@ -810,12 +803,13 @@ GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
 
 GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
-    if (!isfinite(xpos) || !isfinite(ypos))
+    _GLFW_REQUIRE_INIT();
+
+    if (xpos != xpos || xpos < -DBL_MAX || xpos > DBL_MAX ||
+        ypos != ypos || ypos < -DBL_MAX || ypos > DBL_MAX)
     {
         _glfwInputError(GLFW_INVALID_VALUE,
                         "Invalid cursor position %f %f",
@@ -903,10 +897,10 @@ GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
 
 GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWcursor* cursor = (_GLFWcursor*) handle;
 
+    _GLFW_REQUIRE_INIT();
+
     if (cursor == NULL)
         return;
 
@@ -938,12 +932,12 @@ GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
 
 GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) windowHandle;
     _GLFWcursor* cursor = (_GLFWcursor*) cursorHandle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     window->cursor = cursor;
 
     _glfw.platform.setCursor(window, cursor);
@@ -951,33 +945,30 @@ GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle)
 
 GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* handle, GLFWkeyfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWkeyfun, window->callbacks.key, cbfun);
     return cbfun;
 }
 
 GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* handle, GLFWcharfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWcharfun, window->callbacks.character, cbfun);
     return cbfun;
 }
 
 GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* handle, GLFWcharmodsfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWcharmodsfun, window->callbacks.charmods, cbfun);
     return cbfun;
 }
@@ -985,11 +976,10 @@ GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* handle, GLFWcharmods
 GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
                                                       GLFWmousebuttonfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWmousebuttonfun, window->callbacks.mouseButton, cbfun);
     return cbfun;
 }
@@ -997,11 +987,10 @@ GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* handle,
 GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
                                                   GLFWcursorposfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWcursorposfun, window->callbacks.cursorPos, cbfun);
     return cbfun;
 }
@@ -1009,11 +998,10 @@ GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* handle,
 GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
                                                       GLFWcursorenterfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWcursorenterfun, window->callbacks.cursorEnter, cbfun);
     return cbfun;
 }
@@ -1021,22 +1009,20 @@ GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* handle,
 GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* handle,
                                             GLFWscrollfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWscrollfun, window->callbacks.scroll, cbfun);
     return cbfun;
 }
 
 GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* handle, GLFWdropfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWdropfun, window->callbacks.drop, cbfun);
     return cbfun;
 }
@@ -1495,7 +1481,7 @@ GLFWAPI void glfwSetTime(double time)
 {
     _GLFW_REQUIRE_INIT();
 
-    if (!isfinite(time) || time < 0.0 || time > 18446744073.0)
+    if (time != time || time < 0.0 || time > 18446744073.0)
     {
         _glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
         return;
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/internal.h b/src/libraries/raylib/raylib/src/external/glfw/src/internal.h
index fc3ceda..8873359 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/internal.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/internal.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -48,8 +48,6 @@
 #define GLFW_INCLUDE_NONE
 #include "../include/GLFW/glfw3.h"
 
-#include <stdbool.h>
-
 #define _GLFW_INSERT_FIRST      0
 #define _GLFW_INSERT_LAST       1
 
@@ -109,7 +107,6 @@ typedef void (APIENTRY * PFNGLCLEARPROC)(GLbitfield);
 typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGPROC)(GLenum);
 typedef void (APIENTRY * PFNGLGETINTEGERVPROC)(GLenum,GLint*);
 typedef const GLubyte* (APIENTRY * PFNGLGETSTRINGIPROC)(GLenum,GLuint);
-typedef void (APIENTRY * PFNGLFLUSHPROC)(void);
 
 #define EGL_SUCCESS 0x3000
 #define EGL_NOT_INITIALIZED 0x3001
@@ -153,9 +150,6 @@ typedef void (APIENTRY * PFNGLFLUSHPROC)(void);
 #define EGL_NO_DISPLAY ((EGLDisplay) 0)
 #define EGL_NO_CONTEXT ((EGLContext) 0)
 #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType) 0)
-#define EGL_PBUFFER_BIT 0x0001
-#define EGL_WIDTH 0x3057
-#define EGL_HEIGHT 0x3056
 
 #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
 #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
@@ -187,7 +181,6 @@ typedef void (APIENTRY * PFNGLFLUSHPROC)(void);
 #define EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE 0x3450
 #define EGL_PLATFORM_ANGLE_TYPE_METAL_ANGLE 0x3489
 #define EGL_PLATFORM_ANGLE_NATIVE_PLATFORM_TYPE_ANGLE 0x348f
-#define EGL_PLATFORM_SURFACELESS_MESA 0x31dd
 
 typedef int EGLint;
 typedef unsigned int EGLBoolean;
@@ -212,7 +205,6 @@ typedef EGLContext (APIENTRY * PFN_eglCreateContext)(EGLDisplay,EGLConfig,EGLCon
 typedef EGLBoolean (APIENTRY * PFN_eglDestroySurface)(EGLDisplay,EGLSurface);
 typedef EGLBoolean (APIENTRY * PFN_eglDestroyContext)(EGLDisplay,EGLContext);
 typedef EGLSurface (APIENTRY * PFN_eglCreateWindowSurface)(EGLDisplay,EGLConfig,EGLNativeWindowType,const EGLint*);
-typedef EGLSurface (APIENTRY * PFN_eglCreatePbufferSurface)(EGLDisplay,EGLContext,const EGLint*);
 typedef EGLBoolean (APIENTRY * PFN_eglMakeCurrent)(EGLDisplay,EGLSurface,EGLSurface,EGLContext);
 typedef EGLBoolean (APIENTRY * PFN_eglSwapBuffers)(EGLDisplay,EGLSurface);
 typedef EGLBoolean (APIENTRY * PFN_eglSwapInterval)(EGLDisplay,EGLint);
@@ -229,7 +221,6 @@ typedef GLFWglproc (APIENTRY * PFN_eglGetProcAddress)(const char*);
 #define eglDestroySurface _glfw.egl.DestroySurface
 #define eglDestroyContext _glfw.egl.DestroyContext
 #define eglCreateWindowSurface _glfw.egl.CreateWindowSurface
-#define eglCreatePbufferSurface _glfw.egl.CreatePbufferSurface
 #define eglMakeCurrent _glfw.egl.MakeCurrent
 #define eglSwapBuffers _glfw.egl.SwapBuffers
 #define eglSwapInterval _glfw.egl.SwapInterval
@@ -286,7 +277,6 @@ typedef enum VkStructureType
     VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
     VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
     VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,
-    VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkStructureType;
 
@@ -375,16 +365,16 @@ struct _GLFWerror
 //
 struct _GLFWinitconfig
 {
-    bool          hatButtons;
+    GLFWbool      hatButtons;
     int           angleType;
     int           platformID;
     PFN_vkGetInstanceProcAddr vulkanLoader;
     struct {
-        bool      menubar;
-        bool      chdir;
+        GLFWbool  menubar;
+        GLFWbool  chdir;
     } ns;
     struct {
-        bool      xcbVulkanSurface;
+        GLFWbool  xcbVulkanSurface;
     } x11;
     struct {
         int       libdecorMode;
@@ -403,18 +393,19 @@ struct _GLFWwndconfig
     int           ypos;
     int           width;
     int           height;
-    bool          resizable;
-    bool          visible;
-    bool          decorated;
-    bool          focused;
-    bool          autoIconify;
-    bool          floating;
-    bool          maximized;
-    bool          centerCursor;
-    bool          focusOnShow;
-    bool          mousePassthrough;
-    bool          scaleToMonitor;
-    bool          scaleFramebuffer;
+    const char*   title;
+    GLFWbool      resizable;
+    GLFWbool      visible;
+    GLFWbool      decorated;
+    GLFWbool      focused;
+    GLFWbool      autoIconify;
+    GLFWbool      floating;
+    GLFWbool      maximized;
+    GLFWbool      centerCursor;
+    GLFWbool      focusOnShow;
+    GLFWbool      mousePassthrough;
+    GLFWbool      scaleToMonitor;
+    GLFWbool      scaleFramebuffer;
     struct {
         char      frameName[256];
     } ns;
@@ -423,8 +414,8 @@ struct _GLFWwndconfig
         char      instanceName[256];
     } x11;
     struct {
-        bool      keymenu;
-        bool      showDefault;
+        GLFWbool  keymenu;
+        GLFWbool  showDefault;
     } win32;
     struct {
         char      appId[256];
@@ -443,15 +434,15 @@ struct _GLFWctxconfig
     int           source;
     int           major;
     int           minor;
-    bool          forward;
-    bool          debug;
-    bool          noerror;
+    GLFWbool      forward;
+    GLFWbool      debug;
+    GLFWbool      noerror;
     int           profile;
     int           robustness;
     int           release;
     _GLFWwindow*  share;
     struct {
-        bool      offline;
+        GLFWbool  offline;
     } nsgl;
 };
 
@@ -476,11 +467,11 @@ struct _GLFWfbconfig
     int         accumBlueBits;
     int         accumAlphaBits;
     int         auxBuffers;
-    bool        stereo;
+    GLFWbool    stereo;
     int         samples;
-    bool        sRGB;
-    bool        doublebuffer;
-    bool        transparent;
+    GLFWbool    sRGB;
+    GLFWbool    doublebuffer;
+    GLFWbool    transparent;
     uintptr_t   handle;
 };
 
@@ -499,7 +490,6 @@ struct _GLFWcontext
     PFNGLGETSTRINGIPROC  GetStringi;
     PFNGLGETINTEGERVPROC GetIntegerv;
     PFNGLGETSTRINGPROC   GetString;
-    PFNGLFLUSHPROC       Flush;
 
     void (*makeCurrent)(_GLFWwindow*);
     void (*swapBuffers)(_GLFWwindow*);
@@ -554,7 +544,6 @@ struct _GLFWwindow
     GLFWbool            stickyKeys;
     GLFWbool            stickyMouseButtons;
     GLFWbool            lockKeyMods;
-    GLFWbool            disableMouseButtonLimit;
     int                 cursorMode;
     char                mouseButtons[GLFW_MOUSE_BUTTON_LAST + 1];
     char                keys[GLFW_KEY_LAST + 1];
@@ -807,22 +796,21 @@ struct _GLFWlibrary
         EGLint          major, minor;
         GLFWbool        prefix;
 
-        bool            KHR_create_context;
-        bool            KHR_create_context_no_error;
-        bool            KHR_gl_colorspace;
-        bool            KHR_get_all_proc_addresses;
-        bool            KHR_context_flush_control;
-        bool            EXT_client_extensions;
-        bool            EXT_platform_base;
-        bool            EXT_platform_x11;
-        bool            EXT_platform_wayland;
-        bool            EXT_present_opaque;
-        bool            ANGLE_platform_angle;
-        bool            ANGLE_platform_angle_opengl;
-        bool            ANGLE_platform_angle_d3d;
-        bool            ANGLE_platform_angle_vulkan;
-        bool            ANGLE_platform_angle_metal;
-        bool            MESA_platform_surfaceless;
+        GLFWbool        KHR_create_context;
+        GLFWbool        KHR_create_context_no_error;
+        GLFWbool        KHR_gl_colorspace;
+        GLFWbool        KHR_get_all_proc_addresses;
+        GLFWbool        KHR_context_flush_control;
+        GLFWbool        EXT_client_extensions;
+        GLFWbool        EXT_platform_base;
+        GLFWbool        EXT_platform_x11;
+        GLFWbool        EXT_platform_wayland;
+        GLFWbool        EXT_present_opaque;
+        GLFWbool        ANGLE_platform_angle;
+        GLFWbool        ANGLE_platform_angle_opengl;
+        GLFWbool        ANGLE_platform_angle_d3d;
+        GLFWbool        ANGLE_platform_angle_vulkan;
+        GLFWbool        ANGLE_platform_angle_metal;
 
         void*           handle;
 
@@ -837,7 +825,6 @@ struct _GLFWlibrary
         PFN_eglDestroySurface       DestroySurface;
         PFN_eglDestroyContext       DestroyContext;
         PFN_eglCreateWindowSurface  CreateWindowSurface;
-        PFN_eglCreatePbufferSurface CreatePbufferSurface;
         PFN_eglMakeCurrent          MakeCurrent;
         PFN_eglSwapBuffers          SwapBuffers;
         PFN_eglSwapInterval         SwapInterval;
@@ -866,14 +853,13 @@ struct _GLFWlibrary
         void*           handle;
         char*           extensions[2];
         PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
-        bool            KHR_surface;
-        bool            KHR_win32_surface;
-        bool            MVK_macos_surface;
-        bool            EXT_metal_surface;
-        bool            KHR_xlib_surface;
-        bool            KHR_xcb_surface;
-        bool            KHR_wayland_surface;
-        bool            EXT_headless_surface;
+        GLFWbool        KHR_surface;
+        GLFWbool        KHR_win32_surface;
+        GLFWbool        MVK_macos_surface;
+        GLFWbool        EXT_metal_surface;
+        GLFWbool        KHR_xlib_surface;
+        GLFWbool        KHR_xcb_surface;
+        GLFWbool        KHR_wayland_surface;
     } vk;
 
     struct {
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.c b/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.c
index e4d2852..07d41d3 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Linux - www.glfw.org
+// GLFW 3.4 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
@@ -32,7 +32,6 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/inotify.h>
-#include <sys/ioctl.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <dirent.h>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.h b/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.h
index 1ea3deb..64462b0 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/linux_joystick.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Linux - www.glfw.org
+// GLFW 3.4 Linux - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/macos_time.c b/src/libraries/raylib/raylib/src/external/glfw/src/macos_time.c
deleted file mode 100755
index c66ea3c..0000000
--- a/src/libraries/raylib/raylib/src/external/glfw/src/macos_time.c
+++ /dev/null
@@ -1,57 +0,0 @@
-//========================================================================
-// GLFW 3.5 macOS - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2009-2016 Camilla Löwy <elmindreda@glfw.org>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-
-#include "internal.h"
-
-#if defined(GLFW_BUILD_MACOS_TIMER)
-
-#include <mach/mach_time.h>
-
-
-//////////////////////////////////////////////////////////////////////////
-//////                       GLFW platform API                      //////
-//////////////////////////////////////////////////////////////////////////
-
-void _glfwPlatformInitTimer(void)
-{
-    mach_timebase_info_data_t info;
-    mach_timebase_info(&info);
-
-    _glfw.timer.macos.frequency = (info.denom * 1e9) / info.numer;
-}
-
-uint64_t _glfwPlatformGetTimerValue(void)
-{
-    return mach_absolute_time();
-}
-
-uint64_t _glfwPlatformGetTimerFrequency(void)
-{
-    return _glfw.timer.macos.frequency;
-}
-
-#endif // GLFW_BUILD_MACOS_TIMER
-
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/macos_time.h b/src/libraries/raylib/raylib/src/external/glfw/src/macos_time.h
deleted file mode 100755
index 77bf119..0000000
--- a/src/libraries/raylib/raylib/src/external/glfw/src/macos_time.h
+++ /dev/null
@@ -1,35 +0,0 @@
-//========================================================================
-// GLFW 3.5 macOS - www.glfw.org
-//------------------------------------------------------------------------
-// Copyright (c) 2009-2021 Camilla Löwy <elmindreda@glfw.org>
-//
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-//
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-//
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgment in the product documentation would
-//    be appreciated but is not required.
-//
-// 2. Altered source versions must be plainly marked as such, and must not
-//    be misrepresented as being the original software.
-//
-// 3. This notice may not be removed or altered from any source
-//    distribution.
-//
-//========================================================================
-
-#define GLFW_MACOS_LIBRARY_TIMER_STATE _GLFWtimerMacOS macos;
-
-// macOS-specific global timer data
-//
-typedef struct _GLFWtimerMacOS
-{
-    uint64_t        frequency;
-} _GLFWtimerMacOS;
-
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h b/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h
index cd32e5d..5d8b9e1 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
 //
@@ -61,53 +61,94 @@
 const char* _glfwDefaultMappings[] =
 {
 #if defined(_GLFW_WIN32)
-"03000000fa2d00000100000000000000,3DRUDDER,leftx:a0,lefty:a1,rightx:a5,righty:a2,platform:Windows,",
-"03000000c82d00002038000000000000,8bitdo,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000951000000000000,8BitDo Dogbone Modkit,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b11,platform:Windows,",
-"03000000c82d000011ab000000000000,8BitDo F30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000300f00000a01000000000000,3 In 1 Conversion Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000fa190000918d000000000000,3 In 1 Conversion Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000fa2d00000100000000000000,3dRudder Foot Motion Controller,leftx:a0,lefty:a1,rightx:a5,righty:a2,platform:Windows,",
+"03000000d0160000040d000000000000,4Play Adapter,a:b1,b:b3,back:b4,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,leftstick:b14,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b15,righttrigger:b9,rightx:a3,righty:a4,start:b5,x:b0,y:b2,platform:Windows,",
+"03000000d0160000050d000000000000,4Play Adapter,a:b1,b:b3,back:b4,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,leftstick:b14,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b15,righttrigger:b9,rightx:a3,righty:a4,start:b5,x:b0,y:b2,platform:Windows,",
+"03000000d0160000060d000000000000,4Play Adapter,a:b1,b:b3,back:b4,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,leftstick:b14,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b15,righttrigger:b9,rightx:a3,righty:a4,start:b5,x:b0,y:b2,platform:Windows,",
+"03000000d0160000070d000000000000,4Play Adapter,a:b1,b:b3,back:b4,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,leftstick:b14,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b15,righttrigger:b9,rightx:a3,righty:a4,start:b5,x:b0,y:b2,platform:Windows,",
+"03000000d0160000600a000000000000,4Play Adapter,a:b1,b:b3,back:b4,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,leftstick:b14,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b15,righttrigger:b9,rightx:a3,righty:a4,start:b5,x:b0,y:b2,platform:Windows,",
+"03000000c82d00000031000000000000,8BitDo Adapter,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000531000000000000,8BitDo Adapter 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000951000000000000,8BitDo Dogbone,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a2,rightx:a3,righty:a5,start:b11,platform:Windows,",
+"03000000008000000210000000000000,8BitDo F30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"030000003512000011ab000000000000,8BitDo F30 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000c82d00001028000000000000,8BitDo F30 Arcade Joystick,a:b0,b:b1,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d000011ab000000000000,8BitDo F30 Arcade Joystick,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000801000000900000000000000,8BitDo F30 Arcade Stick,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000c82d00001038000000000000,8BitDo F30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00000090000000000000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000650000000000000,8BitDo M30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:a4,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c82d00005106000000000000,8BitDo M30 Gamepad,a:b1,b:b0,back:b10,guide:b2,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000151000000000000,8BitDo M30 ModKit,a:b0,b:b1,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,rightshoulder:b6,righttrigger:b7,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00006a28000000000000,8BitDo GameCube,a:b0,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b9,paddle2:b8,rightshoulder:b10,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b1,y:b4,platform:Windows,",
+"03000000c82d00001251000000000000,8BitDo Lite 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00001151000000000000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000150000000000000,8BitDo M30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a3,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000151000000000000,8BitDo M30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a2,rightshoulder:b6,righttrigger:b7,rightx:a3,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000650000000000000,8BitDo M30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00005106000000000000,8BitDo M30,a:b0,b:b1,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,guide:b2,leftshoulder:b8,lefttrigger:b9,rightshoulder:b6,righttrigger:b7,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00002090000000000000,8BitDo Micro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00000310000000000000,8BitDo N30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000451000000000000,8BitDo N30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a2,rightx:a3,righty:a5,start:b11,platform:Windows,",
 "03000000c82d00002028000000000000,8BitDo N30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00008010000000000000,8BitDo N30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c82d00000451000000000000,8BitDo N30 Modkit,a:b1,b:b0,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,start:b11,platform:Windows,",
+"03000000c82d0000e002000000000000,8BitDo N30,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,start:b6,platform:Windows,",
 "03000000c82d00000190000000000000,8BitDo N30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00001590000000000000,8BitDo N30 Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00006528000000000000,8BitDo N30 Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000022000000090000000000000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000203800000900000000000000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000290000000000000,8BitDo N64,+rightx:b9,+righty:b3,-rightx:b4,-righty:b8,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,platform:Windows,",
+"03000000c82d00003038000000000000,8BitDo N64,+rightx:b9,+righty:b3,-rightx:b4,-righty:b8,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,platform:Windows,",
+"03000000c82d00006928000000000000,8BitDo N64,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b11,platform:Windows,",
+"03000000c82d00002590000000000000,8BitDo NEOGEO,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"030000003512000012ab000000000000,8BitDo NES30,a:b2,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b0,platform:Windows,",
+"03000000c82d000012ab000000000000,8BitDo NES30,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000022000000090000000000000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000203800000900000000000000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00002038000000000000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000751000000000000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a2,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000851000000000000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a2,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000c82d00000360000000000000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00002867000000000000,8BitDo S30 Modkit,a:b0,b:b1,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,leftshoulder:b8,lefttrigger:b9,rightshoulder:b6,righttrigger:b7,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000361000000000000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000660000000000000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000131000000000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000231000000000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000331000000000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000431000000000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00002867000000000000,8BitDo S30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a2,rightshoulder:b6,righttrigger:b7,rightx:a3,righty:a5,start:b10,x:b3,y:b4,platform:Windows,",
 "03000000c82d00000130000000000000,8BitDo SF30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000060000000000000,8Bitdo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000061000000000000,8Bitdo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d000021ab000000000000,8BitDo SFC30,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000102800000900000000000000,8Bitdo SFC30 GamePad,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00003028000000000000,8Bitdo SFC30 GamePad,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000030000000000000,8BitDo SN30,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000060000000000000,8BitDo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000061000000000000,8BitDo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000102800000900000000000000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d000021ab000000000000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00003028000000000000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"030000003512000020ab000000000000,8BitDo SN30,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000030000000000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000351000000000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a2,rightshoulder:b7,rightx:a3,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00001290000000000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d000020ab000000000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00004028000000000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00006228000000000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000351000000000000,8BitDo SN30 Modkit,a:b1,b:b0,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000021000000000000,8BitDo SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000c82d00000160000000000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00000161000000000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000121000000000000,8BitDo SN30 Pro for Android,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c82d00000260000000000000,8BitDo SN30 Pro+,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000261000000000000,8BitDo SN30 Pro+,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000c82d00000031000000000000,8BitDo Wireless Adapter,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c82d00001890000000000000,8BitDo Zero 2,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000260000000000000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00000261000000000000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
+"03000000c82d00001230000000000000,8BitDo Ultimate,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001b30000000000000,8BitDo Ultimate 2C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b5,paddle2:b2,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001d30000000000000,8BitDo Ultimate 2C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b5,paddle2:b2,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001530000000000000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001630000000000000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001730000000000000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001130000000000000,8BitDo Ultimate Wired,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b26,paddle1:b24,paddle2:b25,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001330000000000000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b23,paddle2:b19,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00000121000000000000,8BitDo Xbox One SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000a00500003232000000000000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c82d00001890000000000000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Windows,",
 "03000000c82d00003032000000000000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Windows,",
-"03000000a00500003232000000000000,8Bitdo Zero GamePad,a:b0,b:b1,back:b10,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000a30c00002700000000000000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000a30c00002800000000000000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
-"030000008f0e00001200000000000000,Acme GA-02,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000c01100000355000011010000,ACRUX USB GAME PAD,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000fa190000f0ff000000000000,Acteck AGJ-3200,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"030000006f0e00001413000000000000,Afterglow,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000008f0e00001200000000000000,Acme GA02,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000c01100000355000000000000,Acrux,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000fa190000f0ff000000000000,Acteck AGJ 3200,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000d1180000402c000000000000,ADT1,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a3,rightx:a2,righty:a5,x:b3,y:b4,platform:Windows,",
+"030000006f0e00008801000000000000,Afterglow Deluxe Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000341a00003608000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00000263000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00001101000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
@@ -115,310 +156,748 @@ const char* _glfwDefaultMappings[] =
 "030000006f0e00001402000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00001901000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00001a01000000000000,Afterglow PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000d62000001d57000000000000,Airflo PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00001301000000000000,Afterglow Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00001302000000000000,Afterglow Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00001304000000000000,Afterglow Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00001413000000000000,Afterglow Xbox Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00003901000000000000,Afterglow Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ab1200000103000000000000,Afterglow Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000000f9000000000000,Afterglow Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000100000008200000000000000,Akishop Customs PS360,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000007c1800000006000000000000,Alienware Dual Compatible PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000491900001904000000000000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000710100001904000000000000,Amazon Luna Controller,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b8,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b4,rightstick:b7,rightx:a3,righty:a4,start:b6,x:b3,y:b2,platform:Windows,",
-"03000000ef0500000300000000000000,AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Windows,",
-"03000000d6200000e557000000000000,Batarang,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"0300000008100000e501000000000000,Anbernic Game Pad,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000020500000913000000000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000373500000710000000000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000373500004610000000000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000190e00000110000000000000,Aquaplus Piece,a:b1,b:b0,back:b3,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b2,platform:Windows,",
+"03000000830500000160000000000000,Arcade,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b3,x:b4,y:b4,platform:Windows,",
+"03000000120c0000100e000000000000,Armor 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000490b00004406000000000000,ASCII Seamic Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"03000000869800002500000000000000,Astro C40 TR PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000a30c00002700000000000000,Astro City Mini,a:b2,b:b1,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000a30c00002800000000000000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000050b00000579000000000000,ASUS ROG Kunai 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000050b00000679000000000000,ASUS ROG Kunai 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000503200000110000000000000,Atari VCS Classic Controller,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,start:b3,platform:Windows,",
+"03000000503200000210000000000000,Atari VCS Modern Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,rightx:a3,righty:a4,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000380800001889000000000000,AtGames Legends Gamer Pro,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b13,lefttrigger:b14,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000008a3500000102000000000000,Backbone One,a:b4,b:b5,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b10,leftstick:b17,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b18,righttrigger:b13,rightx:a3,righty:a4,start:b15,x:b7,y:b8,platform:Windows,",
+"030000008a3500000201000000000000,Backbone One,a:b4,b:b5,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b10,leftstick:b17,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b18,righttrigger:b13,rightx:a3,righty:a4,start:b15,x:b7,y:b8,platform:Windows,",
+"030000008a3500000302000000000000,Backbone One,a:b4,b:b5,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b10,leftstick:b17,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b18,righttrigger:b13,rightx:a3,righty:a4,start:b15,x:b7,y:b8,platform:Windows,",
+"030000008a3500000402000000000000,Backbone One,a:b4,b:b5,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b10,leftstick:b17,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b18,righttrigger:b13,rightx:a3,righty:a4,start:b15,x:b7,y:b8,platform:Windows,",
+"03000000e4150000103f000000000000,Batarang,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000d6200000e557000000000000,Batarang PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000c01100001352000000000000,Battalife Joystick,a:b6,b:b7,back:b2,leftshoulder:b0,leftx:a0,lefty:a1,rightshoulder:b1,start:b3,x:b4,y:b5,platform:Windows,",
 "030000006f0e00003201000000000000,Battlefield 4 PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000d62000002a79000000000000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000ad1b000001f9000000000000,BB 070,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000d62000002a79000000000000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000bc2000005250000000000000,Beitong G3,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b5,righttrigger:b9,rightx:a3,righty:a4,start:b15,x:b3,y:b4,platform:Windows,",
+"030000000d0500000208000000000000,Belkin Nostromo N40,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
 "03000000bc2000006012000000000000,Betop 2126F,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000bc2000000055000000000000,Betop BFM Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000bc2000000055000000000000,Betop BFM,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000790000000700000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000808300000300000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000bc2000006312000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000bc2000006321000000000000,BETOP CONTROLLER,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000bc2000006321000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000bc2000006412000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000c01100000555000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000c01100000655000000000000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000790000000700000000000000,Betop Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000808300000300000000000000,Betop Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
+"030000006f0e00006401000000000000,BF One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000300f00000202000000000000,Bigben,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a5,righty:a2,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006b1400000209000000000000,Bigben,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006b1400000055000000000000,Bigben PS3 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "030000006b1400000103000000000000,Bigben PS3 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Windows,",
-"03000000120c0000210e000000000000,Brook Mars,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"0300000066f700000500000000000000,BrutalLegendTest,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000d81d00000b00000000000000,BUFFALO BSGP1601 Series ,a:b5,b:b3,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b13,x:b4,y:b2,platform:Windows,",
+"03000000120c0000200e000000000000,Brook Mars PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000210e000000000000,Brook Mars PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f10e000000000000,Brook PS2 Adapter,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000120c0000310c000000000000,Brook Super Converter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000d81d00000b00000000000000,Buffalo BSGP1601 Series,a:b5,b:b3,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b13,x:b4,y:b2,platform:Windows,",
+"030000005a1c00002400000000000000,Capcom Home Arcade Controller,a:b3,b:b4,back:b7,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b6,x:b0,y:b1,platform:Windows,",
+"030000005b1c00002400000000000000,Capcom Home Arcade Controller,a:b3,b:b4,back:b7,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b6,x:b0,y:b1,platform:Windows,",
+"030000005b1c00002500000000000000,Capcom Home Arcade Controller,a:b3,b:b4,back:b7,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b6,x:b0,y:b1,platform:Windows,",
+"030000006d04000042c2000000000000,ChillStream,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000e82000006058000000000000,Cideko AK08b,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000457500000401000000000000,Cobra,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000005e0400008e02000000000000,Controller (XBOX 360 For Windows),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
-"030000005e040000a102000000000000,Controller (Xbox 360 Wireless Receiver for Windows),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
-"030000005e040000ff02000000000000,Controller (Xbox One For Windows) - Wired,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
-"030000005e040000ea02000000000000,Controller (Xbox One For Windows) - Wireless,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000b0400003365000000000000,Competition Pro,a:b0,b:b1,back:b2,leftx:a0,lefty:a1,start:b3,platform:Windows,",
+"030000004c050000c505000000000000,CronusMax Adapter,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d814000007cd000000000000,Cthulhu,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d8140000cefa000000000000,Cthulhu,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000260900008888000000000000,Cyber Gadget GameCube Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:a4,rightx:a2,righty:a3~,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000a306000022f6000000000000,Cyborg V.3 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"030000003807000002cb000000000000,Cyborg,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000a306000022f6000000000000,Cyborg V.3 Rumble,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000f806000000a3000000000000,DA Leader,a:b7,b:b6,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b0,leftstick:b8,lefttrigger:b1,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:b3,rightx:a2,righty:a3,start:b12,x:b4,y:b5,platform:Windows,",
+"030000001a1c00000001000000000000,Datel Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000451300000830000000000000,Defender Game Racer X7,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"030000007d0400000840000000000000,Destroyer Tiltpad,+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b1,b:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,x:b0,y:b3,platform:Windows,",
-"03000000791d00000103000000000000,Dual Box WII,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000bd12000002e0000000000000,Dual USB Vibration Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,platform:Windows,",
-"030000008f0e00000910000000000000,DualShock 2,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,platform:Windows,",
-"030000006f0e00003001000000000000,EA SPORTS PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000791d00000103000000000000,Dual Box Wii,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000c0160000e105000000000000,Dual Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004f040000070f000000000000,Dual Power,a:b8,b:b9,back:b4,dpdown:b1,dpleft:b2,dpright:b3,dpup:b0,leftshoulder:b13,leftstick:b6,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b12,rightstick:b7,righttrigger:b15,start:b5,x:b10,y:b11,platform:Windows,",
+"030000004f04000012b3000000000000,Dual Power 3,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
+"030000004f04000020b3000000000000,Dual Trigger,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
+"03000000bd12000002e0000000000000,Dual Vibration Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,platform:Windows,",
+"03000000ff1100003133000000000000,DualForce,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b1,platform:Windows,",
+"030000006f0e00003001000000000000,EA Sports PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000fc0400000250000000000000,Easy Grip,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"03000000bc2000000091000000000000,EasySMX Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"030000006e0500000a20000000000000,Elecom DUX60 MMO,a:b2,b:b3,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b14,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b15,righttrigger:b13,rightx:a3,righty:a4,start:b20,x:b0,y:b1,platform:Windows,",
 "03000000b80500000410000000000000,Elecom Gamepad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Windows,",
 "03000000b80500000610000000000000,Elecom Gamepad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Windows,",
+"03000095090000010000000000000000,Elecom JC-U609,a:b0,b:b1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,start:b8,x:b3,y:b4,platform:Windows,",
+"0300004112000000e500000000000000,Elecom JC-U909Z,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,start:b8,x:b3,y:b4,platform:Windows,",
+"03000041120000001050000000000000,Elecom JC-U911,a:b1,b:b2,back:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,start:b0,x:b4,y:b5,platform:Windows,",
+"030000006e0500000520000000000000,Elecom P301U PlayStation Controller Adapter,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
+"03000000411200004450000000000000,Elecom U1012,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
+"030000006e0500000320000000000000,Elecom U3613M,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
+"030000006e0500000e20000000000000,Elecom U3912T,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
+"030000006e0500000f20000000000000,Elecom U4013S,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
+"030000006e0500001320000000000000,Elecom U4113,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006e0500001020000000000000,Elecom U4113S,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Windows,",
+"030000006e0500000720000000000000,Elecom W01U,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Windows,",
+"030000007d0400000640000000000000,Eliminator AfterShock,a:b1,b:b2,back:b9,dpdown:+a3,dpleft:-a5,dpright:+a5,dpup:-a3,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a4,righty:a2,start:b8,x:b0,y:b3,platform:Windows,",
 "03000000120c0000f61c000000000000,Elite,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000430b00000300000000000000,EMS Production PS2 Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000062000001801000000000000,EMS TrioLinker Plus II,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b2,y:b3,platform:Windows,",
+"03000000242f000000b7000000000000,ESM 9110,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Windows,",
+"03000000101c0000181c000000000000,Essential,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b4,leftx:a1,lefty:a0,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
 "030000008f0e00000f31000000000000,EXEQ,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Windows,",
-"03000000341a00000108000000000000,EXEQ RF USB Gamepad 8206,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"030000006f0e00008401000000000000,Faceoff Deluxe+ Audio Wired Controller for Nintendo Switch,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006f0e00008001000000000000,Faceoff Wired Pro Controller for Nintendo Switch,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000852100000201000000000000,FF-GP1,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00008500000000000000,Fighting Commander 2016 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00008400000000000000,Fighting Commander 5,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00008700000000000000,Fighting Stick mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00008800000000000000,Fighting Stick mini 4,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b8,x:b0,y:b3,platform:Windows,",
-"030000000d0f00002700000000000000,FIGHTING STICK V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"78696e70757403000000000000000000,Fightstick TES,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000790000002201000000000000,Game Controller for PC,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000341a00000108000000000000,EXEQ RF Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"030000006f0e00008401000000000000,Faceoff Deluxe Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00008101000000000000,Faceoff Deluxe Pro Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00008001000000000000,Faceoff Pro Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000021000000090000000000000,FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Windows,",
+"0300000011040000c600000000000000,FC801,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000852100000201000000000000,FF GP1,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000ad1b000028f0000000000000,Fightpad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b00002ef0000000000000,Fightpad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000038f0000000000000,Fightpad TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,rightshoulder:b5,righttrigger:b9,start:b7,x:b2,y:b3,platform:Windows,",
+"03005036852100000000000000000000,Final Fantasy XIV Online Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000f806000001a3000000000000,Firestorm,a:b9,b:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b0,leftstick:b10,lefttrigger:b1,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b11,righttrigger:b3,start:b12,x:b8,y:b4,platform:Windows,",
+"03000000b50700000399000000000000,Firestorm 2,a:b2,b:b4,back:b10,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b8,righttrigger:b9,start:b11,x:b3,y:b5,platform:Windows,",
+"03000000b50700001302000000000000,Firestorm D3,a:b0,b:b2,leftshoulder:b4,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,x:b1,y:b3,platform:Windows,",
+"03000000b40400001024000000000000,Flydigi Apex,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000151900004000000000000000,Flydigi Vader 2,a:b27,b:b26,back:b19,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,leftshoulder:b23,leftstick:b17,lefttrigger:b21,leftx:a0,lefty:a1,rightshoulder:b22,rightstick:b16,righttrigger:b20,rightx:a3,righty:a4,start:b18,x:b25,y:b24,platform:Windows,",
+"03000000b40400001124000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b14,paddle1:b4,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b2,y:b3,platform:Windows,",
+"03000000b40400001224000000000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b2,paddle1:b16,paddle2:b17,paddle3:b14,paddle4:b15,rightshoulder:b7,rightstick:b13,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"030000008305000000a0000000000000,G08XU,a:b0,b:b1,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b5,x:b2,y:b3,platform:Windows,",
 "0300000066f700000100000000000000,Game VIB Joystick,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Windows,",
-"03000000260900002625000000000000,Gamecube Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,lefttrigger:a4,leftx:a0,lefty:a1,righttrigger:a5,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000790000004618000000000000,GameCube Controller Adapter,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
-"030000008f0e00000d31000000000000,GAMEPAD 3 TURBO,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000280400000140000000000000,GamePad Pro USB,a:b1,b:b2,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000ac0500003d03000000000000,GameSir,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000ac0500004d04000000000000,GameSir,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000ffff00000000000000000000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000c01100000140000000000000,GameStop PS4 Fun Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000009b2800003200000000000000,GC/N64 to USB v3.4,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:+a2,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,",
-"030000009b2800006000000000000000,GC/N64 to USB v3.6,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:+a2,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,",
+"03000000260900002625000000000000,GameCube Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,lefttrigger:a4,leftx:a0,lefty:a1,righttrigger:a5,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000341a000005f7000000000000,GameCube Controller,a:b2,b:b3,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b1,y:b0,platform:Windows,",
+"03000000430b00000500000000000000,GameCube Controller,a:b0,b:b2,dpdown:b10,dpleft:b8,dpright:b9,dpup:b11,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:a3,rightx:a5,righty:a2,start:b7,x:b1,y:b3,platform:Windows,",
+"03000000790000004718000000000000,GameCube Controller,a:b1,b:b0,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000790000004618000000000000,GameCube Controller Adapter,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
+"030000008f0e00000d31000000000000,Gamepad 3 Turbo,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000ac0500003d03000000000000,GameSir G3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000ac0500005b05000000000000,GameSir G3w,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000ac0500002d02000000000000,GameSir G4,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000ac0500004d04000000000000,GameSir G4,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000ac0500001a06000000000000,GameSir T3 2.02,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000373500009410000000000000,GameSir Tegenaria Lite,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"030000004c0e00001035000000000000,Gamester,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"030000000d0f00001110000000000000,GameStick Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"0300000047530000616d000000000000,GameStop,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000c01100000140000000000000,GameStop PS4 Fun Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000b62500000100000000000000,Gametel GT004 01,a:b3,b:b0,dpdown:b10,dpleft:b9,dpright:b8,dpup:b11,leftshoulder:b4,rightshoulder:b5,start:b7,x:b1,y:b2,platform:Windows,",
+"030000008f0e00001411000000000000,Gamo2 Divaller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000120c0000a857000000000000,Gator Claw,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000c9110000f055000000000000,GC100XF,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "030000008305000009a0000000000000,Genius,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "030000008305000031b0000000000000,Genius Maxfire Blaze 3,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "03000000451300000010000000000000,Genius Maxfire Grandias 12,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "030000005c1a00003330000000000000,Genius MaxFire Grandias 12V,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000300f00000b01000000000000,GGE909 Recoil Pad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000f0250000c283000000000000,Gioteck,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000300f00000b01000000000000,GGE909 Recoil,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000f0250000c283000000000000,Gioteck PlayStation Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000f025000021c1000000000000,Gioteck PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000f0250000c383000000000000,Gioteck VX2 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000f0250000c483000000000000,Gioteck VX2 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"030000007d0400000540000000000000,Gravis Eliminator GamePad Pro,a:b1,b:b2,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000f025000031c1000000000000,Gioteck PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000f0250000c383000000000000,Gioteck VX2 PlayStation Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000f0250000c483000000000000,Gioteck VX2 PlayStation Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000d11800000094000000000000,Google Stadia Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:b11,rightx:a3,righty:a4,start:b9,x:b2,y:b3,platform:Windows,",
+"030000004f04000026b3000000000000,GP XID,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"0300000079000000d418000000000000,GPD Win,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c6240000025b000000000000,GPX,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000007d0400000840000000000000,Gravis Destroyer Tilt,+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b1,b:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,x:b0,y:b3,platform:Windows,",
+"030000007d0400000540000000000000,Gravis Eliminator Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000280400000140000000000000,Gravis GamePad Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a3,dpup:-a4,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000008f0e00000610000000000000,GreenAsia,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a5,righty:a2,start:b11,x:b3,y:b0,platform:Windows,",
+"03000000ac0500006b05000000000000,GT2a,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000341a00000302000000000000,Hama Scorpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00004900000000000000,Hatsune Miku Sho Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000001008000001e1000000000000,Havit HV-G60,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000d81400000862000000000000,HitBox Edition Cthulhu+,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,lefttrigger:b4,rightshoulder:b7,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000632500002605000000000000,HJD-X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"030000008a2e0000dd10000000000000,Hand Held Legend GC Ultimate,a:b0,b:b2,back:b17,dpdown:b5,dpleft:b6,dpright:b7,dpup:b4,guide:b18,leftshoulder:b10,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b19,misc2:b24,paddle1:b13,paddle2:b12,rightshoulder:b11,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b16,x:b1,y:b3,platform:Windows,",
+"030000008a2e0000df10000000000000,Hand Held Legend ProGCC,a:b1,b:b0,back:b17,dpdown:b5,dpleft:b6,dpright:b7,dpup:b4,guide:b18,leftshoulder:b10,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b19,paddle1:b13,paddle2:b12,rightshoulder:b11,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b16,x:b3,y:b2,platform:Windows,",
+"030000000d0f00004900000000000000,Hatsune Miku Sho PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000001008000001e1000000000000,Havit HV G60,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b0,platform:Windows,",
+"030000000d0f00000c00000000000000,HEXT,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000d81400000862000000000000,HitBox Edition Cthulhu,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,lefttrigger:b4,rightshoulder:b7,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000632500002605000000000000,HJD X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"030000000d0f00000a00000000000000,Hori DOA,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00008500000000000000,Hori Fighting Commander 2016 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00002500000000000000,Hori Fighting Commander 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
 "030000000d0f00002d00000000000000,Hori Fighting Commander 3 Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00005f00000000000000,Hori Fighting Commander 4 (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00005e00000000000000,Hori Fighting Commander 4 (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00004000000000000000,Hori Fighting Stick Mini 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,lefttrigger:b4,rightshoulder:b7,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00005f00000000000000,Hori Fighting Commander 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00005e00000000000000,Hori Fighting Commander 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000000d0f00008400000000000000,Hori Fighting Commander 5,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006201000000000000,Hori Fighting Commander Octa,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006401000000000000,Hori Fighting Commander Octa,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00005100000000000000,Hori Fighting Commander PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00008600000000000000,Hori Fighting Commander Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f0000ba00000000000000,Hori Fighting Commander Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00008800000000000000,Hori Fighting Stick mini 4 PS3,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b8,x:b0,y:b3,platform:Windows,",
+"030000000d0f00008700000000000000,Hori Fighting Stick mini 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000000d0f00001000000000000000,Hori Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00003200000000000000,Hori Fightstick 3W,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000c000000000000000,Hori Fightstick 4,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00000d00000000000000,Hori Fightstick EX2,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"030000000d0f00003701000000000000,Hori Fightstick Mini,a:b1,b:b0,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Windows,",
+"030000000d0f00004000000000000000,Hori Fightstick Mini 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,lefttrigger:b4,rightshoulder:b7,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00002100000000000000,Hori Fightstick V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00002700000000000000,Hori Fightstick V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000a000000000000000,Hori Grip TAC4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b13,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000a500000000000000,Hori Miku Project Diva X HD PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000a600000000000000,Hori Miku Project Diva X HD PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000000d0f00000101000000000000,Hori Mini Hatsune Miku FT,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000000d0f00005400000000000000,Hori Pad 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000000d0f00000900000000000000,Hori Pad 3 Turbo,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000000d0f00004d00000000000000,Hori Pad A,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00009200000000000000,Hori Pokken Tournament DX Pro Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00001600000000007803,HORI Real Arcade Pro EX-SE (Xbox 360),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00003801000000000000,Hori PC Engine Mini Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,platform:Windows,",
+"030000000d0f00009200000000000000,Hori Pokken Tournament DX Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00002301000000000000,Hori PS4 Controller Light,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"030000000d0f00001100000000000000,Hori Real Arcade Pro 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00002600000000000000,Hori Real Arcade Pro 3P,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00004b00000000000000,Hori Real Arcade Pro 3W,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006a00000000000000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006b00000000000000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00008a00000000000000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00008b00000000000000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006f00000000000000,Hori Real Arcade Pro 4 VLX,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00007000000000000000,Hori Real Arcade Pro 4 VLX,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00003d00000000000000,Hori Real Arcade Pro N3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b10,leftstick:b4,lefttrigger:b11,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b6,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000ae00000000000000,Hori Real Arcade Pro N4,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00008c00000000000000,Hori Real Arcade Pro P4,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f0000aa00000000000000,Hori Real Arcade Pro S,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000d800000000000000,Hori Real Arcade Pro S,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Windows,",
+"030000000d0f00002200000000000000,Hori Real Arcade Pro V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00005b00000000000000,Hori Real Arcade Pro V4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00005c00000000000000,Hori Real Arcade Pro V4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000af00000000000000,Hori Real Arcade Pro VHS,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00001b00000000000000,Hori Real Arcade Pro VX,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000002f5000000000000,Hori Real Arcade Pro VX,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b11,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Windows,",
 "030000000d0f00009c00000000000000,Hori TAC Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f0000c100000000000000,Horipad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00006e00000000000000,HORIPAD 4 (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00006600000000000000,HORIPAD 4 (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000c900000000000000,Hori Taiko Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006400000000000000,Horipad 3TP,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00001300000000000000,Horipad 3W,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "030000000d0f00005500000000000000,Horipad 4 FPS,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f0000ee00000000000000,HORIPAD mini4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000250900000017000000000000,HRAP2 on PS/SS/N64 Joypad to USB BOX,a:b2,b:b1,back:b9,leftshoulder:b5,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b6,start:b8,x:b3,y:b0,platform:Windows,",
-"030000008f0e00001330000000000000,HuiJia SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000d81d00000f00000000000000,iBUFFALO BSGP1204 Series,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000d81d00001000000000000000,iBUFFALO BSGP1204P Series,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000830500006020000000000000,iBuffalo SNES Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Windows,",
+"030000000d0f00006e00000000000000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f00006600000000000000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000000d0f00004200000000000000,Horipad A,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000ad1b000001f5000000000000,Horipad EXT2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f0000ee00000000000000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000c100000000000000,Horipad Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000d0f0000f600000000000000,Horipad Nintendo Switch Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"030000000d0f00000202000000000000,Horipad O Nintendo Switch 2 Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,misc2:b14,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Windows,",
+"030000000d0f00006700000000000000,Horipad One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000000d0f00009601000000000000,Horipad Steam,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc2:b2,paddle1:b5,paddle2:b15,paddle3:b18,paddle4:b19,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"030000000d0f0000dc00000000000000,Horipad Switch,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000242e00000b20000000000000,Hyperkin Admiral N64 Controller,+rightx:b11,+righty:b13,-rightx:b8,-righty:b12,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b5,start:b9,platform:Windows,",
+"03000000242e0000ff0b000000000000,Hyperkin N64 Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,platform:Windows,",
+"03000000790000004e95000000000000,Hyperkin N64 Controller Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a5,righty:a2,start:b9,platform:Windows,",
+"03000000242e00006a48000000000000,Hyperkin RetroN Sq,a:b3,b:b7,back:b5,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,leftshoulder:b0,rightshoulder:b1,start:b4,x:b2,y:b6,platform:Windows,",
+"03000000242f00000a20000000000000,Hyperkin Scout,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000242e00000a20000000000000,Hyperkin Scout Premium SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000242e00006a38000000000000,Hyperkin Trooper 2,a:b0,b:b1,back:b4,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b3,start:b5,platform:Windows,",
+"03000000f00300008d04000000000000,HyperX Clutch,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:-a2,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:+a5,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000d81d00000e00000000000000,iBuffalo AC02 Arcade Joystick,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b11,righttrigger:b3,rightx:a2,righty:a5,start:b8,x:b4,y:b5,platform:Windows,",
+"03000000d81d00000f00000000000000,iBuffalo BSGP1204 Series,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000d81d00001000000000000000,iBuffalo BSGP1204P Series,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"030000005c0a00000285000000000000,iDroidCon,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b6,platform:Windows,",
+"03000000696400006964000000000000,iDroidCon Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000511d00000230000000000000,iGUGU Gamecore,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b1,leftstick:b4,lefttrigger:b3,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b2,platform:Windows,",
 "03000000b50700001403000000000000,Impact Black,a:b2,b:b3,back:b8,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
-"030000006f0e00002401000000000000,INJUSTICE FightStick PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000ac0500002c02000000000000,IPEGA,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000491900000204000000000000,Ipega PG-9023,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000491900000304000000000000,Ipega PG-9087 - Bluetooth Gamepad,+righty:+a5,-righty:-a4,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,start:b11,x:b3,y:b4,platform:Windows,",
-"030000006e0500000a20000000000000,JC-DUX60 ELECOM MMO Gamepad,a:b2,b:b3,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b14,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b15,righttrigger:b13,rightx:a3,righty:a4,start:b20,x:b0,y:b1,platform:Windows,",
-"030000006e0500000520000000000000,JC-P301U,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
-"030000006e0500000320000000000000,JC-U3613M (DInput),a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Windows,",
-"030000006e0500000720000000000000,JC-W01U,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Windows,",
+"030000006f0e00002401000000000000,Injustice Fightstick PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000830500005130000000000000,InterAct ActionPad,a:b0,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"03000000ef0500000300000000000000,InterAct AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Windows,",
+"03000000fd0500000230000000000000,InterAct AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a5,start:b11,x:b0,y:b1,platform:Windows,",
+"03000000fd0500000030000000000000,Interact GoPad,a:b3,b:b4,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,x:b0,y:b1,platform:Windows,",
+"03000000fd0500003902000000000000,InterAct Hammerhead,a:b3,b:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b2,lefttrigger:b8,rightshoulder:b7,rightstick:b5,righttrigger:b9,start:b10,x:b0,y:b1,platform:Windows,",
+"03000000fd0500002a26000000000000,InterAct Hammerhead FX,a:b3,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b0,y:b1,platform:Windows,",
+"03000000fd0500002f26000000000000,InterAct Hammerhead FX,a:b4,b:b5,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b1,y:b2,platform:Windows,",
+"03000000fd0500005302000000000000,InterAct ProPad,a:b3,b:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,x:b0,y:b1,platform:Windows,",
+"03000000ac0500002c02000000000000,Ipega Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000491900000204000000000000,Ipega PG9023,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000491900000304000000000000,Ipega PG9087,+righty:+a5,-righty:-a4,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,start:b11,x:b3,y:b4,platform:Windows,",
 "030000007e0500000620000000000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Windows,",
-"030000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Windows,",
 "030000007e0500000720000000000000,Joy-Con (R),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b12,leftshoulder:b4,leftstick:b11,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Windows,",
-"030000007e0500000720000001000000,Joy-Con (R),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b12,leftshoulder:b4,leftstick:b11,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000bd12000003c0000010010000,Joypad Alpha Shock,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000bd12000003c0000000000000,JY-P70UR,a:b1,b:b0,back:b5,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b8,rightstick:b11,righttrigger:b9,rightx:a3,righty:a2,start:b4,x:b3,y:b2,platform:Windows,",
-"03000000242f00002d00000000000000,JYS Wireless Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000242f00008a00000000000000,JYS Wireless Adapter,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b0,y:b3,platform:Windows,",
+"03000000250900000017000000000000,Joypad Adapter,a:b2,b:b1,back:b9,leftshoulder:b5,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b6,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000bd12000003c0000000000000,Joypad Alpha Shock,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000ff1100004033000000000000,JPD FFB,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a2,start:b15,x:b3,y:b0,platform:Windows,",
+"03000000242f00002d00000000000000,JYS Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000242f00008a00000000000000,JYS Adapter,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b0,y:b3,platform:Windows,",
+"03000000c4100000c082000000000000,KADE,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000828200000180000000000000,Keio,a:b4,b:b5,back:b8,leftshoulder:b2,lefttrigger:b3,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,start:b9,x:b0,y:b1,platform:Windows,",
 "03000000790000000200000000000000,King PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000bd12000001e0000000000000,Leadership,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"030000006f0e00000103000000000000,Logic3,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00000104000000000000,Logic3,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000008f0e00001300000000000000,Logic3,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "030000006d040000d1ca000000000000,Logitech ChillStream,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006d040000d2ca000000000000,Logitech Cordless Precision,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006d04000011c2000000000000,Logitech Cordless Wingman,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b9,leftstick:b5,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b2,righttrigger:b7,rightx:a3,righty:a4,x:b4,platform:Windows,",
 "030000006d04000016c2000000000000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006d04000018c2000000000000,Logitech F510 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006d04000019c2000000000000,Logitech F710 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006d0400001ac2000000000000,Logitech Precision Gamepad,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006d0400001dc2000000000000,Logitech F310,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006d04000018c2000000000000,Logitech F510,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006d0400001ec2000000000000,Logitech F510,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006d04000019c2000000000000,Logitech F710,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006d0400001fc2000000000000,Logitech F710,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006d0400001ac2000000000000,Logitech Precision,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006d04000009c2000000000000,Logitech WingMan,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,",
+"030000006d0400000bc2000000000000,Logitech WingMan Action Pad,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b8,lefttrigger:a5~,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b5,righttrigger:a2~,start:b8,x:b3,y:b4,platform:Windows,",
 "030000006d0400000ac2000000000000,Logitech WingMan RumblePad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,rightx:a3,righty:a4,x:b3,y:b4,platform:Windows,",
-"03000000380700006652000000000000,Mad Catz C.T.R.L.R,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700005032000000000000,Mad Catz FightPad PRO (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700005082000000000000,Mad Catz FightPad PRO (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700008433000000000000,Mad Catz FightStick TE S+ (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700008483000000000000,Mad Catz FightStick TE S+ (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700008134000000000000,Mad Catz FightStick TE2+ PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b7,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b4,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700008184000000000000,Mad Catz FightStick TE2+ PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,leftstick:b10,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700006252000000000000,Mad Catz Micro C.T.R.L.R,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700005645000000000000,Lynx,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000222200006000000000000000,Macally,a:b1,b:b2,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b33,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700003888000000000000,Mad Catz Arcade Fightstick TE S Plus PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700008532000000000000,Mad Catz Arcade Fightstick TE S PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700006352000000000000,Mad Catz CTRLR,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700006652000000000000,Mad Catz CTRLR,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700005032000000000000,Mad Catz Fightpad Pro PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700005082000000000000,Mad Catz Fightpad Pro PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000380700008031000000000000,Mad Catz FightStick Alpha PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000003807000038b7000000000000,Mad Catz Fightstick TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,rightshoulder:b5,righttrigger:b9,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700008433000000000000,Mad Catz Fightstick TE S PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700008483000000000000,Mad Catz Fightstick TE S PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000380700008134000000000000,Mad Catz Fightstick TE2 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b7,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b4,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700008184000000000000,Mad Catz Fightstick TE2 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,leftstick:b10,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000380700006252000000000000,Mad Catz Micro CTRLR,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700008232000000000000,Mad Catz PlayStation Brawlpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700008731000000000000,Mad Catz PlayStation Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000003807000056a8000000000000,Mad Catz PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700001888000000000000,Mad Catz SFIV Fightstick PS3,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b4,righttrigger:b6,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000380700008081000000000000,Mad Catz SFV Arcade Fightstick Alpha PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000380700001847000000000000,Mad Catz Street Fighter 4 Xbox 360 FightStick,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,rightshoulder:b5,righttrigger:b9,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000380700008034000000000000,Mad Catz TE2 PS3 Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700008084000000000000,Mad Catz TE2 PS4 Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700008532000000000000,Madcatz Arcade Fightstick TE S PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700003888000000000000,Madcatz Arcade Fightstick TE S+ PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000380700001888000000000000,MadCatz SFIV FightStick PS3,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b5,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b4,righttrigger:b6,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000380700008081000000000000,MADCATZ SFV Arcade FightStick Alpha PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700008084000000000000,Mad Catz TE2 PS4 Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
 "030000002a0600001024000000000000,Matricom,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b2,y:b3,platform:Windows,",
 "030000009f000000adbb000000000000,MaxJoypad Virtual Controller,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
 "03000000250900000128000000000000,Mayflash Arcade Stick,a:b1,b:b2,back:b8,leftshoulder:b0,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b3,righttrigger:b7,start:b9,x:b5,y:b6,platform:Windows,",
+"030000008f0e00001330000000000000,Mayflash Controller Adapter,a:b1,b:b2,back:b8,dpdown:h0.8,dpleft:h0.2,dpright:h0.1,dpup:h0.4,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a3~,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000242f00003700000000000000,Mayflash F101,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000790000003018000000000000,Mayflash F300 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000242f00003900000000000000,Mayflash F300 Elite Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000790000004418000000000000,Mayflash GameCube Controller,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000790000004318000000000000,Mayflash GameCube Controller Adapter,a:b1,b:b2,back:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b0,leftshoulder:b4,leftstick:b0,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b0,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000790000004318000000000000,Mayflash GameCube Controller Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000242f00007300000000000000,Mayflash Magic NS,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b0,y:b3,platform:Windows,",
 "0300000079000000d218000000000000,Mayflash Magic NS,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000d620000010a7000000000000,Mayflash Magic NS,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000008f0e00001030000000000000,Mayflash USB Adapter for original Sega Saturn controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b5,rightshoulder:b2,righttrigger:b7,start:b9,x:b3,y:b4,platform:Windows,",
-"0300000025090000e803000000000000,Mayflash Wii Classic Controller,a:b1,b:b0,back:b8,dpdown:b13,dpleft:b12,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Windows,",
-"03000000790000000018000000000000,Mayflash WiiU Pro Game Controller Adapter (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000790000002418000000000000,Mega Drive,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,rightshoulder:b2,start:b9,x:b3,y:b4,platform:Windows,",
-"03000000380700006382000000000000,MLG GamePad PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000c62400002a89000000000000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c62400002b89000000000000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c62400001a89000000000000,MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000c62400001b89000000000000,MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000efbe0000edfe000000000000,Monect Virtual Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000242f0000f500000000000000,Mayflash N64 Adapter,a:b2,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a5,start:b9,platform:Windows,",
+"03000000242f0000f400000000000000,Mayflash N64 Controller Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a5,start:b9,platform:Windows,",
+"03000000790000007918000000000000,Mayflash N64 Controller Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b9,leftx:a0,lefty:a1,righttrigger:b7,rightx:a3,righty:a2,start:b8,platform:Windows,",
+"030000008f0e00001030000000000000,Mayflash Saturn Adapter,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,lefttrigger:b7,rightshoulder:b6,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"0300000025090000e803000000000000,Mayflash Wii Classic Adapter,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:a4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:a5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Windows,",
+"03000000790000000318000000000000,Mayflash Wii DolphinBar,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000790000000018000000000000,Mayflash Wii U Pro Adapter,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000790000002418000000000000,Mega Drive Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,rightshoulder:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"0300000079000000ae18000000000000,Mega Drive Controller,a:b0,b:b1,back:b7,dpdown:b14,dpleft:b15,dpright:b13,dpup:b2,rightshoulder:b6,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"03000000c0160000990a000000000000,Mega Drive Controller,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,righttrigger:b2,start:b3,platform:Windows,",
+"030000005e0400002800000000000000,Microsoft Dual Strike,a:b3,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,rightx:a0,righty:a1~,start:b5,x:b1,y:b0,platform:Windows,",
+"030000005e0400000300000000000000,Microsoft SideWinder,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,",
+"030000005e0400000700000000000000,Microsoft SideWinder,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"030000005e0400000e00000000000000,Microsoft SideWinder Freestyle Pro,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,start:b8,x:b3,y:b4,platform:Windows,",
+"030000005e0400002700000000000000,Microsoft SideWinder Plug and Play,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b4,righttrigger:b5,x:b2,y:b3,platform:Windows,",
+"03000000280d00000202000000000000,Miller Lite Cantroller,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,start:b5,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000023f0000000000000,MLG,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a6,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"03000000ad1b00003ef0000000000000,MLG Fightstick TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b8,rightshoulder:b5,righttrigger:b9,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700006382000000000000,MLG PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004523000015e0000000000000,Mobapad Chitu HD,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000491900000904000000000000,Mobapad Chitu HD,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000ffff00000000000000000000,Mocute M053,a:b3,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b11,leftstick:b7,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b6,righttrigger:b4,rightx:a3,righty:a4,start:b8,x:b1,y:b0,platform:Windows,",
+"03000000d6200000e589000000000000,Moga 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000d62000007162000000000000,Moga Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000d6200000ad0d000000000000,Moga Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c62400002a89000000000000,Moga XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c62400002b89000000000000,Moga XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c62400001a89000000000000,Moga XP5X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c62400001b89000000000000,Moga XP5X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000250900006688000000000000,MP-8866 Super Dual Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
-"030000006b140000010c000000000000,NACON GC-400ES,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000921200004b46000000000000,NES 2-port Adapter,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b11,platform:Windows,",
-"03000000790000004518000000000000,NEXILUX GAMECUBE Controller Adapter,platform:Windows,a:b1,b:b0,x:b2,y:b3,start:b9,rightshoulder:b7,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a5,righty:a2,lefttrigger:a3,righttrigger:a4,",
+"03000000091200004488000000000000,MUSIA PlayStation 2 Input Display,a:b0,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,leftstick:b6,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b7,righttrigger:b11,rightx:a2,righty:a3,start:b5,x:b1,y:b3,platform:Windows,",
+"03000000f70600000100000000000000,N64 Adaptoid,+rightx:b2,+righty:b1,-rightx:b4,-righty:b5,a:b0,b:b3,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,platform:Windows,",
+"030000006b140000010c000000000000,Nacon GC 400ES,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"030000006b1400001106000000000000,Nacon Revolution 3 PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"0300000085320000170d000000000000,Nacon Revolution 5 Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"0300000085320000190d000000000000,Nacon Revolution 5 Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000006b140000100d000000000000,Nacon Revolution Infinity PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000006b140000080d000000000000,Nacon Revolution Unlimited Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000bd12000001c0000000000000,Nebular,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a5,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000eb0300000000000000000000,NeGcon Adapter,a:a2,b:b13,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,lefttrigger:a4,leftx:a1,righttrigger:b11,start:b3,x:a3,y:b12,platform:Windows,",
+"0300000038070000efbe000000000000,NEO SE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"0300000092120000474e000000000000,NeoGeo X Arcade Stick,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,x:b3,y:b2,platform:Windows,",
+"03000000921200004b46000000000000,NES 2 port Adapter,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b11,platform:Windows,",
+"03000000000f00000100000000000000,NES Controller,a:b1,b:b0,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Windows,",
+"03000000921200004346000000000000,NES Controller,a:b0,b:b1,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Windows,",
+"03000000790000004518000000000000,NEXILUX GameCube Controller Adapter,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
 "030000001008000001e5000000000000,NEXT SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,righttrigger:b6,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000050b00000045000000000000,Nexus,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b10,x:b2,y:b3,platform:Windows,",
 "03000000152000000182000000000000,NGDS,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000bd12000015d0000000000000,Nintendo Retrolink USB Super SNES Classic Controller,a:b2,b:b1,back:b8,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Windows,",
-"030000007e0500000920000000000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"030000007e0500006920000000000000,Nintendo Switch 2 Pro Controller,a:b0,b:b1,back:b14,dpdown:b8,dpleft:b10,dpright:b9,dpup:b11,guide:b16,leftshoulder:b12,leftstick:b15,lefttrigger:b13,leftx:a0,lefty:a1~,misc1:b17,misc2:b20,paddle1:b18,paddle2:b19,rightshoulder:b4,rightstick:b7,righttrigger:b5,rightx:a2,righty:a3~,start:b6,x:b2,y:b3,platform:Windows,",
+"030000007e0500000920000000000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "030000000d0500000308000000000000,Nostromo N45,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b12,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b2,y:b3,platform:Windows,",
-"03000000550900001472000000000000,NVIDIA Controller v01.04,a:b11,b:b10,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b7,leftstick:b5,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b4,righttrigger:a5,rightx:a3,righty:a6,start:b3,x:b9,y:b8,platform:Windows,",
-"030000004b120000014d000000000000,NYKO AIRFLO,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:a3,leftstick:a0,lefttrigger:b6,rightshoulder:b5,rightstick:a2,righttrigger:b7,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000d620000013a7000000000000,NSW wired controller,platform:Windows,a:b1,b:b2,x:b0,y:b3,back:b8,guide:b12,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,",
-"03000000782300000a10000000000000,Onlive Wireless Controller,a:b15,b:b14,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b5,leftshoulder:b11,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b13,y:b12,platform:Windows,",
+"030000007e0500007320000000000000,NSO GameCube Controller,a:b1,b:b3,dpdown:b8,dpleft:b10,dpright:b9,dpup:b11,guide:b16,leftshoulder:b13,lefttrigger:b12,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b4,rightx:a2,righty:a3~,start:b6,x:b0,y:b2,platform:Windows,",
+"030000007e0500001920000000000000,NSO N64 Controller,+rightx:b8,+righty:b2,-rightx:b3,-righty:b7,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,righttrigger:b10,start:b9,platform:Windows,",
+"030000007e0500001720000000000000,NSO SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b15,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000550900001472000000000000,NVIDIA Controller,a:b11,b:b10,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b7,leftstick:b5,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b4,righttrigger:a5,rightx:a3,righty:a6,start:b3,x:b9,y:b8,platform:Windows,",
+"03000000550900001072000000000000,NVIDIA Shield,a:b9,b:b8,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b3,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b2,righttrigger:a4,rightx:a2,righty:a5,start:b0,x:b7,y:b6,platform:Windows,",
+"030000005509000000b4000000000000,NVIDIA Virtual,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000120c00000288000000000000,Nyko Air Flo Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"030000004b120000014d000000000000,NYKO Airflo EX,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000d62000001d57000000000000,Nyko Airflo PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000791d00000900000000000000,Nyko Playpad,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000782300000a10000000000000,Onlive Controller,a:b15,b:b14,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b5,leftshoulder:b11,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b13,y:b12,platform:Windows,",
+"030000000d0f00000401000000000000,Onyx,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000008916000001fd000000000000,Onza CE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a3,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000008916000000fd000000000000,Onza TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000d62000006d57000000000000,OPP PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006b14000001a1000000000000,Orange Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000362800000100000000000000,OUYA Game Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:b13,rightx:a3,righty:a4,x:b1,y:b2,platform:Windows,",
-"03000000120c0000f60e000000000000,P4 Wired Gamepad,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b5,lefttrigger:b7,rightshoulder:b4,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006f0e00000901000000000000,PDP Versus Fighting Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000008f0e00000300000000000000,Piranha xtreme,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
-"030000004c050000da0c000000000000,PlayStation Classic Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
-"030000004c0500003713000000000000,PlayStation Vita,a:b1,b:b2,back:b8,dpdown:b13,dpleft:b15,dpright:b14,dpup:b12,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"0300000009120000072f000000000000,OrangeFox86 DreamPicoPort,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:-a2,leftx:a0,lefty:a1,righttrigger:-a5,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000362800000100000000000000,OUYA Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,platform:Windows,",
+"03000000120c0000f60e000000000000,P4 Gamepad,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b5,lefttrigger:b7,rightshoulder:b4,righttrigger:b6,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000790000002201000000000000,PC Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"030000006f0e00008501000000000000,PDP Fightpad Pro GameCube Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"030000006f0e00000901000000000000,PDP PS3 Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00008901000000000000,PDP Realmz Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000008f0e00004100000000000000,PlaySega,a:b1,b:b0,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b8,x:b4,y:b3,platform:Windows,",
+"03000000d620000011a7000000000000,PowerA Core Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000dd62000015a7000000000000,PowerA Fusion Nintendo Switch Arcade Stick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d620000012a7000000000000,PowerA Fusion Nintendo Switch Fight Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000dd62000016a7000000000000,PowerA Fusion Pro Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d620000013a7000000000000,PowerA Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d62000003340000000000000,PowerA OPS Pro Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000d62000002640000000000000,PowerA OPS Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000d62000006dca000000000000,PowerA Pro Ex,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"0300000062060000d570000000000000,PowerA PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d620000014a7000000000000,PowerA Spectra Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006d04000084ca000000000000,Precision,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
 "03000000d62000009557000000000000,Pro Elite PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000c62400001a53000000000000,Pro Ex Mini,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000d62000009f31000000000000,Pro Ex mini PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000d6200000c757000000000000,Pro Ex mini PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000632500002306000000000000,PS Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000e30500009605000000000000,PS to USB convert cable,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000120c0000110e000000000000,Pro5,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000100800000100000000000000,PS1 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
 "030000008f0e00007530000000000000,PS1 Controller,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b1,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000100800000300000000000000,PS2 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a4,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000250900000088000000000000,PS2 Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000250900006888000000000000,PS2 Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b6,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
 "03000000250900008888000000000000,PS2 Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
-"03000000666600006706000000000000,PS2 Controller,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Windows,",
 "030000006b1400000303000000000000,PS2 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
 "030000009d0d00001330000000000000,PS2 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000151a00006222000000000000,PS2 Dual Plus Adapter,a:b2,b:b1,back:b9,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000120a00000100000000000000,PS3 Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000120c00001307000000000000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000120c00001cf1000000000000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f90e000000000000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000250900000118000000000000,PS3 Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000250900000218000000000000,PS3 Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
 "03000000250900000500000000000000,PS3 Controller,a:b2,b:b1,back:b9,dpdown:h0.8,dpleft:h0.4,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b0,y:b3,platform:Windows,",
 "030000004c0500006802000000000000,PS3 Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b10,lefttrigger:a3~,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:a4~,rightx:a2,righty:a5,start:b8,x:b3,y:b0,platform:Windows,",
+"030000004f1f00000800000000000000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000632500007505000000000000,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000888800000803000000000000,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.8,dpleft:h0.4,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b9,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b0,y:b3,platform:Windows,",
+"03000000888800000803000000000000,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b9,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b0,platform:Windows,",
+"03000000888800000804000000000000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Windows,",
+"030000008f0e00000300000000000000,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,",
 "030000008f0e00001431000000000000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000003807000056a8000000000000,PS3 RF pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000100000008200000000000000,PS360+ v1.66,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:h0.4,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004c050000a00b000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004c050000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004c050000cc09000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004c050000e60c000000000000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000ff000000cb01000000000000,PSP,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000300f00000011000000000000,QanBa Arcade JoyStick 1008,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b10,x:b0,y:b3,platform:Windows,",
-"03000000300f00001611000000000000,QanBa Arcade JoyStick 4018,a:b1,b:b2,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b8,x:b0,y:b3,platform:Windows,",
-"03000000222c00000020000000000000,QANBA DRONE ARCADE JOYSTICK,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,rightshoulder:b5,righttrigger:a4,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000300f00001210000000000000,QanBa Joystick Plus,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000341a00000104000000000000,QanBa Joystick Q4RAF,a:b5,b:b6,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b0,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b3,righttrigger:b7,start:b9,x:b1,y:b2,platform:Windows,",
-"03000000222c00000223000000000000,Qanba Obsidian Arcade Joystick PS3 Mode,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000222c00000023000000000000,Qanba Obsidian Arcade Joystick PS4 Mode,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000ba2200002010000000000000,PS3 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a5,righty:a2,start:b9,x:b3,y:b2,platform:Windows,",
+"03000000120c00000807000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000111e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000121e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000130e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000150e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000180e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000181e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000191e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c00001e0e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000a957000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000aa57000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f21c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f31c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f41c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f51c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120c0000f70e000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000120e0000120c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000160e0000120c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000001a1e0000120c000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000004c050000a00b000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000004c050000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000004c050000cc09000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000004c0500005f0e000000000000,PS5 Access Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000004c050000e60c000000000000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000004c050000f20d000000000000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000830500005020000000000000,PSX,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b2,y:b3,platform:Windows,",
+"03000000300f00000111000000000000,Qanba 2,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000300f00000211000000000000,Qanba 2P,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000300f00000011000000000000,Qanba Arcade Stick 1008,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b10,x:b0,y:b3,platform:Windows,",
+"03000000300f00001611000000000000,Qanba Arcade Stick 4018,a:b1,b:b2,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b8,x:b0,y:b3,platform:Windows,",
+"03000000222c00000025000000000000,Qanba Dragon Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000222c00000020000000000000,Qanba Drone Arcade Stick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,rightshoulder:b5,righttrigger:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000300f00001211000000000000,Qanba Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000300f00001210000000000000,Qanba Joystick Plus,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000341a00000104000000000000,Qanba Joystick Q4RAF,a:b5,b:b6,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b0,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b3,righttrigger:b7,start:b9,x:b1,y:b2,platform:Windows,",
+"03000000222c00000223000000000000,Qanba Obsidian Arcade Stick PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000222c00000023000000000000,Qanba Obsidian Arcade Stick PS4,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000008a2400006682000000000000,R1 Mobile Controller,a:b3,b:b1,back:b7,leftx:a0,lefty:a1,start:b6,x:b4,y:b0,platform:Windows,",
+"03000000086700006626000000000000,RadioShack,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000ff1100004733000000000000,Ramox FPS Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b0,platform:Windows,",
+"030000009b2800002300000000000000,Raphnet 3DO Adapter,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b2,start:b3,platform:Windows,",
+"030000009b2800006900000000000000,Raphnet 3DO Adapter,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b2,start:b3,platform:Windows,",
+"030000009b2800000800000000000000,Raphnet Dreamcast Adapter,a:b2,b:b1,dpdown:b5,dpleft:b6,dpright:b7,dpup:b4,lefttrigger:a2,leftx:a0,righttrigger:a3,righty:a1,start:b3,x:b10,y:b9,platform:Windows,",
+"030000009b280000d000000000000000,Raphnet Dreamcast Adapter,a:b1,b:b0,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,lefttrigger:+a5,leftx:a0,lefty:a1,righttrigger:+a2,start:b3,x:b5,y:b4,platform:Windows,",
+"030000009b2800006200000000000000,Raphnet GameCube Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,",
+"030000009b2800003200000000000000,Raphnet GC and N64 Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:+a2,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,",
+"030000009b2800006000000000000000,Raphnet GC and N64 Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:+a2,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Windows,",
+"030000009b2800001800000000000000,Raphnet Jaguar Adapter,a:b2,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b10,start:b3,x:b11,y:b12,platform:Windows,",
+"030000009b2800003c00000000000000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Windows,",
+"030000009b2800006100000000000000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Windows,",
+"030000009b2800006300000000000000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Windows,",
+"030000009b2800006400000000000000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Windows,",
+"030000009b2800000200000000000000,Raphnet NES Adapter,a:b7,b:b6,back:b5,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,start:b4,platform:Windows,",
+"030000009b2800004400000000000000,Raphnet PS1 and PS2 Adapter,a:b1,b:b2,back:b5,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b9,rightx:a3,righty:a4,start:b4,x:b0,y:b3,platform:Windows,",
+"030000009b2800004300000000000000,Raphnet Saturn,a:b0,b:b1,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,",
+"030000009b2800000500000000000000,Raphnet Saturn Adapter 2.0,a:b1,b:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000009b2800000300000000000000,Raphnet SNES Adapter,a:b0,b:b4,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Windows,",
+"030000009b2800002600000000000000,Raphnet SNES Adapter,a:b1,b:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800002e00000000000000,Raphnet SNES Adapter,a:b1,b:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800002f00000000000000,Raphnet SNES Adapter,a:b1,b:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800005600000000000000,Raphnet SNES Adapter,a:b1,b:b4,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800005700000000000000,Raphnet SNES Adapter,a:b1,b:b4,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800001e00000000000000,Raphnet Vectrex Adapter,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a1,lefty:a2,x:b2,y:b3,platform:Windows,",
+"030000009b2800002b00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800002c00000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,",
+"030000009b2800008000000000000000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Windows,",
+"03000000790000008f18000000000000,Rapoo Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,",
+"0300000032150000a602000000000000,Razer Huntsman V3 Pro,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b12,dpright:b13,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000321500000003000000000000,Razer Hydra,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000321500000204000000000000,Razer Panthera (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000321500000104000000000000,Razer Panthera (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000f8270000bf0b000000000000,Razer Kishi,a:b6,b:b7,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b18,leftshoulder:b12,leftstick:b19,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b13,rightstick:b20,righttrigger:b15,rightx:a3,righty:a4,start:b17,x:b9,y:b10,platform:Windows,",
+"03000000321500000204000000000000,Razer Panthera PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000321500000104000000000000,Razer Panthera PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000321500000010000000000000,Razer Raiju,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000321500000507000000000000,Razer Raiju Mobile,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000321500000707000000000000,Razer Raiju Mobile,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000321500000011000000000000,Razer Raion Fightpad for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000321500000710000000000000,Razer Raiju TE,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000321500000a10000000000000,Razer Raiju TE,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000321500000410000000000000,Razer Raiju UE,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000321500000910000000000000,Razer Raiju UE,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000321500000011000000000000,Razer Raion PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
 "03000000321500000009000000000000,Razer Serval,+lefty:+a2,-lefty:-a1,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,leftx:a0,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
-"030000000d0f00001100000000000000,REAL ARCADE PRO.3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00006a00000000000000,Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00006b00000000000000,Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00008a00000000000000,Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00008b00000000000000,Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00007000000000000000,REAL ARCADE PRO.4 VLX,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00002200000000000000,REAL ARCADE Pro.V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00005b00000000000000,Real Arcade Pro.V4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000000d0f00005c00000000000000,Real Arcade Pro.V4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000790000001100000000000000,Retrolink SNES Controller,a:b2,b:b1,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000bd12000013d0000000000000,Retrolink USB SEGA Saturn Classic,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b5,lefttrigger:b6,rightshoulder:b2,righttrigger:b7,start:b8,x:b3,y:b4,platform:Windows,",
-"0300000000f000000300000000000000,RetroUSB.com RetroPad,a:b1,b:b5,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Windows,",
-"0300000000f00000f100000000000000,RetroUSB.com Super RetroPort,a:b1,b:b5,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Windows,",
+"03000000921200004547000000000000,Retro Bit Sega Genesis Controller Adapter,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b6,x:b3,y:b4,platform:Windows,",
+"03000000790000001100000000000000,Retro Controller,a:b1,b:b2,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,leftshoulder:b6,lefttrigger:b7,rightshoulder:b4,righttrigger:b5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000830500006020000000000000,Retro Controller,a:b0,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b8,righttrigger:b9,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000632500007805000000000000,Retro Fighters Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"0300000003040000c197000000000000,Retrode Adapter,a:b0,b:b4,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Windows,",
+"03000000bd12000013d0000000000000,Retrolink Sega Saturn Classic Controller,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b5,lefttrigger:b6,rightshoulder:b2,righttrigger:b7,start:b8,x:b3,y:b4,platform:Windows,",
+"03000000bd12000015d0000000000000,Retrolink SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000341200000400000000000000,RetroUSB N64 RetroPort,+rightx:b8,+righty:b10,-rightx:b9,-righty:b11,a:b7,b:b6,dpdown:b2,dpleft:b1,dpright:b0,dpup:b3,leftshoulder:b13,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b12,start:b4,platform:Windows,",
+"0300000000f000000300000000000000,RetroUSB RetroPad,a:b1,b:b5,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Windows,",
+"0300000000f00000f100000000000000,RetroUSB Super RetroPort,a:b1,b:b5,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Windows,",
+"03000000830500000960000000000000,Revenger,a:b0,b:b1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b3,x:b4,y:b5,platform:Windows,",
 "030000006b140000010d000000000000,Revolution Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006b140000020d000000000000,Revolution Pro Controller 2(1/2),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006b140000020d000000000000,Revolution Pro Controller 2,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006b140000130d000000000000,Revolution Pro Controller 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00001f01000000000000,Rock Candy,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00004601000000000000,Rock Candy,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c6240000fefa000000000000,Rock Candy Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00008701000000000000,Rock Candy Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00001e01000000000000,Rock Candy PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00002801000000000000,Rock Candy PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "030000006f0e00002f01000000000000,Rock Candy PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004f04000003d0000000000000,run'n'drive,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b7,leftshoulder:a3,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:a4,rightstick:b11,righttrigger:b5,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000830500007030000000000000,Rockfire Space Ranger,a:b0,b:b1,back:b5,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b9,righttrigger:b8,start:b2,x:b3,y:b4,platform:Windows,",
+"03000000050b0000e318000000000000,ROG Chakram,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,platform:Windows,",
+"03000000050b0000e518000000000000,ROG Chakram,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,platform:Windows,",
+"03000000050b00005819000000000000,ROG Chakram Core,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,platform:Windows,",
+"03000000050b0000181a000000000000,ROG Chakram X,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,platform:Windows,",
+"03000000050b00001a1a000000000000,ROG Chakram X,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,platform:Windows,",
+"03000000050b00001c1a000000000000,ROG Chakram X,a:b1,b:b0,leftx:a0,lefty:a1,x:b2,y:b3,platform:Windows,",
+"030000004f04000001d0000000000000,Rumble Force,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
+"030000000d0f0000ad00000000000000,RX Gamepad,a:b0,b:b4,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b3,rightshoulder:b6,start:b9,x:b2,y:b1,platform:Windows,",
+"030000008916000000fe000000000000,Sabertooth,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c6240000045d000000000000,Sabertooth,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e00001311000000000000,Saffun Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b0,platform:Windows,",
 "03000000a30600001af5000000000000,Saitek Cyborg,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000a306000023f6000000000000,Saitek Cyborg V.1 Game pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000300f00001201000000000000,Saitek Dual Analog Pad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000a306000023f6000000000000,Saitek Cyborg,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000300f00001201000000000000,Saitek Dual Analog,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
 "03000000a30600000701000000000000,Saitek P220,a:b2,b:b3,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b4,righttrigger:b5,x:b0,y:b1,platform:Windows,",
-"03000000a30600000cff000000000000,Saitek P2500 Force Rumble Pad,a:b2,b:b3,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b0,y:b1,platform:Windows,",
+"03000000a30600000cff000000000000,Saitek P2500 Force Rumble,a:b2,b:b3,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b0,y:b1,platform:Windows,",
+"03000000a30600000d5f000000000000,Saitek P2600,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Windows,",
+"03000000a30600000dff000000000000,Saitek P2600,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a5,righty:a2,start:b8,x:b0,y:b3,platform:Windows,",
 "03000000a30600000c04000000000000,Saitek P2900,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000300f00001001000000000000,Saitek P480 Rumble Pad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000a306000018f5000000000000,Saitek P3200,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000300f00001001000000000000,Saitek P480 Rumble,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000a30600000901000000000000,Saitek P880,a:b2,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b8,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b5,rightx:a3,righty:a2,x:b0,y:b1,platform:Windows,",
 "03000000a30600000b04000000000000,Saitek P990,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000a30600000b04000000010000,Saitek P990 Dual Analog Pad,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Windows,",
-"03000000a30600002106000000000000,Saitek PS1000,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000a306000020f6000000000000,Saitek PS2700,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000300f00001101000000000000,Saitek Rumble Pad,a:b2,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
-"03000000730700000401000000000000,Sanwa PlayOnline Mobile,a:b0,b:b1,back:b2,leftx:a0,lefty:a1,start:b3,platform:Windows,",
-"0300000000050000289b000000000000,Saturn_Adapter_2.0,a:b1,b:b2,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000009b2800000500000000000000,Saturn_Adapter_2.0,a:b1,b:b2,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000a30c00002500000000000000,Sega Genesis Mini 3B controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,righttrigger:b5,start:b9,platform:Windows,",
-"03000000a30c00002400000000000000,Sega Mega Drive Mini 6B controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000341a00000208000000000000,SL-6555-SBK,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:-a4,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a3,righty:a2,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000341a00000908000000000000,SL-6566,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"030000008f0e00000800000000000000,SpeedLink Strike FX,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000a30600002106000000000000,Saitek PS1000 PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000a306000020f6000000000000,Saitek PS2700 PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000300f00001101000000000000,Saitek Rumble,a:b2,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000e804000000a0000000000000,Samsung EIGP20,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000c01100000252000000000000,Sanwa Easy Grip,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"03000000c01100004350000000000000,Sanwa Micro Grip P3,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,x:b3,y:b2,platform:Windows,",
+"03000000411200004550000000000000,Sanwa Micro Grip Pro,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a1,righty:a2,start:b9,x:b1,y:b3,platform:Windows,",
+"03000000c01100004150000000000000,Sanwa Micro Grip Pro,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
+"03000000c01100004450000000000000,Sanwa Online Grip,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b8,rightstick:b11,righttrigger:b9,rightx:a3,righty:a2,start:b14,x:b3,y:b4,platform:Windows,",
+"03000000730700000401000000000000,Sanwa PlayOnline Mobile,a:b0,b:b1,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Windows,",
+"03000000830500006120000000000000,Sanwa Smart Grip II,a:b0,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,x:b1,y:b3,platform:Windows,",
+"03000000c01100000051000000000000,Satechi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"030000004f04000028b3000000000000,Score A,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000952e00002577000000000000,Scuf PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000a30c00002500000000000000,Sega Genesis Mini 3B Controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,righttrigger:b5,start:b9,platform:Windows,",
+"03000000a30c00002400000000000000,Sega Mega Drive Mini 6B Controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000d804000086e6000000000000,Sega Multi Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:a2,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,",
+"0300000000050000289b000000000000,Sega Saturn Adapter,a:b1,b:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,start:b9,x:b0,y:b3,platform:Windows,",
+"0300000000f000000800000000000000,Sega Saturn Controller,a:b1,b:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,rightshoulder:b7,righttrigger:b3,start:b0,x:b5,y:b6,platform:Windows,",
+"03000000730700000601000000000000,Sega Saturn Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Windows,",
+"03000000b40400000a01000000000000,Sega Saturn Controller,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Windows,",
+"030000003b07000004a1000000000000,SFX,a:b0,b:b2,back:b7,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b9,righttrigger:b5,start:b8,x:b1,y:b3,platform:Windows,",
+"03000000f82100001900000000000000,Shogun Bros Chameleon X1,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000120c00001c1e000000000000,SnakeByte 4S PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"03000000140300000918000000000000,SNES Controller,a:b0,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
+"0300000081170000960a000000000000,SNES Controller,a:b4,b:b0,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b5,y:b1,platform:Windows,",
+"03000000811700009d0a000000000000,SNES Controller,a:b0,b:b4,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Windows,",
+"030000008b2800000300000000000000,SNES Controller,a:b0,b:b4,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Windows,",
+"03000000921200004653000000000000,SNES Controller,a:b0,b:b4,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Windows,",
+"030000008f0e00000910000000000000,Sony DualShock 2,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,platform:Windows,",
+"03000000317300000100000000000000,Sony DualShock 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000666600006706000000000000,Sony PlayStation Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Windows,",
+"03000000e30500009605000000000000,Sony PlayStation Adapter,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000fe1400002a23000000000000,Sony PlayStation Adapter,a:b0,b:b1,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,x:b2,y:b3,platform:Windows,",
+"030000004c050000da0c000000000000,Sony PlayStation Classic Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000632500002306000000000000,Sony PlayStation Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000f0250000c183000000000000,Sony PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000d9040000160f000000000000,Sony PlayStation Controller Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000ff000000cb01000000000000,Sony PlayStation Portable,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
+"030000004c0500003713000000000000,Sony PlayStation Vita,a:b1,b:b2,back:b8,dpdown:b13,dpleft:b15,dpright:b14,dpup:b12,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000341a00000208000000000000,Speedlink 6555,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:-a4,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a3,righty:a2,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000341a00000908000000000000,Speedlink 6566,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000380700001722000000000000,Speedlink Competition Pro,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,x:b2,y:b3,platform:Windows,",
+"030000008f0e00000800000000000000,Speedlink Strike FX,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000c01100000591000000000000,Speedlink Torid,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000d11800000094000000000000,Stadia Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:b11,rightx:a3,righty:a4,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000de280000fc11000000000000,Steam Virtual Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000de280000ff11000000000000,Steam Virtual Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000120c0000160e000000000000,Steel Play Metaltech PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
 "03000000110100001914000000000000,SteelSeries,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftstick:b13,lefttrigger:b6,leftx:a0,lefty:a1,rightstick:b14,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000381000001214000000000000,SteelSeries Free,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000110100003114000000000000,SteelSeries Stratus Duo,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000381000003014000000000000,SteelSeries Stratus Duo,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000381000003114000000000000,SteelSeries Stratus Duo,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000381000001814000000000000,SteelSeries Stratus XL,a:b0,b:b1,back:b18,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b19,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000790000001c18000000000000,STK-7024X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000ff1100003133000000000000,SVEN X-PAD,a:b2,b:b3,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a4,start:b5,x:b0,y:b1,platform:Windows,",
-"03000000d620000011a7000000000000,Switch,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000457500002211000000000000,SZMY-POWER PC Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004f04000007d0000000000000,T Mini Wireless,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004f0400000ab1000000000000,T.16000M,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,start:b10,x:b2,y:b3,platform:Windows,",
+"03000000380700003847000000000000,Street Fighter Fightstick TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b11,start:b7,x:b2,y:b3,platform:Windows,",
+"030000001f08000001e4000000000000,Super Famicom Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000790000000418000000000000,Super Famicom Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b33,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000341200001300000000000000,Super Racer,a:b2,b:b3,back:b8,leftshoulder:b5,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b4,righttrigger:b7,x:b0,y:b1,platform:Windows,",
+"03000000457500002211000000000000,Szmy Power PC Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004f0400000ab1000000000000,T16000M,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,start:b10,x:b2,y:b3,platform:Windows,",
+"030000000d0f00007b00000000000000,TAC GEAR,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000e40a00000307000000000000,Taito Egret II Mini Control Panel,a:b4,b:b2,back:b6,guide:b9,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b1,start:b7,x:b8,y:b3,platform:Windows,",
+"03000000e40a00000207000000000000,Taito Egret II Mini Controller,a:b4,b:b2,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,guide:b9,rightshoulder:b0,righttrigger:b1,start:b7,x:b8,y:b3,platform:Windows,",
+"03000000d814000001a0000000000000,TE Kitty,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
 "03000000fa1900000706000000000000,Team 5,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000b50700001203000000000000,Techmobility X6-38V,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000ba2200000701000000000000,Technology Innovation PS2 Adapter,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b2,platform:Windows,",
+"03000000c61100001000000000000000,Tencent Xianyou Gamepad,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,x:b3,y:b4,platform:Windows,",
+"03000000790000001c18000000000000,TGZ Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000790000002601000000000000,TGZ Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000591c00002400000000000000,THEC64 Joystick,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000591c00002600000000000000,THEGamepad,a:b2,b:b1,back:b6,leftx:a0,lefty:a1,start:b7,x:b3,y:b0,platform:Windows,",
 "030000004f04000015b3000000000000,Thrustmaster Dual Analog 4,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
-"030000004f04000023b3000000000000,Thrustmaster Dual Trigger 3-in-1,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
-"030000004f0400000ed0000000000000,ThrustMaster eSwap PRO Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004f04000023b3000000000000,Thrustmaster Dual Trigger PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004f0400000ed0000000000000,Thrustmaster eSwap Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004f04000008d0000000000000,Thrustmaster Ferrari 150 PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "030000004f04000000b3000000000000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b11,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b1,y:b3,platform:Windows,",
-"030000004f04000004b3000000000000,Thrustmaster Firestorm Dual Power 3,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
-"03000000666600000488000000000000,TigerGame PS/PS2 Game Controller Adapter,a:b2,b:b1,back:b9,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"030000004f04000004b3000000000000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Windows,",
+"030000004f04000003d0000000000000,Thrustmaster Run N Drive PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b7,leftshoulder:a3,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:a4,rightstick:b11,righttrigger:b5,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000004f04000009d0000000000000,Thrustmaster Run N Drive PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006d04000088ca000000000000,Thunderpad,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"03000000666600000288000000000000,TigerGame PlayStation Adapter,a:b2,b:b1,back:b9,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000666600000488000000000000,TigerGame PlayStation Adapter,a:b2,b:b1,back:b9,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"030000004f04000007d0000000000000,TMini,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000571d00002100000000000000,Tomee NES Controller Adapter,a:b1,b:b0,back:b2,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,start:b3,platform:Windows,",
+"03000000571d00002000000000000000,Tomee SNES Controller Adapter,a:b0,b:b1,back:b6,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,leftshoulder:b4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000d62000006000000000000000,Tournament PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000c01100000055000000000000,Tronsmart,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "030000005f140000c501000000000000,Trust Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "03000000b80500000210000000000000,Trust Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
 "030000004f04000087b6000000000000,TWCS Throttle,dpdown:b8,dpleft:b9,dpright:b7,dpup:b6,leftstick:b5,lefttrigger:-a5,leftx:a0,lefty:a1,righttrigger:+a5,platform:Windows,",
-"03000000d90400000200000000000000,TwinShock PS2,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
-"030000006e0500001320000000000000,U4113,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000411200000450000000000000,Twin Shock,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a4,start:b11,x:b3,y:b0,platform:Windows,",
+"03000000d90400000200000000000000,TwinShock PS2 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000151900005678000000000000,Uniplay U6,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
 "03000000101c0000171c000000000000,uRage Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000300f00000701000000000000,USB 4-Axis 12-Button Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000341a00002308000000000000,USB gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"030000005509000000b4000000000000,USB gamepad,a:b10,b:b11,back:b5,dpdown:b1,dpleft:b2,dpright:b3,dpup:b0,guide:b14,leftshoulder:b8,leftstick:b6,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b9,rightstick:b7,righttrigger:a5,rightx:a2,righty:a3,start:b4,x:b12,y:b13,platform:Windows,",
-"030000006b1400000203000000000000,USB gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000790000000a00000000000000,USB gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000f0250000c183000000000000,USB gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000ff1100004133000000000000,USB gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a4,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000632500002305000000000000,USB Vibration Joystick (BM),a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000790000001a18000000000000,Venom,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
-"03000000790000001b18000000000000,Venom Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006f0e00000302000000000000,Victrix Pro Fight Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
-"030000006f0e00000702000000000000,Victrix Pro Fight Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Windows,",
+"030000000b0400003065000000000000,USB Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000242f00006e00000000000000,USB Controller,a:b1,b:b4,back:b10,leftshoulder:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b9,righttrigger:b7,rightx:a2,righty:a5,start:b11,x:b0,y:b3,platform:Windows,",
+"03000000300f00000701000000000000,USB Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000341a00002308000000000000,USB Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000666600000188000000000000,USB Controller,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Windows,",
+"030000006b1400000203000000000000,USB Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"03000000790000000a00000000000000,USB Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000b404000081c6000000000000,USB Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000b50700001503000000000000,USB Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a5,righty:a2,start:b9,x:b0,y:b1,platform:Windows,",
+"03000000bd12000012d0000000000000,USB Controller,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ff1100004133000000000000,USB Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a4,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000632500002305000000000000,USB Vibration Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000882800000305000000000000,V5 Game Pad,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,x:b2,y:b3,platform:Windows,",
+"03000000790000001a18000000000000,Venom PS4 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000790000001b18000000000000,Venom PS4 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000006f0e00000302000000000000,Victrix PS4 Pro Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
+"030000006f0e00000702000000000000,Victrix PS4 Pro Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Windows,",
 "0300000034120000adbe000000000000,vJoy Device,a:b0,b:b1,back:b15,dpdown:b6,dpleft:b7,dpright:b8,dpup:b5,guide:b16,leftshoulder:b9,leftstick:b13,lefttrigger:b11,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b14,righttrigger:b12,rightx:a3,righty:a4,start:b4,x:b2,y:b3,platform:Windows,",
+"03000000120c0000ab57000000000000,Warrior Joypad JS083,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"030000007e0500003003000000000000,Wii U Pro,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,leftshoulder:b6,leftstick:b11,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b12,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Windows,",
+"0300000032150000030a000000000000,Wildcat,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"0300000032150000140a000000000000,Wolverine,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000002e160000efbe000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b10,rightshoulder:b5,righttrigger:b11,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700001647000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700002045000000000000,Xbox 360 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000380700002644000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a2,righty:a5,start:b8,x:b2,y:b3,platform:Windows,",
+"03000000380700002647000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000003807000026b7000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700003647000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a7,righty:a5,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e0400001907000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e0400008e02000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e0400009102000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000000fd000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000001fd000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b000016f0000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000ad1b00008e02000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c62400000053000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c6240000fdfa000000000000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700002847000000000000,Xbox 360 Fightpad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000a102000000000000,Xbox 360 Wireless Receiver,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "030000005e0400000a0b000000000000,Xbox Adaptive Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000120c00000a88000000000000,Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a2,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"03000000120c00001088000000000000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2~,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5~,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000002a0600002000000000000000,Xbox Controller,a:b0,b:b1,back:b13,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,leftshoulder:b5,leftstick:b14,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b15,righttrigger:b7,rightx:a2,righty:a5,start:b12,x:b2,y:b3,platform:Windows,",
+"03000000380700001645000000000000,Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"03000000380700002645000000000000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000380700003645000000000000,Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"03000000380700008645000000000000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e0400000202000000000000,Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b11,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"030000005e0400008502000000000000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e0400008702000000000000,Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b4,rightstick:b9,righttrigger:b7,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"030000005e0400008902000000000000,Xbox Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b10,leftstick:b8,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b9,righttrigger:b4,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Windows,",
+"030000005e0400000c0b000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000d102000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000dd02000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000e002000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000e302000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000ea02000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000fd02000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000005e040000ff02000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:-a2,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e0000a802000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"030000006f0e0000c802000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
+"03000000c62400003a54000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "030000005e040000130b000000000000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
 "03000000341a00000608000000000000,Xeox,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000450c00002043000000000000,XEOX Gamepad SL-6556-BK,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
-"03000000ac0500005b05000000000000,Xiaoji Gamesir-G3w,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Windows,",
-"03000000172700004431000000000000,XiaoMi Game Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a7,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000786901006e70000000000000,XInput Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Windows,",
-"03000000790000004f18000000000000,ZD-T Android,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
-"03000000120c0000101e000000000000,ZEROPLUS P4 Wired Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
+"03000000450c00002043000000000000,Xeox SL6556BK,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Windows,",
+"030000006f0e00000300000000000000,XGear,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a5,righty:a2,start:b9,x:b3,y:b0,platform:Windows,",
+"03000000e0ff00000201000000000000,Xiaomi Black Shark (L),back:b0,dpdown:b11,dpleft:b9,dpright:b10,dpup:b8,leftshoulder:b5,lefttrigger:b7,leftx:a0,lefty:a1,platform:Windows,",
+"03000000172700004431000000000000,Xiaomi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a7,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000172700003350000000000000,Xiaomi XMGP01YM,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000bc2000005060000000000000,Xiaomi XMGP01YM,+lefty:+a2,+righty:+a5,-lefty:-a1,-righty:-a4,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,start:b11,x:b3,y:b4,platform:Windows,",
+"030000007d0400000340000000000000,Xterminator Digital Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:-a4,lefttrigger:+a4,leftx:a0,lefty:a1,paddle1:b7,paddle2:b6,rightshoulder:b5,rightstick:b9,righttrigger:b2,rightx:a3,righty:a5,start:b8,x:b3,y:b4,platform:Windows,",
+"030000002c3600000100000000000000,Yawman Arrow,+rightx:h0.2,+righty:h0.4,-rightx:h0.8,-righty:h0.1,a:b4,b:b5,back:b6,dpdown:b15,dpleft:b14,dpright:b16,dpup:b13,leftshoulder:b10,leftstick:b0,lefttrigger:-a4,leftx:a0,lefty:a1,paddle1:b11,paddle2:b12,rightshoulder:b8,rightstick:b9,righttrigger:+a4,start:b3,x:b1,y:b2,platform:Windows,",
+"03000000790000004f18000000000000,ZDT Android Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Windows,",
+"03000000120c00000500000000000000,Zeroplus Adapter,a:b2,b:b1,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b0,righttrigger:b5,rightx:a3,righty:a2,start:b8,x:b3,y:b0,platform:Windows,",
+"03000000120c0000101e000000000000,Zeroplus P4 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Windows,",
 "78696e70757401000000000000000000,XInput Gamepad (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
 "78696e70757402000000000000000000,XInput Wheel (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
 "78696e70757403000000000000000000,XInput Arcade Stick (GLFW),platform:Windows,a:b0,b:b1,x:b2,y:b3,leftshoulder:b4,rightshoulder:b5,back:b6,start:b7,leftstick:b8,rightstick:b9,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:a4,righttrigger:a5,dpup:h0.1,dpright:h0.2,dpdown:h0.4,dpleft:h0.8,",
@@ -429,423 +908,743 @@ const char* _glfwDefaultMappings[] =
 #endif // _GLFW_WIN32
 
 #if defined(_GLFW_COCOA)
-"030000008f0e00000300000009010000,2In1 USB Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"030000008f0e00000300000009010000,2 In 1 Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000c82d00000031000001000000,8BitDo Adapter,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00000531000000020000,8BitDo Adapter 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00000951000000010000,8BitDo Dogbone,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightx:a2,righty:a3,start:b11,platform:Mac OS X,",
 "03000000c82d00000090000001000000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
 "03000000c82d00001038000000010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00000650000001000000,8BitDo M30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000c82d00005106000000010000,8BitDo M30 Gamepad,a:b1,b:b0,back:b10,guide:b2,leftshoulder:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00006a28000000010000,8BitDo GameCube,a:b0,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b9,paddle2:b8,rightshoulder:b10,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b1,y:b4,platform:Mac OS X,",
+"03000000c82d00001251000000010000,8BitDo Lite 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00001251000000020000,8BitDo Lite 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00001151000000010000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00001151000000020000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000a30c00002400000006020000,8BitDo M30,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,guide:b9,leftshoulder:b6,lefttrigger:b5,rightshoulder:b4,righttrigger:b7,start:b8,x:b3,y:b0,platform:Mac OS X,",
+"03000000c82d00000151000000010000,8BitDo M30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00000650000001000000,8BitDo M30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00005106000000010000,8BitDo M30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,guide:b2,leftshoulder:b6,lefttrigger:a5,rightshoulder:b7,righttrigger:a4,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00002090000000010000,8BitDo Micro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000451000000010000,8BitDo N30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightx:a2,righty:a3,start:b11,platform:Mac OS X,",
 "03000000c82d00001590000001000000,8BitDo N30 Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
 "03000000c82d00006528000000010000,8BitDo N30 Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"030000003512000012ab000001000000,8BitDo NES30 Gamepad,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000022000000090000001000000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000203800000900000000010000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00000190000001000000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000102800000900000000000000,8Bitdo SFC30 GamePad Joystick,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00001290000001000000,8BitDo SN30 Gamepad,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00004028000000010000,8Bitdo SN30 GamePad,a:b1,b:b0,x:b4,y:b3,back:b10,start:b11,leftshoulder:b6,rightshoulder:b7,dpup:-a1,dpdown:+a1,dpleft:-a0,dpright:+a0,platform:Mac OS X,",
+"03000000c82d00006928000000010000,8BitDo N64,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,platform:Mac OS X,",
+"03000000c82d00002590000000010000,8BitDo NEOGEO,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00002590000001000000,8BitDo NEOGEO,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00002690000000010000,8BitDo NEOGEO,+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b10,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000003512000012ab000001000000,8BitDo NES30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d000012ab000001000000,8BitDo NES30,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00002028000000010000,8BitDo NES30,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000022000000090000001000000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000203800000900000000010000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000190000001000000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000751000000010000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00000851000000010000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00000660000000010000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000660000000020000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000131000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000231000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000331000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000431000001000000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00002867000000010000,8BitDo S30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00003028000000010000,8Bitdo SFC30 Gamepad,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000102800000900000000000000,8BitDo SFC30 Joystick,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000351000000010000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00001290000001000000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00004028000000010000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
 "03000000c82d00000160000001000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
 "03000000c82d00000161000000010000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a5,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00000260000001000000,8BitDo SN30 Pro+,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00000261000000010000,8BitDo SN30 Pro+,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000c82d00000031000001000000,8BitDo Wireless Adapter,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000c82d00001890000001000000,8BitDo Zero 2,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000260000001000000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00000261000000010000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000c82d00001230000000010000,8BitDo Ultimate,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001b30000001000000,8BitDo Ultimate 2C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b5,paddle2:b2,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001d30000001000000,8BitDo Ultimate 2C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b5,paddle2:b2,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001530000001000000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001630000001000000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001730000001000000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001130000000020000,8BitDo Ultimate Wired,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b24,paddle2:b25,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001330000000020000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b23,paddle2:b19,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001330000001000000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b23,paddle2:b19,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000a00500003232000008010000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000a00500003232000009010000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c82d00001890000001000000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
 "03000000c82d00003032000000010000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a31,start:b11,x:b4,y:b3,platform:Mac OS X,",
-"03000000a00500003232000008010000,8Bitdo Zero GamePad,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000a00500003232000009010000,8Bitdo Zero GamePad,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000a30c00002700000003030000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
-"03000000a30c00002800000003030000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
-"03000000050b00000045000031000000,ASUS Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
-"03000000ef0500000300000000020000,AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Mac OS X,",
 "03000000491900001904000001010000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Mac OS X,",
 "03000000710100001904000000010000,Amazon Luna Controller,a:b0,b:b1,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Mac OS X,",
+"0300000008100000e501000019040000,Anbernic Handheld,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000373500004610000001000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000a30c00002700000003030000,Astro City Mini,a:b2,b:b1,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000a30c00002800000003030000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a3,lefty:a4,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000050b00000045000031000000,ASUS Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"03000000050b00000579000000010000,ASUS ROG Kunai 3,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b42,paddle1:b9,paddle2:b11,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,platform:Mac OS X,",
+"03000000050b00000679000000010000,ASUS ROG Kunai 3,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b23,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,platform:Mac OS X,",
+"03000000503200000110000045010000,Atari VCS Classic,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b3,start:b2,platform:Mac OS X,",
+"03000000503200000110000047010000,Atari VCS Classic Controller,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b3,start:b2,platform:Mac OS X,",
+"03000000503200000210000047010000,Atari VCS Modern Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a4,rightx:a2,righty:a3,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000008a3500000102000000010000,Backbone One,a:b0,b:b1,back:b16,dpdown:b11,dpleft:b13,dpright:b12,dpup:b10,guide:b17,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3~,start:b15,x:b2,y:b3,platform:Mac OS X,",
+"030000008a3500000201000000010000,Backbone One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000008a3500000202000000010000,Backbone One,a:b0,b:b1,back:b16,dpdown:b11,dpleft:b13,dpright:b12,dpup:b10,guide:b17,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3~,start:b15,x:b2,y:b3,platform:Mac OS X,",
+"030000008a3500000402000000010000,Backbone One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000008a3500000302000000010000,Backbone One PlayStation Edition,a:b0,b:b1,back:b16,dpdown:b11,dpleft:b13,dpright:b12,dpup:b10,guide:b17,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3~,start:b15,x:b2,y:b3,platform:Mac OS X,",
 "03000000c62400001a89000000010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b6,leftstick:b15,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b16,righttrigger:a4,rightx:a2,righty:a3,start:b13,x:b3,y:b4,platform:Mac OS X,",
 "03000000c62400001b89000000010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000d62000002a79000000010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000120c0000200e000000010000,Brook Mars,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000120c0000210e000000010000,Brook Mars,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000d62000002a79000000010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"03000000120c0000200e000000010000,Brook Mars PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"03000000120c0000210e000000010000,Brook Mars PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
 "030000008305000031b0000000000000,Cideko AK08b,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000d8140000cecf000000000000,Cthulhu,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "03000000260900008888000088020000,Cyber Gadget GameCube Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:a5,rightx:a2,righty:a3~,start:b7,x:b2,y:b3,platform:Mac OS X,",
-"03000000a306000022f6000001030000,Cyborg V.3 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000a306000022f6000001030000,Cyborg V3 Rumble Pad PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000791d00000103000009010000,Dual Box Wii Classic Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"030000006e0500000720000010020000,Elecom JC-W01U,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Mac OS X,",
+"030000006f0e00008401000003010000,Faceoff Deluxe Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b13,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000151900004000000001000000,Flydigi Vader 2,a:b14,b:b15,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Mac OS X,",
+"03000000b40400001124000001040000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b14,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000b40400001224000003030000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b2,paddle1:b16,paddle2:b17,paddle3:b14,paddle4:b15,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
 "03000000790000004618000000010000,GameCube Controller Adapter,a:b4,b:b0,dpdown:b56,dpleft:b60,dpright:b52,dpup:b48,lefttrigger:a12,leftx:a0,lefty:a4,rightshoulder:b28,righttrigger:a16,rightx:a20,righty:a8,start:b36,x:b8,y:b12,platform:Mac OS X,",
-"03000000ad1b000001f9000000000000,Gamestop BB-070 X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"03000000ac0500001a06000002020000,GameSir T3 2.02,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000373500000411000023000000,GameSir X4A Xbox Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000ad1b000001f9000000000000,Gamestop BB070 X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
 "0500000047532047616d657061640000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
-"03000000c01100000140000000010000,GameStop PS4 Fun Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000006f0e00000102000000000000,GameStop Xbox 360 Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000007d0400000540000001010000,Gravis Eliminator GamePad Pro,a:b1,b:b2,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000280400000140000000020000,Gravis Gamepad Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000008f0e00000300000007010000,GreenAsia Inc. USB Joystick,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Mac OS X,",
+"03000000c01100000140000000010000,GameStop PS4 Fun Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000006f0e00000102000000000000,GameStop Xbox 360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"03000000ff1100003133000007010000,GameWare PC Control Pad,a:b2,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a4,start:b11,x:b3,y:b0,platform:Mac OS X,",
+"03000000d11800000094000000010000,Google Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"030000007d0400000540000001010000,Gravis Eliminator Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000280400000140000000020000,Gravis GamePad Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000008f0e00000300000007010000,GreenAsia Joystick,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Mac OS X,",
 "030000000d0f00002d00000000100000,Hori Fighting Commander 3 Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00005f00000000010000,Hori Fighting Commander 4 (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00005e00000000010000,Hori Fighting Commander 4 (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00005f00000000000000,HORI Fighting Commander 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00005e00000000000000,HORI Fighting Commander 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00004d00000000000000,HORI Gem Pad 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00009200000000010000,Hori Pokken Tournament DX Pro Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00006e00000000010000,HORIPAD 4 (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00006600000000010000,HORIPAD 4 (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f00006600000000000000,HORIPAD FPS PLUS 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000000d0f0000ee00000000010000,HORIPAD mini4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000008f0e00001330000011010000,HuiJia SNES Controller,a:b4,b:b2,back:b16,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,leftshoulder:b12,rightshoulder:b14,start:b18,x:b6,y:b0,platform:Mac OS X,",
-"03000000830500006020000000010000,iBuffalo SNES Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Mac OS X,",
-"03000000830500006020000000000000,iBuffalo USB 2-axis 8-button Gamepad,a:b1,b:b0,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Mac OS X,",
+"030000000d0f00005f00000000000000,Hori Fighting Commander 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00005f00000000010000,Hori Fighting Commander 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00005e00000000000000,Hori Fighting Commander 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00005e00000000010000,Hori Fighting Commander 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00008400000000010000,Hori Fighting Commander PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00008500000000010000,Hori Fighting Commander PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000341a00000302000014010000,Hori Fighting Stick Mini,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00008800000000010000,Hori Fighting Stick mini 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00008700000000010000,Hori Fighting Stick mini 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00004d00000000000000,Hori Gem Pad 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00003801000008010000,Hori PC Engine Mini Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,platform:Mac OS X,",
+"030000000d0f00009200000000010000,Hori Pokken Tournament DX Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f0000aa00000072050000,Hori Real Arcade Pro for Nintendo Switch,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"030000000d0f00000002000017010000,Hori Split Pad Fit,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00000002000015010000,Hori Switch Split Pad Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00006e00000000010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00006600000000010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f00006600000000000000,Horipad FPS Plus 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f0000ee00000000010000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f0000c100000072050000,Horipad Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000242e0000ff0b000000010000,Hyperkin N64 Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,platform:Mac OS X,",
+"03000000790000004e95000000010000,Hyperkin N64 Controller Adapter,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a5,righty:a2,start:b9,platform:Mac OS X,",
+"03000000830500006020000000000000,iBuffalo Super Famicom Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Mac OS X,",
+"03000000ef0500000300000000020000,InterAct AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Mac OS X,",
+"03000000fd0500000030000010010000,Interact GoPad,a:b3,b:b4,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,x:b0,y:b1,platform:Mac OS X,",
 "030000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Mac OS X,",
 "030000007e0500000720000001000000,Joy-Con (R),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b12,leftshoulder:b4,leftstick:b11,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Mac OS X,",
-"03000000242f00002d00000007010000,JYS Wireless Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000242f00002d00000007010000,JYS Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"030000006d04000019c2000000000000,Logitech Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000006d04000016c2000000020000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000006d04000016c2000000030000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000006d04000016c2000014040000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000006d04000016c2000000000000,Logitech F310 Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000006d04000018c2000000000000,Logitech F510 Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000006d04000016c2000000000000,Logitech F310,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000006d04000018c2000000000000,Logitech F510,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000006d04000019c2000005030000,Logitech F710,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000006d0400001fc2000000000000,Logitech F710 Gamepad (XInput),a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000006d04000018c2000000010000,Logitech RumblePad 2 USB,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3~,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000006d04000019c2000000000000,Logitech Wireless Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000380700005032000000010000,Mad Catz FightPad PRO (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000380700005082000000010000,Mad Catz FightPad PRO (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000380700008433000000010000,Mad Catz FightStick TE S+ (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000380700008483000000010000,Mad Catz FightStick TE S+ (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000790000000600000007010000,Marvo GT-004,a:b2,b:b1,x:b3,y:b0,back:b8,start:b9,leftstick:b10,rightstick:b11,leftshoulder:b4,rightshoulder:b5,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7,platform:Mac OS X,",
+"030000006d0400001fc2000000000000,Logitech F710,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000006d04000018c2000000010000,Logitech RumblePad 2,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3~,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000380700005032000000010000,Mad Catz PS3 Fightpad Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000380700008433000000010000,Mad Catz PS3 Fightstick TE S Plus,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000380700005082000000010000,Mad Catz PS4 Fightpad Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"03000000380700008483000000010000,Mad Catz PS4 Fightstick TE S Plus,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"0300000049190000020400001b010000,Manba One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b22,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000790000000600000007010000,Marvo GT-004,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"030000008f0e00001330000011010000,Mayflash Controller Adapter,a:b2,b:b4,back:b16,dpdown:h0.8,dpleft:h0.2,dpright:h0.1,dpup:h0.4,leftshoulder:b12,lefttrigger:b16,leftx:a0,lefty:a2,rightshoulder:b14,rightx:a6~,righty:a4,start:b18,x:b0,y:b6,platform:Mac OS X,",
+"03000000790000004318000000010000,Mayflash GameCube Adapter,a:b4,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a12,leftx:a0,lefty:a4,rightshoulder:b28,righttrigger:a16,rightx:a20,righty:a8,start:b36,x:b8,y:b12,platform:Mac OS X,",
 "03000000790000004418000000010000,Mayflash GameCube Controller,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "03000000242f00007300000000020000,Mayflash Magic NS,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b0,y:b3,platform:Mac OS X,",
 "0300000079000000d218000026010000,Mayflash Magic NS,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
 "03000000d620000010a7000003010000,Mayflash Magic NS,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"0300000025090000e803000000000000,Mayflash Wii Classic Controller,a:b1,b:b0,back:b8,dpdown:b13,dpleft:b12,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Mac OS X,",
-"03000000790000000018000000010000,Mayflash Wii U Pro Controller Adapter,a:b4,b:b8,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b16,leftstick:b40,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,rightstick:b44,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b12,platform:Mac OS X,",
-"03000000790000000018000000000000,Mayflash WiiU Pro Game Controller Adapter (DInput),a:b4,b:b8,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b16,leftstick:b40,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,rightstick:b44,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b12,platform:Mac OS X,",
-"03000000d8140000cecf000000000000,MC Cthulhu,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000005e0400002700000001010000,Microsoft SideWinder Plug & Play Game Pad,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b4,leftx:a0,lefty:a1,righttrigger:b5,x:b2,y:b3,platform:Mac OS X,",
-"03000000d62000007162000001000000,Moga Pro 2 HID,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Mac OS X,",
-"03000000c62400002a89000000010000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000c62400002b89000000010000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000632500007505000000020000,NEOGEO mini PAD Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"030000008f0e00001030000011010000,Mayflash Saturn Adapter,a:b0,b:b2,dpdown:b28,dpleft:b30,dpright:b26,dpup:b24,leftshoulder:b10,lefttrigger:b14,rightshoulder:b12,righttrigger:b4,start:b18,x:b6,y:b8,platform:Mac OS X,",
+"0300000025090000e803000000000000,Mayflash Wii Classic Adapter,a:b1,b:b0,back:b8,dpdown:b13,dpleft:b12,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Mac OS X,",
+"03000000790000000318000000010000,Mayflash Wii DolphinBar,a:b8,b:b12,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b44,leftshoulder:b16,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b4,platform:Mac OS X,",
+"03000000790000000018000000000000,Mayflash Wii U Pro Adapter,a:b4,b:b8,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b16,leftstick:b40,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,rightstick:b44,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b12,platform:Mac OS X,",
+"03000000790000000018000000010000,Mayflash Wii U Pro Adapter,a:b4,b:b8,back:b32,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b16,leftstick:b40,lefttrigger:b24,leftx:a0,lefty:a4,rightshoulder:b20,rightstick:b44,righttrigger:b28,rightx:a8,righty:a12,start:b36,x:b0,y:b12,platform:Mac OS X,",
+"030000005e0400002800000002010000,Microsoft Dual Strike,a:b3,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,rightx:a0,righty:a1~,start:b5,x:b1,y:b0,platform:Mac OS X,",
+"030000005e0400000300000006010000,Microsoft SideWinder,a:b0,b:b1,back:b9,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Mac OS X,",
+"030000005e0400000700000006010000,Microsoft SideWinder,a:b0,b:b1,back:b8,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Mac OS X,",
+"030000005e0400002700000001010000,Microsoft SideWinder Plug and Play,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b4,righttrigger:b5,x:b2,y:b3,platform:Mac OS X,",
+"030000004523000015e0000072050000,Mobapad Chitu HD,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"03000000d62000007162000001000000,Moga Pro 2,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Mac OS X,",
+"03000000c62400002a89000000010000,MOGA XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000c62400002b89000000010000,MOGA XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000853200008906000000010000,Nacon Revolution X Unlimited,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000632500007505000000020000,NeoGeo mini PAD Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,x:b2,y:b3,platform:Mac OS X,",
 "03000000921200004b46000003020000,NES 2-port Adapter,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b11,platform:Mac OS X,",
 "030000001008000001e5000006010000,NEXT SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,righttrigger:b6,start:b9,x:b3,y:b0,platform:Mac OS X,",
-"03000000d620000011a7000000020000,Nintendo Switch Core (Plus) Wired Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000d620000011a7000010050000,Nintendo Switch PowerA Wired Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000007e0500006920000001010000,Nintendo Switch 2 Pro Controller,a:b0,b:b1,back:b14,dpdown:b8,dpleft:b10,dpright:b9,dpup:b11,guide:b16,leftshoulder:b12,leftstick:b15,lefttrigger:b13,leftx:a0,lefty:a1~,misc1:b17,misc2:b20,paddle1:b18,paddle2:b19,rightshoulder:b4,rightstick:b7,righttrigger:b5,rightx:a2,righty:a3~,start:b6,x:b2,y:b3,platform:Mac OS X,",
 "030000007e0500000920000000000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
 "030000007e0500000920000001000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
-"03000000550900001472000025050000,NVIDIA Controller v01.04,a:b0,b:b1,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Mac OS X,",
-"030000006f0e00000901000002010000,PDP Versus Fighting Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000008f0e00000300000000000000,Piranha xtreme,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Mac OS X,",
-"030000004c050000da0c000000010000,Playstation Classic Controller,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
-"030000004c0500003713000000010000,PlayStation Vita,a:b1,b:b2,back:b8,dpdown:b13,dpleft:b15,dpright:b14,dpup:b12,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000007e0500000920000010020000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,platform:Mac OS X,",
+"050000007e05000009200000ff070000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b10,x:b2,y:b3,platform:Mac OS X,",
+"030000007e0500007320000001010000,NSO GameCube Controller,a:b1,b:b3,dpdown:b8,dpleft:b10,dpright:b9,dpup:b11,guide:b16,leftshoulder:b13,lefttrigger:b12,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b4,rightx:a2,righty:a3~,start:b6,x:b0,y:b2,platform:Mac OS X,",
+"030000007e0500001920000001000000,NSO N64 Controller,+rightx:b8,+righty:b7,-rightx:b3,-righty:b2,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,righttrigger:b10,start:b9,platform:Mac OS X,",
+"030000007e0500001720000001000000,NSO SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b15,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"03000000550900001472000025050000,NVIDIA Controller,a:b0,b:b1,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Mac OS X,",
+"030000004b120000014d000000010000,Nyko Airflo EX,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"0300000009120000072f000000010000,OrangeFox86 DreamPicoPort,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a2,leftx:a0,lefty:a1,righttrigger:a5,rightx:a3,righty:a4,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000006f0e00000901000002010000,PDP PS3 Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000008f0e00000300000000000000,Piranha Xtreme PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000d620000011a7000000020000,PowerA Core Plus Gamecube Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"03000000d620000011a7000010050000,PowerA Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "03000000d62000006dca000000010000,PowerA Pro Ex,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "03000000100800000300000006010000,PS2 Adapter,a:b2,b:b1,back:b8,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a4,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
 "030000004c0500006802000000000000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Mac OS X,",
 "030000004c0500006802000000010000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Mac OS X,",
-"030000004c050000a00b000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000004c050000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000004c050000c405000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"050000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000004c0500006802000072050000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Mac OS X,",
+"030000004c050000a00b000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000004c050000c405000000000000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000004c050000c405000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"0300004b4c0500005f0e000000010000,PS5 Access Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000004c050000f20d000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"050000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"050000004c050000f20d000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000005e040000e002000001000000,PXN P30 Pro Mobile,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"03000000222c00000225000000010000,Qanba Dragon Arcade Joystick PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000222c00000020000000010000,Qanba Drone Arcade Stick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000009b2800005600000020020000,Raphnet SNES Adapter,a:b1,b:b4,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Mac OS X,",
+"030000009b2800008000000022020000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a3,righty:a4,start:b3,x:b0,y:b5,platform:Mac OS X,",
 "030000008916000000fd000000000000,Razer Onza TE,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"03000000321500000204000000010000,Razer Panthera (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000321500000104000000010000,Razer Panthera (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000321500000010000000010000,Razer RAIJU,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000321500000204000000010000,Razer Panthera PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000321500000104000000010000,Razer Panthera PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"03000000321500000010000000010000,Razer Raiju,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "03000000321500000507000001010000,Razer Raiju Mobile,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000321500000011000000010000,Razer Raion Fightpad for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000321500000011000000010000,Razer Raion PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
 "03000000321500000009000000020000,Razer Serval,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Mac OS X,",
 "030000003215000000090000163a0000,Razer Serval,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Mac OS X,",
 "0300000032150000030a000000000000,Razer Wildcat,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"03000000790000001100000000000000,Retrolink Classic Controller,a:b2,b:b1,back:b8,leftshoulder:b4,leftx:a3,lefty:a4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000632500008005000000010000,Redgear,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000632500002305000000010000,Redragon Saturn,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000921200004547000000020000,Retro Bit Sega Genesis Controller Adapter,a:b0,b:b2,dpdown:+a2,dpleft:-a0,dpright:+a0,dpup:-a2,lefttrigger:b14,rightshoulder:b10,righttrigger:b4,start:b12,x:b6,y:b8,platform:Mac OS X,",
+"03000000790000001100000000000000,Retro Controller,a:b1,b:b2,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,leftshoulder:b6,lefttrigger:b7,rightshoulder:b4,righttrigger:b5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000790000001100000005010000,Retro Controller,a:b1,b:b2,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b4,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000830500006020000000010000,Retro Controller,a:b0,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b8,righttrigger:b9,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"0300000003040000c197000000000000,Retrode Adapter,a:b0,b:b4,back:b2,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,leftshoulder:b6,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Mac OS X,",
 "03000000790000001100000006010000,Retrolink SNES Controller,a:b2,b:b1,back:b8,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000341200000400000000000000,RetroUSB N64 RetroPort,+rightx:b8,+righty:b10,-rightx:b9,-righty:b11,a:b7,b:b6,dpdown:b2,dpleft:b1,dpright:b0,dpup:b3,leftshoulder:b13,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b12,start:b4,platform:Mac OS X,",
 "030000006b140000010d000000010000,Revolution Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000006b140000130d000000010000,Revolution Pro Controller 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000c6240000fefa000000000000,Rock Candy Gamepad for PS3,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"03000000730700000401000000010000,Sanwa PlayOnline Mobile,a:b0,b:b1,back:b2,leftx:a0,lefty:a1,start:b3,platform:Mac OS X,",
+"030000004c0500006802000002100000,Rii RK707,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b2,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b3,righttrigger:b9,rightx:a2,righty:a3,start:b1,x:b15,y:b12,platform:Mac OS X,",
+"030000006f0e00008701000005010000,Rock Candy Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000c6240000fefa000000000000,Rock Candy PS3,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"03000000e804000000a000001b010000,Samsung EIGP20,a:b1,b:b3,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b11,leftx:a1,lefty:a3,rightshoulder:b12,rightx:a4,righty:a5,start:b16,x:b7,y:b9,platform:Mac OS X,",
+"03000000730700000401000000010000,Sanwa PlayOnline Mobile,a:b0,b:b1,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Mac OS X,",
+"03000000a30c00002500000006020000,Sega Genesis Mini 3B Controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,righttrigger:b5,start:b9,platform:Mac OS X,",
 "03000000811700007e05000000000000,Sega Saturn,a:b2,b:b4,dpdown:b16,dpleft:b15,dpright:b14,dpup:b17,leftshoulder:b8,lefttrigger:a5,leftx:a0,lefty:a2,rightshoulder:b9,righttrigger:a4,start:b13,x:b0,y:b6,platform:Mac OS X,",
-"03000000b40400000a01000000000000,Sega Saturn USB Gamepad,a:b0,b:b1,back:b5,guide:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Mac OS X,",
-"030000003512000021ab000000000000,SFC30 Joystick,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
+"03000000b40400000a01000000000000,Sega Saturn,a:b0,b:b1,back:b5,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,guide:b2,leftshoulder:b6,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Mac OS X,",
+"030000003512000021ab000000000000,SFC30 Joystick,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Mac OS X,",
 "0300000000f00000f100000000000000,SNES RetroPort,a:b2,b:b3,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b5,rightshoulder:b7,start:b6,x:b0,y:b1,platform:Mac OS X,",
-"030000004c050000e60c000000010000,Sony DualSense,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000004c050000cc09000000000000,Sony DualShock 4 V2,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000004c050000a00b000000000000,Sony DualShock 4 Wireless Adaptor,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000d11800000094000000010000,Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"030000004c050000a00b000000000000,Sony DualShock 4 Adapter,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000004c050000cc09000000000000,Sony DualShock 4 V2,a:b1,b:b2,back:b13,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"03000000666600006706000088020000,Sony PlayStation Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Mac OS X,",
+"030000004c050000da0c000000010000,Sony PlayStation Classic Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"030000004c0500003713000000010000,Sony PlayStation Vita,a:b1,b:b2,back:b8,dpdown:b13,dpleft:b15,dpright:b14,dpup:b12,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000005e0400008e02000001000000,Steam Virtual Gamepad,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"03000000110100002014000000000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b12,x:b2,y:b3,platform:Mac OS X,",
+"03000000110100002014000000000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,x:b2,y:b3,platform:Mac OS X,",
 "03000000110100002014000001000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,x:b2,y:b3,platform:Mac OS X,",
 "03000000381000002014000001000000,SteelSeries Nimbus,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,x:b2,y:b3,platform:Mac OS X,",
+"05000000484944204465766963650000,SteelSeries Nimbus Plus,a:b0,b:b1,back:b15,dpdown:b11,dpleft:b13,dpright:b12,dpup:b10,guide:b16,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3~,start:b14,x:b2,y:b3,platform:Mac OS X,",
 "050000004e696d6275732b0000000000,SteelSeries Nimbus Plus,a:b0,b:b1,back:b15,dpdown:b11,dpleft:b13,dpright:b12,dpup:b10,guide:b16,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3~,start:b14,x:b2,y:b3,platform:Mac OS X,",
+"03000000381000003014000000000000,SteelSeries Stratus Duo,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"03000000381000003114000000000000,SteelSeries Stratus Duo,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
 "03000000110100001714000000000000,SteelSeries Stratus XL,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,start:b12,x:b2,y:b3,platform:Mac OS X,",
 "03000000110100001714000020010000,SteelSeries Stratus XL,a:b0,b:b1,dpdown:b9,dpleft:b11,dpright:b10,dpup:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3~,start:b12,x:b2,y:b3,platform:Mac OS X,",
-"03000000457500002211000000010000,SZMY-POWER PC Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000000d0f0000f600000000010000,Switch Hori Pad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Mac OS X,",
+"03000000457500002211000000010000,SZMY Power PC Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000e40a00000307000001000000,Taito Egret II Mini Control Panel,a:b4,b:b2,back:b6,guide:b9,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b1,start:b7,x:b8,y:b3,platform:Mac OS X,",
+"03000000e40a00000207000001000000,Taito Egret II Mini Controller,a:b4,b:b2,back:b6,guide:b9,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b1,start:b7,x:b8,y:b3,platform:Mac OS X,",
+"03000000790000001c18000000010000,TGZ Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000790000001c18000003100000,TGZ Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000591c00002400000021000000,THEC64 Joystick,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"03000000591c00002600000021000000,THEGamepad,a:b2,b:b1,back:b6,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b0,platform:Mac OS X,",
 "030000004f04000015b3000000000000,Thrustmaster Dual Analog 3.2,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Mac OS X,",
-"030000004f0400000ed0000000020000,ThrustMaster eSwap PRO Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000004f0400000ed0000000020000,Thrustmaster eSwap Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
 "030000004f04000000b3000000000000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b11,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b1,y:b3,platform:Mac OS X,",
-"03000000bd12000015d0000000000000,Tomee SNES USB Controller,a:b2,b:b1,back:b8,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
-"03000000bd12000015d0000000010000,Tomee SNES USB Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000571d00002100000021000000,Tomee NES Controller Adapter,a:b1,b:b0,back:b2,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,start:b3,platform:Mac OS X,",
+"03000000bd12000015d0000000010000,Tomee Retro Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000bd12000015d0000000000000,Tomee SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000571d00002000000021000000,Tomee SNES Controller Adapter,a:b0,b:b1,back:b6,dpdown:+a4,dpleft:-a0,dpright:+a0,dpup:-a4,leftshoulder:b4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"030000005f140000c501000000020000,Trust Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
 "03000000100800000100000000000000,Twin USB Joystick,a:b4,b:b2,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b12,leftstick:b20,lefttrigger:b8,leftx:a0,lefty:a2,rightshoulder:b14,rightstick:b22,righttrigger:b10,rightx:a6,righty:a4,start:b18,x:b6,y:b0,platform:Mac OS X,",
-"030000006f0e00000302000025040000,Victrix Pro Fight Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"030000006f0e00000702000003060000,Victrix Pro Fight Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000791d00000103000009010000,Wii Classic Controller,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Mac OS X,",
+"03000000632500002605000000010000,Uberwith Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000151900005678000010010000,Uniplay U6,a:b3,b:b6,back:b25,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b17,leftstick:b31,lefttrigger:b21,leftx:a1,lefty:a3,rightshoulder:b19,rightstick:b33,righttrigger:b23,rightx:a4,righty:a5,start:b27,x:b11,y:b13,platform:Mac OS X,",
+"030000006f0e00000302000025040000,Victrix PS4 Pro Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
+"030000006f0e00000702000003060000,Victrix PS4 Pro Fightstick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Mac OS X,",
 "050000005769696d6f74652028303000,Wii Remote,a:b4,b:b5,back:b7,dpdown:b3,dpleft:b0,dpright:b1,dpup:b2,guide:b8,leftshoulder:b11,lefttrigger:b12,leftx:a0,lefty:a1,start:b6,x:b10,y:b9,platform:Mac OS X,",
 "050000005769696d6f74652028313800,Wii U Pro Controller,a:b16,b:b15,back:b7,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b8,leftshoulder:b19,leftstick:b23,lefttrigger:b21,leftx:a0,lefty:a1,rightshoulder:b20,rightstick:b24,righttrigger:b22,rightx:a2,righty:a3,start:b6,x:b18,y:b17,platform:Mac OS X,",
-"030000005e0400008e02000000000000,X360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000006f0e00000104000000000000,Xbox 360 Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"03000000c6240000045d000000000000,Xbox 360 Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e0400008e02000000000000,Xbox 360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e0400008e02000010010000,Xbox 360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1~,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4~,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000006f0e00000104000000000000,Xbox 360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"03000000c6240000045d000000000000,Xbox 360 Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
 "030000005e0400000a0b000000000000,Xbox Adaptive Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000050b000003090000,Xbox Elite Wireless Controller Series 2,a:b0,b:b1,back:b31,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b53,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000c62400003a54000000000000,Xbox One PowerA Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000d102000000000000,Xbox One Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000dd02000000000000,Xbox One Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000e302000000000000,Xbox One Wired Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000050b000003090000,Xbox Elite Controller Series 2,a:b0,b:b1,back:b31,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b53,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000130b000011050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000200b000011050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000200b000013050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000200b000015050000,Xbox One Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000d102000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000dd02000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000e002000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000e002000003090000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000e302000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000ea02000000000000,Xbox One Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
+"030000005e040000fd02000003090000,Xbox One Controller,a:b0,b:b1,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000220b000013050000,Xbox One Elite 2 Controller,a:b0,b:b1,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,paddle1:b11,paddle2:b13,paddle3:b12,paddle4:b14,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Mac OS X,",
+"03000000c62400003a54000000000000,Xbox One PowerA Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
 "030000005e040000130b000001050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
 "030000005e040000130b000005050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"030000005e040000e002000000000000,Xbox Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000e002000003090000,Xbox Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000ea02000000000000,Xbox Wireless Controller,a:b0,b:b1,back:b9,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,start:b8,x:b2,y:b3,platform:Mac OS X,",
-"030000005e040000fd02000003090000,Xbox Wireless Controller,a:b0,b:b1,back:b16,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000172700004431000029010000,XiaoMi Game Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Mac OS X,",
-"03000000120c0000100e000000010000,ZEROPLUS P4 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
-"03000000120c0000101e000000010000,ZEROPLUS P4 Wired Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"030000005e040000130b000009050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000130b000013050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000130b000015050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000130b000007050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000130b000017050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000130b000022050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"030000005e040000220b000017050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000172700004431000029010000,XiaoMi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Mac OS X,",
+"03000000120c0000100e000000010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
+"03000000120c0000101e000000010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Mac OS X,",
 #endif // _GLFW_COCOA
 
 #if defined(GLFW_BUILD_LINUX_JOYSTICK)
+"03000000c82d00000031000011010000,8BitDo Adapter,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000631000000010000,8BitDo Adapter 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c82d00000951000000010000,8BitDo Dogbone,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightx:a2,righty:a3,start:b11,platform:Linux,",
+"03000000021000000090000011010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
 "03000000c82d00000090000011010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000c82d00001038000000010000,8Bitdo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00001038000000010000,8BitDo FC30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00006a28000000010000,8BitDo GameCube,a:b0,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b9,paddle2:b8,rightshoulder:b10,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b1,y:b4,platform:Linux,",
+"03000000c82d00001251000011010000,8BitDo Lite 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00001251000000010000,8BitDo Lite 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00001151000011010000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00001151000000010000,8BitDo Lite SE,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000151000000010000,8BitDo M30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000650000011010000,8BitDo M30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "05000000c82d00005106000000010000,8BitDo M30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000a20000000020000,8BitDo M30 Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c82d00002090000011010000,8BitDo Micro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00002090000000010000,8BitDo Micro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000451000000010000,8BitDo N30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftx:a0,lefty:a1,rightx:a2,righty:a3,start:b11,platform:Linux,",
 "03000000c82d00001590000011010000,8BitDo N30 Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
 "05000000c82d00006528000000010000,8BitDo N30 Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00006928000011010000,8BitDo N64,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,platform:Linux,",
+"05000000c82d00006928000000010000,8BitDo N64,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,platform:Linux,",
+"05000000c82d00002590000001000000,8BitDo NEOGEO,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000008000000210000011010000,8BitDo NES30,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000c82d00000310000011010000,8BitDo NES30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,lefttrigger:b6,rightshoulder:b9,righttrigger:b8,start:b11,x:b3,y:b4,platform:Linux,",
 "05000000c82d00008010000000010000,8BitDo NES30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b7,lefttrigger:b6,rightshoulder:b9,righttrigger:b8,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000022000000090000011010000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000203800000900000000010000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000c82d00002038000000010000,8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"03000000c82d00000190000011010000,8Bitdo NES30 Pro 8Bitdo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000022000000090000011010000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000190000011010000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000203800000900000000010000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00002038000000010000,8BitDo NES30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000751000000010000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:a8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000c82d00000851000000010000,8BitDo P30,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:a8,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000660000011010000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00001030000011010000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00000660000000010000,8BitDo Pro 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000020000000000000,8BitDo Pro 2 for Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"06000000c82d00000020000006010000,8BitDo Pro 2 for Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c82d00000131000011010000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000231000011010000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000331000011010000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000431000011010000,8BitDo Receiver,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00002867000000010000,8BitDo S30,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b8,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000060000011010000,8BitDo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
 "05000000c82d00000060000000010000,8BitDo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000c82d00000061000000010000,8Bitdo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"03000000c82d000021ab000010010000,8BitDo SFC30,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
-"030000003512000012ab000010010000,8Bitdo SFC30 GamePad,a:b2,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b0,platform:Linux,",
-"05000000102800000900000000010000,8Bitdo SFC30 GamePad,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000c82d00003028000000010000,8Bitdo SFC30 GamePad,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00000061000000010000,8BitDo SF30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"030000003512000012ab000010010000,8BitDo SFC30,a:b2,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b0,platform:Linux,",
+"030000003512000021ab000010010000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d000021ab000010010000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000102800000900000000010000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00003028000000010000,8BitDo SFC30,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00000351000000010000,8BitDo SN30,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
 "03000000c82d00000160000000000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Linux,",
 "03000000c82d00000160000011010000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
 "03000000c82d00000161000000000000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Linux,",
 "03000000c82d00001290000011010000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a3,righty:a4,start:b11,x:b4,y:b3,platform:Linux,",
 "05000000c82d00000161000000010000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
 "05000000c82d00006228000000010000,8BitDo SN30 Pro,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"03000000c82d00000260000011010000,8BitDo SN30 Pro+,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000c82d00000261000000010000,8BitDo SN30 Pro+,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"05000000202800000900000000010000,8BitDo SNES30 Gamepad,a:b1,b:b0,back:b10,dpdown:b122,dpleft:b119,dpright:b120,dpup:b117,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
-"03000000c82d00000031000011010000,8BitDo Wireless Adapter (DInput),a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b2,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005e0400008e02000020010000,8BitDo Wireless Adapter (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000c82d00001890000011010000,8BitDo Zero 2,a:b1,b:b0,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00000260000011010000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00000261000000010000,8BitDo SN30 Pro Plus,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000202800000900000000010000,8BitDo SNES30,a:b1,b:b0,back:b10,dpdown:b122,dpleft:b119,dpright:b120,dpup:b117,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
+"05000000c82d00001230000000010000,8BitDo Ultimate,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000a31000014010000,8BitDo Ultimate 2C,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c82d00001d30000011010000,8BitDo Ultimate 2C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b5,paddle2:b2,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000c82d00001b30000001000000,8BitDo Ultimate 2C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b5,paddle2:b2,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00001530000011010000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00001630000011010000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00001730000011010000,8BitDo Ultimate C,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00001130000011010000,8BitDo Ultimate Wired,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b24,paddle2:b25,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000631000010010000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c82d00000631000014010000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c82d00000760000011010000,8BitDo Ultimate Wireless,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000c82d00001230000011010000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,paddle1:b2,paddle2:b5,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00001330000011010000,8BitDo Ultimate Wireless,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b26,paddle1:b23,paddle2:b19,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00000121000011010000,8BitDo Xbox One SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000c82d00000121000000010000,8BitDo Xbox One SN30 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000a00500003232000001000000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000a00500003232000008010000,8BitDo Zero,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c82d00001890000011010000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b4,y:b3,platform:Linux,",
 "05000000c82d00003032000000010000,8BitDo Zero 2,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b4,y:b3,platform:Linux,",
-"050000005e040000e002000030110000,8BitDo Zero 2 (XInput),a:b0,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Linux,",
-"05000000a00500003232000001000000,8Bitdo Zero GamePad,a:b0,b:b1,back:b10,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Linux,",
-"05000000a00500003232000008010000,8Bitdo Zero GamePad,a:b0,b:b1,back:b10,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000c01100000355000011010000,ACRUX USB GAME PAD,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000006f0e00001302000000010000,Afterglow,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006f0e00003901000020060000,Afterglow Controller for Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c01100000355000011010000,Acrux Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00008801000011010000,Afterglow Deluxe Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006f0e00003901000000430000,Afterglow Prismatic Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006f0e00003901000013020000,Afterglow Prismatic Wired Controller 048-007-NA,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000100000008200000011010000,Akishop Customs PS360+ v1.66,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000007c1800000006000010010000,Alienware Dual Compatible Game Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b3,platform:Linux,",
-"05000000491900000204000021000000,Amazon Fire Game Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b17,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000006f0e00003901000013020000,Afterglow Prismatic Controller 048-007-NA,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e00001302000000010000,Afterglow Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e00003901000020060000,Afterglow Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000100000008200000011010000,Akishop Customs PS360,a:b1,b:b2,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000007c1800000006000010010000,Alienware Dual Compatible Game PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b3,platform:Linux,",
+"05000000491900000204000021000000,Amazon Fire Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b17,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b12,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "03000000491900001904000011010000,Amazon Luna Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b9,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Linux,",
 "05000000710100001904000000010000,Amazon Luna Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
+"0300000008100000e501000001010000,Anbernic Handheld,a:b1,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a4,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000020500000913000010010000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000373500000710000010010000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000373500004610000001000000,Anbernic RG P01,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000190e00000110000010010000,Aquaplus Piece,a:b1,b:b0,back:b3,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b2,platform:Linux,",
 "03000000790000003018000011010000,Arcade Fightstick F300,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000a30c00002700000011010000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a0,lefty:a1,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000a30c00002700000011010000,Astro City Mini,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
 "03000000a30c00002800000011010000,Astro City Mini,a:b2,b:b1,back:b8,leftx:a0,lefty:a1,rightshoulder:b4,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
 "05000000050b00000045000031000000,ASUS Gamepad,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b10,x:b2,y:b3,platform:Linux,",
 "05000000050b00000045000040000000,ASUS Gamepad,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b10,x:b2,y:b3,platform:Linux,",
-"03000000503200000110000000000000,Atari Classic Controller,a:b0,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,x:b1,platform:Linux,",
-"05000000503200000110000000000000,Atari Classic Controller,a:b0,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,x:b1,platform:Linux,",
-"03000000503200000210000000000000,Atari Game Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
-"05000000503200000210000000000000,Atari Game Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
-"03000000120c00000500000010010000,AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Linux,",
-"03000000ef0500000300000000010000,AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Linux,",
-"03000000c62400001b89000011010000,BDA MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000d62000002a79000011010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000c21100000791000011010000,Be1 GC101 Controller 1.03 mode,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000c31100000791000011010000,Be1 GC101 GAMEPAD 1.03 mode,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005e0400008e02000003030000,Be1 GC101 Xbox 360 Controller mode,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"05000000bc2000000055000001000000,BETOP AX1 BFM,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000666600006706000000010000,boom PSX to PC Converter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Linux,",
-"03000000120c0000200e000011010000,Brook Mars,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000120c0000210e000011010000,Brook Mars,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000050b00000579000011010000,ASUS ROG Kunai 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b36,paddle1:b52,paddle2:b53,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000050b00000679000000010000,ASUS ROG Kunai 3,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b21,paddle1:b22,paddle2:b23,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000503200000110000000000000,Atari VCS Classic Controller,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,platform:Linux,",
+"03000000503200000110000011010000,Atari VCS Classic Controller,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,platform:Linux,",
+"05000000503200000110000000000000,Atari VCS Classic Controller,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,platform:Linux,",
+"05000000503200000110000044010000,Atari VCS Classic Controller,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,platform:Linux,",
+"05000000503200000110000046010000,Atari VCS Classic Controller,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b4,start:b3,platform:Linux,",
+"03000000503200000210000000000000,Atari VCS Modern Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a4,rightx:a2,righty:a3,start:b8,x:b2,y:b3,platform:Linux,",
+"03000000503200000210000011010000,Atari VCS Modern Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
+"05000000503200000210000000000000,Atari VCS Modern Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
+"05000000503200000210000045010000,Atari VCS Modern Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
+"05000000503200000210000046010000,Atari VCS Modern Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
+"05000000503200000210000047010000,Atari VCS Modern Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b6,lefttrigger:+a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:-a4,rightx:a2,righty:a3,start:b8,x:b2,y:b3,platform:Linux,",
+"030000008a3500000201000011010000,Backbone One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000008a3500000202000011010000,Backbone One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000008a3500000302000011010000,Backbone One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000008a3500000402000011010000,Backbone One,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c62400001b89000011010000,BDA MOGA XP5X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000d62000002a79000011010000,BDA PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000c21100000791000011010000,Be1 GC101 Controller 1.03,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000c31100000791000011010000,Be1 GC101 Controller 1.03,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000005e0400008e02000003030000,Be1 GC101 Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000bc2000004d50000011010000,Beitong A1T2 BFM,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000bc2000000055000001000000,Betop AX1 BFM,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000bc2000006412000011010000,Betop Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b30,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"030000006b1400000209000011010000,Bigben,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000120c0000300e000011010000,Brook Audio Fighting Board PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000120c0000310e000011010000,Brook Audio Fighting Board PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000120c0000200e000011010000,Brook Mars PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000120c0000210e000011010000,Brook Mars PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "03000000120c0000f70e000011010000,Brook Universal Fighting Board,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000ffff0000ffff000000010000,Chinese-made Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
+"03000000d81d00000b00000010010000,Buffalo BSGP1601,a:b5,b:b3,back:b12,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b8,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b9,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b13,x:b4,y:b2,platform:Linux,",
 "03000000e82000006058000001010000,Cideko AK08b,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000af1e00002400000010010000,Clockwork Pi DevTerm,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b9,x:b3,y:b0,platform:Linux,",
 "030000000b0400003365000000010000,Competition Pro,a:b0,b:b1,back:b2,leftx:a0,lefty:a1,start:b3,platform:Linux,",
 "03000000260900008888000000010000,Cyber Gadget GameCube Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:a5,rightx:a2,righty:a3~,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000a306000022f6000011010000,Cyborg V.3 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000b40400000a01000000010000,CYPRESS USB Gamepad,a:b0,b:b1,back:b5,guide:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Linux,",
-"03000000790000000600000010010000,DragonRise Inc. Generic USB Joystick,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b3,y:b0,platform:Linux,",
-"030000004f04000004b3000010010000,Dual Power 2,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
+"03000000a306000022f6000011010000,Cyborg V3 Rumble,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:+a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:-a3,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
+"030000005e0400008e02000002010000,Data Frog S80,a:b1,b:b0,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
+"03000000791d00000103000010010000,Dual Box Wii Classic Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
 "030000006f0e00003001000001010000,EA Sports PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000341a000005f7000010010000,GameCube {HuiJia USB box},a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000c11100000191000011010000,EasySMX,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000242f00009100000000010000,EasySMX ESM-9101,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006e0500000320000010010000,Elecom U3613M,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Linux,",
+"030000006e0500000720000010010000,Elecom W01U,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Linux,",
+"030000007d0400000640000010010000,Eliminator AfterShock,a:b1,b:b2,back:b9,dpdown:+a3,dpleft:-a5,dpright:+a5,dpup:-a3,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a4,righty:a2,start:b8,x:b0,y:b3,platform:Linux,",
+"03000000430b00000300000000010000,EMS Production PS2 Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a5,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"030000006f0e00008401000011010000,Faceoff Deluxe Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00008101000011010000,Faceoff Deluxe Pro Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00008001000011010000,Faceoff Pro Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000852100000201000010010000,FF GP1,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"05000000b40400001224000001010000,Flydigi APEX 4,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b14,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b20,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000b40400001124000011010000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b14,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000b40400001224000011010000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b2,paddle1:b16,paddle2:b17,paddle3:b14,paddle4:b15,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000151900004000000001000000,Flydigi Vader 2,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b12,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b14,paddle1:b2,paddle2:b5,paddle3:b16,paddle4:b17,rightshoulder:b7,rightstick:b13,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000007e0500003703000000000000,GameCube Adapter,a:b0,b:b1,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b6,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b2,platform:Linux,",
+"19000000030000000300000002030000,GameForce Controller,a:b1,b:b0,back:b8,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,guide:b16,leftshoulder:b4,leftstick:b14,lefttrigger:b6,leftx:a1,lefty:a0,rightshoulder:b5,rightstick:b15,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000ac0500005b05000010010000,GameSir G3w,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
 "03000000bc2000000055000011010000,GameSir G3w,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000558500001b06000010010000,GameSir G4 Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000ac0500002d0200001b010000,GameSir G4s,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b33,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000ac0500007a05000011010000,GameSir G5,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b16,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000373500009710000001020000,GameSir Kaleid Flux,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000ac0500001a06000011010000,GameSir T3 2.02,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000bc2000005656000011010000,GameSir T4w,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000373500009410000010010000,GameSir Tegenaria Lite,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "0500000047532047616d657061640000,GameStop Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
 "030000006f0e00000104000000010000,Gamestop Logic3 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000008f0e00000800000010010000,Gasia Co. Ltd PS(R) Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"030000006f0e00001304000000010000,Generic X-Box pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000008f0e00000800000010010000,Gasia PlayStation Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
 "03000000451300000010000010010000,Genius Maxfire Grandias 12,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"03000000f0250000c183000010010000,Goodbetterbest Ltd USB Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000f0250000c283000010010000,Gioteck VX2 PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"190000004b4800000010000000010000,GO-Advance Controller,a:b1,b:b0,back:b10,dpdown:b7,dpleft:b8,dpright:b9,dpup:b6,leftshoulder:b4,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b13,start:b15,x:b2,y:b3,platform:Linux,",
+"190000004b4800000010000001010000,GO-Advance Controller,a:b1,b:b0,back:b12,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,leftshoulder:b4,leftstick:b13,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b16,righttrigger:b15,start:b17,x:b2,y:b3,platform:Linux,",
+"190000004b4800000011000000010000,GO-Super Gamepad,a:b0,b:b1,back:b12,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b16,leftshoulder:b4,leftstick:b14,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b15,righttrigger:b7,rightx:a2,righty:a3,start:b13,x:b3,y:b2,platform:Linux,",
+"03000000f0250000c183000010010000,Goodbetterbest Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000d11800000094000011010000,Google Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
+"05000000d11800000094000000010000,Google Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
 "0300000079000000d418000000010000,GPD Win 2 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000007d0400000540000000010000,Gravis Eliminator GamePad Pro,a:b1,b:b2,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000280400000140000000010000,Gravis GamePad Pro USB ,a:b1,b:b2,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000008f0e00000610000000010000,GreenAsia Electronics 4Axes 12Keys GamePad ,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,platform:Linux,",
-"030000008f0e00001200000010010000,GreenAsia Inc. USB Joystick,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000001010000,GPD Win Max 2 6800U Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000007d0400000540000000010000,Gravis Eliminator Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000280400000140000000010000,Gravis GamePad Pro,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000008f0e00000610000000010000,GreenAsia Electronics Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a3,righty:a2,start:b11,x:b3,y:b0,platform:Linux,",
+"030000008f0e00001200000010010000,GreenAsia Joystick,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
 "0500000047532067616d657061640000,GS gamepad,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
 "03000000f0250000c383000010010000,GT VX2,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"06000000adde0000efbe000002010000,Hidromancer Game Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000d81400000862000011010000,HitBox (PS3/PC) Analog Mode,a:b1,b:b2,back:b8,guide:b9,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b12,x:b0,y:b3,platform:Linux,",
-"03000000c9110000f055000011010000,HJC Game GAMEPAD,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"03000000632500002605000010010000,HJD-X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000000d0f00000d00000000010000,hori,a:b0,b:b6,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b3,leftx:b4,lefty:b5,rightshoulder:b7,start:b9,x:b1,y:b2,platform:Linux,",
-"030000000d0f00001000000011010000,HORI CO. LTD. FIGHTING STICK 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f0000c100000011010000,HORI CO. LTD. HORIPAD S,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00006a00000011010000,HORI CO. LTD. Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00006b00000011010000,HORI CO. LTD. Real Arcade Pro.4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00002200000011010000,HORI CO. LTD. REAL ARCADE Pro.V3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00008500000010010000,HORI Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00008600000002010000,Hori Fighting Commander,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"030000000d0f00005f00000011010000,Hori Fighting Commander 4 (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00005e00000011010000,Hori Fighting Commander 4 (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000008a2e0000dd10000011010000,Hand Held Legend GC Ultimate,a:b0,b:b2,back:b17,dpdown:b5,dpleft:b6,dpright:b7,dpup:b4,guide:b18,leftshoulder:b10,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b19,misc2:b24,paddle1:b13,paddle2:b12,rightshoulder:b11,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b16,x:b1,y:b3,platform:Linux,",
+"030000008a2e0000df10000011010000,Hand Held Legend ProGCC,a:b1,b:b0,back:b17,dpdown:b5,dpleft:b6,dpright:b7,dpup:b4,guide:b18,leftshoulder:b10,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b19,paddle1:b13,paddle2:b12,rightshoulder:b11,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b16,x:b3,y:b2,platform:Linux,",
+"06000000adde0000efbe000002010000,Hidromancer Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d81400000862000011010000,HitBox PS3 PC Analog Mode,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,guide:b9,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b12,x:b0,y:b3,platform:Linux,",
+"03000000c9110000f055000011010000,HJC Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"030000000d0f00006d00000020010000,Hori EDGE 301,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:+a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:+a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000000d0f00008400000011010000,Hori Fighting Commander,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00005f00000011010000,Hori Fighting Commander 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00005e00000011010000,Hori Fighting Commander 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000000d0f00005001000009040000,Hori Fighting Commander Octa Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000000d0f00008500000010010000,Hori Fighting Commander PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00008600000002010000,Hori Fighting Commander Xbox 360,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"030000000d0f00003701000013010000,Hori Fighting Stick Mini,a:b1,b:b0,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b3,y:b2,platform:Linux,",
+"030000000d0f00008800000011010000,Hori Fighting Stick mini 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00008700000011010000,Hori Fighting Stick mini 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,rightshoulder:b5,rightstick:b11,righttrigger:a4,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000000d0f00001000000011010000,Hori Fightstick 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000ad1b000003f5000033050000,Hori Fightstick VX,+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b8,guide:b10,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b2,y:b3,platform:Linux,",
+"030000000d0f00004d00000011010000,Hori Gem Pad 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000ad1b000001f5000033050000,Hori Pad EX Turbo 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000000d0f00009200000011010000,Hori Pokken Tournament DX Pro Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f0000aa00000011010000,HORI Real Arcade Pro,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"030000000d0f0000d800000072056800,HORI Real Arcade Pro S,a:b0,b:b1,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
-"030000000d0f00001600000000010000,Hori Real Arcade Pro.EX-SE (Xbox 360),a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b2,y:b3,platform:Linux,",
-"030000000d0f00006e00000011010000,HORIPAD 4 (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00006600000011010000,HORIPAD 4 (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f0000ee00000011010000,HORIPAD mini4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"030000000d0f00006700000001010000,HORIPAD ONE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000008f0e00001330000010010000,HuiJia SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b9,x:b3,y:b0,platform:Linux,",
+"030000000d0f00003801000011010000,Hori PC Engine Mini Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,platform:Linux,",
+"030000000d0f00009200000011010000,Hori Pokken Tournament DX Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00001100000011010000,Hori Real Arcade Pro 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00002200000011010000,Hori Real Arcade Pro 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00006a00000011010000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00006b00000011010000,Hori Real Arcade Pro 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00001600000000010000,Hori Real Arcade Pro EXSE,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b2,y:b3,platform:Linux,",
+"030000000d0f0000aa00000011010000,Hori Real Arcade Pro for Nintendo Switch,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"030000000d0f00008501000017010000,Hori Split Pad Fit,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000000d0f00008501000015010000,Hori Switch Split Pad Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000000d0f00006e00000011010000,Horipad 4 PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00006600000011010000,Horipad 4 PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000000d0f0000ee00000011010000,Horipad Mini 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f0000c100000011010000,Horipad Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f00006700000001010000,Horipad One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000000d0f0000ab01000011010000,Horipad Steam,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc2:b2,paddle1:b19,paddle2:b18,paddle3:b15,paddle4:b5,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000000d0f00009601000091000000,Horipad Steam,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc2:b2,paddle1:b19,paddle2:b18,paddle3:b15,paddle4:b5,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000000d0f0000f600000001000000,Horipad Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000341a000005f7000010010000,HuiJia GameCube Controller Adapter,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Linux,",
+"05000000242e00000b20000001000000,Hyperkin Admiral N64 Controller,+rightx:b11,+righty:b13,-rightx:b8,-righty:b12,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b14,leftx:a0,lefty:a1,rightshoulder:b5,start:b9,platform:Linux,",
+"03000000242e0000ff0b000011010000,Hyperkin N64 Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,platform:Linux,",
+"03000000242e00006a38000010010000,Hyperkin Trooper 2,a:b0,b:b1,back:b4,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b3,start:b5,platform:Linux,",
 "03000000242e00008816000001010000,Hyperkin X91,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000830500006020000010010000,iBuffalo SNES Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,",
-"050000006964726f69643a636f6e0000,idroid:con,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000b50700001503000010010000,impact,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
-"03000000d80400008200000003000000,IMS PCU#0 Gamepad Interface,a:b1,b:b0,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b5,x:b3,y:b2,platform:Linux,",
-"03000000fd0500000030000000010000,InterAct GoPad I-73000 (Fighting Game Layout),a:b3,b:b4,back:b6,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,start:b7,x:b0,y:b1,platform:Linux,",
-"0500000049190000020400001b010000,Ipega PG-9069 - Bluetooth Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b161,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000632500007505000011010000,Ipega PG-9099 - Bluetooth Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"030000006e0500000320000010010000,JC-U3613M - DirectInput Mode,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Linux,",
-"03000000300f00001001000010010000,Jess Tech Dual Analog Rumble Pad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
-"03000000300f00000b01000010010000,Jess Tech GGE909 PC Recoil Pad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000ba2200002010000001010000,Jess Technology USB Game Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000f00300008d03000011010000,HyperX Clutch,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000830500006020000010010000,iBuffalo Super Famicom Controller,a:b1,b:b0,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,",
+"030000008f0e00001330000001010000,iCode Retro Adapter,b:b3,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b9,lefttrigger:b10,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b1,start:b7,x:b2,y:b0,platform:Linux,",
+"050000006964726f69643a636f6e0000,idroidcon Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000b50700001503000010010000,Impact,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
+"03000000d80400008200000003000000,IMS PCU0,a:b1,b:b0,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b5,x:b3,y:b2,platform:Linux,",
+"03000000120c00000500000010010000,InterAct AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Linux,",
+"03000000ef0500000300000000010000,InterAct AxisPad,a:b2,b:b3,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b11,x:b0,y:b1,platform:Linux,",
+"03000000fd0500000030000000010000,InterAct GoPad,a:b3,b:b4,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,x:b0,y:b1,platform:Linux,",
+"03000000fd0500002a26000000010000,InterAct HammerHead FX,a:b3,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b2,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b5,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b0,y:b1,platform:Linux,",
+"0500000049190000020400001b010000,Ipega PG 9069,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b161,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000632500007505000011010000,Ipega PG 9099,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"0500000049190000030400001b010000,Ipega PG9099,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000491900000204000000000000,Ipega PG9118,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000300f00001101000010010000,Jess Tech Colour Rumble Pad,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
+"03000000300f00001001000010010000,Jess Tech Dual Analog Rumble,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
+"03000000300f00000b01000010010000,Jess Tech GGE909 PC Recoil,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000ba2200002010000001010000,Jess Technology Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
 "030000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Linux,",
 "050000007e0500000620000001000000,Joy-Con (L),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b13,leftshoulder:b4,leftstick:b10,rightshoulder:b5,start:b8,x:b2,y:b3,platform:Linux,",
 "030000007e0500000720000001000000,Joy-Con (R),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b12,leftshoulder:b4,leftstick:b11,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Linux,",
 "050000007e0500000720000001000000,Joy-Con (R),+leftx:h0.2,+lefty:h0.4,-leftx:h0.8,-lefty:h0.1,a:b0,b:b1,back:b12,leftshoulder:b4,leftstick:b11,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Linux,",
 "03000000bd12000003c0000010010000,Joypad Alpha Shock,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000242f00002d00000011010000,JYS Wireless Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000242f00008a00000011010000,JYS Wireless Adapter,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b0,y:b3,platform:Linux,",
+"03000000242f00002d00000011010000,JYS Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000242f00008a00000011010000,JYS Adapter,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b0,y:b3,platform:Linux,",
 "030000006f0e00000103000000020000,Logic3 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006d040000d1ca000000000000,Logitech ChillStream,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006d040000d1ca000000000000,Logitech Chillstream,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006d040000d1ca000011010000,Logitech Chillstream,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006d04000019c2000010010000,Logitech Cordless RumblePad 2,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006d04000016c2000010010000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006d04000016c2000011010000,Logitech Dual Action,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000006d0400001dc2000014400000,Logitech F310 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006d0400001ec2000019200000,Logitech F510 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006d0400001ec2000020200000,Logitech F510 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006d04000019c2000011010000,Logitech F710 Gamepad (DInput),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000006d0400001fc2000005030000,Logitech F710 Gamepad (XInput),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006d0400000ac2000010010000,Logitech Inc. WingMan RumblePad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,rightx:a3,righty:a4,x:b3,y:b4,platform:Linux,",
+"030000006d0400001dc2000014400000,Logitech F310,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006d0400001ec2000019200000,Logitech F510,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006d0400001ec2000020200000,Logitech F510,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006d04000019c2000011010000,Logitech F710,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006d0400001fc2000005030000,Logitech F710,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000006d04000018c2000010010000,Logitech RumblePad 2,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006d04000011c2000010010000,Logitech WingMan Cordless RumblePad,a:b0,b:b1,back:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b5,leftshoulder:b6,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b10,rightx:a3,righty:a4,start:b8,x:b3,y:b4,platform:Linux,",
-"050000004d4f435554452d3035305800,M54-PC,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"05000000380700006652000025010000,Mad Catz C.T.R.L.R ,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700005032000011010000,Mad Catz FightPad PRO (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700005082000011010000,Mad Catz FightPad PRO (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006d0400000ac2000010010000,Logitech WingMan RumblePad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,rightx:a3,righty:a4,x:b3,y:b4,platform:Linux,",
+"05000000380700006652000025010000,Mad Catz CTRLR,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700008532000010010000,Mad Catz Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700005032000011010000,Mad Catz Fightpad Pro PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700005082000011010000,Mad Catz Fightpad Pro PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "03000000ad1b00002ef0000090040000,Mad Catz Fightpad SFxT,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000380700008034000011010000,Mad Catz fightstick (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700008084000011010000,Mad Catz fightstick (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700008433000011010000,Mad Catz FightStick TE S+ (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700008483000011010000,Mad Catz FightStick TE S+ (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700001647000010040000,Mad Catz Wired Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000380700003847000090040000,Mad Catz Wired Xbox 360 Controller (SFIV),a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000380700008031000011010000,Mad Catz FightStick Alpha PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700008081000011010000,Mad Catz FightStick Alpha PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700008034000011010000,Mad Catz Fightstick PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700008084000011010000,Mad Catz Fightstick PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000380700008433000011010000,Mad Catz Fightstick TE S PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700008483000011010000,Mad Catz Fightstick TE S PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000380700001888000010010000,Mad Catz Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700003888000010010000,Mad Catz Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:a0,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000380700001647000010040000,Mad Catz Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000380700003847000090040000,Mad Catz Xbox 360 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
 "03000000ad1b000016f0000090040000,Mad Catz Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000380700001888000010010000,MadCatz PC USB Wired Stick 8818,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000380700003888000010010000,MadCatz PC USB Wired Stick 8838,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:a0,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000242f0000f700000001010000,Magic-S Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000120c00000500000000010000,Manta Dualshock 2,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000120c00000500000000010000,Manta DualShock 2,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
+"030000008f0e00001330000010010000,Mayflash Controller Adapter,a:b1,b:b2,back:b8,dpdown:h0.8,dpleft:h0.2,dpright:h0.1,dpup:h0.4,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a3~,righty:a2,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000790000004318000010010000,Mayflash GameCube Adapter,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
 "03000000790000004418000010010000,Mayflash GameCube Controller,a:b1,b:b0,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
-"03000000790000004318000010010000,Mayflash GameCube Controller Adapter,a:b1,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000242f00007300000011010000,Mayflash Magic NS,a:b1,b:b4,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b0,y:b3,platform:Linux,",
 "0300000079000000d218000011010000,Mayflash Magic NS,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000d620000010a7000011010000,Mayflash Magic NS,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"0300000025090000e803000001010000,Mayflash Wii Classic Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:a4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:a5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,",
-"03000000780000000600000010010000,Microntek USB Joystick,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
-"030000005e0400000e00000000010000,Microsoft SideWinder,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Linux,",
-"030000005e0400008e02000004010000,Microsoft X-Box 360 pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400008e02000062230000,Microsoft X-Box 360 pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"050000005e040000050b000003090000,Microsoft X-Box One Elite 2 pad,a:b0,b:b1,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005e040000e302000003020000,Microsoft X-Box One Elite pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e040000d102000001010000,Microsoft X-Box One pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e040000dd02000003020000,Microsoft X-Box One pad (Firmware 2015),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e040000d102000003020000,Microsoft X-Box One pad v2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400008502000000010000,Microsoft X-Box pad (Japan),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
-"030000005e0400008902000021010000,Microsoft X-Box pad v2 (US),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
-"030000005e040000000b000008040000,Microsoft Xbox One Elite 2 pad - Wired,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e040000ea02000008040000,Microsoft Xbox One S pad - Wired,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000c62400001a53000000010000,Mini PE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000242f0000f700000001010000,Mayflash Magic S Pro,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000008f0e00001030000010010000,Mayflash Saturn Adapter,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,lefttrigger:b7,rightshoulder:b6,righttrigger:b2,start:b9,x:b3,y:b4,platform:Linux,",
+"0300000025090000e803000001010000,Mayflash Wii Classic Adapter,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:a4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:a5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,",
+"03000000790000000318000011010000,Mayflash Wii DolphinBar,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Linux,",
+"03000000790000000018000011010000,Mayflash Wii U Pro Adapter,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000b50700001203000010010000,Mega World Logic 3 Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
+"03000000b50700004f00000000010000,Mega World Logic 3 Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b1,platform:Linux,",
+"03000000780000000600000010010000,Microntek Joystick,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
+"030000005e0400002800000000010000,Microsoft Dual Strike,a:b3,b:b2,back:b4,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,rightx:a0,righty:a1~,start:b5,x:b1,y:b0,platform:Linux,",
+"030000005e0400000300000000010000,Microsoft SideWinder,a:b0,b:b1,back:b9,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Linux,",
+"030000005e0400000700000000010000,Microsoft SideWinder,a:b0,b:b1,back:b8,leftshoulder:b6,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b2,start:b9,x:b3,y:b4,platform:Linux,",
+"030000005e0400000e00000000010000,Microsoft SideWinder Freestyle Pro,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,rightshoulder:b7,start:b8,x:b3,y:b4,platform:Linux,",
+"030000005e0400002700000000010000,Microsoft SideWinder Plug and Play,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,lefttrigger:b4,righttrigger:b5,x:b2,y:b3,platform:Linux,",
+"030000005e0400008502000000010000,Microsoft Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
+"030000005e0400008902000021010000,Microsoft Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
+"030000005e0400008e02000001000000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.1,dpleft:h0.2,dpright:h0.8,dpup:h0.4,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000004010000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000056210000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000062230000,Microsoft Xbox 360,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000d102000001010000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000d102000003020000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000dd02000003020000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea02000008040000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea0200000f050000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000120b000009050000,Microsoft Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000e302000003020000,Microsoft Xbox One Elite,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000000b000007040000,Microsoft Xbox One Elite 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b12,paddle2:b14,paddle3:b13,paddle4:b15,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000000b000008040000,Microsoft Xbox One Elite 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b12,paddle2:b14,paddle3:b13,paddle4:b15,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000005e040000050b000003090000,Microsoft Xbox One Elite 2,a:b0,b:b1,back:b17,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e0400008e02000030110000,Microsoft Xbox One Elite 2,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b13,paddle3:b12,paddle4:b14,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b00000b050000,Microsoft Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000016050000,Microsoft Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000017050000,Microsoft Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000120b000001050000,Microsoft Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000030000000300000002000000,Miroof,a:b1,b:b0,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b2,platform:Linux,",
-"05000000d6200000e589000001000000,Moga 2 HID,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
+"03000000790000001c18000010010000,Mobapad Chitu HD,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000004d4f435554452d3035335800,Mocute 053X,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"05000000e80400006e0400001b010000,Mocute 053X M59,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000004d4f435554452d3035305800,Mocute 054X,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000d6200000e589000001000000,Moga 2,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
 "05000000d6200000ad0d000001000000,Moga Pro,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
-"05000000d62000007162000001000000,Moga Pro 2 HID,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
-"03000000c62400002b89000011010000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"05000000c62400002a89000000010000,MOGA XP5-A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b22,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"05000000c62400001a89000000010000,MOGA XP5-X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000250900006688000000010000,MP-8866 Super Dual Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Linux,",
-"030000006b140000010c000010010000,NACON GC-400ES,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"05000000d62000007162000001000000,Moga Pro 2,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b7,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a3,start:b6,x:b2,y:b3,platform:Linux,",
+"03000000c62400002b89000011010000,MOGA XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000c62400002a89000000010000,MOGA XP5A Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b22,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"05000000c62400001a89000000010000,MOGA XP5X Plus,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000250900006688000000010000,MP8866 Super Dual Box,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Linux,",
+"030000005e0400008e02000010020000,MSI GC20 V2,a:b0,b:b1,back:b6,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000f70600000100000000010000,N64 Adaptoid,+rightx:b2,+righty:b1,-rightx:b4,-righty:b5,a:b0,b:b3,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b6,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b7,start:b8,platform:Linux,",
+"030000006b1400000906000014010000,Nacon Asymmetric Wireless PS4 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006b140000010c000010010000,Nacon GC 400ES,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000853200000706000012010000,Nacon GC-100,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"05000000853200000503000000010000,Nacon MG-X Pro,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"0300000085320000170d000011010000,Nacon Revolution 5 Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"0300000085320000190d000011010000,Nacon Revolution 5 Pro,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "030000000d0f00000900000010010000,Natec Genesis P44,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000790000004518000010010000,NEXILUX GAMECUBE Controller Adapter,a:b1,b:b0,x:b2,y:b3,start:b9,rightshoulder:b7,dpup:h0.1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,leftx:a0,lefty:a1,rightx:a5,righty:a2,lefttrigger:a3,righttrigger:a4,platform:Linux,",
+"030000004f1f00000800000011010000,NeoGeo PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"0300000092120000474e000000010000,NeoGeo X Arcade Stick,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,start:b9,x:b3,y:b2,platform:Linux,",
+"03000000790000004518000010010000,Nexilux GameCube Controller Adapter,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:a4,rightx:a5,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
 "030000001008000001e5000010010000,NEXT SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,righttrigger:b6,start:b9,x:b3,y:b0,platform:Linux,",
 "060000007e0500003713000000000000,Nintendo 3DS,a:b0,b:b1,back:b8,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,",
-"060000007e0500000820000000000000,Nintendo Combined Joy-Cons (joycond),a:b0,b:b1,back:b9,dpdown:b15,dpleft:b16,dpright:b17,dpup:b14,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
 "030000007e0500003703000000016800,Nintendo GameCube Controller,a:b0,b:b2,dpdown:b6,dpleft:b4,dpright:b5,dpup:b7,lefttrigger:a4,leftx:a0,lefty:a1~,rightshoulder:b9,righttrigger:a5,rightx:a2,righty:a3~,start:b8,x:b1,y:b3,platform:Linux,",
 "03000000790000004618000010010000,Nintendo GameCube Controller Adapter,a:b1,b:b0,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a5~,righty:a2~,start:b9,x:b2,y:b3,platform:Linux,",
-"050000007e0500000620000001800000,Nintendo Switch Left Joy-Con,a:b9,b:b8,back:b5,leftshoulder:b2,leftstick:b6,leftx:a1,lefty:a0~,rightshoulder:b4,start:b0,x:b7,y:b10,platform:Linux,",
-"030000007e0500000920000011810000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
-"050000007e0500000920000001000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"050000007e0500000920000001800000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
-"050000007e0500000720000001800000,Nintendo Switch Right Joy-Con,a:b1,b:b2,back:b9,leftshoulder:b4,leftstick:b10,leftx:a1~,lefty:a0~,rightshoulder:b6,start:b8,x:b0,y:b3,platform:Linux,",
-"050000007e0500001720000001000000,Nintendo Switch SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b2,y:b3,platform:Linux,",
-"050000007e0500003003000001000000,Nintendo Wii Remote Pro Controller,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,",
-"05000000010000000100000003000000,Nintendo Wiimote,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"030000000d0500000308000010010000,Nostromo n45 Dual Analog Gamepad,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b12,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b2,y:b3,platform:Linux,",
+"030000007e0500006920000011010000,Nintendo Switch 2 Pro Controller,a:b0,b:b1,back:b14,dpdown:b8,dpleft:b10,dpright:b9,dpup:b11,guide:b16,leftshoulder:b12,leftstick:b15,lefttrigger:b13,leftx:a0,lefty:a1~,misc1:b17,misc2:b20,paddle1:b18,paddle2:b19,rightshoulder:b4,rightstick:b7,righttrigger:b5,rightx:a2,righty:a3~,start:b6,x:b2,y:b3,platform:Linux,",
+"060000004e696e74656e646f20537700,Nintendo Switch Combined Joy-Cons,a:b0,b:b1,back:b9,dpdown:b15,dpleft:b16,dpright:b17,dpup:b14,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
+"060000007e0500000620000000000000,Nintendo Switch Combined Joy-Cons,a:b0,b:b1,back:b9,dpdown:b15,dpleft:b16,dpright:b17,dpup:b14,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
+"060000007e0500000820000000000000,Nintendo Switch Combined Joy-Cons,a:b0,b:b1,back:b9,dpdown:b15,dpleft:b16,dpright:b17,dpup:b14,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
+"050000004c69632050726f20436f6e00,Nintendo Switch Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"050000007e0500000620000001800000,Nintendo Switch Left Joy-Con,a:b16,b:b15,back:b4,leftshoulder:b6,leftstick:b12,leftx:a1,lefty:a0~,rightshoulder:b8,start:b9,x:b14,y:b17,platform:Linux,",
+"030000007e0500000920000000026803,Nintendo Switch Pro Controller,a:b1,b:b0,back:b4,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b5,leftshoulder:b9,leftstick:b7,lefttrigger:a4,leftx:a0,lefty:a1,rightshoulder:b10,rightstick:b8,righttrigger:a5,rightx:a2,righty:a3,start:b6,x:b3,y:b2,platform:Linux,",
+"030000007e0500000920000011810000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
+"050000007e0500000920000001000000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"050000007e0500000920000001800000,Nintendo Switch Pro Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b5,leftstick:b12,lefttrigger:b7,leftx:a0,lefty:a1,misc1:b4,rightshoulder:b6,rightstick:b13,righttrigger:b8,rightx:a2,righty:a3,start:b10,x:b3,y:b2,platform:Linux,",
+"050000007e0500000720000001800000,Nintendo Switch Right Joy-Con,a:b1,b:b2,back:b9,leftshoulder:b4,leftstick:b10,leftx:a1~,lefty:a0,rightshoulder:b6,start:b8,x:b0,y:b3,platform:Linux,",
+"05000000010000000100000003000000,Nintendo Wii Remote,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"050000007e0500003003000001000000,Nintendo Wii U Pro Controller,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,",
+"050000005a1d00000218000003000000,Nokia GC 5000,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"030000000d0500000308000010010000,Nostromo n45 Dual Analog,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b4,leftstick:b12,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b2,y:b3,platform:Linux,",
+"030000007e0500007320000011010000,NSO GameCube Controller,a:b1,b:b3,dpdown:b8,dpleft:b10,dpright:b9,dpup:b11,guide:b16,leftshoulder:b13,lefttrigger:b12,leftx:a0,lefty:a1~,rightshoulder:b5,righttrigger:b4,rightx:a2,righty:a3~,start:b6,x:b0,y:b2,platform:Linux,",
+"030000007e0500001920000011810000,NSO N64 Controller,+rightx:b2,+righty:b3,-rightx:b4,-righty:b10,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b5,rightshoulder:b7,righttrigger:b9,start:b11,platform:Linux,",
+"050000007e0500001920000001000000,NSO N64 Controller,+rightx:b8,+righty:b7,-rightx:b3,-righty:b2,a:b1,b:b0,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,righttrigger:b10,start:b9,platform:Linux,",
+"050000007e0500001920000001800000,NSO N64 Controller,+rightx:b2,+righty:b3,-rightx:b4,-righty:b10,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,lefttrigger:b8,leftx:a0,lefty:a1,misc1:b5,rightshoulder:b7,righttrigger:b9,start:b11,platform:Linux,",
+"030000007e0500001e20000011810000,NSO Sega Genesis Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b6,misc1:b3,rightshoulder:b2,righttrigger:b4,start:b5,platform:Linux,",
+"030000007e0500001720000011810000,NSO SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b2,platform:Linux,",
+"050000007e0500001720000001000000,NSO SNES Controller,a:b0,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,lefttrigger:b7,rightshoulder:b6,righttrigger:b8,start:b10,x:b3,y:b2,platform:Linux,",
+"050000007e0500001720000001800000,NSO SNES Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b2,platform:Linux,",
 "03000000550900001072000011010000,NVIDIA Controller,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b8,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000550900001472000011010000,NVIDIA Controller v01.04,a:b0,b:b1,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Linux,",
-"05000000550900001472000001000000,NVIDIA Controller v01.04,a:b0,b:b1,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Linux,",
+"03000000550900001472000011010000,NVIDIA Controller,a:b0,b:b1,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b8,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Linux,",
+"05000000550900001472000001000000,NVIDIA Controller,a:b0,b:b1,back:b14,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b4,leftstick:b7,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b8,rightshoulder:b5,rightstick:b8,righttrigger:a4,rightx:a2,righty:a5,start:b6,x:b2,y:b3,platform:Linux,",
+"030000004b120000014d000000010000,NYKO Airflo EX,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
 "03000000451300000830000010010000,NYKO CORE,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"19000000010000000100000001010000,odroidgo2_joypad,a:b1,b:b0,dpdown:b7,dpleft:b8,dpright:b9,dpup:b6,guide:b10,leftshoulder:b4,leftstick:b12,lefttrigger:b11,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b13,righttrigger:b14,start:b15,x:b2,y:b3,platform:Linux,",
-"19000000010000000200000011000000,odroidgo2_joypad_v11,a:b1,b:b0,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b12,leftshoulder:b4,leftstick:b14,lefttrigger:b13,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b15,righttrigger:b16,start:b17,x:b2,y:b3,platform:Linux,",
-"030000005e0400000202000000010000,Old Xbox pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
-"03000000c0160000dc27000001010000,OnyxSoft Dual JoyDivision,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b6,x:b2,y:b3,platform:Linux,",
-"05000000362800000100000002010000,OUYA Game Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,platform:Linux,",
-"05000000362800000100000003010000,OUYA Game Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,platform:Linux,",
-"03000000830500005020000010010000,Padix Co. Ltd. Rockfire PSX/USB Bridge,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b2,y:b3,platform:Linux,",
-"03000000790000001c18000011010000,PC Game Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000ff1100003133000010010000,PC Game Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"030000006f0e0000b802000001010000,PDP AFTERGLOW Wired Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006f0e0000b802000013020000,PDP AFTERGLOW Wired Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"19000000010000000100000001010000,ODROID Go 2,a:b1,b:b0,dpdown:b7,dpleft:b8,dpright:b9,dpup:b6,guide:b10,leftshoulder:b4,leftstick:b12,lefttrigger:b11,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b13,righttrigger:b14,start:b15,x:b2,y:b3,platform:Linux,",
+"19000000010000000200000011000000,ODROID Go 2,a:b1,b:b0,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b12,leftshoulder:b4,leftstick:b14,lefttrigger:b13,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b15,righttrigger:b16,start:b17,x:b2,y:b3,platform:Linux,",
+"05000000362800000100000002010000,OUYA Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,platform:Linux,",
+"05000000362800000100000003010000,OUYA Controller,a:b0,b:b3,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,guide:b14,leftshoulder:b4,leftstick:b6,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:a5,rightx:a3,righty:a4,x:b1,y:b2,platform:Linux,",
+"05000000362800000100000004010000,OUYA Controller,a:b0,b:b3,back:b14,dpdown:b9,dpleft:b10,dpright:b11,dpup:b8,leftshoulder:b4,leftstick:b6,lefttrigger:b12,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b7,righttrigger:b13,rightx:a3,righty:a4,start:b16,x:b1,y:b2,platform:Linux,",
+"03000000830500005020000010010000,Padix Rockfire PlayStation Bridge,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b11,x:b2,y:b3,platform:Linux,",
+"03000000ff1100003133000010010000,PC Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"030000006f0e0000b802000001010000,PDP Afterglow Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e0000b802000013020000,PDP Afterglow Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000006f0e00006401000001010000,PDP Battlefield One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006f0e00008001000011010000,PDP CO. LTD. Faceoff Wired Pro Controller for Nintendo Switch,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e0000d702000006640000,PDP Black Camo Wired Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:b13,dpleft:b14,dpright:b13,dpup:b14,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000006f0e00003101000000010000,PDP EA Sports Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e00008501000011010000,PDP Fightpad Pro Gamecube Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
 "030000006f0e0000c802000012010000,PDP Kingdom Hearts Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000006f0e00008701000011010000,PDP Rock Candy Wired Controller for Nintendo Switch,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"030000006f0e00000901000011010000,PDP Versus Fighting Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000006f0e0000a802000023020000,PDP Wired Controller for Xbox One,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"030000006f0e00008501000011010000,PDP Wired Fight Pad Pro for Nintendo Switch,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"0500000049190000030400001b010000,PG-9099,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"05000000491900000204000000000000,PG-9118,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000004c050000da0c000011010000,Playstation Controller,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
-"030000004c0500003713000011010000,PlayStation Vita,a:b1,b:b2,back:b8,dpdown:b13,dpleft:b15,dpright:b14,dpup:b12,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00002801000011010000,PDP PS3 Rock Candy Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00000901000011010000,PDP PS3 Versus Fighting,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00002f01000011010000,PDP Wired PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000ad1b000004f9000000010000,PDP Xbox 360 Versus Fighting,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:a2,rightshoulder:b5,righttrigger:a5,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e0000f102000000000000,PDP Xbox Atomic,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e0000a802000023020000,PDP Xbox One Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"030000006f0e0000a702000023020000,PDP Xbox One Raven Black,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e0000d802000006640000,PDP Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e0000ef02000007640000,PDP Xbox Series Kinetic Wired Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000c62400000053000000010000,PowerA,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000c62400003a54000001010000,PowerA 1428124-01,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d62000000540000001010000,PowerA Advantage Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d620000011a7000011010000,PowerA Core Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000dd62000015a7000011010000,PowerA Fusion Nintendo Switch Arcade Stick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000d620000012a7000011010000,PowerA Fusion Nintendo Switch Fight Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000d62000000140000001010000,PowerA Fusion Pro 2 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000dd62000016a7000000000000,PowerA Fusion Pro Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000c62400001a53000000010000,PowerA Mini Pro Ex,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d620000013a7000011010000,PowerA Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000d62000006dca000011010000,PowerA Pro Ex,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000d62000000228000001010000,PowerA Wired Controller for Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000c62400001a58000001010000,PowerA Xbox One Cabled,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000c62400001a54000001010000,PowerA Xbox One Mini Wired Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d620000014a7000011010000,PowerA Spectra Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000c62400001a58000001010000,PowerA Xbox One,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d62000000220000001010000,PowerA Xbox One Controller,a:b0,b:b1,back:b7,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Linux,",
+"03000000d62000000228000001010000,PowerA Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c62400001a54000001010000,PowerA Xbox One Mini Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d62000000240000001010000,PowerA Xbox One Spectra Infinity,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d62000000520000050010000,PowerA Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d62000000b20000001010000,PowerA Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000d62000000f20000001010000,PowerA Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b7,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000006d040000d2ca000011010000,Precision Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000250900000017000010010000,PS/SS/N64 Adapter,a:b1,b:b2,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b5,lefttrigger:b9,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2~,righty:a3,start:b8,platform:Linux,",
 "03000000ff1100004133000010010000,PS2 Controller,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
 "03000000341a00003608000011010000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000004c0500006802000010010000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Linux,",
 "030000004c0500006802000010810000,PS3 Controller,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
 "030000004c0500006802000011010000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Linux,",
 "030000004c0500006802000011810000,PS3 Controller,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
+"030000005f1400003102000010010000,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
 "030000006f0e00001402000011010000,PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000008f0e00000300000010010000,PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
 "050000004c0500006802000000000000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Linux,",
@@ -854,148 +1653,257 @@ const char* _glfwDefaultMappings[] =
 "050000004c0500006802000000810000,PS3 Controller,a:b0,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
 "05000000504c415953544154494f4e00,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Linux,",
 "060000004c0500006802000000010000,PS3 Controller,a:b14,b:b13,back:b0,dpdown:b6,dpleft:b7,dpright:b5,dpup:b4,guide:b16,leftshoulder:b10,leftstick:b1,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b11,rightstick:b2,righttrigger:b9,rightx:a2,righty:a3,start:b3,x:b15,y:b12,platform:Linux,",
-"030000004c050000a00b000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004c050000a00b000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "030000004c050000a00b000011810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"030000004c050000c405000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004c050000c405000000810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
+"030000004c050000c405000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "030000004c050000c405000011810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"030000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"030000004c050000cc09000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000004c050000cc09000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "030000004c050000cc09000011810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"03000000c01100000140000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"050000004c050000c405000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000c01100000140000011010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"050000004c050000c405000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "050000004c050000c405000000810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
 "050000004c050000c405000001800000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"050000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"050000004c050000cc09000000010000,PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "050000004c050000cc09000000810000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
 "050000004c050000cc09000001800000,PS4 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"030000004c050000e60c000011010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"050000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000ff000000cb01000010010000,PSP,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000300f00001211000011010000,QanBa Arcade JoyStick,a:b2,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b5,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b6,start:b9,x:b1,y:b3,platform:Linux,",
-"030000009b2800004200000001010000,Raphnet Technologies Dual NES to USB v2.0,a:b0,b:b1,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Linux,",
-"030000009b2800003200000001010000,Raphnet Technologies GC/N64 to USB v3.4,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Linux,",
-"030000009b2800006000000001010000,Raphnet Technologies GC/N64 to USB v3.6,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Linux,",
-"030000009b2800000300000001010000,raphnet.net 4nes4snes v1.5,a:b0,b:b4,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Linux,",
+"0300004b4c0500005f0e000011010000,PS5 Access Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000004c050000e60c000011010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000004c050000e60c000011810000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
+"030000004c050000f20d000011010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b14,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000004c050000f20d000011810000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
+"050000004c050000e60c000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"050000004c050000e60c000000810000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
+"050000004c050000f20d000000010000,PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"050000004c050000f20d000000810000,PS5 Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
+"03000000300f00001211000011010000,Qanba Arcade Joystick,a:b2,b:b0,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b5,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b6,start:b9,x:b1,y:b3,platform:Linux,",
+"03000000222c00000225000011010000,Qanba Dragon Arcade Joystick PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000222c00000025000011010000,Qanba Dragon Arcade Joystick PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000222c00001220000011010000,Qanba Drone 2 Arcade Joystick PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000222c00001020000011010000,Qanba Drone 2 Arcade Joystick PS5,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000222c00000020000011010000,Qanba Drone Arcade PS4 Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,rightshoulder:b5,righttrigger:a4,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000300f00001210000010010000,Qanba Joystick Plus,a:b0,b:b1,back:b8,leftshoulder:b5,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b4,righttrigger:b6,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000222c00000223000011010000,Qanba Obsidian Arcade Joystick PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000222c00000023000011010000,Qanba Obsidian Arcade Joystick PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000009b2800000300000001010000,Raphnet 4nes4snes,a:b0,b:b4,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Linux,",
+"030000009b2800004200000001010000,Raphnet Dual NES Adapter,a:b0,b:b1,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,start:b3,platform:Linux,",
+"0300132d9b2800006500000000000000,Raphnet GameCube Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Linux,",
+"0300132d9b2800006500000001010000,Raphnet GameCube Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Linux,",
+"030000009b2800003200000001010000,Raphnet GC and N64 Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Linux,",
+"030000009b2800006000000001010000,Raphnet GC and N64 Adapter,a:b0,b:b7,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b2,righttrigger:b5,rightx:a3,righty:a4,start:b3,x:b1,y:b8,platform:Linux,",
+"030000009b2800006100000001010000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Linux,",
+"030000009b2800006400000001010000,Raphnet N64 Adapter,+rightx:b9,+righty:b7,-rightx:b8,-righty:b6,a:b0,b:b1,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,leftshoulder:b4,lefttrigger:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b3,platform:Linux,",
+"030000009b2800008000000020020000,Raphnet Wii Classic Adapter,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Linux,",
+"030000009b2800008000000001010000,Raphnet Wii Classic Adapter V3,a:b1,b:b4,back:b2,dpdown:b13,dpleft:b14,dpright:b15,dpup:b12,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b5,platform:Linux,",
+"03000000f8270000bf0b000011010000,Razer Kishi,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "030000008916000001fd000024010000,Razer Onza Classic Edition,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000008916000000fd000024010000,Razer Onza Tournament Edition,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000321500000204000011010000,Razer Panthera (PS3),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000321500000104000011010000,Razer Panthera (PS4),a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000321500000810000011010000,Razer Panthera Evo Arcade Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000321500000010000011010000,Razer RAIJU,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000321500000204000011010000,Razer Panthera PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000321500000104000011010000,Razer Panthera PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000321500000810000011010000,Razer Panthera PS4 Evo Arcade Stick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000321500000010000011010000,Razer Raiju,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000321500000507000000010000,Razer Raiju Mobile,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b21,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000321500000011000011010000,Razer Raion Fightpad for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"05000000321500000a10000001000000,Razer Raiju Tournament Edition,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b13,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000321500000011000011010000,Razer Raion PS4 Fightpad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
 "030000008916000000fe000024010000,Razer Sabertooth,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000c6240000045d000024010000,Razer Sabertooth,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000c6240000045d000025010000,Razer Sabertooth,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000321500000009000011010000,Razer Serval,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
 "050000003215000000090000163a0000,Razer Serval,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
 "0300000032150000030a000001010000,Razer Wildcat,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000790000001100000010010000,Retrolink SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000321500000b10000011010000,Razer Wolverine PS5 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"0300000032150000140a000001010000,Razer Wolverine Ultimate Xbox,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000000d0f0000c100000010010000,Retro Bit Legacy16,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,guide:b12,leftshoulder:b4,lefttrigger:b6,misc1:b13,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
+"030000000d0f0000c100000072056800,Retro Bit Legacy16,a:b1,b:b0,back:b4,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,guide:b5,leftshoulder:b9,lefttrigger:+a4,misc1:b11,rightshoulder:b10,righttrigger:+a5,start:b6,x:b3,y:b2,platform:Linux,",
+"03000000790000001100000010010000,Retro Controller,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b4,righttrigger:b5,start:b9,x:b0,y:b3,platform:Linux,",
+"0300000003040000c197000011010000,Retrode Adapter,a:b0,b:b4,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b1,y:b5,platform:Linux,",
+"190000004b4800000111000000010000,RetroGame Joypad,a:b1,b:b0,back:b8,dpdown:b14,dpleft:b15,dpright:b16,dpup:b13,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
 "0300000081170000990a000001010000,Retronic Adapter,a:b0,leftx:a0,lefty:a1,platform:Linux,",
 "0300000000f000000300000000010000,RetroPad,a:b1,b:b5,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Linux,",
+"00000000526574726f53746f6e653200,RetroStone 2 Controller,a:b1,b:b0,back:b10,dpdown:b15,dpleft:b16,dpright:b17,dpup:b14,leftshoulder:b6,lefttrigger:b8,rightshoulder:b7,righttrigger:b9,start:b11,x:b4,y:b3,platform:Linux,",
+"03000000341200000400000000010000,RetroUSB N64 RetroPort,+rightx:b8,+righty:b10,-rightx:b9,-righty:b11,a:b7,b:b6,dpdown:b2,dpleft:b1,dpright:b0,dpup:b3,leftshoulder:b13,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b12,start:b4,platform:Linux,",
 "030000006b140000010d000011010000,Revolution Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006b140000130d000011010000,Revolution Pro Controller 3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006f0e00001f01000000010000,Rock Candy,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e00008701000011010000,Rock Candy Nintendo Switch Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
 "030000006f0e00001e01000011010000,Rock Candy PS3 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000c6240000fefa000000010000,Rock Candy Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000006f0e00004601000001010000,Rock Candy Xbox One Controller,a:b0,b:b1,back:b6,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000a306000023f6000011010000,Saitek Cyborg V.1 Game Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00001311000011010000,Saffun Controller,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b0,platform:Linux,",
+"03000000a306000023f6000011010000,Saitek Cyborg PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000a30600001005000000010000,Saitek P150,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b7,lefttrigger:b6,rightshoulder:b2,righttrigger:b5,x:b3,y:b4,platform:Linux,",
 "03000000a30600000701000000010000,Saitek P220,a:b2,b:b3,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b4,righttrigger:b5,x:b0,y:b1,platform:Linux,",
-"03000000a30600000cff000010010000,Saitek P2500 Force Rumble Pad,a:b2,b:b3,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b0,y:b1,platform:Linux,",
-"03000000a30600000c04000011010000,Saitek P2900 Wireless Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b12,x:b0,y:b3,platform:Linux,",
+"03000000a30600000cff000010010000,Saitek P2500 Force Rumble,a:b2,b:b3,back:b11,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,start:b10,x:b0,y:b1,platform:Linux,",
+"03000000a30600000d5f000010010000,Saitek P2600,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b11,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Linux,",
+"03000000a30600000c04000011010000,Saitek P2900,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b9,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b12,x:b0,y:b3,platform:Linux,",
+"03000000a306000018f5000010010000,Saitek P3200 Rumble,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000300f00001201000010010000,Saitek P380,a:b2,b:b3,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b9,x:b0,y:b1,platform:Linux,",
 "03000000a30600000901000000010000,Saitek P880,a:b2,b:b3,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a3,righty:a2,x:b0,y:b1,platform:Linux,",
-"03000000a30600000b04000000010000,Saitek P990 Dual Analog Pad,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Linux,",
-"03000000a306000018f5000010010000,Saitek PLC Saitek P3200 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000a306000020f6000011010000,Saitek PS2700 Rumble Pad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000a30600000b04000000010000,Saitek P990 Dual Analog,a:b1,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a2,start:b8,x:b0,y:b3,platform:Linux,",
+"03000000a306000020f6000011010000,Saitek PS2700 Rumble,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
+"05000000e804000000a000001b010000,Samsung EIGP20,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "03000000d81d00000e00000010010000,Savior,a:b0,b:b1,back:b8,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b11,righttrigger:b3,start:b9,x:b4,y:b5,platform:Linux,",
-"03000000f025000021c1000010010000,ShanWan Gioteck PS3 Wired Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000632500007505000010010000,SHANWAN PS3/PC Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000bc2000000055000010010000,ShanWan PS3/PC Wired GamePad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005f140000c501000010010000,SHANWAN Trust Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000632500002305000010010000,ShanWan USB Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000341a00000908000010010000,SL-6566,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"030000004c050000e60c000011810000,Sony DualSense,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"050000004c050000e60c000000810000,Sony DualSense ,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b11,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:a5,rightx:a3,righty:a4,start:b9,x:b3,y:b2,platform:Linux,",
-"03000000250900000500000000010000,Sony PS2 pad with SmartJoy adapter,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Linux,",
-"030000005e0400008e02000073050000,Speedlink TORID Wireless Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400008e02000020200000,SpeedLink XEOX Pro Analog Gamepad pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000d11800000094000011010000,Stadia Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000952e00004b43000011010000,Scuf Envision,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000952e00004d43000011010000,Scuf Envision,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000952e00004e43000011010000,Scuf Envision,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b9,righttrigger:a4,rightx:a2,righty:a5,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000a30c00002500000011010000,Sega Genesis Mini 3B Controller,a:b2,b:b1,dpdown:+a4,dpleft:-a3,dpright:+a3,dpup:-a4,righttrigger:b5,start:b9,platform:Linux,",
+"03000000790000001100000011010000,Sega Saturn,a:b1,b:b2,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b4,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000790000002201000011010000,Sega Saturn,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,lefttrigger:b5,rightshoulder:b6,righttrigger:b7,start:b9,x:b2,y:b3,platform:Linux,",
+"03000000b40400000a01000000010000,Sega Saturn,a:b0,b:b1,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b7,rightshoulder:b5,righttrigger:b2,start:b8,x:b3,y:b4,platform:Linux,",
+"03000000632500002305000010010000,ShanWan Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000632500002605000010010000,Shanwan Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000632500007505000010010000,Shanwan Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000bc2000000055000010010000,Shanwan Gamepad,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000f025000021c1000010010000,Shanwan Gioteck PS3 Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000341a00000908000010010000,SL6566,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"030000004b2900000430000011000000,Snakebyte Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000004c050000cc09000001000000,Sony DualShock 4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"03000000666600006706000000010000,Sony PlayStation Adapter,a:b2,b:b1,back:b8,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b9,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b10,righttrigger:b5,rightx:a2,righty:a3,start:b11,x:b3,y:b0,platform:Linux,",
+"030000004c050000da0c000011010000,Sony PlayStation Controller,a:b2,b:b1,back:b8,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000d9040000160f000000010000,Sony PlayStation Controller Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000ff000000cb01000010010000,Sony PlayStation Portable,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Linux,",
+"030000004c0500003713000011010000,Sony PlayStation Vita,a:b1,b:b2,back:b8,dpdown:b13,dpleft:b15,dpright:b14,dpup:b12,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,rightx:a3,righty:a4,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000250900000500000000010000,Sony PS2 pad with SmartJoy Adapter,a:b2,b:b1,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Linux,",
+"030000005e0400008e02000073050000,Speedlink Torid,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000020200000,SpeedLink Xeox Pro Analog,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000de2800000112000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000de2800000112000011010000,Steam Controller,a:b2,b:b3,back:b10,dpdown:+a5,dpleft:-a4,dpright:+a4,dpup:-a5,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a7,leftx:a0,lefty:a1,paddle1:b15,paddle2:b16,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a3,start:b11,x:b4,y:b5,platform:Linux,",
 "03000000de2800000211000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000de2800000211000011010000,Steam Controller,a:b2,b:b3,back:b10,dpdown:b18,dpleft:b19,dpright:b20,dpup:b17,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b15,paddle2:b16,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b5,platform:Linux,",
+"03000000de2800000211000011010000,Steam Controller,a:b2,b:b3,back:b10,dpdown:b18,dpleft:b19,dpright:b20,dpup:b17,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b16,paddle2:b15,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b5,platform:Linux,",
 "03000000de2800004211000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000de2800004211000011010000,Steam Controller,a:b2,b:b3,back:b10,dpdown:b18,dpleft:b19,dpright:b20,dpup:b17,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,paddle1:b15,paddle2:b16,rightshoulder:b7,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b4,y:b5,platform:Linux,",
+"03000000de2800004211000011010000,Steam Controller,a:b2,b:b3,back:b10,dpdown:b18,dpleft:b19,dpright:b20,dpup:b17,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a7,leftx:a0,lefty:a1,paddle1:b16,paddle2:b15,rightshoulder:b7,righttrigger:a6,rightx:a2,righty:a3,start:b11,x:b4,y:b5,platform:Linux,",
 "03000000de280000fc11000001000000,Steam Controller,a:b0,b:b1,back:b6,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "05000000de2800000212000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,platform:Linux,",
 "05000000de2800000511000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,platform:Linux,",
 "05000000de2800000611000001000000,Steam Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,paddle1:b11,paddle2:b10,rightshoulder:b5,righttrigger:a3,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000de2800000512000010010000,Steam Deck,a:b3,b:b4,back:b11,dpdown:b17,dpleft:b18,dpright:b19,dpup:b16,guide:b13,leftshoulder:b7,leftstick:b14,lefttrigger:a9,leftx:a0,lefty:a1,rightshoulder:b8,rightstick:b15,righttrigger:a8,rightx:a2,righty:a3,start:b12,x:b5,y:b6,platform:Linux,",
+"03000000de2800000512000011010000,Steam Deck,a:b3,b:b4,back:b11,dpdown:b17,dpleft:b18,dpright:b19,dpup:b16,guide:b13,leftshoulder:b7,leftstick:b14,lefttrigger:a9,leftx:a0,lefty:a1,misc1:b2,paddle1:b21,paddle2:b20,paddle3:b23,paddle4:b22,rightshoulder:b8,rightstick:b15,righttrigger:a8,rightx:a2,righty:a3,start:b12,x:b5,y:b6,platform:Linux,",
 "03000000de280000ff11000001000000,Steam Virtual Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000004e696d6275732b0000000000,SteelSeries Nimbus Plus,a:b0,b:b1,back:b10,guide:b11,leftshoulder:b4,leftstick:b8,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:b7,rightx:a2,righty:a3,start:b12,x:b2,y:b3,platform:Linux,",
 "03000000381000003014000075010000,SteelSeries Stratus Duo,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000381000003114000075010000,SteelSeries Stratus Duo,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "0500000011010000311400001b010000,SteelSeries Stratus Duo,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b32,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "05000000110100001914000009010000,SteelSeries Stratus XL,a:b0,b:b1,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000ad1b000038f0000090040000,Street Fighter IV FightStick TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000003b07000004a1000000010000,Suncom SFX Plus for USB,a:b0,b:b2,back:b7,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b9,righttrigger:b5,start:b8,x:b1,y:b3,platform:Linux,",
+"03000000ad1b000038f0000090040000,Street Fighter IV Fightstick TE,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000003b07000004a1000000010000,Suncom SFX Plus,a:b0,b:b2,back:b7,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,lefttrigger:b4,rightshoulder:b9,righttrigger:b5,start:b8,x:b1,y:b3,platform:Linux,",
+"030000001f08000001e4000010010000,Super Famicom Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Linux,",
 "03000000666600000488000000010000,Super Joy Box 5 Pro,a:b2,b:b1,back:b9,dpdown:b14,dpleft:b15,dpright:b13,dpup:b12,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a2,righty:a3,start:b8,x:b3,y:b0,platform:Linux,",
-"0300000000f00000f100000000010000,Super RetroPort,a:b1,b:b5,back:b2,leftshoulder:b6,leftx:a0,lefty:a1,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Linux,",
-"03000000457500002211000010010000,SZMY-POWER CO. LTD. GAMEPAD,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"030000008f0e00000d31000010010000,SZMY-POWER CO. LTD. GAMEPAD 3 TURBO,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000008f0e00001431000010010000,SZMY-POWER CO. LTD. PS3 gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000004f04000020b3000010010000,Thrustmaster 2 in 1 DT,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
+"0300000000f00000f100000000010000,Super RetroPort,a:b1,b:b5,back:b2,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b6,rightshoulder:b7,start:b3,x:b0,y:b4,platform:Linux,",
+"030000008f0e00000d31000010010000,SZMY Power 3 Turbo,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000457500000401000011010000,SZMY Power DS4 Wired Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,misc1:b13,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000457500002211000010010000,SZMY Power Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"030000008f0e00001431000010010000,SZMY Power PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000e40a00000307000011010000,Taito Egret II Mini Control Panel,a:b4,b:b2,back:b6,guide:b9,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b1,start:b7,x:b8,y:b3,platform:Linux,",
+"03000000e40a00000207000011010000,Taito Egret II Mini Controller,a:b4,b:b2,back:b6,guide:b9,leftx:a0,lefty:a1,rightshoulder:b0,righttrigger:b1,start:b7,x:b8,y:b3,platform:Linux,",
+"03000000ba2200000701000001010000,Technology Innovation PS2 Adapter,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a5,righty:a2,start:b9,x:b3,y:b2,platform:Linux,",
+"03000000790000001c18000011010000,TGZ Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b15,leftshoulder:b6,leftstick:b13,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:b9,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000591c00002400000010010000,THEC64 Joystick,a:b0,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000591c00002600000010010000,THEGamepad,a:b2,b:b1,back:b6,leftshoulder:b4,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b3,y:b0,platform:Linux,",
+"030000004f04000015b3000001010000,Thrustmaster Dual Analog 3.2,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
 "030000004f04000015b3000010010000,Thrustmaster Dual Analog 4,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
-"030000004f04000023b3000000010000,Thrustmaster Dual Trigger 3-in-1,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"030000004f0400000ed0000011010000,ThrustMaster eSwap PRO Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004f04000020b3000010010000,Thrustmaster Dual Trigger,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
+"030000004f04000023b3000000010000,Thrustmaster Dual Trigger PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004f0400000ed0000011010000,Thrustmaster eSwap Pro Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
 "03000000b50700000399000000010000,Thrustmaster Firestorm Digital 2,a:b2,b:b4,back:b11,leftshoulder:b6,leftstick:b10,lefttrigger:b7,leftx:a0,lefty:a1,rightshoulder:b8,rightstick:b0,righttrigger:b9,start:b1,x:b3,y:b5,platform:Linux,",
 "030000004f04000003b3000010010000,Thrustmaster Firestorm Dual Analog 2,a:b0,b:b2,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b8,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b9,rightx:a2,righty:a3,x:b1,y:b3,platform:Linux,",
 "030000004f04000000b3000010010000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b9,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b11,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b10,x:b1,y:b3,platform:Linux,",
-"030000004f04000026b3000002040000,Thrustmaster Gamepad GP XID,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000c6240000025b000002020000,Thrustmaster GPX Gamepad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000004f04000008d0000000010000,Thrustmaster Run N Drive Wireless,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"030000004f04000009d0000000010000,Thrustmaster Run N Drive Wireless PS3,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000004f04000007d0000000010000,Thrustmaster T Mini Wireless,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
-"030000004f04000012b3000010010000,Thrustmaster vibrating gamepad,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
-"03000000bd12000015d0000010010000,Tomee SNES USB Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000d814000007cd000011010000,Toodles 2008 Chimp PC/PS3,a:b0,b:b1,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b2,platform:Linux,",
+"030000004f04000004b3000010010000,Thrustmaster Firestorm Dual Power,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
+"030000004f04000026b3000002040000,Thrustmaster GP XID,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000c6240000025b000002020000,Thrustmaster GPX,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000004f04000008d0000000010000,Thrustmaster Run N Drive PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004f04000009d0000000010000,Thrustmaster Run N Drive PlayStation Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004f04000007d0000000010000,Thrustmaster T Mini,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"030000004f04000012b3000010010000,Thrustmaster Vibrating Gamepad,a:b0,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b5,leftx:a0,lefty:a1,rightshoulder:b6,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b1,y:b3,platform:Linux,",
+"03000000571d00002000000010010000,Tomee SNES Adapter,a:b0,b:b1,back:b6,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000bd12000015d0000010010000,Tomee SNES Controller,a:b2,b:b1,back:b8,dpdown:+a1,dpleft:-a0,dpright:+a0,dpup:-a1,leftshoulder:b4,rightshoulder:b5,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000d814000007cd000011010000,Toodles 2008 Chimp PC PS3,a:b0,b:b1,back:b8,leftshoulder:b4,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,righttrigger:b7,start:b9,x:b3,y:b2,platform:Linux,",
 "030000005e0400008e02000070050000,Torid,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "03000000c01100000591000011010000,Torid,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000100800000100000010010000,Twin USB PS2 Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000680a00000300000003000000,TRBot Virtual Joypad,a:b11,b:b12,back:b15,dpdown:b6,dpleft:b3,dpright:b4,dpup:b5,leftshoulder:b17,leftstick:b21,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b22,righttrigger:a2,rightx:a3,righty:a4,start:b16,x:b13,y:b14,platform:Linux,",
+"03000000780300000300000003000000,TRBot Virtual Joypad,a:b11,b:b12,back:b15,dpdown:b6,dpleft:b3,dpright:b4,dpup:b5,leftshoulder:b17,leftstick:b21,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b22,righttrigger:a2,rightx:a3,righty:a4,start:b16,x:b13,y:b14,platform:Linux,",
+"03000000e00d00000300000003000000,TRBot Virtual Joypad,a:b11,b:b12,back:b15,dpdown:b6,dpleft:b3,dpright:b4,dpup:b5,leftshoulder:b17,leftstick:b21,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b22,righttrigger:a2,rightx:a3,righty:a4,start:b16,x:b13,y:b14,platform:Linux,",
+"03000000f00600000300000003000000,TRBot Virtual Joypad,a:b11,b:b12,back:b15,dpdown:b6,dpleft:b3,dpright:b4,dpup:b5,leftshoulder:b17,leftstick:b21,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b18,rightstick:b22,righttrigger:a2,rightx:a3,righty:a4,start:b16,x:b13,y:b14,platform:Linux,",
+"030000005f140000c501000010010000,Trust Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
+"06000000f51000000870000003010000,Turtle Beach Recon,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000100800000100000010010000,Twin PS2 Adapter,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
+"03000000151900005678000010010000,Uniplay U6,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "03000000100800000300000010010000,USB Gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b3,y:b0,platform:Linux,",
 "03000000790000000600000007010000,USB gamepad,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a3,righty:a4,start:b9,x:b3,y:b0,platform:Linux,",
-"03000000790000001100000000010000,USB Gamepad1,a:b2,b:b1,back:b8,dpdown:a0,dpleft:a1,dpright:a2,dpup:a4,start:b9,platform:Linux,",
-"030000006f0e00000302000011010000,Victrix Pro Fight Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"030000006f0e00000702000011010000,Victrix Pro Fight Stick for PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,x:b0,y:b3,platform:Linux,",
-"05000000ac0500003232000001000000,VR-BOX,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
-"03000000791d00000103000010010000,Wii Classic Controller,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b6,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,righttrigger:b5,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"050000000d0f0000f600000001000000,Wireless HORIPAD Switch Pro Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"030000005e0400008e02000010010000,X360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400008e02000014010000,X360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400001907000000010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400009102000007010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e040000a102000000010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e040000a102000007010000,X360 Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"0000000058626f782033363020576900,Xbox 360 Wireless Controller,a:b0,b:b1,back:b14,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,guide:b7,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Linux,",
-"030000005e040000a102000014010000,Xbox 360 Wireless Receiver (XBOX),a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"0000000058626f782047616d65706100,Xbox Gamepad (userspace driver),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000790000001100000000010000,USB Gamepad,a:b2,b:b1,back:b8,dpdown:a0,dpleft:a1,dpright:a2,dpup:a4,start:b9,platform:Linux,",
+"03000000790000001a18000011010000,Venom PS4 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000790000001b18000011010000,Venom PS4 Arcade Joystick,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"030000006f0e00000302000011010000,Victrix Pro Fightstick PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"030000006f0e00000702000011010000,Victrix Pro Fightstick PS4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,righttrigger:b7,start:b9,touchpad:b13,x:b0,y:b3,platform:Linux,",
+"05000000ac0500003232000001000000,VR Box Controller,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b10,lefttrigger:b4,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b11,righttrigger:b5,rightx:a3,righty:a2,start:b9,x:b2,y:b3,platform:Linux,",
+"05000000434f4d4d414e440000000000,VX Gaming Command Series,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"0000000058626f782033363020576900,Xbox 360 Controller,a:b0,b:b1,back:b14,dpdown:b11,dpleft:b12,dpright:b13,dpup:b10,guide:b7,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b6,x:b2,y:b3,platform:Linux,",
+"030000005e0400001907000000010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000010010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000014010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400009102000007010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000a102000000010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000a102000007010000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000a102000030060000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e00001503000000020000,Xbox 360 Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400008e02000000010000,Xbox 360 EasySMX,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000a102000014010000,Xbox 360 Receiver,a:b0,b:b1,back:b6,dpdown:b14,dpleft:b11,dpright:b12,dpup:b13,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"0000000058626f782047616d65706100,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a4,rightx:a2,righty:a3,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e0400000202000000010000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
+"030000005e0400008e02000072050000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000006f0e00001304000000010000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000ffff0000ffff000000010000,Xbox Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b5,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b2,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b3,y:b4,platform:Linux,",
+"030000005e0400000a0b000005040000,Xbox One Controller,a:b1,b:b0,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b11,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b12,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b2,platform:Linux,",
 "030000005e040000d102000002010000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea02000000000000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea02000001030000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000005e040000e002000003090000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000005e040000fd02000003090000,Xbox One Controller,a:b0,b:b1,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "050000005e040000fd02000030110000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000dd02000003020000,Xbox One Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000005e040000e302000002090000,Xbox One Elite,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000220b000013050000,Xbox One Elite 2 Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "050000005e040000050b000002090000,Xbox One Elite Series 2,a:b0,b:b1,back:b136,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b6,leftstick:b13,lefttrigger:a6,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a5,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005e040000ea02000000000000,Xbox One Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"050000005e040000e002000003090000,Xbox One Wireless Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b10,leftshoulder:b4,leftstick:b8,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b9,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"050000005e040000fd02000003090000,Xbox One Wireless Controller,a:b0,b:b1,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b16,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005e040000ea02000001030000,Xbox One Wireless Controller (Model 1708),a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea02000011050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea02000015050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000ea02000017050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000ea0200000b050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000ea0200000d050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000ea02000016050000,Xbox One S Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000005e040000120b000001050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000005050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000007050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000009050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b00000d050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b00000f050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000011050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000014050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"030000005e040000120b000015050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
 "030000005e040000130b000005050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "050000005e040000130b000001050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
 "050000005e040000130b000005050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
-"030000005e040000120b000005050000,XBox Series pad,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"030000005e0400008e02000000010000,xbox360 Wireless EasySMX,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
-"03000000450c00002043000010010000,XEOX Gamepad SL-6556-BK,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
-"03000000ac0500005b05000010010000,Xiaoji Gamesir-G3w,a:b2,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b3,y:b0,platform:Linux,",
-"05000000172700004431000029010000,XiaoMi Game Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:a7,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Linux,",
-"03000000c0160000e105000001010000,Xin-Mo Xin-Mo Dual Arcade,a:b4,b:b3,back:b6,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b9,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b1,y:b0,platform:Linux,",
-"03000000120c0000100e000011010000,ZEROPLUS P4 Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
-"03000000120c0000101e000011010000,ZEROPLUS P4 Wired Gamepad,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"050000005e040000130b000007050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000130b000009050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000130b000011050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000130b000013050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000130b000015050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000130b000017050000,Xbox Series Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"060000005e040000120b000007050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000120b00000b050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000120b00000d050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000120b00000f050000,Xbox Series Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"060000005e040000120b000011050000,Xbox Series X Controller,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,misc1:b11,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"050000005e040000130b000022050000,Xbox Series X Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,misc1:b15,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000200b000013050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000200b000017050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000200b000023050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"050000005e040000220b000017050000,Xbox Wireless Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000450c00002043000010010000,XEOX SL6556 BK,a:b0,b:b1,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,leftshoulder:b4,leftstick:b10,lefttrigger:b6,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:b7,rightx:a2,righty:a3,start:b9,x:b2,y:b3,platform:Linux,",
+"05000000172700004431000029010000,XiaoMi Controller,a:b0,b:b1,back:b10,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b20,leftshoulder:b6,leftstick:b13,lefttrigger:a7,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,righttrigger:a6,rightx:a2,righty:a5,start:b11,x:b3,y:b4,platform:Linux,",
+"03000000c0160000e105000001010000,XinMo Dual Arcade,a:b4,b:b3,back:b6,dpdown:b12,dpleft:b13,dpright:b14,dpup:b11,guide:b9,leftshoulder:b2,leftx:a0,lefty:a1,rightshoulder:b5,start:b7,x:b1,y:b0,platform:Linux,",
+"030000005e0400008e02000020010000,XInput Adapter,a:b0,b:b1,back:b6,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b8,leftshoulder:b4,leftstick:b9,lefttrigger:a2,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b10,righttrigger:a5,rightx:a3,righty:a4,start:b7,x:b2,y:b3,platform:Linux,",
+"03000000120c0000100e000011010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000120c0000101e000011010000,Zeroplus P4,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
+"03000000120c0000182e000011010000,Zeroplus PS4 Controller,a:b1,b:b2,back:b8,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,guide:b12,leftshoulder:b4,leftstick:b10,lefttrigger:a3,leftx:a0,lefty:a1,rightshoulder:b5,rightstick:b11,righttrigger:a4,rightx:a2,righty:a5,start:b9,x:b0,y:b3,platform:Linux,",
 #endif // GLFW_BUILD_LINUX_JOYSTICK
 };
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h.in b/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h.in
index 99d1833..ed62368 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h.in
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/mappings.h.in
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/monitor.c b/src/libraries/raylib/raylib/src/external/glfw/src/monitor.c
index 7cdf2df..efc286d 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/monitor.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/monitor.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -325,6 +325,9 @@ GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void)
 
 GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
     if (xpos)
         *xpos = 0;
     if (ypos)
@@ -332,9 +335,6 @@ GLFWAPI void glfwGetMonitorPos(GLFWmonitor* handle, int* xpos, int* ypos)
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     _glfw.platform.getMonitorPos(monitor, xpos, ypos);
 }
 
@@ -342,6 +342,9 @@ GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* handle,
                                     int* xpos, int* ypos,
                                     int* width, int* height)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
     if (xpos)
         *xpos = 0;
     if (ypos)
@@ -353,14 +356,14 @@ GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* handle,
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     _glfw.platform.getMonitorWorkarea(monitor, xpos, ypos, width, height);
 }
 
 GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
     if (widthMM)
         *widthMM = 0;
     if (heightMM)
@@ -368,9 +371,6 @@ GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int*
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     if (widthMM)
         *widthMM = monitor->widthMM;
     if (heightMM)
@@ -380,46 +380,42 @@ GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int*
 GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* handle,
                                         float* xscale, float* yscale)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
+
     if (xscale)
         *xscale = 0.f;
     if (yscale)
         *yscale = 0.f;
 
     _GLFW_REQUIRE_INIT();
-
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     _glfw.platform.getMonitorContentScale(monitor, xscale, yscale);
 }
 
 GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     assert(monitor != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return monitor->name;
 }
 
 GLFWAPI void glfwSetMonitorUserPointer(GLFWmonitor* handle, void* pointer)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     assert(monitor != NULL);
 
+    _GLFW_REQUIRE_INIT();
     monitor->userPointer = pointer;
 }
 
 GLFWAPI void* glfwGetMonitorUserPointer(GLFWmonitor* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     assert(monitor != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return monitor->userPointer;
 }
 
@@ -432,15 +428,14 @@ GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun cbfun)
 
 GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
     assert(count != NULL);
 
     *count = 0;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     if (!refreshVideoModes(monitor))
         return NULL;
 
@@ -450,11 +445,11 @@ GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
 
 GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     assert(monitor != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
     if (!_glfw.platform.getVideoMode(monitor, &monitor->currentMode))
         return NULL;
 
@@ -467,15 +462,13 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
     unsigned short* values;
     GLFWgammaramp ramp;
     const GLFWgammaramp* original;
-
+    assert(handle != NULL);
     assert(gamma > 0.f);
-    assert(isfinite(gamma));
+    assert(gamma <= FLT_MAX);
 
     _GLFW_REQUIRE_INIT();
 
-    assert(handle != NULL);
-
-    if (!isfinite(gamma) || gamma <= 0.f)
+    if (gamma != gamma || gamma <= 0.f || gamma > FLT_MAX)
     {
         _glfwInputError(GLFW_INVALID_VALUE, "Invalid gamma value %f", gamma);
         return;
@@ -512,11 +505,11 @@ GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
 
 GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     assert(monitor != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
     _glfwFreeGammaArrays(&monitor->currentRamp);
     if (!_glfw.platform.getGammaRamp(monitor, &monitor->currentRamp))
         return NULL;
@@ -526,6 +519,8 @@ GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
 
 GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
+    assert(monitor != NULL);
     assert(ramp != NULL);
     assert(ramp->size > 0);
     assert(ramp->red != NULL);
@@ -534,9 +529,6 @@ GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     if (ramp->size <= 0)
     {
         _glfwInputError(GLFW_INVALID_VALUE,
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/nsgl_context.m b/src/libraries/raylib/raylib/src/external/glfw/src/nsgl_context.m
index cc67617..daa8367 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/nsgl_context.m
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/nsgl_context.m
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 macOS - www.glfw.org
+// GLFW 3.4 macOS - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2009-2019 Camilla Löwy <elmindreda@glfw.org>
 //
@@ -30,7 +30,6 @@
 
 #include <unistd.h>
 #include <math.h>
-#include <assert.h>
 
 static void makeContextCurrentNSGL(_GLFWwindow* window)
 {
@@ -128,6 +127,8 @@ static void destroyContextNSGL(_GLFWwindow* window)
 //////                       GLFW internal API                      //////
 //////////////////////////////////////////////////////////////////////////
 
+// Initialize OpenGL support
+//
 GLFWbool _glfwInitNSGL(void)
 {
     if (_glfw.nsgl.framework)
@@ -145,10 +146,14 @@ GLFWbool _glfwInitNSGL(void)
     return GLFW_TRUE;
 }
 
+// Terminate OpenGL support
+//
 void _glfwTerminateNSGL(void)
 {
 }
 
+// Create the OpenGL context
+//
 GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
                                 const _GLFWctxconfig* ctxconfig,
                                 const _GLFWfbconfig* fbconfig)
@@ -177,16 +182,16 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
         return GLFW_FALSE;
     }
 
-    // Context robustness modes (GL_KHR_robustness) are not supported by
+    // Context robustness modes (GL_KHR_robustness) are not yet supported by
     // macOS but are not a hard constraint, so ignore and continue
 
-    // Context release behaviors (GL_KHR_context_flush_control) are not 
+    // Context release behaviors (GL_KHR_context_flush_control) are not yet
     // supported by macOS but are not a hard constraint, so ignore and continue
 
-    // Debug contexts (GL_KHR_debug) are not supported by macOS but are not
+    // Debug contexts (GL_KHR_debug) are not yet supported by macOS but are not
     // a hard constraint, so ignore and continue
 
-    // No-error contexts (GL_KHR_no_error) are not supported by macOS but
+    // No-error contexts (GL_KHR_no_error) are not yet supported by macOS but
     // are not a hard constraint, so ignore and continue
 
 #define ADD_ATTRIB(a) \
@@ -212,11 +217,14 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
         ADD_ATTRIB(kCGLPFASupportsAutomaticGraphicsSwitching);
     }
 
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101000
     if (ctxconfig->major >= 4)
     {
         SET_ATTRIB(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion4_1Core);
     }
-    else if (ctxconfig->major >= 3)
+    else
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+    if (ctxconfig->major >= 3)
     {
         SET_ATTRIB(NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core);
     }
@@ -353,6 +361,7 @@ GLFWbool _glfwCreateContextNSGL(_GLFWwindow* window,
 
 GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(nil);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_COCOA)
@@ -362,9 +371,6 @@ GLFWAPI id glfwGetNSGLContext(GLFWwindow* handle)
         return nil;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->context.source != GLFW_NATIVE_CONTEXT_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/null_init.c b/src/libraries/raylib/raylib/src/external/glfw/src/null_init.c
index fd0d9e9..88940fc 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/null_init.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/null_init.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2016 Google Inc.
 // Copyright (c) 2016-2017 Camilla Löwy <elmindreda@glfw.org>
@@ -260,6 +260,5 @@ void _glfwTerminateNull(void)
     free(_glfw.null.clipboardString);
     _glfwTerminateOSMesa();
     _glfwTerminateEGL();
-    memset(&_glfw.null, 0, sizeof(_glfw.null));
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.c b/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.c
index 16dc8cf..ec1f6b5 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2016-2017 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.h b/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.h
index 40a490f..a2199c5 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/null_joystick.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/null_monitor.c b/src/libraries/raylib/raylib/src/external/glfw/src/null_monitor.c
index a9b528f..d818f45 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/null_monitor.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/null_monitor.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2016 Google Inc.
 // Copyright (c) 2016-2019 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/null_platform.h b/src/libraries/raylib/raylib/src/external/glfw/src/null_platform.h
index dbcb835..4843a76 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/null_platform.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/null_platform.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2016 Google Inc.
 // Copyright (c) 2016-2017 Camilla Löwy <elmindreda@glfw.org>
@@ -156,17 +156,6 @@
 #define GLFW_NULL_SC_MENU           120
 #define GLFW_NULL_SC_LAST           GLFW_NULL_SC_MENU
 
-typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;
-
-typedef struct VkHeadlessSurfaceCreateInfoEXT
-{
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkHeadlessSurfaceCreateFlagsEXT flags;
-} VkHeadlessSurfaceCreateInfoEXT;
-
-typedef VkResult (APIENTRY *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance,const VkHeadlessSurfaceCreateInfoEXT*,const VkAllocationCallbacks*,VkSurfaceKHR*);
-
 // Null-specific per-window data
 //
 typedef struct _GLFWwindowNull
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/null_window.c b/src/libraries/raylib/raylib/src/external/glfw/src/null_window.c
index f0e1dcc..cd23ae0 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/null_window.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/null_window.c
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2016 Google Inc.
 // Copyright (c) 2016-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -28,7 +29,6 @@
 #include "internal.h"
 
 #include <stdlib.h>
-#include <string.h>
 
 static void applySizeLimits(_GLFWwindow* window, int* width, int* height)
 {
@@ -60,12 +60,12 @@ static void fitToMonitor(_GLFWwindow* window)
     window->null.height = mode.height;
 }
 
-static void acquireMonitor(_GLFWwindow* window)
+static void acquireMonitorNull(_GLFWwindow* window)
 {
     _glfwInputMonitorWindow(window->monitor, window);
 }
 
-static void releaseMonitor(_GLFWwindow* window)
+static void releaseMonitorNull(_GLFWwindow* window)
 {
     if (window->monitor->window != window)
         return;
@@ -148,7 +148,7 @@ GLFWbool _glfwCreateWindowNull(_GLFWwindow* window,
     {
         _glfwShowWindowNull(window);
         _glfwFocusWindowNull(window);
-        acquireMonitor(window);
+        acquireMonitorNull(window);
 
         if (wndconfig->centerCursor)
             _glfwCenterCursorInContentArea(window);
@@ -169,7 +169,7 @@ GLFWbool _glfwCreateWindowNull(_GLFWwindow* window,
 void _glfwDestroyWindowNull(_GLFWwindow* window)
 {
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorNull(window);
 
     if (_glfw.null.focusedWindow == window)
         _glfw.null.focusedWindow = NULL;
@@ -204,14 +204,14 @@ void _glfwSetWindowMonitorNull(_GLFWwindow* window,
     }
 
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorNull(window);
 
     _glfwInputWindowMonitor(window, monitor);
 
     if (window->monitor)
     {
         window->null.visible = GLFW_TRUE;
-        acquireMonitor(window);
+        acquireMonitorNull(window);
         fitToMonitor(window);
     }
     else
@@ -341,7 +341,7 @@ void _glfwIconifyWindowNull(_GLFWwindow* window)
         _glfwInputWindowIconify(window, GLFW_TRUE);
 
         if (window->monitor)
-            releaseMonitor(window);
+            releaseMonitorNull(window);
     }
 }
 
@@ -353,7 +353,7 @@ void _glfwRestoreWindowNull(_GLFWwindow* window)
         _glfwInputWindowIconify(window, GLFW_FALSE);
 
         if (window->monitor)
-            acquireMonitor(window);
+            acquireMonitorNull(window);
     }
     else if (window->null.maximized)
     {
@@ -553,15 +553,12 @@ const char* _glfwGetClipboardStringNull(void)
 
 EGLenum _glfwGetEGLPlatformNull(EGLint** attribs)
 {
-    if (_glfw.egl.EXT_platform_base && _glfw.egl.MESA_platform_surfaceless)
-        return EGL_PLATFORM_SURFACELESS_MESA;
-    else
-        return 0;
+    return 0;
 }
 
 EGLNativeDisplayType _glfwGetEGLNativeDisplayNull(void)
 {
-    return EGL_DEFAULT_DISPLAY;
+    return 0;
 }
 
 EGLNativeWindowType _glfwGetEGLNativeWindowNull(_GLFWwindow* window)
@@ -703,18 +700,13 @@ int _glfwGetKeyScancodeNull(int key)
 
 void _glfwGetRequiredInstanceExtensionsNull(char** extensions)
 {
-    if (!_glfw.vk.KHR_surface || !_glfw.vk.EXT_headless_surface)
-        return;
-
-    extensions[0] = "VK_KHR_surface";
-    extensions[1] = "VK_EXT_headless_surface";
 }
 
 GLFWbool _glfwGetPhysicalDevicePresentationSupportNull(VkInstance instance,
                                                        VkPhysicalDevice device,
                                                        uint32_t queuefamily)
 {
-    return GLFW_TRUE;
+    return GLFW_FALSE;
 }
 
 VkResult _glfwCreateWindowSurfaceNull(VkInstance instance,
@@ -722,28 +714,7 @@ VkResult _glfwCreateWindowSurfaceNull(VkInstance instance,
                                       const VkAllocationCallbacks* allocator,
                                       VkSurfaceKHR* surface)
 {
-    PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT =
-        (PFN_vkCreateHeadlessSurfaceEXT)
-        vkGetInstanceProcAddr(instance, "vkCreateHeadlessSurfaceEXT");
-    if (!vkCreateHeadlessSurfaceEXT)
-    {
-        _glfwInputError(GLFW_API_UNAVAILABLE,
-                        "Null: Vulkan instance missing VK_EXT_headless_surface extension");
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    }
-
-    VkHeadlessSurfaceCreateInfoEXT sci;
-    memset(&sci, 0, sizeof(sci));
-    sci.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
-
-    const VkResult err = vkCreateHeadlessSurfaceEXT(instance, &sci, allocator, surface);
-    if (err)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Null: Failed to create Vulkan surface: %s",
-                        _glfwGetVulkanResultString(err));
-    }
-
-    return err;
+    // This seems like the most appropriate error to return here
+    return VK_ERROR_EXTENSION_NOT_PRESENT;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/osmesa_context.c b/src/libraries/raylib/raylib/src/external/glfw/src/osmesa_context.c
index c7a4c86..2f12adf 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/osmesa_context.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/osmesa_context.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 OSMesa - www.glfw.org
+// GLFW 3.4 OSMesa - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2016 Google Inc.
 // Copyright (c) 2016-2017 Camilla Löwy <elmindreda@glfw.org>
@@ -180,8 +180,11 @@ GLFWbool _glfwInitOSMesa(void)
 
 void _glfwTerminateOSMesa(void)
 {
-    _glfwPlatformFreeModule(_glfw.osmesa.handle);
-    _glfw.osmesa.handle = NULL;
+    if (_glfw.osmesa.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.osmesa.handle);
+        _glfw.osmesa.handle = NULL;
+    }
 }
 
 #define SET_ATTRIB(a, v) \
@@ -293,12 +296,11 @@ GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
 {
     void* mesaBuffer;
     GLint mesaWidth, mesaHeight, mesaFormat;
-
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
     if (window->context.source != GLFW_OSMESA_CONTEXT_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
@@ -333,12 +335,11 @@ GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
 {
     void* mesaBuffer;
     GLint mesaWidth, mesaHeight, mesaBytes;
-
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
     if (window->context.source != GLFW_OSMESA_CONTEXT_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
@@ -368,10 +369,8 @@ GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
 
 GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (window->context.source != GLFW_OSMESA_CONTEXT_API)
     {
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/platform.c b/src/libraries/raylib/raylib/src/external/glfw/src/platform.c
index 95b8d0b..c4b0a36 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/platform.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/platform.c
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -74,15 +75,6 @@ GLFWbool _glfwSelectPlatform(int desiredID, _GLFWplatform* platform)
         return GLFW_FALSE;
     }
 
-    // Only allow the Null platform if specifically requested
-    if (desiredID == GLFW_PLATFORM_NULL)
-        return _glfwConnectNull(desiredID, platform);
-    else if (count == 0)
-    {
-        _glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "This binary only supports the Null platform");
-        return GLFW_FALSE;
-    }
-
 #if defined(_GLFW_WAYLAND) && defined(_GLFW_X11)
     if (desiredID == GLFW_ANY_PLATFORM)
     {
@@ -187,6 +179,8 @@ GLFWAPI const char* glfwGetVersionString(void)
         " OSMesa"
 #if defined(__MINGW64_VERSION_MAJOR)
         " MinGW-w64"
+#elif defined(__MINGW32__)
+        " MinGW"
 #elif defined(_MSC_VER)
         " VisualC"
 #endif
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/platform.h b/src/libraries/raylib/raylib/src/external/glfw/src/platform.h
index 398f463..75652dc 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/platform.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/platform.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
@@ -28,7 +28,7 @@
 #if defined(GLFW_BUILD_WIN32_TIMER) || \
     defined(GLFW_BUILD_WIN32_MODULE) || \
     defined(GLFW_BUILD_WIN32_THREAD) || \
-    defined(GLFW_BUILD_MACOS_TIMER) || \
+    defined(GLFW_BUILD_COCOA_TIMER) || \
     defined(GLFW_BUILD_POSIX_TIMER) || \
     defined(GLFW_BUILD_POSIX_MODULE) || \
     defined(GLFW_BUILD_POSIX_THREAD) || \
@@ -184,7 +184,7 @@
 #if defined(_WIN32)
  #define GLFW_BUILD_WIN32_TIMER
 #elif defined(__APPLE__)
- #define GLFW_BUILD_MACOS_TIMER
+ #define GLFW_BUILD_COCOA_TIMER
 #else
  #define GLFW_BUILD_POSIX_TIMER
 #endif
@@ -192,9 +192,9 @@
 #if defined(GLFW_BUILD_WIN32_TIMER)
  #include "win32_time.h"
  #define GLFW_PLATFORM_LIBRARY_TIMER_STATE  GLFW_WIN32_LIBRARY_TIMER_STATE
-#elif defined(GLFW_BUILD_MACOS_TIMER)
- #include "macos_time.h"
- #define GLFW_PLATFORM_LIBRARY_TIMER_STATE  GLFW_MACOS_LIBRARY_TIMER_STATE
+#elif defined(GLFW_BUILD_COCOA_TIMER)
+ #include "cocoa_time.h"
+ #define GLFW_PLATFORM_LIBRARY_TIMER_STATE  GLFW_COCOA_LIBRARY_TIMER_STATE
 #elif defined(GLFW_BUILD_POSIX_TIMER)
  #include "posix_time.h"
  #define GLFW_PLATFORM_LIBRARY_TIMER_STATE  GLFW_POSIX_LIBRARY_TIMER_STATE
@@ -207,7 +207,6 @@
 #endif
 
 #if defined(_GLFW_WAYLAND) || defined(_GLFW_X11)
- #include "posix_poll.h"
  #define GLFW_BUILD_POSIX_POLL
 #endif
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_module.c b/src/libraries/raylib/raylib/src/external/glfw/src/posix_module.c
index de99bc6..7d81c67 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_module.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_module.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2021 Camilla Löwy <elmindreda@glfw.org>
 //
@@ -41,8 +41,7 @@ void* _glfwPlatformLoadModule(const char* path)
 
 void _glfwPlatformFreeModule(void* module)
 {
-    if (module)
-        dlclose(module);
+    dlclose(module);
 }
 
 GLFWproc _glfwPlatformGetModuleSymbol(void* module, const char* name)
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.c b/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.c
index 595cf71..b53e36e 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2022 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.h b/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.h
index a0ef396..4bdd244 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_poll.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2022 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.c b/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.c
index bab74d4..3c355a5 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.h b/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.h
index ce298a8..5a5d7b7 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_thread.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.c b/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.c
index 4d7bd7c..a172408 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.h b/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.h
index 39faa0f..94374ad 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/posix_time.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 POSIX - www.glfw.org
+// GLFW 3.4 POSIX - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/vulkan.c b/src/libraries/raylib/raylib/src/external/glfw/src/vulkan.c
index b93a14a..d9fabde 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/vulkan.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/vulkan.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2018 Camilla Löwy <elmindreda@glfw.org>
@@ -34,40 +34,6 @@
 #define _GLFW_FIND_LOADER    1
 #define _GLFW_REQUIRE_LOADER 2
 
-#if defined(__APPLE__)
-
-#include <CoreFoundation/CoreFoundation.h>
-
-static void* loadLocalVulkanLoaderMacOS(void)
-{
-    CFBundleRef bundle = CFBundleGetMainBundle();
-    if (!bundle)
-        return NULL;
-
-    CFURLRef frameworksUrl = CFBundleCopyPrivateFrameworksURL(bundle);
-    if (!frameworksUrl)
-        return NULL;
-
-    CFURLRef loaderUrl = CFURLCreateCopyAppendingPathComponent(
-        kCFAllocatorDefault, frameworksUrl, CFSTR("libvulkan.1.dylib"), false);
-    if (!loaderUrl)
-    {
-        CFRelease(frameworksUrl);
-        return NULL;
-    }
-
-    char path[PATH_MAX];
-    void* handle = NULL;
-
-    if (CFURLGetFileSystemRepresentation(loaderUrl, true, (UInt8*) path, sizeof(path) - 1))
-        handle = _glfwPlatformLoadModule(path);
-
-    CFRelease(loaderUrl);
-    CFRelease(frameworksUrl);
-    return handle;
-}
-
-#endif // __APPLE__
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW internal API                      //////
@@ -89,12 +55,12 @@ GLFWbool _glfwInitVulkan(int mode)
     {
 #if defined(_GLFW_VULKAN_LIBRARY)
         _glfw.vk.handle = _glfwPlatformLoadModule(_GLFW_VULKAN_LIBRARY);
-#elif defined(_WIN32)
+#elif defined(_GLFW_WIN32)
         _glfw.vk.handle = _glfwPlatformLoadModule("vulkan-1.dll");
-#elif defined(__APPLE__)
+#elif defined(_GLFW_COCOA)
         _glfw.vk.handle = _glfwPlatformLoadModule("libvulkan.1.dylib");
         if (!_glfw.vk.handle)
-            _glfw.vk.handle = loadLocalVulkanLoaderMacOS();
+            _glfw.vk.handle = _glfwLoadLocalVulkanLoaderCocoa();
 #elif defined(__OpenBSD__) || defined(__NetBSD__)
         _glfw.vk.handle = _glfwPlatformLoadModule("libvulkan.so");
 #else
@@ -163,21 +129,19 @@ GLFWbool _glfwInitVulkan(int mode)
     for (i = 0;  i < count;  i++)
     {
         if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
-            _glfw.vk.KHR_surface = true;
+            _glfw.vk.KHR_surface = GLFW_TRUE;
         else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
-            _glfw.vk.KHR_win32_surface = true;
+            _glfw.vk.KHR_win32_surface = GLFW_TRUE;
         else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
-            _glfw.vk.MVK_macos_surface = true;
+            _glfw.vk.MVK_macos_surface = GLFW_TRUE;
         else if (strcmp(ep[i].extensionName, "VK_EXT_metal_surface") == 0)
-            _glfw.vk.EXT_metal_surface = true;
+            _glfw.vk.EXT_metal_surface = GLFW_TRUE;
         else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
-            _glfw.vk.KHR_xlib_surface = true;
+            _glfw.vk.KHR_xlib_surface = GLFW_TRUE;
         else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
-            _glfw.vk.KHR_xcb_surface = true;
+            _glfw.vk.KHR_xcb_surface = GLFW_TRUE;
         else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
-            _glfw.vk.KHR_wayland_surface = true;
-        else if (strcmp(ep[i].extensionName, "VK_EXT_headless_surface") == 0)
-            _glfw.vk.EXT_headless_surface = true;
+            _glfw.vk.KHR_wayland_surface = GLFW_TRUE;
     }
 
     _glfw_free(ep);
@@ -191,8 +155,8 @@ GLFWbool _glfwInitVulkan(int mode)
 
 void _glfwTerminateVulkan(void)
 {
-    _glfwPlatformFreeModule(_glfw.vk.handle);
-    _glfw.vk.handle = NULL;
+    if (_glfw.vk.handle)
+        _glfwPlatformFreeModule(_glfw.vk.handle);
 }
 
 const char* _glfwGetVulkanResultString(VkResult result)
@@ -308,11 +272,11 @@ GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
                                                      VkPhysicalDevice device,
                                                      uint32_t queuefamily)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
-
     assert(instance != VK_NULL_HANDLE);
     assert(device != VK_NULL_HANDLE);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
+
     if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
         return GLFW_FALSE;
 
@@ -333,16 +297,15 @@ GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
                                          const VkAllocationCallbacks* allocator,
                                          VkSurfaceKHR* surface)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(instance != VK_NULL_HANDLE);
+    assert(window != NULL);
     assert(surface != NULL);
 
     *surface = VK_NULL_HANDLE;
 
     _GLFW_REQUIRE_INIT_OR_RETURN(VK_ERROR_INITIALIZATION_FAILED);
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-    assert(instance != VK_NULL_HANDLE);
-
     if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
         return VK_ERROR_INITIALIZATION_FAILED;
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/wgl_context.c b/src/libraries/raylib/raylib/src/external/glfw/src/wgl_context.c
index dac695e..8a23ffc 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/wgl_context.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/wgl_context.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 WGL - www.glfw.org
+// GLFW 3.4 WGL - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -186,22 +186,28 @@ static int choosePixelFormatWGL(_GLFWwindow* window,
             u->accumAlphaBits = FIND_ATTRIB_VALUE(WGL_ACCUM_ALPHA_BITS_ARB);
 
             u->auxBuffers = FIND_ATTRIB_VALUE(WGL_AUX_BUFFERS_ARB);
-            u->stereo = FIND_ATTRIB_VALUE(WGL_STEREO_ARB);
+
+            if (FIND_ATTRIB_VALUE(WGL_STEREO_ARB))
+                u->stereo = GLFW_TRUE;
 
             if (_glfw.wgl.ARB_multisample)
                 u->samples = FIND_ATTRIB_VALUE(WGL_SAMPLES_ARB);
 
             if (ctxconfig->client == GLFW_OPENGL_API)
             {
-                if (_glfw.wgl.ARB_framebuffer_sRGB || _glfw.wgl.EXT_framebuffer_sRGB)
-                    u->sRGB = FIND_ATTRIB_VALUE(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
+                if (_glfw.wgl.ARB_framebuffer_sRGB ||
+                    _glfw.wgl.EXT_framebuffer_sRGB)
+                {
+                    if (FIND_ATTRIB_VALUE(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB))
+                        u->sRGB = GLFW_TRUE;
+                }
             }
             else
             {
                 if (_glfw.wgl.EXT_colorspace)
                 {
                     if (FIND_ATTRIB_VALUE(WGL_COLORSPACE_EXT) == WGL_COLORSPACE_SRGB_EXT)
-                        u->sRGB = true;
+                        u->sRGB = GLFW_TRUE;
                 }
             }
         }
@@ -255,7 +261,9 @@ static int choosePixelFormatWGL(_GLFWwindow* window,
             u->accumAlphaBits = pfd.cAccumAlphaBits;
 
             u->auxBuffers = pfd.cAuxBuffers;
-            u->stereo = (pfd.dwFlags & PFD_STEREO);
+
+            if (pfd.dwFlags & PFD_STEREO)
+                u->stereo = GLFW_TRUE;
         }
 
         u->handle = pixelFormat;
@@ -319,8 +327,8 @@ static void swapBuffersWGL(_GLFWwindow* window)
 {
     if (!window->monitor)
     {
-        // HACK: Use DwmFlush when desktop composition is enabled on Windows 7
-        if (!IsWindows8OrGreater())
+        // HACK: Use DwmFlush when desktop composition is enabled on Windows Vista and 7
+        if (!IsWindows8OrGreater() && IsWindowsVistaOrGreater())
         {
             BOOL enabled = FALSE;
 
@@ -345,9 +353,9 @@ static void swapIntervalWGL(int interval)
 
     if (!window->monitor)
     {
-        // HACK: Disable WGL swap interval when desktop composition is enabled on
-        //       Windows 7 to avoid interfering with DWM vsync
-        if (!IsWindows8OrGreater())
+        // HACK: Disable WGL swap interval when desktop composition is enabled on Windows
+        //       Vista and 7 to avoid interfering with DWM vsync
+        if (!IsWindows8OrGreater() && IsWindowsVistaOrGreater())
         {
             BOOL enabled = FALSE;
 
@@ -393,6 +401,8 @@ static void destroyContextWGL(_GLFWwindow* window)
     }
 }
 
+// Initialize WGL
+//
 GLFWbool _glfwInitWGL(void)
 {
     PIXELFORMATDESCRIPTOR pfd;
@@ -511,10 +521,12 @@ GLFWbool _glfwInitWGL(void)
     return GLFW_TRUE;
 }
 
+// Terminate WGL
+//
 void _glfwTerminateWGL(void)
 {
-    _glfwPlatformFreeModule(_glfw.wgl.instance);
-    _glfw.wgl.instance = NULL;
+    if (_glfw.wgl.instance)
+        _glfwPlatformFreeModule(_glfw.wgl.instance);
 }
 
 #define SET_ATTRIB(a, v) \
@@ -524,6 +536,8 @@ void _glfwTerminateWGL(void)
     attribs[index++] = v; \
 }
 
+// Create the OpenGL or OpenGL ES context
+//
 GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
                                const _GLFWctxconfig* ctxconfig,
                                const _GLFWfbconfig* fbconfig)
@@ -656,7 +670,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
         if (ctxconfig->noerror)
         {
             if (_glfw.wgl.ARB_create_context_no_error)
-                SET_ATTRIB(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, true);
+                SET_ATTRIB(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
         }
 
         // NOTE: Only request an explicitly versioned context when necessary, as
@@ -761,6 +775,7 @@ GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
 
 GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_WIN32)
@@ -770,9 +785,6 @@ GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
         return NULL;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (window->context.source != GLFW_NATIVE_CONTEXT_API)
     {
         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_init.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_init.c
index d526fe8..d86e35e 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_init.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_init.c
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -89,6 +90,10 @@ static GLFWbool loadLibraries(void)
         return GLFW_FALSE;
     }
 
+    _glfw.win32.user32.SetProcessDPIAware_ = (PFN_SetProcessDPIAware)
+        _glfwPlatformGetModuleSymbol(_glfw.win32.user32.instance, "SetProcessDPIAware");
+    _glfw.win32.user32.ChangeWindowMessageFilterEx_ = (PFN_ChangeWindowMessageFilterEx)
+        _glfwPlatformGetModuleSymbol(_glfw.win32.user32.instance, "ChangeWindowMessageFilterEx");
     _glfw.win32.user32.EnableNonClientDpiScaling_ = (PFN_EnableNonClientDpiScaling)
         _glfwPlatformGetModuleSymbol(_glfw.win32.user32.instance, "EnableNonClientDpiScaling");
     _glfw.win32.user32.SetProcessDpiAwarenessContext_ = (PFN_SetProcessDpiAwarenessContext)
@@ -166,9 +171,32 @@ static GLFWbool loadLibraries(void)
     return GLFW_TRUE;
 }
 
+// Unload used libraries (DLLs)
+//
+static void freeLibraries(void)
+{
+    if (_glfw.win32.xinput.instance)
+        _glfwPlatformFreeModule(_glfw.win32.xinput.instance);
+
+    if (_glfw.win32.dinput8.instance)
+        _glfwPlatformFreeModule(_glfw.win32.dinput8.instance);
+
+    if (_glfw.win32.user32.instance)
+        _glfwPlatformFreeModule(_glfw.win32.user32.instance);
+
+    if (_glfw.win32.dwmapi.instance)
+        _glfwPlatformFreeModule(_glfw.win32.dwmapi.instance);
+
+    if (_glfw.win32.shcore.instance)
+        _glfwPlatformFreeModule(_glfw.win32.shcore.instance);
+
+    if (_glfw.win32.ntdll.instance)
+        _glfwPlatformFreeModule(_glfw.win32.ntdll.instance);
+}
+
 // Create key code translation tables
 //
-static void createKeyTables(void)
+static void createKeyTablesWin32(void)
 {
     int scancode;
 
@@ -505,8 +533,7 @@ void _glfwUpdateKeyNamesWin32(void)
 
         if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_ADD)
         {
-            const UINT vks[] =
-            {
+            const UINT vks[] = {
                 VK_NUMPAD0,  VK_NUMPAD1,  VK_NUMPAD2, VK_NUMPAD3,
                 VK_NUMPAD4,  VK_NUMPAD5,  VK_NUMPAD6, VK_NUMPAD7,
                 VK_NUMPAD8,  VK_NUMPAD9,  VK_DECIMAL, VK_DIVIDE,
@@ -659,14 +686,14 @@ int _glfwInitWin32(void)
     if (!loadLibraries())
         return GLFW_FALSE;
 
-    createKeyTables();
+    createKeyTablesWin32();
     _glfwUpdateKeyNamesWin32();
 
     if (_glfwIsWindows10Version1703OrGreaterWin32())
         SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
     else if (IsWindows8Point1OrGreater())
         SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);
-    else
+    else if (IsWindowsVistaOrGreater())
         SetProcessDPIAware();
 
     if (!createHelperWindow())
@@ -698,14 +725,7 @@ void _glfwTerminateWin32(void)
     _glfwTerminateEGL();
     _glfwTerminateOSMesa();
 
-    _glfwPlatformFreeModule(_glfw.win32.xinput.instance);
-    _glfwPlatformFreeModule(_glfw.win32.dinput8.instance);
-    _glfwPlatformFreeModule(_glfw.win32.user32.instance);
-    _glfwPlatformFreeModule(_glfw.win32.dwmapi.instance);
-    _glfwPlatformFreeModule(_glfw.win32.shcore.instance);
-    _glfwPlatformFreeModule(_glfw.win32.ntdll.instance);
-
-    memset(&_glfw.win32, 0, sizeof(_glfw.win32));
+    freeLibraries();
 }
 
 #endif // _GLFW_WIN32
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.c
index 6703485..59389a9 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.h b/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.h
index 2d8f59d..9ab6438 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_joystick.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
 //
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_module.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_module.c
index ca5ce9c..47c8dff 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_module.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_module.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2021 Camilla Löwy <elmindreda@glfw.org>
 //
@@ -39,8 +39,7 @@ void* _glfwPlatformLoadModule(const char* path)
 
 void _glfwPlatformFreeModule(void* module)
 {
-    if (module)
-        FreeLibrary((HMODULE) module);
+    FreeLibrary((HMODULE) module);
 }
 
 GLFWproc _glfwPlatformGetModuleSymbol(void* module, const char* name)
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_monitor.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_monitor.c
index 87e5c20..87c85b9 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_monitor.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_monitor.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -33,7 +33,6 @@
 #include <string.h>
 #include <limits.h>
 #include <wchar.h>
-#include <assert.h>
 
 
 // Callback for EnumDisplayMonitors in createMonitor
@@ -540,6 +539,7 @@ void _glfwSetGammaRampWin32(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 
 GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* handle)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_WIN32)
@@ -548,14 +548,12 @@ GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* handle)
         return NULL;
     }
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     return monitor->win32.publicAdapterName;
 }
 
 GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* handle)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_WIN32)
@@ -564,9 +562,6 @@ GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* handle)
         return NULL;
     }
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     return monitor->win32.publicDisplayName;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_platform.h b/src/libraries/raylib/raylib/src/external/glfw/src/win32_platform.h
index 5e9a660..7e3d884 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_platform.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_platform.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -48,14 +48,14 @@
  #define UNICODE
 #endif
 
-// GLFW requires Windows 7 or later
-#if WINVER < 0x0601
+// GLFW requires Windows XP or later
+#if WINVER < 0x0501
  #undef WINVER
- #define WINVER 0x0601
+ #define WINVER 0x0501
 #endif
-#if _WIN32_WINNT < 0x0601
+#if _WIN32_WINNT < 0x0501
  #undef _WIN32_WINNT
- #define _WIN32_WINNT 0x0601
+ #define _WIN32_WINNT 0x0501
 #endif
 
 // GLFW uses DirectInput8 interfaces
@@ -66,21 +66,41 @@
 
 #include <wctype.h>
 #include <windows.h>
-#include <dwmapi.h>
 #include <dinput.h>
 #include <xinput.h>
 #include <dbt.h>
 
 // HACK: Define macros that some windows.h variants don't
+#ifndef WM_MOUSEHWHEEL
+ #define WM_MOUSEHWHEEL 0x020E
+#endif
+#ifndef WM_DWMCOMPOSITIONCHANGED
+ #define WM_DWMCOMPOSITIONCHANGED 0x031E
+#endif
+#ifndef WM_DWMCOLORIZATIONCOLORCHANGED
+ #define WM_DWMCOLORIZATIONCOLORCHANGED 0x0320
+#endif
 #ifndef WM_COPYGLOBALDATA
  #define WM_COPYGLOBALDATA 0x0049
 #endif
+#ifndef WM_UNICHAR
+ #define WM_UNICHAR 0x0109
+#endif
+#ifndef UNICODE_NOCHAR
+ #define UNICODE_NOCHAR 0xFFFF
+#endif
 #ifndef WM_DPICHANGED
  #define WM_DPICHANGED 0x02E0
 #endif
+#ifndef GET_XBUTTON_WPARAM
+ #define GET_XBUTTON_WPARAM(w) (HIWORD(w))
+#endif
 #ifndef EDS_ROTATEDMODE
  #define EDS_ROTATEDMODE 0x00000004
 #endif
+#ifndef DISPLAY_DEVICE_ACTIVE
+ #define DISPLAY_DEVICE_ACTIVE 0x00000001
+#endif
 #ifndef _WIN32_WINNT_WINBLUE
  #define _WIN32_WINNT_WINBLUE 0x0603
 #endif
@@ -93,6 +113,34 @@
 #ifndef USER_DEFAULT_SCREEN_DPI
  #define USER_DEFAULT_SCREEN_DPI 96
 #endif
+#ifndef OCR_HAND
+ #define OCR_HAND 32649
+#endif
+
+#if WINVER < 0x0601
+typedef struct
+{
+    DWORD cbSize;
+    DWORD ExtStatus;
+} CHANGEFILTERSTRUCT;
+#ifndef MSGFLT_ALLOW
+ #define MSGFLT_ALLOW 1
+#endif
+#endif /*Windows 7*/
+
+#if WINVER < 0x0600
+#define DWM_BB_ENABLE 0x00000001
+#define DWM_BB_BLURREGION 0x00000002
+typedef struct
+{
+    DWORD dwFlags;
+    BOOL fEnable;
+    HRGN hRgnBlur;
+    BOOL fTransitionOnMaximized;
+} DWM_BLURBEHIND;
+#else
+ #include <dwmapi.h>
+#endif /*Windows Vista*/
 
 #ifndef DPI_ENUMS_DECLARED
 typedef enum
@@ -117,6 +165,12 @@ typedef enum
 // Replacement for versionhelpers.h macros, as we cannot rely on the
 // application having a correct embedded manifest
 //
+#define IsWindowsVistaOrGreater()                                     \
+    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_VISTA),   \
+                                        LOBYTE(_WIN32_WINNT_VISTA), 0)
+#define IsWindows7OrGreater()                                         \
+    _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WIN7),    \
+                                        LOBYTE(_WIN32_WINNT_WIN7), 0)
 #define IsWindows8OrGreater()                                         \
     _glfwIsWindowsVersionOrGreaterWin32(HIBYTE(_WIN32_WINNT_WIN8),    \
                                         LOBYTE(_WIN32_WINNT_WIN8), 0)
@@ -227,11 +281,15 @@ typedef HRESULT (WINAPI * PFN_DirectInput8Create)(HINSTANCE,DWORD,REFIID,LPVOID*
 #define DirectInput8Create _glfw.win32.dinput8.Create
 
 // user32.dll function pointer typedefs
+typedef BOOL (WINAPI * PFN_SetProcessDPIAware)(void);
+typedef BOOL (WINAPI * PFN_ChangeWindowMessageFilterEx)(HWND,UINT,DWORD,CHANGEFILTERSTRUCT*);
 typedef BOOL (WINAPI * PFN_EnableNonClientDpiScaling)(HWND);
 typedef BOOL (WINAPI * PFN_SetProcessDpiAwarenessContext)(HANDLE);
 typedef UINT (WINAPI * PFN_GetDpiForWindow)(HWND);
 typedef BOOL (WINAPI * PFN_AdjustWindowRectExForDpi)(LPRECT,DWORD,BOOL,DWORD,UINT);
 typedef int (WINAPI * PFN_GetSystemMetricsForDpi)(int,UINT);
+#define SetProcessDPIAware _glfw.win32.user32.SetProcessDPIAware_
+#define ChangeWindowMessageFilterEx _glfw.win32.user32.ChangeWindowMessageFilterEx_
 #define EnableNonClientDpiScaling _glfw.win32.user32.EnableNonClientDpiScaling_
 #define SetProcessDpiAwarenessContext _glfw.win32.user32.SetProcessDpiAwarenessContext_
 #define GetDpiForWindow _glfw.win32.user32.GetDpiForWindow_
@@ -336,18 +394,18 @@ typedef struct _GLFWlibraryWGL
     PFNWGLGETEXTENSIONSSTRINGEXTPROC    GetExtensionsStringEXT;
     PFNWGLGETEXTENSIONSSTRINGARBPROC    GetExtensionsStringARB;
     PFNWGLCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    bool                                EXT_swap_control;
-    bool                                EXT_colorspace;
-    bool                                ARB_multisample;
-    bool                                ARB_framebuffer_sRGB;
-    bool                                EXT_framebuffer_sRGB;
-    bool                                ARB_pixel_format;
-    bool                                ARB_create_context;
-    bool                                ARB_create_context_profile;
-    bool                                EXT_create_context_es2_profile;
-    bool                                ARB_create_context_robustness;
-    bool                                ARB_create_context_no_error;
-    bool                                ARB_context_flush_control;
+    GLFWbool                            EXT_swap_control;
+    GLFWbool                            EXT_colorspace;
+    GLFWbool                            ARB_multisample;
+    GLFWbool                            ARB_framebuffer_sRGB;
+    GLFWbool                            EXT_framebuffer_sRGB;
+    GLFWbool                            ARB_pixel_format;
+    GLFWbool                            ARB_create_context;
+    GLFWbool                            ARB_create_context_profile;
+    GLFWbool                            EXT_create_context_es2_profile;
+    GLFWbool                            ARB_create_context_robustness;
+    GLFWbool                            ARB_create_context_no_error;
+    GLFWbool                            ARB_context_flush_control;
 } _GLFWlibraryWGL;
 
 // Win32-specific per-window data
@@ -417,6 +475,8 @@ typedef struct _GLFWlibraryWin32
 
     struct {
         HINSTANCE                       instance;
+        PFN_SetProcessDPIAware          SetProcessDPIAware_;
+        PFN_ChangeWindowMessageFilterEx ChangeWindowMessageFilterEx_;
         PFN_EnableNonClientDpiScaling   EnableNonClientDpiScaling_;
         PFN_SetProcessDpiAwarenessContext SetProcessDpiAwarenessContext_;
         PFN_GetDpiForWindow             GetDpiForWindow_;
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.c
index 6e418d7..212e666 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.h b/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.h
index ca96fae..dd5948f 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_thread.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.c
index 4a4b2cb..a38e15d 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.h b/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.h
index f72a5d0..ef57a5a 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_time.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/win32_window.c b/src/libraries/raylib/raylib/src/external/glfw/src/win32_window.c
index 8f83a9a..3762b76 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/win32_window.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/win32_window.c
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 Win32 - www.glfw.org
+// GLFW 3.4 Win32 (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -32,7 +33,6 @@
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 #include <windowsx.h>
 #include <shellapi.h>
 
@@ -374,6 +374,9 @@ static void updateFramebufferTransparency(const _GLFWwindow* window)
     BOOL composition, opaque;
     DWORD color;
 
+    if (!IsWindowsVistaOrGreater())
+        return;
+
     if (FAILED(DwmIsCompositionEnabled(&composition)) || !composition)
        return;
 
@@ -437,7 +440,7 @@ static void fitToMonitor(_GLFWwindow* window)
 
 // Make the specified window and its video mode active on its monitor
 //
-static void acquireMonitor(_GLFWwindow* window)
+static void acquireMonitorWin32(_GLFWwindow* window)
 {
     if (!_glfw.win32.acquiredMonitorCount)
     {
@@ -458,7 +461,7 @@ static void acquireMonitor(_GLFWwindow* window)
 
 // Remove the window and restore the original video mode
 //
-static void releaseMonitor(_GLFWwindow* window)
+static void releaseMonitorWin32(_GLFWwindow* window)
 {
     if (window->monitor->window != window)
         return;
@@ -468,7 +471,7 @@ static void releaseMonitor(_GLFWwindow* window)
     {
         SetThreadExecutionState(ES_CONTINUOUS);
 
-        // HACK: Restore mouse trail length saved in acquireMonitor
+        // HACK: Restore mouse trail length saved in acquireMonitorWin32
         SystemParametersInfoW(SPI_SETMOUSETRAILS, _glfw.win32.mouseTrailSize, 0, 0);
     }
 
@@ -711,12 +714,11 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM l
             const int mods = getKeyMods();
 
             scancode = (HIWORD(lParam) & (KF_EXTENDED | 0xff));
-            if (!(scancode & 0xff))
+            if (!scancode)
             {
-                // NOTE: Both media keys and the synthetic key messages from Windows
-                //       Clipboard History are reported with a scancode of zero
-                // HACK: Map the virtual key to a scancode but preserve extended bit
-                scancode |= MapVirtualKeyW((UINT) wParam, MAPVK_VK_TO_VSC);
+                // NOTE: Some synthetic key messages have a scancode of zero
+                // HACK: Map the virtual key back to a usable scancode
+                scancode = MapVirtualKeyW((UINT) wParam, MAPVK_VK_TO_VSC);
             }
 
             // HACK: Alt+PrtSc has a different scancode than just PrtSc
@@ -981,6 +983,7 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM l
 
         case WM_MOUSEHWHEEL:
         {
+            // This message is only sent on Windows Vista and later
             // NOTE: The X-axis is inverted for consistency with macOS and X11
             _glfwInputScroll(window, -((SHORT) HIWORD(wParam) / (double) WHEEL_DELTA), 0.0);
             return 0;
@@ -1048,10 +1051,10 @@ static LRESULT CALLBACK windowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM l
             if (window->monitor && window->win32.iconified != iconified)
             {
                 if (iconified)
-                    releaseMonitor(window);
+                    releaseMonitorWin32(window);
                 else
                 {
-                    acquireMonitor(window);
+                    acquireMonitorWin32(window);
                     fitToMonitor(window);
                 }
             }
@@ -1378,7 +1381,7 @@ static int createNativeWindow(_GLFWwindow* window,
         frameHeight = rect.bottom - rect.top;
     }
 
-    wideTitle = _glfwCreateWideStringFromUTF8Win32(window->title);
+    wideTitle = _glfwCreateWideStringFromUTF8Win32(wndconfig->title);
     if (!wideTitle)
         return GLFW_FALSE;
 
@@ -1404,9 +1407,15 @@ static int createNativeWindow(_GLFWwindow* window,
 
     SetPropW(window->win32.handle, L"GLFW", window);
 
-    ChangeWindowMessageFilterEx(window->win32.handle, WM_DROPFILES, MSGFLT_ALLOW, NULL);
-    ChangeWindowMessageFilterEx(window->win32.handle, WM_COPYDATA, MSGFLT_ALLOW, NULL);
-    ChangeWindowMessageFilterEx(window->win32.handle, WM_COPYGLOBALDATA, MSGFLT_ALLOW, NULL);
+    if (IsWindows7OrGreater())
+    {
+        ChangeWindowMessageFilterEx(window->win32.handle,
+                                    WM_DROPFILES, MSGFLT_ALLOW, NULL);
+        ChangeWindowMessageFilterEx(window->win32.handle,
+                                    WM_COPYDATA, MSGFLT_ALLOW, NULL);
+        ChangeWindowMessageFilterEx(window->win32.handle,
+                                    WM_COPYGLOBALDATA, MSGFLT_ALLOW, NULL);
+    }
 
     window->win32.scaleToMonitor = wndconfig->scaleToMonitor;
     window->win32.keymenu = wndconfig->win32.keymenu;
@@ -1526,7 +1535,7 @@ GLFWbool _glfwCreateWindowWin32(_GLFWwindow* window,
     {
         _glfwShowWindowWin32(window);
         _glfwFocusWindowWin32(window);
-        acquireMonitor(window);
+        acquireMonitorWin32(window);
         fitToMonitor(window);
 
         if (wndconfig->centerCursor)
@@ -1548,7 +1557,7 @@ GLFWbool _glfwCreateWindowWin32(_GLFWwindow* window,
 void _glfwDestroyWindowWin32(_GLFWwindow* window)
 {
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorWin32(window);
 
     if (window->context.destroy)
         window->context.destroy(window);
@@ -1669,7 +1678,7 @@ void _glfwSetWindowSizeWin32(_GLFWwindow* window, int width, int height)
     {
         if (window->monitor->window == window)
         {
-            acquireMonitor(window);
+            acquireMonitorWin32(window);
             fitToMonitor(window);
         }
     }
@@ -1841,7 +1850,7 @@ void _glfwSetWindowMonitorWin32(_GLFWwindow* window,
         {
             if (monitor->window == window)
             {
-                acquireMonitor(window);
+                acquireMonitorWin32(window);
                 fitToMonitor(window);
             }
         }
@@ -1871,7 +1880,7 @@ void _glfwSetWindowMonitorWin32(_GLFWwindow* window,
     }
 
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorWin32(window);
 
     _glfwInputWindowMonitor(window, monitor);
 
@@ -1889,7 +1898,7 @@ void _glfwSetWindowMonitorWin32(_GLFWwindow* window,
             flags |= SWP_FRAMECHANGED;
         }
 
-        acquireMonitor(window);
+        acquireMonitorWin32(window);
 
         GetMonitorInfoW(window->monitor->win32.handle, &mi);
         SetWindowPos(window->win32.handle, HWND_TOPMOST,
@@ -1972,6 +1981,9 @@ GLFWbool _glfwFramebufferTransparentWin32(_GLFWwindow* window)
     if (!window->win32.transparent)
         return GLFW_FALSE;
 
+    if (!IsWindowsVistaOrGreater())
+        return GLFW_FALSE;
+
     if (FAILED(DwmIsCompositionEnabled(&composition)) || !composition)
         return GLFW_FALSE;
 
@@ -2565,6 +2577,7 @@ VkResult _glfwCreateWindowSurfaceWin32(VkInstance instance,
 
 GLFWAPI HWND glfwGetWin32Window(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_WIN32)
@@ -2574,9 +2587,6 @@ GLFWAPI HWND glfwGetWin32Window(GLFWwindow* handle)
         return NULL;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     return window->win32.handle;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/window.c b/src/libraries/raylib/raylib/src/external/glfw/src/window.c
index 5f92e97..1463d16 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/window.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/window.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 - www.glfw.org
+// GLFW 3.4 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -32,7 +32,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <float.h>
-#include <math.h>
+
 
 //////////////////////////////////////////////////////////////////////////
 //////                         GLFW event API                       //////
@@ -135,9 +135,9 @@ void _glfwInputWindowContentScale(_GLFWwindow* window, float xscale, float yscal
 {
     assert(window != NULL);
     assert(xscale > 0.f);
-    assert(isfinite(xscale));
+    assert(xscale < FLT_MAX);
     assert(yscale > 0.f);
-    assert(isfinite(yscale));
+    assert(yscale < FLT_MAX);
 
     if (window->callbacks.scale)
         window->callbacks.scale((GLFWwindow*) window, xscale, yscale);
@@ -208,6 +208,7 @@ GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height,
 
     wndconfig.width   = width;
     wndconfig.height  = height;
+    wndconfig.title   = title;
     ctxconfig.share   = (_GLFWwindow*) share;
 
     if (!_glfwIsValidContextConfig(&ctxconfig))
@@ -265,16 +266,16 @@ void glfwDefaultWindowHints(void)
 
     // The default is a focused, visible, resizable window with decorations
     memset(&_glfw.hints.window, 0, sizeof(_glfw.hints.window));
-    _glfw.hints.window.resizable    = true;
-    _glfw.hints.window.visible      = true;
-    _glfw.hints.window.decorated    = true;
-    _glfw.hints.window.focused      = true;
-    _glfw.hints.window.autoIconify  = true;
-    _glfw.hints.window.centerCursor = true;
-    _glfw.hints.window.focusOnShow  = true;
+    _glfw.hints.window.resizable    = GLFW_TRUE;
+    _glfw.hints.window.visible      = GLFW_TRUE;
+    _glfw.hints.window.decorated    = GLFW_TRUE;
+    _glfw.hints.window.focused      = GLFW_TRUE;
+    _glfw.hints.window.autoIconify  = GLFW_TRUE;
+    _glfw.hints.window.centerCursor = GLFW_TRUE;
+    _glfw.hints.window.focusOnShow  = GLFW_TRUE;
     _glfw.hints.window.xpos         = GLFW_ANY_POSITION;
     _glfw.hints.window.ypos         = GLFW_ANY_POSITION;
-    _glfw.hints.window.scaleFramebuffer = true;
+    _glfw.hints.window.scaleFramebuffer = GLFW_TRUE;
 
     // The default is 24 bits of color, 24 bits of depth and 8 bits of stencil,
     // double buffered
@@ -285,7 +286,7 @@ void glfwDefaultWindowHints(void)
     _glfw.hints.framebuffer.alphaBits    = 8;
     _glfw.hints.framebuffer.depthBits    = 24;
     _glfw.hints.framebuffer.stencilBits  = 8;
-    _glfw.hints.framebuffer.doublebuffer = true;
+    _glfw.hints.framebuffer.doublebuffer = GLFW_TRUE;
 
     // The default is to select the highest available refresh rate
     _glfw.hints.refreshRate = GLFW_DONT_CARE;
@@ -331,40 +332,40 @@ GLFWAPI void glfwWindowHint(int hint, int value)
             _glfw.hints.framebuffer.auxBuffers = value;
             return;
         case GLFW_STEREO:
-            _glfw.hints.framebuffer.stereo = value;
+            _glfw.hints.framebuffer.stereo = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_DOUBLEBUFFER:
-            _glfw.hints.framebuffer.doublebuffer = value;
+            _glfw.hints.framebuffer.doublebuffer = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_TRANSPARENT_FRAMEBUFFER:
-            _glfw.hints.framebuffer.transparent = value;
+            _glfw.hints.framebuffer.transparent = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_SAMPLES:
             _glfw.hints.framebuffer.samples = value;
             return;
         case GLFW_SRGB_CAPABLE:
-            _glfw.hints.framebuffer.sRGB = value;
+            _glfw.hints.framebuffer.sRGB = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_RESIZABLE:
-            _glfw.hints.window.resizable = value;
+            _glfw.hints.window.resizable = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_DECORATED:
-            _glfw.hints.window.decorated = value;
+            _glfw.hints.window.decorated = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_FOCUSED:
-            _glfw.hints.window.focused = value;
+            _glfw.hints.window.focused = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_AUTO_ICONIFY:
-            _glfw.hints.window.autoIconify = value;
+            _glfw.hints.window.autoIconify = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_FLOATING:
-            _glfw.hints.window.floating = value;
+            _glfw.hints.window.floating = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_MAXIMIZED:
-            _glfw.hints.window.maximized = value;
+            _glfw.hints.window.maximized = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_VISIBLE:
-            _glfw.hints.window.visible = value;
+            _glfw.hints.window.visible = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_POSITION_X:
             _glfw.hints.window.xpos = value;
@@ -373,29 +374,29 @@ GLFWAPI void glfwWindowHint(int hint, int value)
             _glfw.hints.window.ypos = value;
             return;
         case GLFW_WIN32_KEYBOARD_MENU:
-            _glfw.hints.window.win32.keymenu = value;
+            _glfw.hints.window.win32.keymenu = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_WIN32_SHOWDEFAULT:
-            _glfw.hints.window.win32.showDefault = value;
+            _glfw.hints.window.win32.showDefault = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_COCOA_GRAPHICS_SWITCHING:
-            _glfw.hints.context.nsgl.offline = value;
+            _glfw.hints.context.nsgl.offline = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_SCALE_TO_MONITOR:
-            _glfw.hints.window.scaleToMonitor = value;
+            _glfw.hints.window.scaleToMonitor = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_SCALE_FRAMEBUFFER:
         case GLFW_COCOA_RETINA_FRAMEBUFFER:
-            _glfw.hints.window.scaleFramebuffer = value;
+            _glfw.hints.window.scaleFramebuffer = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_CENTER_CURSOR:
-            _glfw.hints.window.centerCursor = value;
+            _glfw.hints.window.centerCursor = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_FOCUS_ON_SHOW:
-            _glfw.hints.window.focusOnShow = value;
+            _glfw.hints.window.focusOnShow = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_MOUSE_PASSTHROUGH:
-            _glfw.hints.window.mousePassthrough = value;
+            _glfw.hints.window.mousePassthrough = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_CLIENT_API:
             _glfw.hints.context.client = value;
@@ -413,13 +414,13 @@ GLFWAPI void glfwWindowHint(int hint, int value)
             _glfw.hints.context.robustness = value;
             return;
         case GLFW_OPENGL_FORWARD_COMPAT:
-            _glfw.hints.context.forward = value;
+            _glfw.hints.context.forward = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_CONTEXT_DEBUG:
-            _glfw.hints.context.debug = value;
+            _glfw.hints.context.debug = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_CONTEXT_NO_ERROR:
-            _glfw.hints.context.noerror = value;
+            _glfw.hints.context.noerror = value ? GLFW_TRUE : GLFW_FALSE;
             return;
         case GLFW_OPENGL_PROFILE:
             _glfw.hints.context.profile = value;
@@ -466,10 +467,10 @@ GLFWAPI void glfwWindowHintString(int hint, const char* value)
 
 GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
 
+    _GLFW_REQUIRE_INIT();
+
     // Allow closing of NULL (to match the behavior of free)
     if (window == NULL)
         return;
@@ -500,43 +501,40 @@ GLFWAPI void glfwDestroyWindow(GLFWwindow* handle)
 
 GLFWAPI int glfwWindowShouldClose(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(0);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
     return window->shouldClose;
 }
 
 GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* handle, int value)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
     window->shouldClose = value;
 }
 
 GLFWAPI const char* glfwGetWindowTitle(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
+
     return window->title;
 }
 
 GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
     assert(title != NULL);
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     char* prev = window->title;
     window->title = _glfw_strdup(title);
 
@@ -548,15 +546,14 @@ GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
                                int count, const GLFWimage* images)
 {
     int i;
+    _GLFWwindow* window = (_GLFWwindow*) handle;
 
+    assert(window != NULL);
     assert(count >= 0);
     assert(count == 0 || images != NULL);
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (count < 0)
     {
         _glfwInputError(GLFW_INVALID_VALUE, "Invalid image count for window icon");
@@ -580,26 +577,25 @@ GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
 
 GLFWAPI void glfwGetWindowPos(GLFWwindow* handle, int* xpos, int* ypos)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     if (xpos)
         *xpos = 0;
     if (ypos)
         *ypos = 0;
 
     _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     _glfw.platform.getWindowPos(window, xpos, ypos);
 }
 
 GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     if (window->monitor)
         return;
 
@@ -608,29 +604,27 @@ GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
 
 GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     if (width)
         *width = 0;
     if (height)
         *height = 0;
 
     _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     _glfw.platform.getWindowSize(window, width, height);
 }
 
 GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
     assert(width >= 0);
     assert(height >= 0);
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     window->videoMode.width  = width;
     window->videoMode.height = height;
 
@@ -641,11 +635,11 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
                                      int minwidth, int minheight,
                                      int maxwidth, int maxheight)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     if (minwidth != GLFW_DONT_CARE && minheight != GLFW_DONT_CARE)
     {
         if (minwidth < 0 || minheight < 0)
@@ -684,14 +678,13 @@ GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
 
 GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
     assert(numer != 0);
     assert(denom != 0);
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
     {
         if (numer <= 0 || denom <= 0)
@@ -714,16 +707,15 @@ GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
 
 GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     if (width)
         *width = 0;
     if (height)
         *height = 0;
 
     _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     _glfw.platform.getFramebufferSize(window, width, height);
 }
 
@@ -731,6 +723,9 @@ GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
                                     int* left, int* top,
                                     int* right, int* bottom)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     if (left)
         *left = 0;
     if (top)
@@ -741,51 +736,44 @@ GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
         *bottom = 0;
 
     _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     _glfw.platform.getWindowFrameSize(window, left, top, right, bottom);
 }
 
 GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
                                        float* xscale, float* yscale)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+
     if (xscale)
         *xscale = 0.f;
     if (yscale)
         *yscale = 0.f;
 
     _GLFW_REQUIRE_INIT();
-
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     _glfw.platform.getWindowContentScale(window, xscale, yscale);
 }
 
 GLFWAPI float glfwGetWindowOpacity(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(0.f);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(0.f);
     return _glfw.platform.getWindowOpacity(window);
 }
 
 GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
 {
-    assert(isfinite(opacity));
+    _GLFWwindow* window = (_GLFWwindow*) handle;
+    assert(window != NULL);
+    assert(opacity == opacity);
     assert(opacity >= 0.f);
     assert(opacity <= 1.f);
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
-    if (!isfinite(opacity) || opacity < 0.f || opacity > 1.f)
+    if (opacity != opacity || opacity < 0.f || opacity > 1.f)
     {
         _glfwInputError(GLFW_INVALID_VALUE, "Invalid window opacity %f", opacity);
         return;
@@ -796,31 +784,29 @@ GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
 
 GLFWAPI void glfwIconifyWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
     _glfw.platform.iconifyWindow(window);
 }
 
 GLFWAPI void glfwRestoreWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
     _glfw.platform.restoreWindow(window);
 }
 
 GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     if (window->monitor)
         return;
 
@@ -829,11 +815,11 @@ GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
 
 GLFWAPI void glfwShowWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     if (window->monitor)
         return;
 
@@ -845,21 +831,21 @@ GLFWAPI void glfwShowWindow(GLFWwindow* handle)
 
 GLFWAPI void glfwRequestWindowAttention(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     _glfw.platform.requestWindowAttention(window);
 }
 
 GLFWAPI void glfwHideWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     if (window->monitor)
         return;
 
@@ -868,21 +854,21 @@ GLFWAPI void glfwHideWindow(GLFWwindow* handle)
 
 GLFWAPI void glfwFocusWindow(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     _glfw.platform.focusWindow(window);
 }
 
 GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(0);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(0);
+
     switch (attrib)
     {
         case GLFW_FOCUSED:
@@ -941,11 +927,11 @@ GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
 
 GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
+
     value = value ? GLFW_TRUE : GLFW_FALSE;
 
     switch (attrib)
@@ -987,11 +973,10 @@ GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
 
 GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return (GLFWmonitor*) window->monitor;
 }
 
@@ -1001,15 +986,14 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
                                   int width, int height,
                                   int refreshRate)
 {
+    _GLFWwindow* window = (_GLFWwindow*) wh;
+    _GLFWmonitor* monitor = (_GLFWmonitor*) mh;
+    assert(window != NULL);
     assert(width >= 0);
     assert(height >= 0);
 
     _GLFW_REQUIRE_INIT();
 
-    _GLFWwindow* window = (_GLFWwindow*) wh;
-    _GLFWmonitor* monitor = (_GLFWmonitor*) mh;
-    assert(window != NULL);
-
     if (width <= 0 || height <= 0)
     {
         _glfwInputError(GLFW_INVALID_VALUE,
@@ -1037,32 +1021,29 @@ GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
 
 GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* handle, void* pointer)
 {
-    _GLFW_REQUIRE_INIT();
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT();
     window->userPointer = pointer;
 }
 
 GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* handle)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     return window->userPointer;
 }
 
 GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
                                                   GLFWwindowposfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowposfun, window->callbacks.pos, cbfun);
     return cbfun;
 }
@@ -1070,11 +1051,10 @@ GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* handle,
 GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
                                                     GLFWwindowsizefun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowsizefun, window->callbacks.size, cbfun);
     return cbfun;
 }
@@ -1082,11 +1062,10 @@ GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* handle,
 GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
                                                       GLFWwindowclosefun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowclosefun, window->callbacks.close, cbfun);
     return cbfun;
 }
@@ -1094,11 +1073,10 @@ GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* handle,
 GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
                                                           GLFWwindowrefreshfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowrefreshfun, window->callbacks.refresh, cbfun);
     return cbfun;
 }
@@ -1106,11 +1084,10 @@ GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* handle,
 GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
                                                       GLFWwindowfocusfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowfocusfun, window->callbacks.focus, cbfun);
     return cbfun;
 }
@@ -1118,11 +1095,10 @@ GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* handle,
 GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
                                                           GLFWwindowiconifyfun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowiconifyfun, window->callbacks.iconify, cbfun);
     return cbfun;
 }
@@ -1130,11 +1106,10 @@ GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* handle,
 GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* handle,
                                                             GLFWwindowmaximizefun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowmaximizefun, window->callbacks.maximize, cbfun);
     return cbfun;
 }
@@ -1142,11 +1117,10 @@ GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* handle,
 GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle,
                                                               GLFWframebuffersizefun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWframebuffersizefun, window->callbacks.fbsize, cbfun);
     return cbfun;
 }
@@ -1154,11 +1128,10 @@ GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* handle
 GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* handle,
                                                                     GLFWwindowcontentscalefun cbfun)
 {
-    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
-
     _GLFWwindow* window = (_GLFWwindow*) handle;
     assert(window != NULL);
 
+    _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
     _GLFW_SWAP(GLFWwindowcontentscalefun, window->callbacks.scale, cbfun);
     return cbfun;
 }
@@ -1178,10 +1151,11 @@ GLFWAPI void glfwWaitEvents(void)
 GLFWAPI void glfwWaitEventsTimeout(double timeout)
 {
     _GLFW_REQUIRE_INIT();
-    assert(isfinite(timeout));
+    assert(timeout == timeout);
     assert(timeout >= 0.0);
+    assert(timeout <= DBL_MAX);
 
-    if (!isfinite(timeout) || timeout < 0.0)
+    if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
     {
         _glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", timeout);
         return;
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/wl_init.c b/src/libraries/raylib/raylib/src/external/glfw/src/wl_init.c
index e6da578..2428c72 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/wl_init.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/wl_init.c
@@ -1,7 +1,8 @@
 //========================================================================
-// GLFW 3.5 Wayland - www.glfw.org
+// GLFW 3.4 Wayland (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -135,7 +136,7 @@ static void registryHandleGlobal(void* userData,
         {
             _glfw.wl.seat =
                 wl_registry_bind(registry, name, &wl_seat_interface,
-                                 _glfw_min(8, version));
+                                 _glfw_min(4, version));
             _glfwAddSeatListenerWayland(_glfw.wl.seat);
         }
     }
@@ -244,7 +245,10 @@ static void libdecorReadyCallback(void* userData,
                                   uint32_t time)
 {
     _glfw.wl.libdecor.ready = GLFW_TRUE;
-    wl_callback_destroy(callback);
+
+    assert(_glfw.wl.libdecor.callback == callback);
+    wl_callback_destroy(_glfw.wl.libdecor.callback);
+    _glfw.wl.libdecor.callback = NULL;
 }
 
 static const struct wl_callback_listener libdecorReadyListener =
@@ -254,7 +258,7 @@ static const struct wl_callback_listener libdecorReadyListener =
 
 // Create key code translation tables
 //
-static void createKeyTables(void)
+static void createKeyTablesWayland(void)
 {
     memset(_glfw.wl.keycodes, -1, sizeof(_glfw.wl.keycodes));
     memset(_glfw.wl.scancodes, -1, sizeof(_glfw.wl.scancodes));
@@ -575,14 +579,6 @@ int _glfwInitWayland(void)
         _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_display_get_fd");
     _glfw.wl.client.display_prepare_read = (PFN_wl_display_prepare_read)
         _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_display_prepare_read");
-    _glfw.wl.client.display_create_queue = (PFN_wl_display_create_queue)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_display_create_queue");
-    _glfw.wl.client.display_prepare_read_queue = (PFN_wl_display_prepare_read_queue)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_display_prepare_read_queue");
-    _glfw.wl.client.display_dispatch_queue_pending = (PFN_wl_display_dispatch_queue_pending)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_display_dispatch_queue_pending");
-    _glfw.wl.client.event_queue_destroy = (PFN_wl_event_queue_destroy)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_event_queue_destroy");
     _glfw.wl.client.proxy_marshal = (PFN_wl_proxy_marshal)
         _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_proxy_marshal");
     _glfw.wl.client.proxy_add_listener = (PFN_wl_proxy_add_listener)
@@ -605,12 +601,6 @@ int _glfwInitWayland(void)
         _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_proxy_get_version");
     _glfw.wl.client.proxy_marshal_flags = (PFN_wl_proxy_marshal_flags)
         _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_proxy_marshal_flags");
-    _glfw.wl.client.proxy_create_wrapper = (PFN_wl_proxy_create_wrapper)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_proxy_create_wrapper");
-    _glfw.wl.client.proxy_wrapper_destroy = (PFN_wl_proxy_wrapper_destroy)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_proxy_wrapper_destroy");
-    _glfw.wl.client.proxy_set_queue = (PFN_wl_proxy_set_queue)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.client.handle, "wl_proxy_set_queue");
 
     if (!_glfw.wl.client.display_flush ||
         !_glfw.wl.client.display_cancel_read ||
@@ -620,10 +610,6 @@ int _glfwInitWayland(void)
         !_glfw.wl.client.display_roundtrip ||
         !_glfw.wl.client.display_get_fd ||
         !_glfw.wl.client.display_prepare_read ||
-        !_glfw.wl.client.display_create_queue ||
-        !_glfw.wl.client.display_prepare_read_queue ||
-        !_glfw.wl.client.display_dispatch_queue_pending ||
-        !_glfw.wl.client.event_queue_destroy ||
         !_glfw.wl.client.proxy_marshal ||
         !_glfw.wl.client.proxy_add_listener ||
         !_glfw.wl.client.proxy_destroy ||
@@ -632,10 +618,7 @@ int _glfwInitWayland(void)
         !_glfw.wl.client.proxy_get_user_data ||
         !_glfw.wl.client.proxy_set_user_data ||
         !_glfw.wl.client.proxy_get_tag ||
-        !_glfw.wl.client.proxy_set_tag ||
-        !_glfw.wl.client.proxy_create_wrapper ||
-        !_glfw.wl.client.proxy_wrapper_destroy ||
-        !_glfw.wl.client.proxy_set_queue)
+        !_glfw.wl.client.proxy_set_tag)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
                         "Wayland: Failed to load libwayland-client entry point");
@@ -722,10 +705,6 @@ int _glfwInitWayland(void)
         _glfwPlatformGetModuleSymbol(_glfw.wl.xkb.handle, "xkb_compose_state_get_status");
     _glfw.wl.xkb.compose_state_get_one_sym = (PFN_xkb_compose_state_get_one_sym)
         _glfwPlatformGetModuleSymbol(_glfw.wl.xkb.handle, "xkb_compose_state_get_one_sym");
-    _glfw.wl.xkb.keysym_to_utf32 = (PFN_xkb_keysym_to_utf32)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.xkb.handle, "xkb_keysym_to_utf32");
-    _glfw.wl.xkb.keysym_to_utf8 = (PFN_xkb_keysym_to_utf8)
-        _glfwPlatformGetModuleSymbol(_glfw.wl.xkb.handle, "xkb_keysym_to_utf8");
 
     if (!_glfw.wl.xkb.context_new ||
         !_glfw.wl.xkb.context_unref ||
@@ -798,8 +777,6 @@ int _glfwInitWayland(void)
             _glfwPlatformGetModuleSymbol(_glfw.wl.libdecor.handle, "libdecor_frame_unset_capabilities");
         _glfw.wl.libdecor.libdecor_frame_set_visibility_ = (PFN_libdecor_frame_set_visibility)
             _glfwPlatformGetModuleSymbol(_glfw.wl.libdecor.handle, "libdecor_frame_set_visibility");
-        _glfw.wl.libdecor.libdecor_frame_is_visible_ = (PFN_libdecor_frame_is_visible)
-            _glfwPlatformGetModuleSymbol(_glfw.wl.libdecor.handle, "libdecor_frame_is_visible");
         _glfw.wl.libdecor.libdecor_frame_get_xdg_toplevel_ = (PFN_libdecor_frame_get_xdg_toplevel)
             _glfwPlatformGetModuleSymbol(_glfw.wl.libdecor.handle, "libdecor_frame_get_xdg_toplevel");
         _glfw.wl.libdecor.libdecor_configuration_get_content_size_ = (PFN_libdecor_configuration_get_content_size)
@@ -831,7 +808,6 @@ int _glfwInitWayland(void)
             !_glfw.wl.libdecor.libdecor_frame_set_capabilities_ ||
             !_glfw.wl.libdecor.libdecor_frame_unset_capabilities_ ||
             !_glfw.wl.libdecor.libdecor_frame_set_visibility_ ||
-            !_glfw.wl.libdecor.libdecor_frame_is_visible_ ||
             !_glfw.wl.libdecor.libdecor_frame_get_xdg_toplevel_ ||
             !_glfw.wl.libdecor.libdecor_configuration_get_content_size_ ||
             !_glfw.wl.libdecor.libdecor_configuration_get_window_state_ ||
@@ -846,19 +822,9 @@ int _glfwInitWayland(void)
     _glfw.wl.registry = wl_display_get_registry(_glfw.wl.display);
     wl_registry_add_listener(_glfw.wl.registry, &registryListener, NULL);
 
-    createKeyTables();
+    createKeyTablesWayland();
 
-    _glfw.wl.keyRepeatTimerfd =
-        timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
-    if (_glfw.wl.keyRepeatTimerfd == -1)
-    {
-        _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to create timerfd: %s",
-                        strerror(errno));
-        return GLFW_FALSE;
-    }
-
-    _glfw.wl.xkb.context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+    _glfw.wl.xkb.context = xkb_context_new(0);
     if (!_glfw.wl.xkb.context)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -881,11 +847,19 @@ int _glfwInitWayland(void)
             libdecor_dispatch(_glfw.wl.libdecor.context, 0);
 
             // Create sync point to "know" when libdecor is ready for use
-            struct wl_callback* callback = wl_display_sync(_glfw.wl.display);
-            wl_callback_add_listener(callback, &libdecorReadyListener, NULL);
+            _glfw.wl.libdecor.callback = wl_display_sync(_glfw.wl.display);
+            wl_callback_add_listener(_glfw.wl.libdecor.callback,
+                                     &libdecorReadyListener,
+                                     NULL);
         }
     }
 
+    if (wl_seat_get_version(_glfw.wl.seat) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
+    {
+        _glfw.wl.keyRepeatTimerfd =
+            timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
+    }
+
     if (!_glfw.wl.wmBase)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
@@ -929,6 +903,18 @@ void _glfwTerminateWayland(void)
         libdecor_unref(_glfw.wl.libdecor.context);
     }
 
+    if (_glfw.wl.libdecor.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.wl.libdecor.handle);
+        _glfw.wl.libdecor.handle = NULL;
+    }
+
+    if (_glfw.wl.egl.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.wl.egl.handle);
+        _glfw.wl.egl.handle = NULL;
+    }
+
     if (_glfw.wl.xkb.composeState)
         xkb_compose_state_unref(_glfw.wl.xkb.composeState);
     if (_glfw.wl.xkb.keymap)
@@ -937,11 +923,21 @@ void _glfwTerminateWayland(void)
         xkb_state_unref(_glfw.wl.xkb.state);
     if (_glfw.wl.xkb.context)
         xkb_context_unref(_glfw.wl.xkb.context);
+    if (_glfw.wl.xkb.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.wl.xkb.handle);
+        _glfw.wl.xkb.handle = NULL;
+    }
 
     if (_glfw.wl.cursorTheme)
         wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
     if (_glfw.wl.cursorThemeHiDPI)
         wl_cursor_theme_destroy(_glfw.wl.cursorThemeHiDPI);
+    if (_glfw.wl.cursor.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.wl.cursor.handle);
+        _glfw.wl.cursor.handle = NULL;
+    }
 
     for (unsigned int i = 0; i < _glfw.wl.offerCount; i++)
         wl_data_offer_destroy(_glfw.wl.offers[i].offer);
@@ -1001,18 +997,7 @@ void _glfwTerminateWayland(void)
     if (_glfw.wl.cursorTimerfd >= 0)
         close(_glfw.wl.cursorTimerfd);
 
-    // Free modules only after all Wayland termination functions are called
-
-    _glfwPlatformFreeModule(_glfw.egl.handle);
-    _glfwPlatformFreeModule(_glfw.wl.libdecor.handle);
-    _glfwPlatformFreeModule(_glfw.wl.egl.handle);
-    _glfwPlatformFreeModule(_glfw.wl.xkb.handle);
-    _glfwPlatformFreeModule(_glfw.wl.cursor.handle);
-    _glfwPlatformFreeModule(_glfw.wl.client.handle);
-
     _glfw_free(_glfw.wl.clipboardString);
-
-    memset(&_glfw.wl, 0, sizeof(_glfw.wl));
 }
 
 #endif // _GLFW_WAYLAND
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/wl_monitor.c b/src/libraries/raylib/raylib/src/external/glfw/src/wl_monitor.c
index 1ec5f5a..df30313 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/wl_monitor.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/wl_monitor.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Wayland - www.glfw.org
+// GLFW 3.4 Wayland - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -33,7 +33,6 @@
 #include <string.h>
 #include <errno.h>
 #include <math.h>
-#include <assert.h>
 
 #include "wayland-client-protocol.h"
 
@@ -259,6 +258,7 @@ void _glfwSetGammaRampWayland(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 
 GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* handle)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
@@ -267,9 +267,6 @@ GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* handle)
         return NULL;
     }
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     return monitor->wl.output;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/wl_platform.h b/src/libraries/raylib/raylib/src/external/glfw/src/wl_platform.h
index 405ea63..149cd24 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/wl_platform.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/wl_platform.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 Wayland - www.glfw.org
+// GLFW 3.4 Wayland - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
 //
@@ -28,6 +28,8 @@
 #include <xkbcommon/xkbcommon.h>
 #include <xkbcommon/xkbcommon-compose.h>
 
+#include <stdbool.h>
+
 typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
 
 typedef struct VkWaylandSurfaceCreateInfoKHR
@@ -42,6 +44,9 @@ typedef struct VkWaylandSurfaceCreateInfoKHR
 typedef VkResult (APIENTRY *PFN_vkCreateWaylandSurfaceKHR)(VkInstance,const VkWaylandSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice,uint32_t,struct wl_display*);
 
+#include "xkb_unicode.h"
+#include "posix_poll.h"
+
 typedef int (* PFN_wl_display_flush)(struct wl_display* display);
 typedef void (* PFN_wl_display_cancel_read)(struct wl_display* display);
 typedef int (* PFN_wl_display_dispatch_pending)(struct wl_display* display);
@@ -51,10 +56,6 @@ typedef void (* PFN_wl_display_disconnect)(struct wl_display*);
 typedef int (* PFN_wl_display_roundtrip)(struct wl_display*);
 typedef int (* PFN_wl_display_get_fd)(struct wl_display*);
 typedef int (* PFN_wl_display_prepare_read)(struct wl_display*);
-typedef struct wl_event_queue* (* PFN_wl_display_create_queue)(struct wl_display*);
-typedef void (* PFN_wl_event_queue_destroy)(struct wl_event_queue*);
-typedef int (* PFN_wl_display_prepare_read_queue)(struct wl_display*,struct wl_event_queue*);
-typedef int (* PFN_wl_display_dispatch_queue_pending)(struct wl_display*,struct wl_event_queue*);
 typedef void (* PFN_wl_proxy_marshal)(struct wl_proxy*,uint32_t,...);
 typedef int (* PFN_wl_proxy_add_listener)(struct wl_proxy*,void(**)(void),void*);
 typedef void (* PFN_wl_proxy_destroy)(struct wl_proxy*);
@@ -66,9 +67,6 @@ typedef void (* PFN_wl_proxy_set_tag)(struct wl_proxy*,const char*const*);
 typedef const char* const* (* PFN_wl_proxy_get_tag)(struct wl_proxy*);
 typedef uint32_t (* PFN_wl_proxy_get_version)(struct wl_proxy*);
 typedef struct wl_proxy* (* PFN_wl_proxy_marshal_flags)(struct wl_proxy*,uint32_t,const struct wl_interface*,uint32_t,uint32_t,...);
-typedef void* (* PFN_wl_proxy_create_wrapper)(void*);
-typedef void (* PFN_wl_proxy_wrapper_destroy)(void*);
-typedef void (* PFN_wl_proxy_set_queue)(struct wl_proxy*,struct wl_event_queue*);
 #define wl_display_flush _glfw.wl.client.display_flush
 #define wl_display_cancel_read _glfw.wl.client.display_cancel_read
 #define wl_display_dispatch_pending _glfw.wl.client.display_dispatch_pending
@@ -77,10 +75,6 @@ typedef void (* PFN_wl_proxy_set_queue)(struct wl_proxy*,struct wl_event_queue*)
 #define wl_display_roundtrip _glfw.wl.client.display_roundtrip
 #define wl_display_get_fd _glfw.wl.client.display_get_fd
 #define wl_display_prepare_read _glfw.wl.client.display_prepare_read
-#define wl_display_create_queue _glfw.wl.client.display_create_queue
-#define wl_display_prepare_read_queue _glfw.wl.client.display_prepare_read_queue
-#define wl_display_dispatch_queue_pending _glfw.wl.client.display_dispatch_queue_pending
-#define wl_event_queue_destroy _glfw.wl.client.event_queue_destroy
 #define wl_proxy_marshal _glfw.wl.client.proxy_marshal
 #define wl_proxy_add_listener _glfw.wl.client.proxy_add_listener
 #define wl_proxy_destroy _glfw.wl.client.proxy_destroy
@@ -92,9 +86,6 @@ typedef void (* PFN_wl_proxy_set_queue)(struct wl_proxy*,struct wl_event_queue*)
 #define wl_proxy_set_tag _glfw.wl.client.proxy_set_tag
 #define wl_proxy_get_version _glfw.wl.client.proxy_get_version
 #define wl_proxy_marshal_flags _glfw.wl.client.proxy_marshal_flags
-#define wl_proxy_create_wrapper _glfw.wl.client.proxy_create_wrapper
-#define wl_proxy_wrapper_destroy _glfw.wl.client.proxy_wrapper_destroy
-#define wl_proxy_set_queue _glfw.wl.client.proxy_set_queue
 
 struct wl_shm;
 struct wl_output;
@@ -148,22 +139,18 @@ struct wl_output;
 #define GLFW_WAYLAND_MONITOR_STATE        _GLFWmonitorWayland wl;
 #define GLFW_WAYLAND_CURSOR_STATE         _GLFWcursorWayland  wl;
 
-struct wl_cursor_image
-{
+struct wl_cursor_image {
     uint32_t width;
     uint32_t height;
     uint32_t hotspot_x;
     uint32_t hotspot_y;
     uint32_t delay;
 };
-
-struct wl_cursor
-{
+struct wl_cursor {
     unsigned int image_count;
     struct wl_cursor_image** images;
     char* name;
 };
-
 typedef struct wl_cursor_theme* (* PFN_wl_cursor_theme_load)(const char*, int, struct wl_shm*);
 typedef void (* PFN_wl_cursor_theme_destroy)(struct wl_cursor_theme*);
 typedef struct wl_cursor* (* PFN_wl_cursor_theme_get_cursor)(struct wl_cursor_theme*, const char*);
@@ -193,8 +180,6 @@ typedef int (* PFN_xkb_state_key_get_syms)(struct xkb_state*, xkb_keycode_t, con
 typedef enum xkb_state_component (* PFN_xkb_state_update_mask)(struct xkb_state*, xkb_mod_mask_t, xkb_mod_mask_t, xkb_mod_mask_t, xkb_layout_index_t, xkb_layout_index_t, xkb_layout_index_t);
 typedef xkb_layout_index_t (* PFN_xkb_state_key_get_layout)(struct xkb_state*,xkb_keycode_t);
 typedef int (* PFN_xkb_state_mod_index_is_active)(struct xkb_state*,xkb_mod_index_t,enum xkb_state_component);
-typedef uint32_t (* PFN_xkb_keysym_to_utf32)(xkb_keysym_t);
-typedef int (* PFN_xkb_keysym_to_utf8)(xkb_keysym_t, char*, size_t);
 #define xkb_context_new _glfw.wl.xkb.context_new
 #define xkb_context_unref _glfw.wl.xkb.context_unref
 #define xkb_keymap_new_from_string _glfw.wl.xkb.keymap_new_from_string
@@ -208,8 +193,6 @@ typedef int (* PFN_xkb_keysym_to_utf8)(xkb_keysym_t, char*, size_t);
 #define xkb_state_update_mask _glfw.wl.xkb.state_update_mask
 #define xkb_state_key_get_layout _glfw.wl.xkb.state_key_get_layout
 #define xkb_state_mod_index_is_active _glfw.wl.xkb.state_mod_index_is_active
-#define xkb_keysym_to_utf32 _glfw.wl.xkb.keysym_to_utf32
-#define xkb_keysym_to_utf8 _glfw.wl.xkb.keysym_to_utf8
 
 typedef struct xkb_compose_table* (* PFN_xkb_compose_table_new_from_locale)(struct xkb_context*, const char*, enum xkb_compose_compile_flags);
 typedef void (* PFN_xkb_compose_table_unref)(struct xkb_compose_table*);
@@ -233,62 +216,62 @@ struct libdecor_configuration;
 
 enum libdecor_error
 {
-    LIBDECOR_ERROR_COMPOSITOR_INCOMPATIBLE,
-    LIBDECOR_ERROR_INVALID_FRAME_CONFIGURATION,
+	LIBDECOR_ERROR_COMPOSITOR_INCOMPATIBLE,
+	LIBDECOR_ERROR_INVALID_FRAME_CONFIGURATION,
 };
 
 enum libdecor_window_state
 {
-    LIBDECOR_WINDOW_STATE_NONE = 0,
-    LIBDECOR_WINDOW_STATE_ACTIVE = 1,
-    LIBDECOR_WINDOW_STATE_MAXIMIZED = 2,
-    LIBDECOR_WINDOW_STATE_FULLSCREEN = 4,
-    LIBDECOR_WINDOW_STATE_TILED_LEFT = 8,
-    LIBDECOR_WINDOW_STATE_TILED_RIGHT = 16,
-    LIBDECOR_WINDOW_STATE_TILED_TOP = 32,
-    LIBDECOR_WINDOW_STATE_TILED_BOTTOM = 64
+	LIBDECOR_WINDOW_STATE_NONE = 0,
+	LIBDECOR_WINDOW_STATE_ACTIVE = 1,
+	LIBDECOR_WINDOW_STATE_MAXIMIZED = 2,
+	LIBDECOR_WINDOW_STATE_FULLSCREEN = 4,
+	LIBDECOR_WINDOW_STATE_TILED_LEFT = 8,
+	LIBDECOR_WINDOW_STATE_TILED_RIGHT = 16,
+	LIBDECOR_WINDOW_STATE_TILED_TOP = 32,
+	LIBDECOR_WINDOW_STATE_TILED_BOTTOM = 64
 };
 
 enum libdecor_capabilities
 {
-    LIBDECOR_ACTION_MOVE = 1,
-    LIBDECOR_ACTION_RESIZE = 2,
-    LIBDECOR_ACTION_MINIMIZE = 4,
-    LIBDECOR_ACTION_FULLSCREEN = 8,
-    LIBDECOR_ACTION_CLOSE = 16
+	LIBDECOR_ACTION_MOVE = 1,
+	LIBDECOR_ACTION_RESIZE = 2,
+	LIBDECOR_ACTION_MINIMIZE = 4,
+	LIBDECOR_ACTION_FULLSCREEN = 8,
+	LIBDECOR_ACTION_CLOSE = 16
 };
 
 struct libdecor_interface
 {
-    void (* error)(struct libdecor*,enum libdecor_error,const char*);
-    void (* reserved0)(void);
-    void (* reserved1)(void);
-    void (* reserved2)(void);
-    void (* reserved3)(void);
-    void (* reserved4)(void);
-    void (* reserved5)(void);
-    void (* reserved6)(void);
-    void (* reserved7)(void);
-    void (* reserved8)(void);
-    void (* reserved9)(void);
+	void (* error)(struct libdecor*,enum libdecor_error,const char*);
+	void (* reserved0)(void);
+	void (* reserved1)(void);
+	void (* reserved2)(void);
+	void (* reserved3)(void);
+	void (* reserved4)(void);
+	void (* reserved5)(void);
+	void (* reserved6)(void);
+	void (* reserved7)(void);
+	void (* reserved8)(void);
+	void (* reserved9)(void);
 };
 
 struct libdecor_frame_interface
 {
-    void (* configure)(struct libdecor_frame*,struct libdecor_configuration*,void*);
-    void (* close)(struct libdecor_frame*,void*);
-    void (* commit)(struct libdecor_frame*,void*);
-    void (* dismiss_popup)(struct libdecor_frame*,const char*,void*);
-    void (* reserved0)(void);
-    void (* reserved1)(void);
-    void (* reserved2)(void);
-    void (* reserved3)(void);
-    void (* reserved4)(void);
-    void (* reserved5)(void);
-    void (* reserved6)(void);
-    void (* reserved7)(void);
-    void (* reserved8)(void);
-    void (* reserved9)(void);
+	void (* configure)(struct libdecor_frame*,struct libdecor_configuration*,void*);
+	void (* close)(struct libdecor_frame*,void*);
+	void (* commit)(struct libdecor_frame*,void*);
+	void (* dismiss_popup)(struct libdecor_frame*,const char*,void*);
+	void (* reserved0)(void);
+	void (* reserved1)(void);
+	void (* reserved2)(void);
+	void (* reserved3)(void);
+	void (* reserved4)(void);
+	void (* reserved5)(void);
+	void (* reserved6)(void);
+	void (* reserved7)(void);
+	void (* reserved8)(void);
+	void (* reserved9)(void);
 };
 
 typedef struct libdecor* (* PFN_libdecor_new)(struct wl_display*,const struct libdecor_interface*);
@@ -311,7 +294,6 @@ typedef void (* PFN_libdecor_frame_unset_maximized)(struct libdecor_frame*);
 typedef void (* PFN_libdecor_frame_set_capabilities)(struct libdecor_frame*,enum libdecor_capabilities);
 typedef void (* PFN_libdecor_frame_unset_capabilities)(struct libdecor_frame*,enum libdecor_capabilities);
 typedef void (* PFN_libdecor_frame_set_visibility)(struct libdecor_frame*,bool visible);
-typedef bool (* PFN_libdecor_frame_is_visible)(struct libdecor_frame*);
 typedef struct xdg_toplevel* (* PFN_libdecor_frame_get_xdg_toplevel)(struct libdecor_frame*);
 typedef bool (* PFN_libdecor_configuration_get_content_size)(struct libdecor_configuration*,struct libdecor_frame*,int*,int*);
 typedef bool (* PFN_libdecor_configuration_get_window_state)(struct libdecor_configuration*,enum libdecor_window_state*);
@@ -337,7 +319,6 @@ typedef void (* PFN_libdecor_state_free)(struct libdecor_state*);
 #define libdecor_frame_set_capabilities _glfw.wl.libdecor.libdecor_frame_set_capabilities_
 #define libdecor_frame_unset_capabilities _glfw.wl.libdecor.libdecor_frame_unset_capabilities_
 #define libdecor_frame_set_visibility _glfw.wl.libdecor.libdecor_frame_set_visibility_
-#define libdecor_frame_is_visible _glfw.wl.libdecor.libdecor_frame_is_visible_
 #define libdecor_frame_get_xdg_toplevel _glfw.wl.libdecor.libdecor_frame_get_xdg_toplevel_
 #define libdecor_configuration_get_content_size _glfw.wl.libdecor.libdecor_configuration_get_content_size_
 #define libdecor_configuration_get_window_state _glfw.wl.libdecor.libdecor_configuration_get_window_state_
@@ -374,16 +355,14 @@ typedef struct _GLFWwindowWayland
     GLFWbool                    maximized;
     GLFWbool                    activated;
     GLFWbool                    fullscreen;
+    GLFWbool                    hovered;
     GLFWbool                    transparent;
     GLFWbool                    scaleFramebuffer;
     struct wl_surface*          surface;
+    struct wl_callback*         callback;
 
     struct {
-        struct wl_event_queue*  queue;
         struct wl_egl_window*   window;
-        struct wl_callback*     callback;
-        struct wl_surface*      wrapper;
-        int                     interval;
     } egl;
 
     struct {
@@ -405,6 +384,7 @@ typedef struct _GLFWwindowWayland
         struct libdecor_frame*  frame;
     } libdecor;
 
+    _GLFWcursor*                currentCursor;
     double                      cursorPosX, cursorPosY;
 
     char*                       appId;
@@ -431,9 +411,7 @@ typedef struct _GLFWwindowWayland
         GLFWbool                    decorations;
         struct wl_buffer*           buffer;
         _GLFWfallbackEdgeWayland    top, left, right, bottom;
-        double                      pointerX, pointerY;
-        uint32_t                    buttonPressSerial;
-        const char*                 cursorName;
+        struct wl_surface*          focus;
     } fallback;
 } _GLFWwindowWayland;
 
@@ -472,10 +450,10 @@ typedef struct _GLFWlibraryWayland
 
     const char*                 tag;
 
-    struct wl_surface*          pointerSurface;
     struct wl_cursor_theme*     cursorTheme;
     struct wl_cursor_theme*     cursorThemeHiDPI;
     struct wl_surface*          cursorSurface;
+    const char*                 cursorPreviousName;
     int                         cursorTimerfd;
     uint32_t                    serial;
     uint32_t                    pointerEnterSerial;
@@ -490,19 +468,6 @@ typedef struct _GLFWlibraryWayland
     short int                   scancodes[GLFW_KEY_LAST + 1];
     char                        keynames[GLFW_KEY_LAST + 1][5];
 
-    struct {
-        struct wl_surface*      pointerSurface;
-        unsigned int            events;
-        double                  pointerX;
-        double                  pointerY;
-        double                  scrollX;
-        double                  scrollY;
-        double                  discreteX;
-        double                  discreteY;
-        int                     button;
-        int                     action;
-    } pending;
-
     struct {
         void*                   handle;
         struct xkb_context*     context;
@@ -532,8 +497,6 @@ typedef struct _GLFWlibraryWayland
         PFN_xkb_state_update_mask state_update_mask;
         PFN_xkb_state_key_get_layout state_key_get_layout;
         PFN_xkb_state_mod_index_is_active state_mod_index_is_active;
-        PFN_xkb_keysym_to_utf32 keysym_to_utf32;
-        PFN_xkb_keysym_to_utf8 keysym_to_utf8;
 
         PFN_xkb_compose_table_new_from_locale compose_table_new_from_locale;
         PFN_xkb_compose_table_unref compose_table_unref;
@@ -544,6 +507,7 @@ typedef struct _GLFWlibraryWayland
         PFN_xkb_compose_state_get_one_sym compose_state_get_one_sym;
     } xkb;
 
+    _GLFWwindow*                pointerFocus;
     _GLFWwindow*                keyboardFocus;
 
     struct {
@@ -556,10 +520,6 @@ typedef struct _GLFWlibraryWayland
         PFN_wl_display_roundtrip                    display_roundtrip;
         PFN_wl_display_get_fd                       display_get_fd;
         PFN_wl_display_prepare_read                 display_prepare_read;
-        PFN_wl_display_create_queue                 display_create_queue;
-        PFN_wl_display_prepare_read_queue           display_prepare_read_queue;
-        PFN_wl_display_dispatch_queue_pending       display_dispatch_queue_pending;
-        PFN_wl_event_queue_destroy                  event_queue_destroy;
         PFN_wl_proxy_marshal                        proxy_marshal;
         PFN_wl_proxy_add_listener                   proxy_add_listener;
         PFN_wl_proxy_destroy                        proxy_destroy;
@@ -571,9 +531,6 @@ typedef struct _GLFWlibraryWayland
         PFN_wl_proxy_set_tag                        proxy_set_tag;
         PFN_wl_proxy_get_version                    proxy_get_version;
         PFN_wl_proxy_marshal_flags                  proxy_marshal_flags;
-        PFN_wl_proxy_create_wrapper                 proxy_create_wrapper;
-        PFN_wl_proxy_wrapper_destroy                proxy_wrapper_destroy;
-        PFN_wl_proxy_set_queue                      proxy_set_queue;
     } client;
 
     struct {
@@ -596,6 +553,7 @@ typedef struct _GLFWlibraryWayland
     struct {
         void*                   handle;
         struct libdecor*        context;
+        struct wl_callback*     callback;
         GLFWbool                ready;
         PFN_libdecor_new        libdecor_new_;
         PFN_libdecor_unref      libdecor_unref_;
@@ -617,7 +575,6 @@ typedef struct _GLFWlibraryWayland
         PFN_libdecor_frame_set_capabilities libdecor_frame_set_capabilities_;
         PFN_libdecor_frame_unset_capabilities libdecor_frame_unset_capabilities_;
         PFN_libdecor_frame_set_visibility libdecor_frame_set_visibility_;
-        PFN_libdecor_frame_is_visible libdecor_frame_is_visible_;
         PFN_libdecor_frame_get_xdg_toplevel libdecor_frame_get_xdg_toplevel_;
         PFN_libdecor_configuration_get_content_size libdecor_configuration_get_content_size_;
         PFN_libdecor_configuration_get_window_state libdecor_configuration_get_window_state_;
@@ -732,5 +689,3 @@ void _glfwUpdateBufferScaleFromOutputsWayland(_GLFWwindow* window);
 void _glfwAddSeatListenerWayland(struct wl_seat* seat);
 void _glfwAddDataDeviceListenerWayland(struct wl_data_device* device);
 
-GLFWbool _glfwWaitForEGLFrameWayland(_GLFWwindow* window);
-
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/wl_window.c b/src/libraries/raylib/raylib/src/external/glfw/src/wl_window.c
index fd8553a..505166e 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/wl_window.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/wl_window.c
@@ -1,7 +1,8 @@
 //========================================================================
-// GLFW 3.5 Wayland - www.glfw.org
+// GLFW 3.4 Wayland (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2014 Jonas Ådahl <jadahl@gmail.com>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -24,9 +25,7 @@
 //
 //========================================================================
 
-#if !defined(_GNU_SOURCE)
- #define _GNU_SOURCE
-#endif
+#define _GNU_SOURCE
 
 #include "internal.h"
 
@@ -57,12 +56,6 @@
 #define GLFW_BORDER_SIZE    4
 #define GLFW_CAPTION_HEIGHT 24
 
-#define GLFW_PENDING_SURFACE    1
-#define GLFW_PENDING_BUTTON     2
-#define GLFW_PENDING_MOTION     4
-#define GLFW_PENDING_SCROLL     8
-#define GLFW_PENDING_DISCRETE   16
-
 static int createTmpfileCloexec(char* tmpname)
 {
     int fd;
@@ -201,16 +194,6 @@ static struct wl_buffer* createShmBuffer(const GLFWimage* image)
     return buffer;
 }
 
-static void callbackHandleDone(void* userData, struct wl_callback* callback, uint32_t data)
-{
-    wl_callback_destroy(callback);
-}
-
-static const struct wl_callback_listener noopCallbackListener =
-{
-    callbackHandleDone
-};
-
 static void createFallbackEdge(_GLFWwindow* window,
                                _GLFWfallbackEdgeWayland* edge,
                                struct wl_surface* parent,
@@ -271,9 +254,6 @@ static void createFallbackDecorations(_GLFWwindow* window)
 
 static void destroyFallbackEdge(_GLFWfallbackEdgeWayland* edge)
 {
-    if (edge->surface == _glfw.wl.pointerSurface)
-        _glfw.wl.pointerSurface = NULL;
-
     if (edge->subsurface)
         wl_subsurface_destroy(edge->subsurface);
     if (edge->surface)
@@ -296,148 +276,6 @@ static void destroyFallbackDecorations(_GLFWwindow* window)
     destroyFallbackEdge(&window->wl.fallback.bottom);
 }
 
-static void updateFallbackDecorationCursor(_GLFWwindow* window, double xpos, double ypos)
-{
-    window->wl.fallback.pointerX = xpos;
-    window->wl.fallback.pointerY = ypos;
-
-    const char* cursorName = "left_ptr";
-
-    if (window->resizable)
-    {
-        if (_glfw.wl.pointerSurface == window->wl.fallback.top.surface)
-        {
-            if (ypos < GLFW_BORDER_SIZE)
-                cursorName = "n-resize";
-        }
-        else if (_glfw.wl.pointerSurface == window->wl.fallback.left.surface)
-        {
-            if (ypos < GLFW_BORDER_SIZE)
-                cursorName = "nw-resize";
-            else
-                cursorName = "w-resize";
-        }
-        else if (_glfw.wl.pointerSurface == window->wl.fallback.right.surface)
-        {
-            if (ypos < GLFW_BORDER_SIZE)
-                cursorName = "ne-resize";
-            else
-                cursorName = "e-resize";
-        }
-        else if (_glfw.wl.pointerSurface == window->wl.fallback.bottom.surface)
-        {
-            if (xpos < GLFW_BORDER_SIZE)
-                cursorName = "sw-resize";
-            else if (xpos > window->wl.width + GLFW_BORDER_SIZE)
-                cursorName = "se-resize";
-            else
-                cursorName = "s-resize";
-        }
-    }
-
-    if (window->wl.fallback.cursorName != cursorName)
-    {
-        struct wl_surface* surface = _glfw.wl.cursorSurface;
-        struct wl_cursor_theme* theme = _glfw.wl.cursorTheme;
-        int scale = 1;
-
-        if (window->wl.bufferScale > 1 && _glfw.wl.cursorThemeHiDPI)
-        {
-            // We only support up to scale=2 for now, since libwayland-cursor
-            // requires us to load a different theme for each size.
-            scale = 2;
-            theme = _glfw.wl.cursorThemeHiDPI;
-        }
-
-        struct wl_cursor* cursor = wl_cursor_theme_get_cursor(theme, cursorName);
-        if (!cursor)
-            return;
-
-        // TODO: handle animated cursors too.
-        struct wl_cursor_image* image = cursor->images[0];
-        if (!image)
-            return;
-
-        struct wl_buffer* buffer = wl_cursor_image_get_buffer(image);
-        if (!buffer)
-            return;
-
-        wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.pointerEnterSerial,
-                              surface,
-                              image->hotspot_x / scale,
-                              image->hotspot_y / scale);
-        wl_surface_set_buffer_scale(surface, scale);
-        wl_surface_attach(surface, buffer, 0, 0);
-        wl_surface_damage(surface, 0, 0, image->width, image->height);
-        wl_surface_commit(surface);
-
-        window->wl.fallback.cursorName = cursorName;
-    }
-}
-
-static void handleFallbackDecorationButton(_GLFWwindow* window, int button, int action)
-{
-    if (action != GLFW_PRESS)
-        return;
-
-    const double xpos = window->wl.fallback.pointerX;
-    const double ypos = window->wl.fallback.pointerY;
-    const uint32_t serial = window->wl.fallback.buttonPressSerial;
-
-    if (button == GLFW_MOUSE_BUTTON_LEFT)
-    {
-        uint32_t edges = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
-
-        if (_glfw.wl.pointerSurface == window->wl.fallback.top.surface)
-        {
-            if (ypos < GLFW_BORDER_SIZE)
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
-            else
-                xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
-        }
-        else if (_glfw.wl.pointerSurface == window->wl.fallback.left.surface)
-        {
-            if (ypos < GLFW_BORDER_SIZE)
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
-            else
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
-        }
-        else if (_glfw.wl.pointerSurface == window->wl.fallback.right.surface)
-        {
-            if (ypos < GLFW_BORDER_SIZE)
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
-            else
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
-        }
-        else if (_glfw.wl.pointerSurface == window->wl.fallback.bottom.surface)
-        {
-            if (xpos < GLFW_BORDER_SIZE)
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
-            else if (xpos > window->wl.width + GLFW_BORDER_SIZE)
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
-            else
-                edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
-        }
-
-        if (edges != XDG_TOPLEVEL_RESIZE_EDGE_NONE)
-            xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat, serial, edges);
-    }
-    else if (button == GLFW_MOUSE_BUTTON_RIGHT)
-    {
-        if (!window->wl.xdg.toplevel)
-            return;
-
-        if (_glfw.wl.pointerSurface != window->wl.fallback.top.surface)
-            return;
-
-        if (ypos < GLFW_BORDER_SIZE)
-            return;
-
-        xdg_toplevel_show_window_menu(window->wl.xdg.toplevel, _glfw.wl.seat, serial,
-                                      xpos, ypos - GLFW_CAPTION_HEIGHT - GLFW_BORDER_SIZE);
-    }
-}
-
 static void xdgDecorationHandleConfigure(void* userData,
                                          struct zxdg_toplevel_decoration_v1* decoration,
                                          uint32_t mode)
@@ -478,9 +316,8 @@ static void resizeFramebuffer(_GLFWwindow* window)
 {
     if (window->wl.fractionalScale)
     {
-        // Round halfway away from zero per fractional-scale-v1 protocol spec
-        window->wl.fbWidth = (window->wl.width * window->wl.scalingNumerator + 60) / 120;
-        window->wl.fbHeight = (window->wl.height * window->wl.scalingNumerator + 60) / 120;
+        window->wl.fbWidth = (window->wl.width * window->wl.scalingNumerator) / 120;
+        window->wl.fbHeight = (window->wl.height * window->wl.scalingNumerator) / 120;
     }
     else
     {
@@ -662,7 +499,7 @@ static void setIdleInhibitor(_GLFWwindow* window, GLFWbool enable)
 
 // Make the specified window and its video mode active on its monitor
 //
-static void acquireMonitor(_GLFWwindow* window)
+static void acquireMonitorWayland(_GLFWwindow* window)
 {
     if (window->wl.libdecor.frame)
     {
@@ -683,7 +520,7 @@ static void acquireMonitor(_GLFWwindow* window)
 
 // Remove the window and restore the original video mode
 //
-static void releaseMonitor(_GLFWwindow* window)
+static void releaseMonitorWayland(_GLFWwindow* window)
 {
     if (window->wl.libdecor.frame)
         libdecor_frame_unset_fullscreen(window->wl.libdecor.frame);
@@ -897,10 +734,6 @@ void libdecorFrameHandleConfigure(struct libdecor_frame* frame,
     libdecor_frame_commit(frame, frameState, config);
     libdecor_state_free(frameState);
 
-    // NOTE: Frame visibility must only be set after a frame state has been committed
-    if (window->decorated != libdecor_frame_is_visible(window->wl.libdecor.frame))
-        libdecor_frame_set_visibility(window->wl.libdecor.frame, window->decorated);
-
     if (window->wl.activated != activated)
     {
         window->wl.activated = activated;
@@ -982,39 +815,36 @@ static GLFWbool createLibdecorFrame(_GLFWwindow* window)
         return GLFW_FALSE;
     }
 
+    struct libdecor_state* frameState =
+        libdecor_state_new(window->wl.width, window->wl.height);
+    libdecor_frame_commit(window->wl.libdecor.frame, frameState, NULL);
+    libdecor_state_free(frameState);
+
     if (strlen(window->wl.appId))
         libdecor_frame_set_app_id(window->wl.libdecor.frame, window->wl.appId);
 
     libdecor_frame_set_title(window->wl.libdecor.frame, window->title);
 
-    if (window->resizable)
+    if (window->minwidth != GLFW_DONT_CARE &&
+        window->minheight != GLFW_DONT_CARE)
     {
-        if (window->minwidth != GLFW_DONT_CARE &&
-            window->minheight != GLFW_DONT_CARE)
-        {
-            libdecor_frame_set_min_content_size(window->wl.libdecor.frame,
-                                                window->minwidth,
-                                                window->minheight);
-        }
-
-        if (window->maxwidth != GLFW_DONT_CARE &&
-            window->maxheight != GLFW_DONT_CARE)
-        {
-            libdecor_frame_set_max_content_size(window->wl.libdecor.frame,
-                                                window->maxwidth,
-                                                window->maxheight);
-        }
+        libdecor_frame_set_min_content_size(window->wl.libdecor.frame,
+                                            window->minwidth,
+                                            window->minheight);
     }
-    else
+
+    if (window->maxwidth != GLFW_DONT_CARE &&
+        window->maxheight != GLFW_DONT_CARE)
+    {
+        libdecor_frame_set_max_content_size(window->wl.libdecor.frame,
+                                            window->maxwidth,
+                                            window->maxheight);
+    }
+
+    if (!window->resizable)
     {
         libdecor_frame_unset_capabilities(window->wl.libdecor.frame,
                                           LIBDECOR_ACTION_RESIZE);
-        libdecor_frame_set_min_content_size(window->wl.libdecor.frame,
-                                            window->wl.width,
-                                            window->wl.height);
-        libdecor_frame_set_max_content_size(window->wl.libdecor.frame,
-                                            window->wl.width,
-                                            window->wl.height);
     }
 
     if (window->monitor)
@@ -1025,11 +855,12 @@ static GLFWbool createLibdecorFrame(_GLFWwindow* window)
     }
     else
     {
-        // Frame visibility is applied in libdecorFrameHandleConfigure
-
         if (window->wl.maximized)
             libdecor_frame_set_maximized(window->wl.libdecor.frame);
 
+        if (!window->decorated)
+            libdecor_frame_set_visibility(window->wl.libdecor.frame, false);
+
         setIdleInhibitor(window, GLFW_FALSE);
     }
 
@@ -1291,16 +1122,14 @@ static void setCursorImage(_GLFWwindow* window,
     wl_surface_commit(surface);
 }
 
-static void incrementCursorImage(void)
+static void incrementCursorImage(_GLFWwindow* window)
 {
-    if (!_glfw.wl.pointerSurface)
+    _GLFWcursor* cursor;
+
+    if (!window || !window->wl.hovered)
         return;
 
-    _GLFWwindow* window = wl_surface_get_user_data(_glfw.wl.pointerSurface);
-    if (window->wl.surface != _glfw.wl.pointerSurface)
-        return;
-
-    _GLFWcursor* cursor = window->cursor;
+    cursor = window->wl.currentCursor;
     if (cursor && cursor->wl.cursor)
     {
         cursor->wl.currentImage += 1;
@@ -1328,7 +1157,7 @@ static GLFWbool flushDisplay(void)
     return GLFW_TRUE;
 }
 
-static int translateKey(uint32_t scancode)
+static int translateKeyWayland(uint32_t scancode)
 {
     if (scancode < sizeof(_glfw.wl.keycodes) / sizeof(_glfw.wl.keycodes[0]))
         return _glfw.wl.keycodes[scancode];
@@ -1364,8 +1193,8 @@ static void inputText(_GLFWwindow* window, uint32_t scancode)
     if (xkb_state_key_get_syms(_glfw.wl.xkb.state, keycode, &keysyms) == 1)
     {
         const xkb_keysym_t keysym = composeSymbol(keysyms[0]);
-        const uint32_t codepoint = xkb_keysym_to_utf32(keysym);
-        if (codepoint != 0)
+        const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
+        if (codepoint != GLFW_INVALID_CODEPOINT)
         {
             const int mods = _glfw.wl.xkb.modifiers;
             const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
@@ -1382,27 +1211,24 @@ static void handleEvents(double* timeout)
 #endif
 
     GLFWbool event = GLFW_FALSE;
-    enum { DISPLAY_FD, KEYREPEAT_FD, CURSOR_FD };
+    enum { DISPLAY_FD, KEYREPEAT_FD, CURSOR_FD, LIBDECOR_FD };
     struct pollfd fds[] =
     {
         [DISPLAY_FD] = { wl_display_get_fd(_glfw.wl.display), POLLIN },
         [KEYREPEAT_FD] = { _glfw.wl.keyRepeatTimerfd, POLLIN },
-        [CURSOR_FD] = { _glfw.wl.cursorTimerfd, POLLIN }
+        [CURSOR_FD] = { _glfw.wl.cursorTimerfd, POLLIN },
+        [LIBDECOR_FD] = { -1, POLLIN }
     };
 
+    if (_glfw.wl.libdecor.context)
+        fds[LIBDECOR_FD].fd = libdecor_get_fd(_glfw.wl.libdecor.context);
+
     while (!event)
     {
-        if (_glfw.wl.libdecor.context)
-        {
-            // Dispatch unconditionally because it also processes non-Wayland events
-            if (libdecor_dispatch(_glfw.wl.libdecor.context, 0) > 0)
-                event = GLFW_TRUE;
-        }
-
         while (wl_display_prepare_read(_glfw.wl.display) != 0)
         {
             if (wl_display_dispatch_pending(_glfw.wl.display) > 0)
-                event = GLFW_TRUE;
+                return;
         }
 
         // If an error other than EAGAIN happens, we have likely been disconnected
@@ -1421,11 +1247,6 @@ static void handleEvents(double* timeout)
             return;
         }
 
-        double immediate = 0.0;
-
-        if (event)
-            timeout = &immediate;
-
         if (!_glfwPollPOSIX(fds, sizeof(fds) / sizeof(fds[0]), timeout))
         {
             wl_display_cancel_read(_glfw.wl.display);
@@ -1447,21 +1268,17 @@ static void handleEvents(double* timeout)
 
             if (read(_glfw.wl.keyRepeatTimerfd, &repeats, sizeof(repeats)) == 8)
             {
-                if (_glfw.wl.keyboardFocus)
+                for (uint64_t i = 0; i < repeats; i++)
                 {
-                    for (uint64_t i = 0; i < repeats; i++)
-                    {
-                        _glfwInputKey(_glfw.wl.keyboardFocus,
-                                      translateKey(_glfw.wl.keyRepeatScancode),
-                                      _glfw.wl.keyRepeatScancode,
-                                      GLFW_PRESS,
-                                      _glfw.wl.xkb.modifiers);
-                        inputText(_glfw.wl.keyboardFocus, _glfw.wl.keyRepeatScancode);
-                    }
-
-                    event = GLFW_TRUE;
+                    _glfwInputKey(_glfw.wl.keyboardFocus,
+                                  translateKeyWayland(_glfw.wl.keyRepeatScancode),
+                                  _glfw.wl.keyRepeatScancode,
+                                  GLFW_PRESS,
+                                  _glfw.wl.xkb.modifiers);
+                    inputText(_glfw.wl.keyboardFocus, _glfw.wl.keyRepeatScancode);
                 }
 
+                event = GLFW_TRUE;
             }
         }
 
@@ -1470,7 +1287,13 @@ static void handleEvents(double* timeout)
             uint64_t repeats;
 
             if (read(_glfw.wl.cursorTimerfd, &repeats, sizeof(repeats)) == 8)
-                incrementCursorImage();
+                incrementCursorImage(_glfw.wl.pointerFocus);
+        }
+
+        if (fds[LIBDECOR_FD].revents & POLLIN)
+        {
+            if (libdecor_dispatch(_glfw.wl.libdecor.context, 0) > 0)
+                event = GLFW_TRUE;
         }
     }
 }
@@ -1507,7 +1330,6 @@ static char* readDataOfferAsString(struct wl_data_offer* offer, const char* mime
             if (!longer)
             {
                 _glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
-                _glfw_free(string);
                 close(fds[0]);
                 return NULL;
             }
@@ -1527,7 +1349,6 @@ static char* readDataOfferAsString(struct wl_data_offer* offer, const char* mime
             _glfwInputError(GLFW_PLATFORM_ERROR,
                             "Wayland: Failed to read from data offer pipe: %s",
                             strerror(errno));
-            _glfw_free(string);
             close(fds[0]);
             return NULL;
         }
@@ -1541,70 +1362,6 @@ static char* readDataOfferAsString(struct wl_data_offer* offer, const char* mime
     return string;
 }
 
-static void processPointerEnterSurface(struct wl_surface* surface)
-{
-    _glfw.wl.pointerSurface = surface;
-
-    _GLFWwindow* window = wl_surface_get_user_data(_glfw.wl.pointerSurface);
-    if (window->wl.surface == _glfw.wl.pointerSurface)
-    {
-        _glfwSetCursorWayland(window, window->cursor);
-        _glfwInputCursorEnter(window, GLFW_TRUE);
-    }
-}
-
-static void processPointerLeaveSurface(struct wl_surface* surface)
-{
-    _glfw.wl.pointerSurface = NULL;
-
-    _GLFWwindow* window = wl_surface_get_user_data(surface);
-    if (window->wl.surface == surface)
-        _glfwInputCursorEnter(window, GLFW_FALSE);
-    else
-    {
-        if (window->wl.fallback.decorations)
-            window->wl.fallback.cursorName = NULL;
-    }
-}
-
-static void processPointerMotion(double xpos, double ypos)
-{
-    _GLFWwindow* window = wl_surface_get_user_data(_glfw.wl.pointerSurface);
-    if (window->wl.surface == _glfw.wl.pointerSurface)
-    {
-        if (window->cursorMode != GLFW_CURSOR_DISABLED)
-        {
-            window->wl.cursorPosX = xpos;
-            window->wl.cursorPosY = ypos;
-            _glfwInputCursorPos(window, window->wl.cursorPosX, window->wl.cursorPosY);
-        }
-    }
-    else
-    {
-        if (window->wl.fallback.decorations)
-            updateFallbackDecorationCursor(window, xpos, ypos);
-    }
-}
-
-static void processPointerButton(int button, int action)
-{
-    _GLFWwindow* window = wl_surface_get_user_data(_glfw.wl.pointerSurface);
-    if (window->wl.surface == _glfw.wl.pointerSurface)
-        _glfwInputMouseClick(window, button, action, _glfw.wl.xkb.modifiers);
-    else
-    {
-        if (window->wl.fallback.decorations)
-            handleFallbackDecorationButton(window, button, action);
-    }
-}
-
-static void processPointerScroll(double xoffset, double yoffset)
-{
-    _GLFWwindow* window = wl_surface_get_user_data(_glfw.wl.pointerSurface);
-    if (window->wl.surface == _glfw.wl.pointerSurface)
-        _glfwInputScroll(window, xoffset, yoffset);
-}
-
 static void pointerHandleEnter(void* userData,
                                struct wl_pointer* pointer,
                                uint32_t serial,
@@ -1619,23 +1376,22 @@ static void pointerHandleEnter(void* userData,
     if (wl_proxy_get_tag((struct wl_proxy*) surface) != &_glfw.wl.tag)
         return;
 
+    _GLFWwindow* window = wl_surface_get_user_data(surface);
+
     _glfw.wl.serial = serial;
     _glfw.wl.pointerEnterSerial = serial;
+    _glfw.wl.pointerFocus = window;
 
-    const double xpos = wl_fixed_to_double(sx);
-    const double ypos = wl_fixed_to_double(sy);
-
-    if (wl_pointer_get_version(pointer) >= WL_POINTER_FRAME_SINCE_VERSION)
+    if (surface == window->wl.surface)
     {
-        _glfw.wl.pending.events |= (GLFW_PENDING_SURFACE | GLFW_PENDING_MOTION);
-        _glfw.wl.pending.pointerSurface = surface;
-        _glfw.wl.pending.pointerX = xpos;
-        _glfw.wl.pending.pointerY = ypos;
+        window->wl.hovered = GLFW_TRUE;
+        _glfwSetCursorWayland(window, window->wl.currentCursor);
+        _glfwInputCursorEnter(window, GLFW_TRUE);
     }
     else
     {
-        processPointerEnterSurface(surface);
-        processPointerMotion(xpos, ypos);
+        if (window->wl.fallback.decorations)
+            window->wl.fallback.focus = surface;
     }
 }
 
@@ -1650,15 +1406,24 @@ static void pointerHandleLeave(void* userData,
     if (wl_proxy_get_tag((struct wl_proxy*) surface) != &_glfw.wl.tag)
         return;
 
-    _glfw.wl.serial = serial;
+    _GLFWwindow* window = _glfw.wl.pointerFocus;
+    if (!window)
+        return;
 
-    if (wl_pointer_get_version(pointer) >= WL_POINTER_FRAME_SINCE_VERSION)
+    _glfw.wl.serial = serial;
+    _glfw.wl.pointerFocus = NULL;
+    _glfw.wl.cursorPreviousName = NULL;
+
+    if (window->wl.hovered)
     {
-        _glfw.wl.pending.events |= GLFW_PENDING_SURFACE;
-        _glfw.wl.pending.pointerSurface = NULL;
+        window->wl.hovered = GLFW_FALSE;
+        _glfwInputCursorEnter(window, GLFW_FALSE);
     }
     else
-        processPointerLeaveSurface(surface);
+    {
+        if (window->wl.fallback.decorations)
+            window->wl.fallback.focus = NULL;
+    }
 }
 
 static void pointerHandleMotion(void* userData,
@@ -1667,52 +1432,178 @@ static void pointerHandleMotion(void* userData,
                                 wl_fixed_t sx,
                                 wl_fixed_t sy)
 {
-    if (!_glfw.wl.pointerSurface)
+    _GLFWwindow* window = _glfw.wl.pointerFocus;
+    if (!window)
+        return;
+
+    if (window->cursorMode == GLFW_CURSOR_DISABLED)
         return;
 
     const double xpos = wl_fixed_to_double(sx);
     const double ypos = wl_fixed_to_double(sy);
+    window->wl.cursorPosX = xpos;
+    window->wl.cursorPosY = ypos;
 
-    if (wl_pointer_get_version(pointer) >= WL_POINTER_FRAME_SINCE_VERSION)
+    if (window->wl.hovered)
     {
-        _glfw.wl.pending.events |= GLFW_PENDING_MOTION;
-        _glfw.wl.pending.pointerX = xpos;
-        _glfw.wl.pending.pointerY = ypos;
+        _glfw.wl.cursorPreviousName = NULL;
+        _glfwInputCursorPos(window, xpos, ypos);
+        return;
+    }
+
+    if (window->wl.fallback.decorations)
+    {
+        const char* cursorName = "left_ptr";
+
+        if (window->resizable)
+        {
+            if (window->wl.fallback.focus == window->wl.fallback.top.surface)
+            {
+                if (ypos < GLFW_BORDER_SIZE)
+                    cursorName = "n-resize";
+            }
+            else if (window->wl.fallback.focus == window->wl.fallback.left.surface)
+            {
+                if (ypos < GLFW_BORDER_SIZE)
+                    cursorName = "nw-resize";
+                else
+                    cursorName = "w-resize";
+            }
+            else if (window->wl.fallback.focus == window->wl.fallback.right.surface)
+            {
+                if (ypos < GLFW_BORDER_SIZE)
+                    cursorName = "ne-resize";
+                else
+                    cursorName = "e-resize";
+            }
+            else if (window->wl.fallback.focus == window->wl.fallback.bottom.surface)
+            {
+                if (xpos < GLFW_BORDER_SIZE)
+                    cursorName = "sw-resize";
+                else if (xpos > window->wl.width + GLFW_BORDER_SIZE)
+                    cursorName = "se-resize";
+                else
+                    cursorName = "s-resize";
+            }
+        }
+
+        if (_glfw.wl.cursorPreviousName != cursorName)
+        {
+            struct wl_surface* surface = _glfw.wl.cursorSurface;
+            struct wl_cursor_theme* theme = _glfw.wl.cursorTheme;
+            int scale = 1;
+
+            if (window->wl.bufferScale > 1 && _glfw.wl.cursorThemeHiDPI)
+            {
+                // We only support up to scale=2 for now, since libwayland-cursor
+                // requires us to load a different theme for each size.
+                scale = 2;
+                theme = _glfw.wl.cursorThemeHiDPI;
+            }
+
+            struct wl_cursor* cursor = wl_cursor_theme_get_cursor(theme, cursorName);
+            if (!cursor)
+                return;
+
+            // TODO: handle animated cursors too.
+            struct wl_cursor_image* image = cursor->images[0];
+            if (!image)
+                return;
+
+            struct wl_buffer* buffer = wl_cursor_image_get_buffer(image);
+            if (!buffer)
+                return;
+
+            wl_pointer_set_cursor(_glfw.wl.pointer, _glfw.wl.pointerEnterSerial,
+                                  surface,
+                                  image->hotspot_x / scale,
+                                  image->hotspot_y / scale);
+            wl_surface_set_buffer_scale(surface, scale);
+            wl_surface_attach(surface, buffer, 0, 0);
+            wl_surface_damage(surface, 0, 0, image->width, image->height);
+            wl_surface_commit(surface);
+
+            _glfw.wl.cursorPreviousName = cursorName;
+        }
     }
-    else
-        processPointerMotion(xpos, ypos);
 }
 
 static void pointerHandleButton(void* userData,
                                 struct wl_pointer* pointer,
                                 uint32_t serial,
                                 uint32_t time,
-                                uint32_t buttonID,
+                                uint32_t button,
                                 uint32_t state)
 {
-    if (!_glfw.wl.pointerSurface)
+    _GLFWwindow* window = _glfw.wl.pointerFocus;
+    if (!window)
         return;
 
-    _glfw.wl.serial = serial;
+    if (window->wl.hovered)
+    {
+        _glfw.wl.serial = serial;
 
-    const int button = buttonID - BTN_LEFT;
-    const int action = (state == WL_POINTER_BUTTON_STATE_PRESSED);
+        _glfwInputMouseClick(window,
+                             button - BTN_LEFT,
+                             state == WL_POINTER_BUTTON_STATE_PRESSED,
+                             _glfw.wl.xkb.modifiers);
+        return;
+    }
 
-    _GLFWwindow* window = wl_surface_get_user_data(_glfw.wl.pointerSurface);
     if (window->wl.fallback.decorations)
     {
-        if (action == GLFW_PRESS)
-            window->wl.fallback.buttonPressSerial = serial;
-    }
+        if (button == BTN_LEFT)
+        {
+            uint32_t edges = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
 
-    if (wl_pointer_get_version(pointer) >= WL_POINTER_FRAME_SINCE_VERSION)
-    {
-        _glfw.wl.pending.events |= GLFW_PENDING_BUTTON;
-        _glfw.wl.pending.button = button;
-        _glfw.wl.pending.action = action;
+            if (window->wl.fallback.focus == window->wl.fallback.top.surface)
+            {
+                if (window->wl.cursorPosY < GLFW_BORDER_SIZE)
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
+                else
+                    xdg_toplevel_move(window->wl.xdg.toplevel, _glfw.wl.seat, serial);
+            }
+            else if (window->wl.fallback.focus == window->wl.fallback.left.surface)
+            {
+                if (window->wl.cursorPosY < GLFW_BORDER_SIZE)
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
+                else
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
+            }
+            else if (window->wl.fallback.focus == window->wl.fallback.right.surface)
+            {
+                if (window->wl.cursorPosY < GLFW_BORDER_SIZE)
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
+                else
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
+            }
+            else if (window->wl.fallback.focus == window->wl.fallback.bottom.surface)
+            {
+                if (window->wl.cursorPosX < GLFW_BORDER_SIZE)
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
+                else if (window->wl.cursorPosX > window->wl.width + GLFW_BORDER_SIZE)
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
+                else
+                    edges = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
+            }
+
+            if (edges != XDG_TOPLEVEL_RESIZE_EDGE_NONE)
+            {
+                xdg_toplevel_resize(window->wl.xdg.toplevel, _glfw.wl.seat,
+                                    serial, edges);
+            }
+        }
+        else if (button == BTN_RIGHT)
+        {
+            if (window->wl.xdg.toplevel)
+            {
+                xdg_toplevel_show_window_menu(window->wl.xdg.toplevel,
+                                              _glfw.wl.seat, serial,
+                                              window->wl.cursorPosX,
+                                              window->wl.cursorPosY);
+            }
+        }
     }
-    else
-        processPointerButton(button, action);
 }
 
 static void pointerHandleAxis(void* userData,
@@ -1721,88 +1612,15 @@ static void pointerHandleAxis(void* userData,
                               uint32_t axis,
                               wl_fixed_t value)
 {
-    if (!_glfw.wl.pointerSurface)
+    _GLFWwindow* window = _glfw.wl.pointerFocus;
+    if (!window)
         return;
 
-    if (wl_pointer_get_version(pointer) >= WL_POINTER_FRAME_SINCE_VERSION)
-    {
-        _glfw.wl.pending.events |= GLFW_PENDING_SCROLL;
-        if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL)
-            _glfw.wl.pending.scrollX = -wl_fixed_to_double(value) / 10.0;
-        else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
-            _glfw.wl.pending.scrollY = -wl_fixed_to_double(value) / 10.0;
-    }
-    else
-    {
-        // NOTE: 10 units of motion per mouse wheel step seems to be a common ratio
-        if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL)
-            processPointerScroll(-wl_fixed_to_double(value) / 10.0, 0.0);
-        else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
-            processPointerScroll(0.0, -wl_fixed_to_double(value) / 10.0);
-    }
-}
-
-static void pointerHandleFrame(void* userData, struct wl_pointer* pointer)
-{
-    if (_glfw.wl.pending.events & GLFW_PENDING_SURFACE)
-    {
-        if (_glfw.wl.pointerSurface)
-            processPointerLeaveSurface(_glfw.wl.pointerSurface);
-
-        if (_glfw.wl.pending.pointerSurface)
-            processPointerEnterSurface(_glfw.wl.pending.pointerSurface);
-    }
-
-    if (!_glfw.wl.pointerSurface)
-        return;
-
-    if (_glfw.wl.pending.events & GLFW_PENDING_MOTION)
-        processPointerMotion(_glfw.wl.pending.pointerX, _glfw.wl.pending.pointerY);
-
-    if (_glfw.wl.pending.events & GLFW_PENDING_BUTTON)
-        processPointerButton(_glfw.wl.pending.button, _glfw.wl.pending.action);
-
-    if (_glfw.wl.pending.events & GLFW_PENDING_DISCRETE)
-        processPointerScroll(_glfw.wl.pending.discreteX, _glfw.wl.pending.discreteY);
-    else if (_glfw.wl.pending.events & GLFW_PENDING_SCROLL)
-        processPointerScroll(_glfw.wl.pending.scrollX, _glfw.wl.pending.scrollY);
-
-    memset(&_glfw.wl.pending, 0, sizeof(_glfw.wl.pending));
-}
-
-static void pointerHandleAxisSource(void* userData,
-                                    struct wl_pointer* pointer,
-                                    uint32_t axisSource)
-{
-}
-
-static void pointerHandleAxisStop(void* userData,
-                                  struct wl_pointer* pointer,
-                                  uint32_t time,
-                                  uint32_t axis)
-{
-}
-
-static void pointerHandleAxisDiscrete(void* userData,
-                                      struct wl_pointer* pointer,
-                                      uint32_t axis,
-                                      int32_t discrete)
-{
-}
-
-static void pointerHandleAxisValue120(void* data,
-                                      struct wl_pointer* pointer,
-                                      uint32_t axis,
-                                      int32_t value120)
-{
-    if (!_glfw.wl.pointerSurface)
-        return;
-
-    _glfw.wl.pending.events |= GLFW_PENDING_DISCRETE;
+    // NOTE: 10 units of motion per mouse wheel step seems to be a common ratio
     if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL)
-        _glfw.wl.pending.discreteX = -(value120 / 120.0);
+        _glfwInputScroll(window, -wl_fixed_to_double(value) / 10.0, 0.0);
     else if (axis == WL_POINTER_AXIS_VERTICAL_SCROLL)
-        _glfw.wl.pending.discreteY = -(value120 / 120.0);
+        _glfwInputScroll(window, 0.0, -wl_fixed_to_double(value) / 10.0);
 }
 
 static const struct wl_pointer_listener pointerListener =
@@ -1812,11 +1630,6 @@ static const struct wl_pointer_listener pointerListener =
     pointerHandleMotion,
     pointerHandleButton,
     pointerHandleAxis,
-    pointerHandleFrame,
-    pointerHandleAxisSource,
-    pointerHandleAxisStop,
-    pointerHandleAxisDiscrete,
-    pointerHandleAxisValue120
 };
 
 static void keyboardHandleKeymap(void* userData,
@@ -1839,9 +1652,8 @@ static void keyboardHandleKeymap(void* userData,
         return;
     }
 
-    mapStr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
-    if (mapStr == MAP_FAILED)
-    {
+    mapStr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
+    if (mapStr == MAP_FAILED) {
         close(fd);
         return;
     }
@@ -1849,7 +1661,7 @@ static void keyboardHandleKeymap(void* userData,
     keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
                                         mapStr,
                                         XKB_KEYMAP_FORMAT_TEXT_V1,
-                                        XKB_KEYMAP_COMPILE_NO_FLAGS);
+                                        0);
     munmap(mapStr, size);
     close(fd);
 
@@ -1962,7 +1774,7 @@ static void keyboardHandleKey(void* userData,
     if (!window)
         return;
 
-    const int key = translateKey(scancode);
+    const int key = translateKeyWayland(scancode);
     const int action =
         state == WL_KEYBOARD_KEY_STATE_PRESSED ? GLFW_PRESS : GLFW_RELEASE;
 
@@ -1985,13 +1797,10 @@ static void keyboardHandleKey(void* userData,
 
             timer.it_value.tv_sec = _glfw.wl.keyRepeatDelay / 1000;
             timer.it_value.tv_nsec = (_glfw.wl.keyRepeatDelay % 1000) * 1000000;
-            timerfd_settime(_glfw.wl.keyRepeatTimerfd, 0, &timer, NULL);
         }
     }
-    else if (scancode == _glfw.wl.keyRepeatScancode)
-    {
-        timerfd_settime(_glfw.wl.keyRepeatTimerfd, 0, &timer, NULL);
-    }
+
+    timerfd_settime(_glfw.wl.keyRepeatTimerfd, 0, &timer, NULL);
 
     _glfwInputKey(window, key, scancode, action, _glfw.wl.xkb.modifiers);
 
@@ -2080,11 +1889,7 @@ static void seatHandleCapabilities(void* userData,
     }
     else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && _glfw.wl.pointer)
     {
-        if (wl_pointer_get_version(_glfw.wl.pointer) >= WL_POINTER_RELEASE_SINCE_VERSION)
-            wl_pointer_release(_glfw.wl.pointer);
-        else
-            wl_pointer_destroy(_glfw.wl.pointer);
-
+        wl_pointer_destroy(_glfw.wl.pointer);
         _glfw.wl.pointer = NULL;
     }
 
@@ -2092,21 +1897,10 @@ static void seatHandleCapabilities(void* userData,
     {
         _glfw.wl.keyboard = wl_seat_get_keyboard(seat);
         wl_keyboard_add_listener(_glfw.wl.keyboard, &keyboardListener, NULL);
-
-        if (wl_keyboard_get_version(_glfw.wl.keyboard) <
-            WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
-        {
-            _glfw.wl.keyRepeatRate = 4;
-            _glfw.wl.keyRepeatDelay = 500;
-        }
     }
     else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD) && _glfw.wl.keyboard)
     {
-        if (wl_keyboard_get_version(_glfw.wl.keyboard) >= WL_KEYBOARD_RELEASE_SINCE_VERSION)
-            wl_keyboard_release(_glfw.wl.keyboard);
-        else
-            wl_keyboard_destroy(_glfw.wl.keyboard);
-
+        wl_keyboard_destroy(_glfw.wl.keyboard);
         _glfw.wl.keyboard = NULL;
     }
 }
@@ -2181,41 +1975,41 @@ static void dataDeviceHandleEnter(void* userData,
         _glfw.wl.dragFocus = NULL;
     }
 
-    unsigned int i;
-
-    for (i = 0; i < _glfw.wl.offerCount; i++)
+    for (unsigned int i = 0; i < _glfw.wl.offerCount; i++)
     {
         if (_glfw.wl.offers[i].offer == offer)
-            break;
-    }
-
-    if (i == _glfw.wl.offerCount)
-        return;
-
-    if (surface && wl_proxy_get_tag((struct wl_proxy*) surface) == &_glfw.wl.tag)
-    {
-        _GLFWwindow* window = wl_surface_get_user_data(surface);
-        if (window->wl.surface == surface)
         {
-            if (_glfw.wl.offers[i].text_uri_list)
+            _GLFWwindow* window = NULL;
+
+            if (surface)
+            {
+                if (wl_proxy_get_tag((struct wl_proxy*) surface) == &_glfw.wl.tag)
+                    window = wl_surface_get_user_data(surface);
+            }
+
+            if (surface == window->wl.surface && _glfw.wl.offers[i].text_uri_list)
             {
                 _glfw.wl.dragOffer = offer;
                 _glfw.wl.dragFocus = window;
                 _glfw.wl.dragSerial = serial;
-
-                wl_data_offer_accept(offer, serial, "text/uri-list");
             }
+
+            _glfw.wl.offers[i] = _glfw.wl.offers[_glfw.wl.offerCount - 1];
+            _glfw.wl.offerCount--;
+            break;
         }
     }
 
-    if (!_glfw.wl.dragOffer)
+    if (wl_proxy_get_tag((struct wl_proxy*) surface) != &_glfw.wl.tag)
+        return;
+
+    if (_glfw.wl.dragOffer)
+        wl_data_offer_accept(offer, serial, "text/uri-list");
+    else
     {
         wl_data_offer_accept(offer, serial, NULL);
         wl_data_offer_destroy(offer);
     }
-
-    _glfw.wl.offers[i] = _glfw.wl.offers[_glfw.wl.offerCount - 1];
-    _glfw.wl.offerCount--;
 }
 
 static void dataDeviceHandleLeave(void* userData,
@@ -2249,17 +2043,15 @@ static void dataDeviceHandleDrop(void* userData,
         int count;
         char** paths = _glfwParseUriList(string, &count);
         if (paths)
-        {
             _glfwInputDrop(_glfw.wl.dragFocus, count, (const char**) paths);
 
-            for (int i = 0; i < count; i++)
-                _glfw_free(paths[i]);
+        for (int i = 0; i < count; i++)
+            _glfw_free(paths[i]);
 
-            _glfw_free(paths);
-        }
-
-        _glfw_free(string);
+        _glfw_free(paths);
     }
+
+    _glfw_free(string);
 }
 
 static void dataDeviceHandleSelection(void* userData,
@@ -2317,18 +2109,6 @@ static const struct xdg_activation_token_v1_listener xdgActivationListener =
     xdgActivationHandleDone
 };
 
-static void callbackHandleFrame(void* userData, struct wl_callback* callback, uint32_t data)
-{
-    _GLFWwindow* window = userData;
-    wl_callback_destroy(callback);
-    window->wl.egl.callback = NULL;
-}
-
-static const struct wl_callback_listener frameCallbackListener =
-{
-    callbackHandleFrame
-};
-
 void _glfwAddSeatListenerWayland(struct wl_seat* seat)
 {
     wl_seat_add_listener(seat, &seatListener, NULL);
@@ -2339,42 +2119,6 @@ void _glfwAddDataDeviceListenerWayland(struct wl_data_device* device)
     wl_data_device_add_listener(device, &dataDeviceListener, NULL);
 }
 
-GLFWbool _glfwWaitForEGLFrameWayland(_GLFWwindow* window)
-{
-    double timeout = 0.02;
-
-    while (window->wl.egl.callback)
-    {
-        if (wl_display_prepare_read_queue(_glfw.wl.display, window->wl.egl.queue) != 0)
-        {
-            wl_display_dispatch_queue_pending(_glfw.wl.display, window->wl.egl.queue);
-            continue;
-        }
-
-        if (!flushDisplay())
-        {
-            wl_display_cancel_read(_glfw.wl.display);
-            return GLFW_FALSE;
-        }
-
-        struct pollfd fd = { wl_display_get_fd(_glfw.wl.display), POLLIN };
-
-        if (!_glfwPollPOSIX(&fd, 1, &timeout))
-        {
-            wl_display_cancel_read(_glfw.wl.display);
-            return GLFW_FALSE;
-        }
-
-        wl_display_read_events(_glfw.wl.display);
-        wl_display_dispatch_queue_pending(_glfw.wl.display, window->wl.egl.queue);
-    }
-
-    window->wl.egl.callback = wl_surface_frame(window->wl.egl.wrapper);
-    wl_callback_add_listener(window->wl.egl.callback, &frameCallbackListener, window);
-
-    // If the window is hidden when the wait is over then don't swap
-    return window->wl.visible;
-}
 
 //////////////////////////////////////////////////////////////////////////
 //////                       GLFW platform API                      //////
@@ -2403,27 +2147,6 @@ GLFWbool _glfwCreateWindowWayland(_GLFWwindow* window,
                 return GLFW_FALSE;
             }
 
-            window->wl.egl.queue = wl_display_create_queue(_glfw.wl.display);
-            if (!window->wl.egl.queue)
-            {
-                _glfwInputError(GLFW_PLATFORM_ERROR,
-                                "Wayland: Failed to create EGL frame queue");
-                return GLFW_FALSE;
-            }
-
-            window->wl.egl.wrapper = wl_proxy_create_wrapper(window->wl.surface);
-            if (!window->wl.egl.wrapper)
-            {
-                _glfwInputError(GLFW_PLATFORM_ERROR,
-                                "Wayland: Failed to create surface wrapper");
-                return GLFW_FALSE;
-            }
-
-            wl_proxy_set_queue((struct wl_proxy*) window->wl.egl.wrapper,
-                               window->wl.egl.queue);
-
-            window->wl.egl.interval = 1;
-
             if (!_glfwInitEGL())
                 return GLFW_FALSE;
             if (!_glfwCreateContextEGL(window, ctxconfig, fbconfig))
@@ -2455,22 +2178,11 @@ GLFWbool _glfwCreateWindowWayland(_GLFWwindow* window,
 
 void _glfwDestroyWindowWayland(_GLFWwindow* window)
 {
-    if (window->wl.surface == _glfw.wl.pointerSurface)
-        _glfw.wl.pointerSurface = NULL;
+    if (window == _glfw.wl.pointerFocus)
+        _glfw.wl.pointerFocus = NULL;
 
     if (window == _glfw.wl.keyboardFocus)
-    {
-        struct itimerspec timer = {0};
-        timerfd_settime(_glfw.wl.keyRepeatTimerfd, 0, &timer, NULL);
-
         _glfw.wl.keyboardFocus = NULL;
-    }
-
-    if (window->wl.fractionalScale)
-        wp_fractional_scale_v1_destroy(window->wl.fractionalScale);
-
-    if (window->wl.scalingViewport)
-        wp_viewport_destroy(window->wl.scalingViewport);
 
     if (window->wl.activationToken)
         xdg_activation_token_v1_destroy(window->wl.activationToken);
@@ -2495,15 +2207,6 @@ void _glfwDestroyWindowWayland(_GLFWwindow* window)
     if (window->wl.fallback.buffer)
         wl_buffer_destroy(window->wl.fallback.buffer);
 
-    if (window->wl.egl.callback)
-        wl_callback_destroy(window->wl.egl.callback);
-
-    if (window->wl.egl.wrapper)
-        wl_proxy_wrapper_destroy(window->wl.egl.wrapper);
-
-    if (window->wl.egl.queue)
-        wl_event_queue_destroy(window->wl.egl.queue);
-
     if (window->wl.egl.window)
         wl_egl_window_destroy(window->wl.egl.window);
 
@@ -2737,8 +2440,6 @@ void _glfwHideWindowWayland(_GLFWwindow* window)
 
         wl_surface_attach(window->wl.surface, NULL, 0, 0);
         wl_surface_commit(window->wl.surface);
-
-        flushDisplay();
     }
 }
 
@@ -2809,12 +2510,12 @@ void _glfwSetWindowMonitorWayland(_GLFWwindow* window,
     }
 
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorWayland(window);
 
     _glfwInputWindowMonitor(window, monitor);
 
     if (window->monitor)
-        acquireMonitor(window);
+        acquireMonitorWayland(window);
     else
         _glfwSetWindowSizeWayland(window, width, height);
 }
@@ -2843,7 +2544,7 @@ GLFWbool _glfwWindowMaximizedWayland(_GLFWwindow* window)
 
 GLFWbool _glfwWindowHoveredWayland(_GLFWwindow* window)
 {
-    return window->wl.surface == _glfw.wl.pointerSurface;
+    return window->wl.hovered;
 }
 
 GLFWbool _glfwFramebufferTransparentWayland(_GLFWwindow* window)
@@ -2953,9 +2654,7 @@ void _glfwWaitEventsTimeoutWayland(double timeout)
 
 void _glfwPostEmptyEventWayland(void)
 {
-    struct wl_callback* callback = wl_display_sync(_glfw.wl.display);
-    wl_callback_add_listener(callback, &noopCallbackListener, NULL);
-
+    wl_display_sync(_glfw.wl.display);
     flushDisplay();
 }
 
@@ -2975,7 +2674,7 @@ void _glfwSetCursorPosWayland(_GLFWwindow* window, double x, double y)
 
 void _glfwSetCursorModeWayland(_GLFWwindow* window, int mode)
 {
-    _glfwSetCursorWayland(window, window->cursor);
+    _glfwSetCursorWayland(window, window->wl.currentCursor);
 }
 
 const char* _glfwGetScancodeNameWayland(int scancode)
@@ -3015,23 +2714,23 @@ const char* _glfwGetScancodeNameWayland(int scancode)
         return NULL;
     }
 
-    // WORKAROUND: xkb_keysym_to_utf8() requires the third parameter (size of the output buffer)
-    // to be at least 7 (6 bytes + a null terminator), because it was written when UTF-8
-    // sequences could be up to 6 bytes long. The _glfw.wl.keynames buffers are only 5 bytes
-    // long, because UTF-8 sequences are now limited to 4 bytes and no codepoints were ever assigned
-    // that needed more than that. To work around this, we first copy to a temporary buffer.
-    //
-    // See: https://github.com/xkbcommon/libxkbcommon/issues/418
-    char temp_buffer[7];
-    const int bytes_written = xkb_keysym_to_utf8(keysyms[0], temp_buffer, sizeof(temp_buffer));
-    if (bytes_written <= 0 || bytes_written > 5)
+    const uint32_t codepoint = _glfwKeySym2Unicode(keysyms[0]);
+    if (codepoint == GLFW_INVALID_CODEPOINT)
     {
         _glfwInputError(GLFW_PLATFORM_ERROR,
-                        "Wayland: Failed to encode keysym as UTF-8");
+                        "Wayland: Failed to retrieve codepoint for key name");
         return NULL;
     }
-    memcpy(_glfw.wl.keynames[key], temp_buffer, bytes_written);
 
+    const size_t count = _glfwEncodeUTF8(_glfw.wl.keynames[key],  codepoint);
+    if (count == 0)
+    {
+        _glfwInputError(GLFW_PLATFORM_ERROR,
+                        "Wayland: Failed to encode codepoint for key name");
+        return NULL;
+    }
+
+    _glfw.wl.keynames[key][count] = '\0';
     return _glfw.wl.keynames[key];
 }
 
@@ -3222,16 +2921,10 @@ static void lockPointer(_GLFWwindow* window)
     if (!_glfw.wl.relativePointerManager)
     {
         _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
-                        "Wayland: The compositor does not support relative pointer motion");
+                        "Wayland: The compositor does not support pointer locking");
         return;
     }
 
-    if (!_glfw.wl.pointerConstraints)
-    {
-        _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
-                        "Wayland: The compositor does not support locking the pointer");
-    }
-
     window->wl.relativePointer =
         zwp_relative_pointer_manager_v1_get_relative_pointer(
             _glfw.wl.relativePointerManager,
@@ -3279,12 +2972,6 @@ static const struct zwp_confined_pointer_v1_listener confinedPointerListener =
 
 static void confinePointer(_GLFWwindow* window)
 {
-    if (!_glfw.wl.pointerConstraints)
-    {
-        _glfwInputError(GLFW_FEATURE_UNAVAILABLE,
-                        "Wayland: The compositor does not support confining the pointer");
-    }
-
     window->wl.confinedPointer =
         zwp_pointer_constraints_v1_confine_pointer(
             _glfw.wl.pointerConstraints,
@@ -3309,7 +2996,11 @@ void _glfwSetCursorWayland(_GLFWwindow* window, _GLFWcursor* cursor)
     if (!_glfw.wl.pointer)
         return;
 
-    if (window->wl.surface != _glfw.wl.pointerSurface)
+    window->wl.currentCursor = cursor;
+
+    // If we're not in the correct window just save the cursor
+    // the next time the pointer enters the window the cursor will change
+    if (!window->wl.hovered)
         return;
 
     // Update pointer lock to match cursor mode
@@ -3601,6 +3292,7 @@ GLFWAPI struct wl_display* glfwGetWaylandDisplay(void)
 
 GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_WAYLAND)
@@ -3610,9 +3302,6 @@ GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* handle)
         return NULL;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     return window->wl.surface;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/x11_init.c b/src/libraries/raylib/raylib/src/external/glfw/src/x11_init.c
index b0acbf7..000bde2 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/x11_init.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/x11_init.c
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 X11 - www.glfw.org
+// GLFW 3.4 X11 (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -210,7 +211,7 @@ static int translateKeySyms(const KeySym* keysyms, int width)
 
 // Create key code translation tables
 //
-static void createKeyTables(void)
+static void createKeyTablesX11(void)
 {
     int scancodeMin, scancodeMax;
 
@@ -535,7 +536,6 @@ static void detectEWMH(void)
                                    XA_WINDOW,
                                    (unsigned char**) &windowFromChild))
     {
-        _glfwReleaseErrorHandlerX11();
         XFree(windowFromRoot);
         return;
     }
@@ -909,7 +909,7 @@ static GLFWbool initExtensions(void)
     // Update the key code LUT
     // FIXME: We should listen to XkbMapNotify events to track changes to
     // the keyboard mapping.
-    createKeyTables();
+    createKeyTablesX11();
 
     // String format atoms
     _glfw.x11.NULL_ = XInternAtom(_glfw.x11.display, "NULL", False);
@@ -1592,29 +1592,65 @@ void _glfwTerminateX11(void)
         _glfw.x11.display = NULL;
     }
 
+    if (_glfw.x11.x11xcb.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.x11xcb.handle);
+        _glfw.x11.x11xcb.handle = NULL;
+    }
+
+    if (_glfw.x11.xcursor.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.xcursor.handle);
+        _glfw.x11.xcursor.handle = NULL;
+    }
+
+    if (_glfw.x11.randr.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.randr.handle);
+        _glfw.x11.randr.handle = NULL;
+    }
+
+    if (_glfw.x11.xinerama.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.xinerama.handle);
+        _glfw.x11.xinerama.handle = NULL;
+    }
+
+    if (_glfw.x11.xrender.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.xrender.handle);
+        _glfw.x11.xrender.handle = NULL;
+    }
+
+    if (_glfw.x11.vidmode.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.vidmode.handle);
+        _glfw.x11.vidmode.handle = NULL;
+    }
+
+    if (_glfw.x11.xi.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.xi.handle);
+        _glfw.x11.xi.handle = NULL;
+    }
+
     _glfwTerminateOSMesa();
     // NOTE: These need to be unloaded after XCloseDisplay, as they register
     //       cleanup callbacks that get called by that function
     _glfwTerminateEGL();
     _glfwTerminateGLX();
 
-    _glfwPlatformFreeModule(_glfw.x11.x11xcb.handle);
-    _glfwPlatformFreeModule(_glfw.x11.xcursor.handle);
-    _glfwPlatformFreeModule(_glfw.x11.randr.handle);
-    _glfwPlatformFreeModule(_glfw.x11.xinerama.handle);
-    _glfwPlatformFreeModule(_glfw.x11.xrender.handle);
-    _glfwPlatformFreeModule(_glfw.x11.xshape.handle);
-    _glfwPlatformFreeModule(_glfw.x11.vidmode.handle);
-    _glfwPlatformFreeModule(_glfw.x11.xi.handle);
-    _glfwPlatformFreeModule(_glfw.x11.xlib.handle);
+    if (_glfw.x11.xlib.handle)
+    {
+        _glfwPlatformFreeModule(_glfw.x11.xlib.handle);
+        _glfw.x11.xlib.handle = NULL;
+    }
 
     if (_glfw.x11.emptyEventPipe[0] || _glfw.x11.emptyEventPipe[1])
     {
         close(_glfw.x11.emptyEventPipe[0]);
         close(_glfw.x11.emptyEventPipe[1]);
     }
-
-    memset(&_glfw.x11, 0, sizeof(_glfw.x11));
 }
 
 #endif // _GLFW_X11
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/x11_monitor.c b/src/libraries/raylib/raylib/src/external/glfw/src/x11_monitor.c
index abf9cbf..38af7e0 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/x11_monitor.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/x11_monitor.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 X11 - www.glfw.org
+// GLFW 3.4 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -33,7 +33,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
-#include <assert.h>
 
 
 // Check whether the display mode should be included in enumeration
@@ -151,12 +150,6 @@ void _glfwPollMonitorsX11(void)
             }
 
             XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, oi->crtc);
-            if (!ci)
-            {
-                XRRFreeOutputInfo(oi);
-                continue;
-            }
-
             if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
             {
                 widthMM  = oi->mm_height;
@@ -618,6 +611,7 @@ void _glfwSetGammaRampX11(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
 
 GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* handle)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(None);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
@@ -626,14 +620,12 @@ GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* handle)
         return None;
     }
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     return monitor->x11.crtc;
 }
 
 GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* handle)
 {
+    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(None);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
@@ -642,9 +634,6 @@ GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* handle)
         return None;
     }
 
-    _GLFWmonitor* monitor = (_GLFWmonitor*) handle;
-    assert(monitor != NULL);
-
     return monitor->x11.output;
 }
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/x11_platform.h b/src/libraries/raylib/raylib/src/external/glfw/src/x11_platform.h
index 64915fc..14e363d 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/x11_platform.h
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/x11_platform.h
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 X11 - www.glfw.org
+// GLFW 3.4 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
@@ -452,6 +452,9 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(V
 typedef VkResult (APIENTRY *PFN_vkCreateXcbSurfaceKHR)(VkInstance,const VkXcbSurfaceCreateInfoKHR*,const VkAllocationCallbacks*,VkSurfaceKHR*);
 typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice,uint32_t,xcb_connection_t*,xcb_visualid_t);
 
+#include "xkb_unicode.h"
+#include "posix_poll.h"
+
 #define GLFW_X11_WINDOW_STATE           _GLFWwindowX11 x11;
 #define GLFW_X11_LIBRARY_WINDOW_STATE   _GLFWlibraryX11 x11;
 #define GLFW_X11_MONITOR_STATE          _GLFWmonitorX11 x11;
@@ -460,7 +463,6 @@ typedef VkBool32 (APIENTRY *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(Vk
 #define GLFW_GLX_CONTEXT_STATE          _GLFWcontextGLX glx;
 #define GLFW_GLX_LIBRARY_CONTEXT_STATE  _GLFWlibraryGLX glx;
 
-#define GLFW_INVALID_CODEPOINT 0xffffffffu
 
 // GLX-specific per-context data
 //
@@ -468,7 +470,6 @@ typedef struct _GLFWcontextGLX
 {
     GLXContext      handle;
     GLXWindow       window;
-    GLXFBConfig     fbconfig;
 } _GLFWcontextGLX;
 
 // GLX-specific global data
@@ -503,18 +504,18 @@ typedef struct _GLFWlibraryGLX
     PFNGLXSWAPINTERVALEXTPROC           SwapIntervalEXT;
     PFNGLXSWAPINTERVALMESAPROC          SwapIntervalMESA;
     PFNGLXCREATECONTEXTATTRIBSARBPROC   CreateContextAttribsARB;
-    bool            SGI_swap_control;
-    bool            EXT_swap_control;
-    bool            MESA_swap_control;
-    bool            ARB_multisample;
-    bool            ARB_framebuffer_sRGB;
-    bool            EXT_framebuffer_sRGB;
-    bool            ARB_create_context;
-    bool            ARB_create_context_profile;
-    bool            ARB_create_context_robustness;
-    bool            EXT_create_context_es2_profile;
-    bool            ARB_create_context_no_error;
-    bool            ARB_context_flush_control;
+    GLFWbool        SGI_swap_control;
+    GLFWbool        EXT_swap_control;
+    GLFWbool        MESA_swap_control;
+    GLFWbool        ARB_multisample;
+    GLFWbool        ARB_framebuffer_sRGB;
+    GLFWbool        EXT_framebuffer_sRGB;
+    GLFWbool        ARB_create_context;
+    GLFWbool        ARB_create_context_profile;
+    GLFWbool        ARB_create_context_robustness;
+    GLFWbool        EXT_create_context_es2_profile;
+    GLFWbool        ARB_create_context_no_error;
+    GLFWbool        ARB_context_flush_control;
 } _GLFWlibraryGLX;
 
 // X11-specific per-window data
@@ -983,8 +984,6 @@ unsigned long _glfwGetWindowPropertyX11(Window window,
                                         unsigned char** value);
 GLFWbool _glfwIsVisualTransparentX11(Visual* visual);
 
-uint32_t _glfwKeySym2UnicodeX11(unsigned int keysym);
-
 void _glfwGrabErrorHandlerX11(void);
 void _glfwReleaseErrorHandlerX11(void);
 void _glfwInputErrorX11(int error, const char* message);
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/x11_window.c b/src/libraries/raylib/raylib/src/external/glfw/src/x11_window.c
index f46a7e6..49e60a5 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/x11_window.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/x11_window.c
@@ -1,8 +1,9 @@
 //========================================================================
-// GLFW 3.5 X11 - www.glfw.org
+// GLFW 3.4 X11 (modified for raylib) - www.glfw.org; www.raylib.com
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
+// Copyright (c) 2024 M374LX <wilsalx@gmail.com>
 //
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -235,9 +236,9 @@ static int translateState(int state)
 
 // Translates an X11 key code to a GLFW key token
 //
-static int translateKey(int scancode)
+static int translateKeyX11(int scancode)
 {
-    // Use the pre-filled LUT (see createKeyTables() in x11_init.c)
+    // Use the pre-filled LUT (see createKeyTablesX11() in x11_init.c)
     if (scancode < 0 || scancode > 255)
         return GLFW_KEY_UNKNOWN;
 
@@ -576,10 +577,6 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
         height *= _glfw.x11.contentScaleY;
     }
 
-    // The dimensions must be nonzero, or a BadValue error results.
-    width = _glfw_max(1, width);
-    height = _glfw_max(1, height);
-
     int xpos = 0, ypos = 0;
 
     if (wndconfig->xpos != GLFW_ANY_POSITION && wndconfig->ypos != GLFW_ANY_POSITION)
@@ -758,13 +755,13 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
             const char* resourceName = getenv("RESOURCE_NAME");
             if (resourceName && strlen(resourceName))
                 hint->res_name = (char*) resourceName;
-            else if (strlen(window->title))
-                hint->res_name = (char*) window->title;
+            else if (strlen(wndconfig->title))
+                hint->res_name = (char*) wndconfig->title;
             else
                 hint->res_name = (char*) "glfw-application";
 
-            if (strlen(window->title))
-                hint->res_class = (char*) window->title;
+            if (strlen(wndconfig->title))
+                hint->res_class = (char*) wndconfig->title;
             else
                 hint->res_class = (char*) "GLFW-Application";
         }
@@ -784,7 +781,7 @@ static GLFWbool createNativeWindow(_GLFWwindow* window,
     if (_glfw.x11.im)
         _glfwCreateInputContextX11(window);
 
-    _glfwSetWindowTitleX11(window, window->title);
+    _glfwSetWindowTitleX11(window, wndconfig->title);
     _glfwGetWindowPosX11(window, &window->x11.xpos, &window->x11.ypos);
     _glfwGetWindowSizeX11(window, &window->x11.width, &window->x11.height);
 
@@ -1085,7 +1082,7 @@ static const char* getSelectionString(Atom selection)
 
 // Make the specified window and its video mode active on its monitor
 //
-static void acquireMonitor(_GLFWwindow* window)
+static void acquireMonitorX11(_GLFWwindow* window)
 {
     if (_glfw.x11.saver.count == 0)
     {
@@ -1124,7 +1121,7 @@ static void acquireMonitor(_GLFWwindow* window)
 
 // Remove the window and restore the original video mode
 //
-static void releaseMonitor(_GLFWwindow* window)
+static void releaseMonitorX11(_GLFWwindow* window)
 {
     if (window->monitor->window != window)
         return;
@@ -1246,7 +1243,7 @@ static void processEvent(XEvent *event)
 
         case KeyPress:
         {
-            const int key = translateKey(keycode);
+            const int key = translateKeyX11(keycode);
             const int mods = translateState(event->xkey.state);
             const int plain = !(mods & (GLFW_MOD_CONTROL | GLFW_MOD_ALT));
 
@@ -1308,7 +1305,7 @@ static void processEvent(XEvent *event)
 
                 _glfwInputKey(window, key, keycode, GLFW_PRESS, mods);
 
-                const uint32_t codepoint = _glfwKeySym2UnicodeX11(keysym);
+                const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
                 if (codepoint != GLFW_INVALID_CODEPOINT)
                     _glfwInputChar(window, codepoint, mods, plain);
             }
@@ -1318,7 +1315,7 @@ static void processEvent(XEvent *event)
 
         case KeyRelease:
         {
-            const int key = translateKey(keycode);
+            const int key = translateKeyX11(keycode);
             const int mods = translateState(event->xkey.state);
 
             if (!_glfw.x11.xkb.detectable)
@@ -1810,9 +1807,9 @@ static void processEvent(XEvent *event)
                     if (window->monitor)
                     {
                         if (iconified)
-                            releaseMonitor(window);
+                            releaseMonitorX11(window);
                         else
-                            acquireMonitor(window);
+                            acquireMonitorX11(window);
                     }
 
                     window->x11.iconified = iconified;
@@ -2029,7 +2026,7 @@ GLFWbool _glfwCreateWindowX11(_GLFWwindow* window,
     {
         _glfwShowWindowX11(window);
         updateWindowMode(window);
-        acquireMonitor(window);
+        acquireMonitorX11(window);
 
         if (wndconfig->centerCursor)
             _glfwCenterCursorInContentArea(window);
@@ -2054,7 +2051,7 @@ void _glfwDestroyWindowX11(_GLFWwindow* window)
         enableCursor(window);
 
     if (window->monitor)
-        releaseMonitor(window);
+        releaseMonitorX11(window);
 
     if (window->x11.ic)
     {
@@ -2207,14 +2204,10 @@ void _glfwGetWindowSizeX11(_GLFWwindow* window, int* width, int* height)
 
 void _glfwSetWindowSizeX11(_GLFWwindow* window, int width, int height)
 {
-    // The dimensions must be nonzero, or a BadValue error results
-    width = _glfw_max(1, width);
-    height = _glfw_max(1, height);
-
     if (window->monitor)
     {
         if (window->monitor->window == window)
-            acquireMonitor(window);
+            acquireMonitorX11(window);
     }
     else
     {
@@ -2438,38 +2431,6 @@ void _glfwShowWindowX11(_GLFWwindow* window)
     if (_glfwWindowVisibleX11(window))
         return;
 
-    if (window->floating && _glfw.x11.NET_WM_STATE && _glfw.x11.NET_WM_STATE_ABOVE)
-    {
-        Atom* states = NULL;
-        const unsigned long count =
-            _glfwGetWindowPropertyX11(window->x11.handle,
-                                      _glfw.x11.NET_WM_STATE,
-                                      XA_ATOM, (unsigned char**) &states);
-
-        // NOTE: We don't check for failure as this property may not exist yet
-        //       and that's fine (and we'll create it implicitly with append)
-
-        unsigned long i;
-
-        for (i = 0;  i < count;  i++)
-        {
-            if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
-                break;
-        }
-
-        if (i == count)
-        {
-            XChangeProperty(_glfw.x11.display, window->x11.handle,
-                            _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                            PropModeAppend,
-                            (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
-                            1);
-        }
-
-        if (states)
-            XFree(states);
-    }
-
     XMapWindow(_glfw.x11.display, window->x11.handle);
     waitForVisibilityNotify(window);
 }
@@ -2517,7 +2478,7 @@ void _glfwSetWindowMonitorX11(_GLFWwindow* window,
         if (monitor)
         {
             if (monitor->window == window)
-                acquireMonitor(window);
+                acquireMonitorX11(window);
         }
         else
         {
@@ -2536,7 +2497,7 @@ void _glfwSetWindowMonitorX11(_GLFWwindow* window,
     {
         _glfwSetWindowDecoratedX11(window, window->decorated);
         _glfwSetWindowFloatingX11(window, window->floating);
-        releaseMonitor(window);
+        releaseMonitorX11(window);
     }
 
     _glfwInputWindowMonitor(window, monitor);
@@ -2551,7 +2512,7 @@ void _glfwSetWindowMonitorX11(_GLFWwindow* window,
         }
 
         updateWindowMode(window);
-        acquireMonitor(window);
+        acquireMonitorX11(window);
     }
     else
     {
@@ -2699,10 +2660,6 @@ void _glfwSetWindowFloatingX11(_GLFWwindow* window, GLFWbool enabled)
     }
     else
     {
-        // NOTE: _NET_WM_STATE_ABOVE is added when the window is shown
-        if (enabled)
-            return;
-
         Atom* states = NULL;
         const unsigned long count =
             _glfwGetWindowPropertyX11(window->x11.handle,
@@ -2713,20 +2670,38 @@ void _glfwSetWindowFloatingX11(_GLFWwindow* window, GLFWbool enabled)
         // NOTE: We don't check for failure as this property may not exist yet
         //       and that's fine (and we'll create it implicitly with append)
 
-        unsigned long i;
-
-        for (i = 0;  i < count;  i++)
+        if (enabled)
         {
-            if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
-                break;
+            unsigned long i;
+
+            for (i = 0;  i < count;  i++)
+            {
+                if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
+                    break;
+            }
+
+            if (i == count)
+            {
+                XChangeProperty(_glfw.x11.display, window->x11.handle,
+                                _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
+                                PropModeAppend,
+                                (unsigned char*) &_glfw.x11.NET_WM_STATE_ABOVE,
+                                1);
+            }
         }
-
-        if (i < count)
+        else if (states)
         {
-            states[i] = states[count - 1];
-            XChangeProperty(_glfw.x11.display, window->x11.handle,
-                            _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
-                            PropModeReplace, (unsigned char*) states, count - 1);
+            for (unsigned long i = 0;  i < count;  i++)
+            {
+                if (states[i] == _glfw.x11.NET_WM_STATE_ABOVE)
+                {
+                    states[i] = states[count - 1];
+                    XChangeProperty(_glfw.x11.display, window->x11.handle,
+                                    _glfw.x11.NET_WM_STATE, XA_ATOM, 32,
+                                    PropModeReplace, (unsigned char*) states, count - 1);
+                    break;
+                }
+            }
         }
 
         if (states)
@@ -2944,7 +2919,7 @@ const char* _glfwGetScancodeNameX11(int scancode)
     if (keysym == NoSymbol)
         return NULL;
 
-    const uint32_t codepoint = _glfwKeySym2UnicodeX11(keysym);
+    const uint32_t codepoint = _glfwKeySym2Unicode(keysym);
     if (codepoint == GLFW_INVALID_CODEPOINT)
         return NULL;
 
@@ -3328,6 +3303,7 @@ GLFWAPI Display* glfwGetX11Display(void)
 
 GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
 {
+    _GLFWwindow* window = (_GLFWwindow*) handle;
     _GLFW_REQUIRE_INIT_OR_RETURN(None);
 
     if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
@@ -3336,9 +3312,6 @@ GLFWAPI Window glfwGetX11Window(GLFWwindow* handle)
         return None;
     }
 
-    _GLFWwindow* window = (_GLFWwindow*) handle;
-    assert(window != NULL);
-
     return window->x11.handle;
 }
 
@@ -3352,8 +3325,6 @@ GLFWAPI void glfwSetX11SelectionString(const char* string)
         return;
     }
 
-    assert(string != NULL);
-
     _glfw_free(_glfw.x11.primarySelectionString);
     _glfw.x11.primarySelectionString = _glfw_strdup(string);
 
diff --git a/src/libraries/raylib/raylib/src/external/glfw/src/xkb_unicode.c b/src/libraries/raylib/raylib/src/external/glfw/src/xkb_unicode.c
index 7a4ee10..6b8dfca 100644
--- a/src/libraries/raylib/raylib/src/external/glfw/src/xkb_unicode.c
+++ b/src/libraries/raylib/raylib/src/external/glfw/src/xkb_unicode.c
@@ -1,5 +1,5 @@
 //========================================================================
-// GLFW 3.5 X11 - www.glfw.org
+// GLFW 3.4 X11 - www.glfw.org
 //------------------------------------------------------------------------
 // Copyright (c) 2002-2006 Marcus Geelnard
 // Copyright (c) 2006-2017 Camilla Löwy <elmindreda@glfw.org>
@@ -27,7 +27,7 @@
 
 #include "internal.h"
 
-#if defined(_GLFW_X11)
+#if defined(_GLFW_X11) || defined(_GLFW_WAYLAND)
 
 /*
  * Marcus: This code was originally written by Markus G. Kuhn.
@@ -906,7 +906,7 @@ static const struct codepair {
 
 // Convert XKB KeySym to Unicode
 //
-uint32_t _glfwKeySym2UnicodeX11(unsigned int keysym)
+uint32_t _glfwKeySym2Unicode(unsigned int keysym)
 {
     int min = 0;
     int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
@@ -939,5 +939,5 @@ uint32_t _glfwKeySym2UnicodeX11(unsigned int keysym)
     return GLFW_INVALID_CODEPOINT;
 }
 
-#endif // _GLFW_X11
+#endif // _GLFW_WAYLAND or _GLFW_X11
 
diff --git a/src/libraries/raylib/raylib/src/external/jar_mod.h b/src/libraries/raylib/raylib/src/external/jar_mod.h
index 12b8101..7ecf9f4 100644
--- a/src/libraries/raylib/raylib/src/external/jar_mod.h
+++ b/src/libraries/raylib/raylib/src/external/jar_mod.h
@@ -1538,10 +1538,10 @@ mulong jar_mod_load_file(jar_mod_context_t * modctx, const char* filename)
             modctx->modfile = (muchar *) JARMOD_MALLOC(fsize);
             modctx->modfilesize = fsize;
             memset(modctx->modfile, 0, fsize);
-            if(fread(modctx->modfile, fsize, 1, f) != 1) fsize = 0;
+            fread(modctx->modfile, fsize, 1, f);
             fclose(f);
 
-            if(fsize && !jar_mod_load(modctx, (void *)modctx->modfile, fsize)) fsize = 0;
+            if(!jar_mod_load(modctx, (void *)modctx->modfile, fsize)) fsize = 0;
         } else fsize = 0;
     }
     return fsize;
diff --git a/src/libraries/raylib/raylib/src/external/miniaudio.h b/src/libraries/raylib/raylib/src/external/miniaudio.h
index c6d493e..24e676b 100644
--- a/src/libraries/raylib/raylib/src/external/miniaudio.h
+++ b/src/libraries/raylib/raylib/src/external/miniaudio.h
@@ -1,6 +1,6 @@
 /*
 Audio playback and capture library. Choice of public domain or MIT-0. See license statements at the end of this file.
-miniaudio - v0.11.25 - 2026-03-04
+miniaudio - v0.11.24 - 2026-01-17
 
 David Reid - mackron@gmail.com
 
@@ -3747,7 +3747,7 @@ extern "C" {
 
 #define MA_VERSION_MAJOR    0
 #define MA_VERSION_MINOR    11
-#define MA_VERSION_REVISION 25
+#define MA_VERSION_REVISION 24
 #define MA_VERSION_STRING   MA_XSTRINGIFY(MA_VERSION_MAJOR) "." MA_XSTRINGIFY(MA_VERSION_MINOR) "." MA_XSTRINGIFY(MA_VERSION_REVISION)
 
 #if defined(_MSC_VER) && !defined(__clang__)
@@ -19358,7 +19358,7 @@ MA_API ma_handle ma_dlopen(ma_log* pLog, const char* filename)
             #else
                 /* *sigh* It appears there is no ANSI version of LoadPackagedLibrary()... */
                 WCHAR filenameW[4096];
-                if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, ma_countof(filenameW)) == 0) {
+                if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, sizeof(filenameW)) == 0) {
                     handle = NULL;
                 } else {
                     handle = (ma_handle)LoadPackagedLibrary(filenameW, 0);
@@ -41495,37 +41495,18 @@ Web Audio Backend
 #ifdef MA_HAS_WEBAUDIO
 #include <emscripten/emscripten.h>
 
-#ifndef MA_EMSCRIPTEN_MAJOR
-    #if defined(__EMSCRIPTEN_MAJOR__)
-        #define MA_EMSCRIPTEN_MAJOR __EMSCRIPTEN_MAJOR__
-    #else
-        #define MA_EMSCRIPTEN_MAJOR __EMSCRIPTEN_major__
-    #endif
-#endif
-#ifndef MA_EMSCRIPTEN_MINOR
-    #if defined(__EMSCRIPTEN_MINOR__)
-        #define MA_EMSCRIPTEN_MINOR __EMSCRIPTEN_MINOR__
-    #else
-        #define MA_EMSCRIPTEN_MINOR __EMSCRIPTEN_minor__
-    #endif
-#endif
-#ifndef MA_EMSCRIPTEN_TINY
-    #if defined(__EMSCRIPTEN_TINY__)
-        #define MA_EMSCRIPTEN_TINY __EMSCRIPTEN_TINY__
-    #else
-        #define MA_EMSCRIPTEN_TINY __EMSCRIPTEN_tiny__
-    #endif
-#endif
-
-#if (MA_EMSCRIPTEN_MAJOR > 3) || (MA_EMSCRIPTEN_MAJOR == 3 && (MA_EMSCRIPTEN_MINOR > 1 || (MA_EMSCRIPTEN_MINOR == 1 && MA_EMSCRIPTEN_TINY >= 32)))
+#if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 32)))
     #include <emscripten/webaudio.h>
     #define MA_SUPPORT_AUDIO_WORKLETS
 
-    #if (MA_EMSCRIPTEN_MAJOR > 3) || (MA_EMSCRIPTEN_MAJOR == 3 && (MA_EMSCRIPTEN_MINOR > 1 || (MA_EMSCRIPTEN_MINOR == 1 && MA_EMSCRIPTEN_TINY >= 70)))
+    #if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 70)))
         #define MA_SUPPORT_AUDIO_WORKLETS_VARIABLE_BUFFER_SIZE
     #endif
 #endif
 
+/*
+TODO: Version 0.12: Swap this logic around so that AudioWorklets are used by default. Add MA_NO_AUDIO_WORKLETS.
+*/
 #if defined(MA_ENABLE_AUDIO_WORKLETS) && defined(MA_SUPPORT_AUDIO_WORKLETS)
     #define MA_USE_AUDIO_WORKLETS
 #endif
@@ -59262,10 +59243,6 @@ static ma_result ma_data_source_read_pcm_frames_within_range(ma_data_source* pDa
     ma_uint64 framesRead = 0;
     ma_bool32 loop = ma_data_source_is_looping(pDataSource);
 
-    if (pFramesRead != NULL) {
-        *pFramesRead = 0;
-    }
-
     if (pDataSourceBase == NULL) {
         return MA_AT_END;
     }
@@ -61944,7 +61921,7 @@ extern "C" {
 #define MA_DR_WAV_XSTRINGIFY(x)     MA_DR_WAV_STRINGIFY(x)
 #define MA_DR_WAV_VERSION_MAJOR     0
 #define MA_DR_WAV_VERSION_MINOR     14
-#define MA_DR_WAV_VERSION_REVISION  5
+#define MA_DR_WAV_VERSION_REVISION  4
 #define MA_DR_WAV_VERSION_STRING    MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_MAJOR) "." MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_MINOR) "." MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_REVISION)
 #include <stddef.h>
 #define MA_DR_WAVE_FORMAT_PCM          0x1
@@ -80526,13 +80503,6 @@ MA_PRIVATE ma_uint64 ma_dr_wav__read_smpl_to_metadata_obj(ma_dr_wav__metadata_pa
     MA_DR_WAV_ASSERT(pChunkHeader != NULL);
     if (pMetadata != NULL && bytesJustRead == sizeof(smplHeaderData)) {
         ma_uint32 iSampleLoop;
-        ma_uint32 loopCount;
-        ma_uint32 calculatedLoopCount;
-        loopCount = ma_dr_wav_bytes_to_u32(smplHeaderData + 28);
-        calculatedLoopCount = (pChunkHeader->sizeInBytes - MA_DR_WAV_SMPL_BYTES) / MA_DR_WAV_SMPL_LOOP_BYTES;
-        if (loopCount != calculatedLoopCount) {
-            return totalBytesRead;
-        }
         pMetadata->type                                     = ma_dr_wav_metadata_type_smpl;
         pMetadata->data.smpl.manufacturerId                 = ma_dr_wav_bytes_to_u32(smplHeaderData + 0);
         pMetadata->data.smpl.productId                      = ma_dr_wav_bytes_to_u32(smplHeaderData + 4);
@@ -80543,7 +80513,7 @@ MA_PRIVATE ma_uint64 ma_dr_wav__read_smpl_to_metadata_obj(ma_dr_wav__metadata_pa
         pMetadata->data.smpl.smpteOffset                    = ma_dr_wav_bytes_to_u32(smplHeaderData + 24);
         pMetadata->data.smpl.sampleLoopCount                = ma_dr_wav_bytes_to_u32(smplHeaderData + 28);
         pMetadata->data.smpl.samplerSpecificDataSizeInBytes = ma_dr_wav_bytes_to_u32(smplHeaderData + 32);
-        if (pMetadata->data.smpl.sampleLoopCount == calculatedLoopCount) {
+        if (pMetadata->data.smpl.sampleLoopCount == (pChunkHeader->sizeInBytes - MA_DR_WAV_SMPL_BYTES) / MA_DR_WAV_SMPL_LOOP_BYTES) {
             pMetadata->data.smpl.pLoops = (ma_dr_wav_smpl_loop*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_smpl_loop) * pMetadata->data.smpl.sampleLoopCount, MA_DR_WAV_METADATA_ALIGNMENT);
             for (iSampleLoop = 0; iSampleLoop < pMetadata->data.smpl.sampleLoopCount; ++iSampleLoop) {
                 ma_uint8 smplLoopData[MA_DR_WAV_SMPL_LOOP_BYTES];
@@ -80564,8 +80534,6 @@ MA_PRIVATE ma_uint64 ma_dr_wav__read_smpl_to_metadata_obj(ma_dr_wav__metadata_pa
                 MA_DR_WAV_ASSERT(pMetadata->data.smpl.pSamplerSpecificData != NULL);
                 ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.smpl.pSamplerSpecificData, pMetadata->data.smpl.samplerSpecificDataSizeInBytes, &totalBytesRead);
             }
-        } else {
-            MA_DR_WAV_ZERO_OBJECT(&pMetadata->data.smpl);
         }
     }
     return totalBytesRead;
@@ -83181,13 +83149,19 @@ MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_
                     newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
                     newSample0 += nibble0 * pWav->msadpcm.delta[0];
                     newSample0  = ma_dr_wav_clamp(newSample0, -32768, 32767);
-                    pWav->msadpcm.delta[0] = (ma_int32)ma_dr_wav_clamp(((ma_int64)adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8, 16, 0x7FFFFFFF);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
                     pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
                     pWav->msadpcm.prevFrames[0][1] = newSample0;
                     newSample1  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
                     newSample1 += nibble1 * pWav->msadpcm.delta[0];
                     newSample1  = ma_dr_wav_clamp(newSample1, -32768, 32767);
-                    pWav->msadpcm.delta[0] = (ma_int32)ma_dr_wav_clamp(((ma_int64)adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8, 16, 0x7FFFFFFF);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
                     pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
                     pWav->msadpcm.prevFrames[0][1] = newSample1;
                     pWav->msadpcm.cachedFrames[2] = newSample0;
@@ -83202,7 +83176,10 @@ MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_
                     newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
                     newSample0 += nibble0 * pWav->msadpcm.delta[0];
                     newSample0  = ma_dr_wav_clamp(newSample0, -32768, 32767);
-                    pWav->msadpcm.delta[0] = (ma_int32)ma_dr_wav_clamp(((ma_int64)adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8, 16, 0x7FFFFFFF);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
                     pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
                     pWav->msadpcm.prevFrames[0][1] = newSample0;
                     if (pWav->msadpcm.predictor[1] >= ma_dr_wav_countof(coeff1Table) || pWav->msadpcm.predictor[1] >= ma_dr_wav_countof(coeff2Table)) {
@@ -83211,7 +83188,10 @@ MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_
                     newSample1  = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8;
                     newSample1 += nibble1 * pWav->msadpcm.delta[1];
                     newSample1  = ma_dr_wav_clamp(newSample1, -32768, 32767);
-                    pWav->msadpcm.delta[1] = (ma_int32)ma_dr_wav_clamp(((ma_int64)adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8, 16, 0x7FFFFFFF);
+                    pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8;
+                    if (pWav->msadpcm.delta[1] < 16) {
+                        pWav->msadpcm.delta[1] = 16;
+                    }
                     pWav->msadpcm.prevFrames[1][0] = pWav->msadpcm.prevFrames[1][1];
                     pWav->msadpcm.prevFrames[1][1] = newSample1;
                     pWav->msadpcm.cachedFrames[2] = newSample0;
@@ -95845,7 +95825,7 @@ For more information, please refer to <http://unlicense.org/>
 ===============================================================================
 ALTERNATIVE 2 - MIT No Attribution
 ===============================================================================
-Copyright 2026 David Reid
+Copyright 2025 David Reid
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/src/libraries/raylib/raylib/src/external/pep.h b/src/libraries/raylib/raylib/src/external/pep.h
deleted file mode 100644
index bc8a793..0000000
--- a/src/libraries/raylib/raylib/src/external/pep.h
+++ /dev/null
@@ -1,1328 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Prediction-Encoded Pixels (pep)
-//
-//  author(s):
-//  ENDESGA - https://x.com/ENDESGA | https://bsky.app/profile/endesga.bsky.social
-//
-//  contributer(s):
-//  Mariusz Dzikowski - https://github.com/demurzasty
-//  Akreson - https://github.com/Akreson
-//  Alepacho - https://github.com/Alepacho
-//
-//  https://github.com/ENDESGA/pep
-//  2026 - CC0 - FOSS forever
-//
-
-// The .pep type is a pixel art format made to compress as small as possible.
-// It uses a custom "Prediction by Partial Matching" compression method
-// designed from the ground up for palettized pixel art.
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma region - DEPENDENCIES
-//
-
-#pragma once
-
-#ifndef _GNU_SOURCE
-	#define _GNU_SOURCE
-#endif
-
-#include <stdint.h> // uint*_t
-#include <stdlib.h> // mem-alloc
-#include <stdio.h> // FILE
-#include <string.h> // memset
-
-#pragma endregion dependencies
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma region - MACROS
-//
-
-#define __PEP_STRINGIFY( VALUE ) #VALUE
-#define _PEP_STRINGIFY( VALUE ) __PEP_STRINGIFY( VALUE )
-
-////////////////////////////////////////////////////////////////
-#pragma region - memory
-
-// This defines a set of macros that serve as wrappers for the standard
-// C library memory management functions: `malloc`, `realloc`, and `free`.
-// These macros can be used to easily replace the underlying memory allocation
-// implementation in a project, for example, with a custom allocator or a
-// debug-enabled version, without modifying all call sites.
-#ifndef PEP_MALLOC
-	#define PEP_MALLOC( size ) malloc( size )
-	#define PEP_REALLOC( ptr, size ) realloc( ptr, size )
-	#define PEP_FREE( ptr ) free( ptr )
-#endif
-
-#pragma endregion memory
-
-////////////////////////////////////////////////////////////////
-#pragma region - bits
-
-// Provides a cross-platform macro to count leading zeros in a 32-bit integer.
-#ifndef PEP_COUNT_LEADING_ZEROS
-	#ifdef _MSC_VER
-		// Microsoft Visual C++ compiler.
-		#define PEP_COUNT_LEADING_ZEROS( x ) __lzcnt( x )
-	#else
-		// GCC/Clang compilers.
-		#define PEP_COUNT_LEADING_ZEROS( x ) __builtin_clz( x )
-	#endif
-#endif
-
-// How many bits do we need to fit N values?
-#define PEP_BITS_TO_FIT( N ) ( ( ( N ) <= 1 ) ? 1 : ( 32 - PEP_COUNT_LEADING_ZEROS( ( N ) - 1 ) ) )
-
-#pragma endregion bits
-
-////////////////////////////////////////////////////////////////
-#pragma region - hash
-
-// Standard hash multipliers, there might be better ones:
-#define _PEP_HASH_N 1540483477u // 0x5BD1E995 MurmurHash2
-#define _PEP_HASH_W 3332679571u // 0xC6A4A793 MurmurHash64A
-#define _PEP_HASH_NW 3432918353u // 0xCC9E2D51 MurmurHash3
-#define _PEP_HASH_NE 2246822507u // 0x85EBCA6B MurmurHash3
-// Hash-prospector, avalanche-optimized, by Chris Wellons:
-#define _PEP_HASH_NN 2146121005u // 0x7FEB352D lowbias32
-#define _PEP_HASH_WW 2890668881u // 0xAC4C1B51 triple32 round-2
-#define _PEP_HASH_NNW 830770091u // 0x31848BAB triple32 round-3
-#define _PEP_HASH_NNE 1935289751u // 0x735A2D97 prospector
-#define _PEP_HASH_NWW 2943497623u // 0xAF723597 prospector
-
-#pragma endregion hash
-
-#pragma endregion macros
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma region - CONSTANTS
-//
-
-#define PEP_NAME "pep"
-
-////////////////////////////////////////////////////////////////
-#pragma region - version
-
-#define PEP_VERSION_MAJOR 0
-#define PEP_VERSION_MINOR 6
-#define PEP_VERSION_PATCH 0
-#define PEP_VERSION _PEP_STRINGIFY( PEP_VERSION_MAJOR ) "." _PEP_STRINGIFY( PEP_VERSION_MINOR ) "." _PEP_STRINGIFY( PEP_VERSION_PATCH )
-
-#pragma endregion version
-
-////////////////////////////////////////////////////////////////
-#pragma region - frequency
-
-// This is the amount of frequencies per context, and the amount of contexts,
-// with [256] being the order0 context.
-// Originally there were 256*256 contexts, but I found the image didn't get
-// much bigger with the same amount of frequencies. Theoretically the more
-// contexts you have the smaller the image is...
-#define PEP_FREQ_N 257
-#define PEP_FREQ_END ( PEP_FREQ_N - 1 )
-#define PEP_CONTEXTS_MAX PEP_FREQ_END
-
-// PEP_FREQ_MAX is the maximum accumulative frequency.
-// This is the starting maximum, and is scaled as the image compresses, via
-// the palette-delta; which seems to roughly correlate with the complexity.
-// This value works better for low-res images.
-#define PEP_FREQ_MAX ( PEP_FREQ_END >> 1 )
-
-#pragma endregion frequency
-
-////////////////////////////////////////////////////////////////
-#pragma region - arithmetic -coding
-
-// These constants are for the 63bit arithmetic-coding, specifically not 64bit
-// because of overflow.
-#define PEP_CODE_BITS 24lu
-#define PEP_CODE_BITS_INV ( 32lu - PEP_CODE_BITS )
-#define PEP_FREQ_MAX_BITS 14lu
-#define PEP_PROB_MAX_VALUE ( 1 << PEP_FREQ_MAX_BITS )
-#define PEP_CODE_MAX_VALUE ( ( 1 << PEP_CODE_BITS ) - 1 )
-
-#pragma endregion arithmetic -coding
-
-#pragma endregion defaults
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma region - DECLARATIONS
-//
-
-////////////////////////////////////////////////////////////////
-#pragma region - formats
-
-// .pep can automatically convert from RGBA to BGRA (little/big endian),
-// which is often for low-level/backend rendering pipelines.
-// Windows only supports ARGB for example, and so sometimes it's easier to
-// make the whole application use that format.
-typedef enum
-{
-	pep_rgba,
-	pep_bgra,
-
-	pep_abgr,
-	pep_argb
-}
-pep_format;
-
-// Palette colors can be restricted in the serialization phase to a maximum
-// amount of bits per channel.
-// The default is 8 bits per channel (standard 32 bit colors).
-// This is NOT bits-per-pixel and does NOT cap palette_size.
-typedef enum
-{
-	pep_1bit,
-	pep_2bit,
-	pep_4bit,
-	pep_8bit
-}
-pep_channel_bits;
-
-#pragma endregion formats
-
-////////////////////////////////////////////////////////////////
-#pragma region - arithmetic -coding
-
-// During the compression process the context per frequency-group needs to be
-// tracked, with the sum of all frequencies being stored.
-typedef struct
-{
-	uint16_t freq[ PEP_FREQ_N ];
-	uint32_t sum;
-}
-_pep_context;
-
-// Arithmetic coding structures:
-typedef struct
-{
-	uint8_t* data_ref;
-	uint32_t low;
-	uint32_t range;
-}
-_pep_ac_encode;
-
-typedef struct
-{
-	uint8_t* data_ref;
-	uint8_t* end_of_data;
-	uint32_t low;
-	uint32_t range;
-	uint32_t code;
-}
-_pep_ac_decode;
-
-typedef struct
-{
-	uint32_t high;
-	uint32_t low;
-	uint32_t scale;
-}
-_pep_prob;
-
-typedef struct
-{
-	_pep_prob prob;
-	uint32_t symbol;
-}
-_pep_sym_decode;
-
-#pragma endregion arithmetic -coding
-
-////////////////////////////////////////////////////////////////
-#pragma region - pep
-
-// This is the main struct-type that contains values for using this format.
-//
-// `channel_bits` controls how many bits each R/G/B/A component of every
-// palette entry is quantized to during serialization. It does NOT limit
-// the number of palette entries (that's `palette_size`, up to 256).
-// For example, pep_2bit means each channel has 4 possible values (0/85/170/255),
-// so the palette can only draw from 4*4*4 = 64 distinct RGB colors.
-typedef struct
-{
-	uint8_t* bytes;
-	uint64_t bytes_size;
-	uint16_t width;
-	uint16_t height;
-	pep_format format;
-	uint32_t palette[ 256 ];
-	uint8_t palette_size;
-	pep_channel_bits channel_bits;
-	uint8_t model;
-}
-pep;
-
-#pragma endregion pep
-
-////////////////////////////////////////////////////////////////
-#pragma region - functions
-
-pep pep_compress( const uint32_t* in_pixels, const uint16_t width, const uint16_t height, const pep_format in_format, const pep_channel_bits in_channel_bits );
-uint32_t* pep_decompress( const pep* const in_pep, const pep_format out_format, const uint8_t first_color_transparent, uint8_t const pre_multiply );
-void pep_free( pep* in_pep );
-uint8_t* pep_serialize( const pep* in_pep, uint32_t* const out_size );
-pep pep_deserialize( const uint8_t* const in_bytes, const uint32_t in_bytes_size );
-uint8_t pep_save( const pep* const in_pep, const char* const file_path );
-pep pep_load( const char* const file_path );
-
-#pragma endregion functions
-
-#pragma endregion declarations
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma region - DEFINITIONS
-//
-
-#ifdef PEP_IMPLEMENTATION
-
-#pragma region - private / functions
-
-static _pep_prob _pep_get_prob_from_context( const _pep_context* const context, const uint32_t symbol );
-static void _pep_arith_encode( _pep_ac_encode* const ac, const _pep_prob prob );
-static void _pep_arith_encode_normalize( _pep_ac_encode* const ac );
-static uint32_t _pep_arith_decode_curr_freq( _pep_ac_decode* const ac, const uint32_t scale );
-static void _pep_arith_decode_update( _pep_ac_decode* const ac, const _pep_prob prob );
-static _pep_sym_decode _pep_get_sym_from_freq( const _pep_context* const context, const uint32_t target_freq );
-static uint32_t _pep_pre_multiply( const uint32_t pixel, const pep_format format );
-static uint32_t _pep_reformat( const uint32_t in_color, const pep_format in_format, const pep_format out_format );
-
-#pragma endregion private / functions
-
-#ifdef _MSC_VER
-	// Intrin header is only needed for implementation.
-	#include <intrin.h> // __lzcnt
-
-	// Disable unsafe fopen usage warning on MSVC compiler.
-	#pragma warning( push )
-	#pragma warning( disable : 4996 )
-#endif
-
-////////////////////////////////////////////////////////////////
-#pragma region - arithmetic
-
-////////////////////////////////
-#pragma region | encode
-
-// Getting cumulative frequnce of symbol
-static _pep_prob _pep_get_prob_from_context( const _pep_context* const context, const uint32_t symbol )
-{
-	_pep_prob prob = { 0 };
-	prob.scale = context->sum;
-
-	for( uint32_t index = 0; index < symbol; ++index )
-	{
-		prob.low += context->freq[ index ];
-	}
-
-	prob.high = prob.low + context->freq[ symbol ];
-	return prob;
-}
-
-// This encodes a symbol into the arithmetic-coding range. It scales the
-// current range based on the symbol's frequency and total frequency count.
-static void _pep_arith_encode( _pep_ac_encode* const ac, const _pep_prob prob )
-{
-	ac->range /= prob.scale;
-	ac->low += prob.low * ac->range;
-	ac->range *= prob.high - prob.low;
-}
-
-// Adjusts the arithmetic-coding range by removing a boundary value
-// Main goal of this process is to keep our range from getting
-// too small.
-static void _pep_arith_encode_normalize( _pep_ac_encode* const ac )
-{
-	while( 1 )
-	{
-		if( ( ac->low ^ ( ac->low + ac->range ) ) >= PEP_CODE_MAX_VALUE )
-		{
-			if( ac->range >= PEP_PROB_MAX_VALUE ) break;
-
-			ac->range = PEP_PROB_MAX_VALUE - ( ac->low & ( PEP_PROB_MAX_VALUE - 1 ) );
-		}
-
-		uint8_t byte = ac->low >> PEP_CODE_BITS;
-		ac->low <<= PEP_CODE_BITS_INV;
-		ac->range <<= PEP_CODE_BITS_INV;
-		*ac->data_ref++= byte;
-	}
-}
-
-#pragma endregion encode
-
-////////////////////////////////
-#pragma region | decode
-
-// Getting current frequency by doing reverse trasformation
-static uint32_t _pep_arith_decode_curr_freq( _pep_ac_decode* const ac, const uint32_t scale )
-{
-	ac->range /= scale;
-	uint32_t result = ( ac->code - ac->low ) / ( ac->range );
-	return result;
-}
-
-// Same as with the encode_normalize, only on decode we reading in value
-static void _pep_arith_decode_update( _pep_ac_decode* const ac, const _pep_prob prob )
-{
-	ac->low += ac->range * prob.low;
-	ac->range *= prob.high - prob.low;
-
-	while( 1 )
-	{
-		if( ( ac->low ^ ( ac->low + ac->range ) ) >= PEP_CODE_MAX_VALUE )
-		{
-			if( ac->range < PEP_PROB_MAX_VALUE )
-			{
-				ac->range = PEP_PROB_MAX_VALUE - ( ac->low & ( PEP_PROB_MAX_VALUE - 1 ) );
-			}
-			else break;
-		}
-
-		uint8_t in_byte = 0;
-		if( ac->data_ref != ac->end_of_data )
-		{
-			in_byte = *ac->data_ref++;
-		}
-
-		ac->code = ( ac->code << 8 ) | in_byte;
-		ac->range <<= 8;
-		ac->low <<= 8;
-	}
-}
-
-static _pep_sym_decode _pep_get_sym_from_freq( const _pep_context* const context, const uint32_t target_freq )
-{
-	_pep_sym_decode result = { 0 };
-
-	uint32_t s = 0;
-	uint32_t freq = 0;
-	for( ; s <= PEP_FREQ_END; ++s )
-	{
-		freq += context->freq[ s ];
-		if( freq > target_freq ) break;
-	}
-	if( s > PEP_FREQ_END ) s = PEP_FREQ_END;
-
-	result.prob.high = freq;
-	result.prob.low = freq - context->freq[ s ];
-	result.prob.scale = context->sum;
-	result.symbol = s;
-
-	return result;
-}
-
-#pragma endregion decode
-
-#pragma endregion arithmetic
-
-////////////////////////////////////////////////////////////////
-#pragma region - compression
-
-////////////////////////////////
-#pragma region | compression / hidden
-
-// pep supports pre-multiplying the RGB channels with the A channel.
-static uint32_t _pep_pre_multiply( const uint32_t pixel, const pep_format format )
-{
-	uint8_t* bytes = ( uint8_t* )( &pixel );
-
-	if( format <= pep_bgra )
-	{
-		uint32_t scaled_a = ( uint32_t )( bytes[ 3 ] ) * 257;
-		bytes[ 1 ] = ( uint8_t )( ( ( uint32_t )( bytes[ 1 ] ) * scaled_a + 32896 ) >> 16 );
-		bytes[ 2 ] = ( uint8_t )( ( ( uint32_t )( bytes[ 2 ] ) * scaled_a + 32896 ) >> 16 );
-		bytes[ 3 ] = ( uint8_t )( ( ( uint32_t )( bytes[ 3 ] ) * scaled_a + 32896 ) >> 16 );
-	}
-	else
-	{
-		uint32_t scaled_a = ( uint32_t )( bytes[ 0 ] ) * 257;
-		bytes[ 0 ] = ( uint8_t )( ( ( uint32_t )( bytes[ 0 ] ) * scaled_a + 32896 ) >> 16 );
-		bytes[ 1 ] = ( uint8_t )( ( ( uint32_t )( bytes[ 1 ] ) * scaled_a + 32896 ) >> 16 );
-		bytes[ 2 ] = ( uint8_t )( ( ( uint32_t )( bytes[ 2 ] ) * scaled_a + 32896 ) >> 16 );
-	}
-
-	return pixel;
-}
-
-// pep supports "dynamic formats", where you can specify what the in-bytes are,
-// and reformat to a different channel-order.
-// This means two "identical" pep files can have different formats, but you
-// can choose how to reformat it when it decompresses!
-static uint32_t _pep_reformat( const uint32_t in_color, const pep_format in_format, const pep_format out_format )
-{
-	if( in_format == out_format ) return in_color;
-
-	if( in_format <= pep_bgra && out_format <= pep_bgra )
-	{ // RGBA <-> BGRA: swap R and B
-		return( in_color & 0xff00ff00 ) | ( ( in_color & 0x000000ff ) << 16 ) | ( ( in_color & 0x00ff0000 ) >> 16 );
-	}
-	else if( in_format >= pep_abgr && out_format >= pep_abgr )
-	{ // ABGR <-> ARGB: swap R and B
-		return( in_color & 0x00ff00ff ) | ( ( in_color & 0x0000ff00 ) << 16 ) | ( ( in_color & 0xff000000 ) >> 16 );
-	}
-	else if( ( in_format ^ out_format ) == 2 )
-	{ // Alpha flip: RGBA <-> ARGB or BGRA <-> ABGR
-		return( ( in_color & 0x000000ff ) << 24 ) | ( ( in_color & 0x0000ff00 ) << 8 ) | ( ( in_color & 0x00ff0000 ) >> 8 ) | ( ( in_color & 0xff000000 ) >> 24 );
-	}
-	else if( in_format < out_format )
-	{ // Flip: RGBA/BGRA -> ABGR/ARGB
-		return( ( in_color & 0xff000000 ) >> 24 ) | ( ( in_color & 0x00ffffff ) << 8 );
-	}
-	else
-	{ // Flip: ABGR/ARGB -> RGBA/BGRA
-		return( ( in_color & 0x000000ff ) << 24 ) | ( ( in_color & 0xffffff00 ) >> 8 );
-	}
-}
-
-// Update the frequency table after encoding/decoding a symbol.
-// This increments the symbol's frequency and the total sum.
-// When we hit freq_max, we increase the freq_max via a complexity
-// approximation via the palette-size, then we scale everything down
-// to a quarter to keep the frequencies manageable.
-// This dynamic part helps the compression adapt to the image's patterns.
-#define _PEP_UPDATE( CONTEXT, SYMBOL, FREQ_MAX, PALETTE_SIZE )\
-	do\
-	{\
-		CONTEXT->freq[ SYMBOL ] += 2;\
-		CONTEXT->sum += 2;\
-		if( CONTEXT->freq[ SYMBOL ] >= FREQ_MAX || CONTEXT->sum >= PEP_PROB_MAX_VALUE )\
-		{\
-			FREQ_MAX += ( PEP_FREQ_END - PALETTE_SIZE ) >> 1;\
-			CONTEXT->sum = 0;\
-			for( uint64_t f = 0; f < PEP_FREQ_N; f++ )\
-			{\
-				const uint16_t _f = CONTEXT->freq[ f ];\
-				if( _f == 0 ) continue;\
-				const uint16_t scaled = ( _f + 1 ) >> 1;\
-				CONTEXT->freq[ f ] = scaled;\
-				CONTEXT->sum += scaled;\
-			}\
-		}\
-	}\
-	while( 0 )
-
-#pragma endregion hidden
-
-////////////////////////////////
-#pragma region | compression / visible
-
-#define PEP_HASH_BIT_CONTEXT ( 1u << 16 )
-
-enum
-{
-	_PEP_TAP_HASH,
-	_PEP_TAP_NW,
-	_PEP_TAP_W
-};
-
-// Different context models perform differently depending on the pixel data.
-// From lots of testing it seems these 3 structures give the best results
-// across the 3 major types of pixel art.
-// Pep will sacrifice some time to ensure the file is as small as possible
-// by testing all 3 of these without assumptions.
-static const int8_t _pep_models[] =
-	{
-		_PEP_TAP_HASH, // typically for ~2 colors
-		_PEP_TAP_NW, // typically for ~4-8 colors
-		_PEP_TAP_W // typically for >=64 colors
-	};
-#define PEP_NUM_MODELS ( ( uint8_t )( sizeof( _pep_models ) / sizeof( _pep_models[ 0 ] ) ) )
-
-typedef struct
-{
-	_pep_context* contexts;
-	uint32_t index_end;
-	uint32_t index_escape;
-	int8_t kind;
-}
-_pep_model_context;
-
-// Allocate only the context regions a given model uses, then seed order-0.
-static uint8_t _pep_model_init( _pep_model_context* m, int8_t kind, uint32_t pcount )
-{
-	memset( m, 0, sizeof( *m ) );
-	m->kind = kind;
-	m->index_escape = pcount;
-	m->index_end = pcount + 1;
-
-	// order0 starts at offset 0, followed by the specific context level
-	uint32_t off = 1;
-	switch( kind )
-	{
-		case _PEP_TAP_HASH:
-		{
-			off += PEP_HASH_BIT_CONTEXT;
-			break;
-		}
-		case _PEP_TAP_NW:
-		{
-			off += m->index_end * m->index_end;
-			break;
-		}
-		case _PEP_TAP_W:
-		{
-			off += m->index_end;
-			break;
-		}
-	}
-
-	m->contexts = ( _pep_context* )calloc( off, sizeof( _pep_context ) );
-	if( !m->contexts ) return 0;
-
-	_pep_context* order0 = &m->contexts[ 0 ];
-	for( uint32_t index = 0; index < pcount; index++ ) order0->freq[ index ] = 1;
-	order0->sum = pcount;
-	return 1;
-}
-
-static void _pep_model_free( _pep_model_context* m )
-{
-	if( m->contexts )
-	{
-		free( m->contexts );
-		m->contexts = NULL;
-	}
-}
-
-// Resolve the context pointer for the specific level of this pixel.
-static _pep_context* _pep_build_level( const _pep_model_context* m, const uint8_t* idx, uint32_t pos, uint32_t x, uint32_t y, uint16_t width )
-{
-	// It's only possible to tap previous values:
-	/*
-	 -   NNW  NN  NNE
-	NWW  NW   N   NE
-	WW   W   [x]
-	*/
-	// The 10th NNWW tap has dimishing returns
-
-	const uint32_t SENT = m->index_escape;
-	const uint32_t index_end = m->index_end;
-	const uint32_t Wv = ( x > 0 ) ? idx[ pos - 1 ] : SENT;
-	const uint32_t Nv = ( y > 0 ) ? idx[ pos - width ] : SENT;
-
-	switch( m->kind )
-	{
-		case _PEP_TAP_HASH:
-		{
-			const uint32_t NWv = ( x > 0 && y > 0 ) ? idx[ pos - width - 1 ] : SENT;
-			const uint32_t NNv = ( y > 1 ) ? idx[ pos - 2 * width ] : SENT;
-			const uint32_t WWv = ( x > 1 ) ? idx[ pos - 2 ] : SENT;
-			const uint32_t NEv = ( ( x + 1 ) < width && y > 0 ) ? idx[ pos - width + 1 ] : SENT;
-			const uint32_t NNWv = ( y > 1 && x > 0 ) ? idx[ pos - 2 * width - 1 ] : SENT;
-			const uint32_t NNEv = ( y > 1 && ( x + 1 ) < width ) ? idx[ pos - 2 * width + 1 ] : SENT;
-			const uint32_t NWWv = ( x > 1 && y > 0 ) ? idx[ pos - width - 2 ] : SENT;
-
-			uint32_t h = Nv * _PEP_HASH_N + Wv * _PEP_HASH_W + NWv * _PEP_HASH_NW + NEv * _PEP_HASH_NE + NNv * _PEP_HASH_NN + WWv * _PEP_HASH_WW + NNWv * _PEP_HASH_NNW + NNEv * _PEP_HASH_NNE + NWWv * _PEP_HASH_NWW;
-			h ^= h >> 15;
-			return &m->contexts[ 1 + ( h & ( PEP_HASH_BIT_CONTEXT - 1 ) ) ];
-		}
-		case _PEP_TAP_NW:
-		{
-			return &m->contexts[ 1 + Nv * index_end + Wv ];
-		}
-		case _PEP_TAP_W:
-		{
-			return &m->contexts[ 1 + Wv ];
-		}
-	}
-	return NULL;
-}
-
-// Encode all pixels with one model and return the size of the byte stream.
-static uint64_t _pep_encode_model( const uint8_t* idx, uint16_t width, uint16_t height, uint32_t pcount, uint8_t model, uint8_t* out )
-{
-	_pep_model_context m;
-	if( !_pep_model_init( &m, _pep_models[ model ], pcount ) ) return 0;
-	const uint32_t index_escape = m.index_escape;
-
-	_pep_ac_encode ac = { 0 };
-	ac.range = ( uint32_t )( ( 1llu << 32 ) - 1 );
-	ac.data_ref = out;
-	uint16_t freq_max = PEP_FREQ_MAX;
-	_pep_context* order0 = &m.contexts[ 0 ];
-
-	uint32_t pos = 0;
-	for( uint32_t y = 0; y < height; y++ )
-	{
-		for( uint32_t x = 0; x < width; x++, pos++ )
-		{
-			const uint32_t symbol = idx[ pos ];
-			_pep_context* context = _pep_build_level( &m, idx, pos, x, y, width );
-			uint8_t encoded_in_level = 0;
-
-			if( context->sum != 0 )
-			{
-				if( context->freq[ symbol ] != 0 )
-				{
-					_pep_prob prob = _pep_get_prob_from_context( context, symbol );
-					_pep_arith_encode( &ac, prob );
-					_pep_arith_encode_normalize( &ac );
-					_PEP_UPDATE( context, symbol, freq_max, pcount );
-					encoded_in_level = 1;
-				}
-				else
-				{
-					_pep_prob prob = _pep_get_prob_from_context( context, index_escape );
-					_pep_arith_encode( &ac, prob );
-					_pep_arith_encode_normalize( &ac );
-					context->freq[ index_escape ] += 1;
-					context->sum += 1;
-				}
-			}
-
-			if( !encoded_in_level )
-			{
-				_pep_prob prob = _pep_get_prob_from_context( order0, symbol );
-				_pep_arith_encode( &ac, prob );
-				_pep_arith_encode_normalize( &ac );
-				_PEP_UPDATE( order0, symbol, freq_max, pcount );
-
-				if( context->sum == 0 )
-				{
-					context->freq[ index_escape ] = 1;
-					context->sum = 1;
-				}
-				context->freq[ symbol ] = 1;
-				context->sum += 1;
-			}
-		}
-	}
-
-	for( uint8_t index = 0; index < 4; index++ )
-	{
-		uint8_t byte = ac.low >> PEP_CODE_BITS;
-		ac.low <<= PEP_CODE_BITS_INV;
-		*ac.data_ref++= byte;
-	}
-
-	uint64_t size = ( uint64_t ) ( ac.data_ref - out );
-	_pep_model_free( &m );
-	return size;
-}
-
-// The format of the in_pixels has to be the same as in_format.
-// out_format is the one applied to the newly compressed pep
-
-// Compresses raw pixels into a pep, trying each context model and keeping the
-// smallest result (the winning model index is stored in out.model).
-pep pep_compress( const uint32_t* in_pixels, const uint16_t width, const uint16_t height, const pep_format in_format, const pep_channel_bits in_channel_bits )
-{
-	pep out_pep = { 0 };
-	uint32_t area = ( uint32_t )width * height;
-	if( in_pixels == NULL || area == 0 ) return out_pep;
-
-	out_pep.width = width;
-	out_pep.height = height;
-	out_pep.format = in_format;
-	out_pep.channel_bits = in_channel_bits;
-
-	uint8_t* idx = ( uint8_t* )PEP_MALLOC( area );
-	
-	uint32_t palette[ 256 ];
-	uint16_t count = 0; // 1-256 distinct colours
-	const uint32_t* p = in_pixels;
-	const uint32_t* p_end = p + area;
-	uint32_t last_p = 0,
-	this_p = 0;
-	while( p < p_end )
-	{
-		this_p = *p;
-		if( p > in_pixels && this_p == last_p )
-		{
-			p++;
-			continue;
-		}
-		uint16_t n = 0;
-		while( n < count && this_p != palette[ n ] ) n++;
-		if( n >= count && count < 256 ) palette[ count++ ] = this_p;
-		last_p = this_p;
-		p++;
-	}
-	memcpy( out_pep.palette, palette, ( size_t ) count * sizeof( uint32_t ) );
-	out_pep.palette_size = ( uint8_t )count;
-	for( uint32_t index = 0; index < area; index++ )
-	{
-		uint32_t c = in_pixels[ index ];
-		uint16_t k = 0;
-		while( k < count && palette[ k ] != c ) k++;
-		idx[ index ] = ( uint8_t )( k < count ? k : 0 );
-	}
-	const uint32_t pcount = out_pep.palette_size ? out_pep.palette_size : 256;
-
-	uint8_t* best = ( uint8_t* )PEP_MALLOC( ( size_t ) area * sizeof( uint32_t ) + 64 );
-	uint8_t* tmp = ( uint8_t* )PEP_MALLOC( ( size_t ) area * sizeof( uint32_t ) + 64 );
-	uint64_t best_size = 0;
-	uint8_t best_model = 0;
-
-	for( uint8_t model = 0; model < PEP_NUM_MODELS; model++ )
-	{
-		uint64_t size = _pep_encode_model( idx, width, height, pcount, model, tmp );
-		if( size == 0 ) continue;
-		
-		if( best_size == 0 || size < best_size )
-		{
-			best_size = size;
-			best_model = model;
-			memcpy( best, tmp, size );
-		}
-	}
-
-	out_pep.bytes = ( uint8_t* )PEP_REALLOC( best, best_size );
-	out_pep.bytes_size = best_size;
-	out_pep.model = ( uint8_t )best_model;
-
-	PEP_FREE( tmp );
-	PEP_FREE( idx );
-	return out_pep;
-}
-
-// Decode all pixels with one model (mirror of _pep_encode_model).
-static void _pep_decode_model( const uint8_t* in_bytes, uint64_t in_size, uint16_t width, uint16_t height, uint32_t pcount, uint8_t model, const uint32_t* palette, pep_format in_format, pep_format out_format, uint8_t pre_multiply, uint8_t* idx, uint32_t* out_pixels )
-{
-	_pep_model_context m;
-	if( !_pep_model_init( &m, _pep_models[ model ], pcount ) ) return;
-	const uint32_t index_escape = m.index_escape;
-
-	_pep_ac_decode ac = { 0 };
-	ac.range = ( uint32_t )( ( 1llu << 32 ) - 1 );
-	ac.data_ref = ( uint8_t* )in_bytes;
-	ac.end_of_data = ( uint8_t* )in_bytes + in_size;
-	for( uint8_t index = 0; index < 4; ++index )
-	{
-		uint8_t b = 0;
-		if( ac.data_ref != ac.end_of_data ) b = *ac.data_ref++;
-		ac.code = ( ac.code << 8 ) | b;
-	}
-
-	uint16_t freq_max = PEP_FREQ_MAX;
-	_pep_context* order0 = &m.contexts[ 0 ];
-	uint32_t pos = 0;
-
-	for( uint32_t y = 0; y < height; y++ )
-	{
-		for( uint32_t x = 0; x < width; x++, pos++ )
-		{
-			_pep_context* context = _pep_build_level( &m, idx, pos, x, y, width );
-			uint32_t symbol = 0;
-			uint8_t decoded_in_level = 0;
-
-			if( context->sum != 0 )
-			{
-				uint32_t f = _pep_arith_decode_curr_freq( &ac, context->sum );
-				_pep_sym_decode r = _pep_get_sym_from_freq( context, f );
-				_pep_arith_decode_update( &ac, r.prob );
-
-				if( r.symbol != index_escape )
-				{
-					symbol = r.symbol;
-					_PEP_UPDATE( context, symbol, freq_max, pcount );
-					decoded_in_level = 1;
-				}
-				else
-				{
-					context->freq[ index_escape ] += 1;
-					context->sum += 1;
-				}
-			}
-
-			if( !decoded_in_level )
-			{
-				uint32_t f = _pep_arith_decode_curr_freq( &ac, order0->sum );
-				_pep_sym_decode r = _pep_get_sym_from_freq( order0, f );
-				_pep_arith_decode_update( &ac, r.prob );
-				symbol = r.symbol;
-				_PEP_UPDATE( order0, symbol, freq_max, pcount );
-
-				if( context->sum == 0 )
-				{
-					context->freq[ index_escape ] = 1;
-					context->sum = 1;
-				}
-				context->freq[ symbol ] = 1;
-				context->sum += 1;
-			}
-
-			idx[ pos ] = ( uint8_t )symbol;
-			uint32_t pixel = ( symbol < pcount ) ? _pep_reformat( palette[ symbol ], in_format, out_format ) : 0;
-			if( pre_multiply != 0 ) pixel = _pep_pre_multiply( pixel, out_format );
-			out_pixels[ pos ] = pixel;
-		}
-	}
-	_pep_model_free( &m );
-}
-
-uint32_t* pep_decompress( const pep* const in_pep, const pep_format out_format, const uint8_t transparent_first_color, uint8_t const pre_multiply )
-{
-	if( in_pep == NULL ) return NULL;
-	if( in_pep->bytes == NULL || in_pep->bytes_size == 0 || in_pep->width == 0 || in_pep->height == 0 ) return NULL;
-
-	const uint16_t width = in_pep->width,
-	height = in_pep->height;
-	const uint32_t area = ( uint32_t )width * height;
-	uint32_t* out_pixels = ( uint32_t* )PEP_MALLOC( area * sizeof( uint32_t ) );
-	uint8_t* idx = ( uint8_t* )PEP_MALLOC( area );
-
-	const uint32_t pcount = in_pep->palette_size ? in_pep->palette_size : 256;
-	static uint32_t palette[ 256 ];
-	memcpy( palette, in_pep->palette, pcount * sizeof( uint32_t ) );
-	if( transparent_first_color != 0 )
-	{
-		if( in_pep->format <= pep_bgra ) palette[ 0 ] &= 0x00ffffff;
-		else palette[ 0 ] &= 0xffffff00;
-	}
-
-	uint8_t model = in_pep->model;
-	if( model >= PEP_NUM_MODELS ) model = 0;
-
-	_pep_decode_model( in_pep->bytes, in_pep->bytes_size, width, height, pcount, model, palette, in_pep->format, out_format, pre_multiply, idx, out_pixels );
-
-	PEP_FREE( idx );
-	return out_pixels;
-}
-
-void pep_free( pep* in_pep )
-{
-	if( in_pep && in_pep->bytes )
-	{
-		free( in_pep->bytes );
-		in_pep->bytes = NULL;
-		in_pep->bytes_size = 0;
-	}
-}
-
-#pragma endregion visible
-
-#pragma endregion compression
-
-////////////////////////////////////////////////////////////////
-#pragma region - serialization
-
-uint8_t* pep_serialize( const pep* in_pep, uint32_t* const out_size )
-{
-	if( !in_pep || !in_pep->width || !in_pep->height || !in_pep->bytes_size || !in_pep->bytes )
-	{
-		*out_size = 0;
-		return NULL;
-	}
-
-	uint16_t palette_count = in_pep->palette_size ? in_pep->palette_size : 256;
-
-	const uint16_t w = in_pep->width - 1;
-	const uint16_t h = in_pep->height - 1;
-	const uint8_t is_small = ( w <= 255 && h <= 255 ) ? 1 : 0;
-	const uint8_t dim_bytes = is_small ? 2 : 3;
-
-	// calculate variable-length size bytes
-	uint8_t size_bytes = 0;
-	uint32_t temp_size = in_pep->bytes_size;
-	while( temp_size >= 0x80 )
-	{
-		size_bytes++;
-		temp_size >>= 7;
-	}
-	++size_bytes;
-
-	// check if bitmap (black and white)
-	uint8_t is_bitmap = 0;
-	if( palette_count == 2 )
-	{
-		const uint8_t* const color0 = ( uint8_t* )( &in_pep->palette[ 0 ] );
-		const uint8_t* const color1 = ( uint8_t* )( &in_pep->palette[ 1 ] );
-
-		const uint8_t is_white0 = ( color0[ 0 ] == 255 && color0[ 1 ] == 255 && color0[ 2 ] == 255 && color0[ 3 ] == 255 );
-		const uint8_t is_white1 = ( color1[ 0 ] == 255 && color1[ 1 ] == 255 && color1[ 2 ] == 255 && color1[ 3 ] == 255 );
-
-		if( in_pep->format <= pep_bgra )
-		{
-			is_bitmap = ( ( is_white0 && color1[ 0 ] == 0 && color1[ 1 ] == 0 && color1[ 2 ] == 0 && color1[ 3 ] == 255 ) || ( color0[ 0 ] == 0 && color0[ 1 ] == 0 && color0[ 2 ] == 0 && color0[ 3 ] == 255 && is_white1 ) );
-		}
-		else
-		{
-			is_bitmap = ( ( is_white0 && color1[ 0 ] == 255 && color1[ 1 ] == 0 && color1[ 2 ] == 0 && color1[ 3 ] == 0 ) || ( color0[ 0 ] == 255 && color0[ 1 ] == 0 && color0[ 2 ] == 0 && color0[ 3 ] == 0 && is_white1 ) );
-		}
-	}
-
-	// check if all palette alphas are 255
-	uint8_t only_rgb = 1;
-	if( !is_bitmap )
-	{
-		for( uint16_t index = 0; index < palette_count; index++ )
-		{
-			if( ( ( ( uint8_t* )( &in_pep->palette[ index ] ) )[ 3 ] ) != 0xff )
-			{
-				only_rgb = 0;
-				break;
-			}
-		}
-	}
-
-	// calculate palette bytes
-	uint16_t palette_bytes = 0;
-	if( !is_bitmap )
-	{
-		const uint16_t channel_bits = 1 << in_pep->channel_bits;
-		if( channel_bits == 8 )
-		{
-			palette_bytes = palette_count * ( only_rgb ? 3 : 4 );
-		}
-		else
-		{
-			const uint16_t channels = only_rgb ? 3 : 4;
-			palette_bytes = ( channel_bits * channels * palette_count + 7 ) >> 3;
-		}
-	}
-
-	// allocate the exact size (subtract 1 for palette_size byte if bitmap)
-	const uint64_t total_size = dim_bytes + size_bytes + ( is_bitmap ? 0 : 1 ) + palette_bytes + in_pep->bytes_size + 4 + 1;
-	uint8_t* out_bytes = ( uint8_t* )PEP_MALLOC( total_size );
-	uint8_t* out_bytes_ref = out_bytes;
-
-	// flags: format (2), channel_bits (2), is_small (1), only_rgb (1), is_bitmap (1)
-	*out_bytes_ref++= ( in_pep->format & 0x3 ) | ( ( in_pep->channel_bits & 0x3 ) << 2 ) | ( ( is_small & 0x1 ) << 4 ) | ( ( only_rgb & 0x1 ) << 5 ) | ( ( is_bitmap & 0x1 ) << 6 );
-	*out_bytes_ref++= in_pep->model; // takes the last extra byte
-
-	// width/height
-	if( is_small )
-	{
-		*out_bytes_ref++= w & 0xff;
-		*out_bytes_ref++= h & 0xff;
-	}
-	else
-	{
-		const uint32_t packed_dims = ( ( w & 0xfff ) << 12 ) | ( h & 0xfff );
-		*out_bytes_ref++= ( packed_dims >> 16 ) & 0xff;
-		*out_bytes_ref++= ( packed_dims >> 8 ) & 0xff;
-		*out_bytes_ref++= packed_dims & 0xff;
-	}
-
-	// variable-length size
-	uint32_t size = in_pep->bytes_size;
-	while( size >= 0x80 )
-	{
-		*out_bytes_ref++= ( size | 0x80 ) & 0xff;
-		size >>= 7;
-	}
-	*out_bytes_ref++= size;
-
-	if( !is_bitmap )
-	{
-		// palette size
-		*out_bytes_ref++= in_pep->palette_size;
-
-		// palette
-		const uint16_t channel_bits = 1 << in_pep->channel_bits;
-		const uint8_t shift = 8 - channel_bits;
-		const uint8_t mask = ( 1 << channel_bits ) - 1;
-
-		if( channel_bits == 8 )
-		{
-			for( uint16_t index = 0; index < palette_count; index++ )
-			{
-				uint8_t* color = ( uint8_t* )( &( in_pep->palette[ index ] ) );
-				*out_bytes_ref++= color[ 0 ];
-				*out_bytes_ref++= color[ 1 ];
-				*out_bytes_ref++= color[ 2 ];
-				if( !only_rgb ) *out_bytes_ref++= color[ 3 ];
-			}
-		}
-		else
-		{
-			uint32_t bit_buffer = 0;
-			uint8_t bit_count = 0;
-
-			for( uint16_t index = 0; index < palette_count; index++ )
-			{
-				uint8_t* color = ( uint8_t* )( &( in_pep->palette[ index ] ) );
-
-				bit_buffer = ( bit_buffer << channel_bits ) | ( ( color[ 0 ] >> shift ) &mask );
-				bit_buffer = ( bit_buffer << channel_bits ) | ( ( color[ 1 ] >> shift ) &mask );
-				bit_buffer = ( bit_buffer << channel_bits ) | ( ( color[ 2 ] >> shift ) &mask );
-				bit_count += channel_bits * 3;
-
-				if( !only_rgb )
-				{
-					bit_buffer = ( bit_buffer << channel_bits ) | ( ( color[ 3 ] >> shift ) &mask );
-					bit_count += channel_bits;
-				}
-
-				while( bit_count >= 8 )
-				{
-					bit_count -= 8;
-					*out_bytes_ref++= ( bit_buffer >> bit_count ) & 0xff;
-				}
-			}
-
-			if( bit_count > 0 )
-			{
-				*out_bytes_ref++= ( bit_buffer << ( 8 - bit_count ) ) & 0xff;
-			}
-		}
-	}
-
-	memcpy( out_bytes_ref, in_pep->bytes, in_pep->bytes_size );
-	out_bytes_ref += in_pep->bytes_size;
-	*out_bytes_ref = '\0';
-
-	*out_size = out_bytes_ref - out_bytes;
-	return out_bytes;
-}
-
-pep pep_deserialize( const uint8_t* const in_bytes, const uint32_t in_bytes_size )
-{
-	pep out_pep = { 0 };
-
-	if( !in_bytes || in_bytes_size == 0 ) return out_pep;
-
-	const uint8_t* bytes_ref = in_bytes;
-	const uint8_t* const bytes_end = in_bytes + in_bytes_size;
-
-	// packed flags
-	if( bytes_ref + 1 > bytes_end ) return out_pep;
-	uint8_t packed_flags = *bytes_ref++;
-	if( bytes_ref + 1 > bytes_end ) return out_pep;
-	out_pep.model = *bytes_ref++;
-	out_pep.format = ( pep_format ) ( packed_flags & 0x3 );
-	out_pep.channel_bits = ( pep_channel_bits ) ( ( packed_flags >> 2 ) & 0x3 );
-	uint8_t is_small = ( packed_flags >> 4 ) & 0x1;
-	uint8_t only_rgb = ( packed_flags >> 5 ) & 0x1;
-	uint8_t is_bitmap = ( packed_flags >> 6 ) & 0x1;
-
-	// width/height
-	uint8_t dim_bytes = is_small ? 2 : 3;
-	if( bytes_ref + dim_bytes > bytes_end ) return out_pep;
-	uint16_t w,
-	h;
-	if( is_small )
-	{
-		w = *bytes_ref++;
-		h = *bytes_ref++;
-	}
-	else
-	{
-		uint32_t packed_dims = ( *bytes_ref++ << 16 );
-		packed_dims |= ( *bytes_ref++ << 8 );
-		packed_dims |= *bytes_ref++;
-		w = ( packed_dims >> 12 ) & 0xfff;
-		h = packed_dims & 0xfff;
-	}
-	out_pep.width = w + 1;
-	out_pep.height = h + 1;
-
-	// variable-length size
-	uint32_t bytes_size = 0;
-	uint8_t shift = 0;
-	uint8_t byte_val;
-	do
-	{
-		if( bytes_ref >= bytes_end ) return out_pep;
-		byte_val = *bytes_ref++;
-		if( shift < 32 ) bytes_size |= ( ( uint32_t )( byte_val &0x7f ) ) << shift;
-		shift += 7;
-	}
-	while( ( byte_val & 0x80 ) && shift < 35 );
-	out_pep.bytes_size = bytes_size;
-
-	// handle bitmap or read palette
-	uint32_t remaining = ( uint32_t )( bytes_end - bytes_ref );
-
-	if( is_bitmap )
-	{
-		if( remaining < bytes_size ) return out_pep;
-
-		out_pep.palette_size = 2;
-		out_pep.palette[ 0 ] = out_pep.format <= pep_bgra ? 0xff000000 : 0x000000ff;
-		out_pep.palette[ 1 ] = 0xffffffff;
-	}
-	else
-	{
-		// palette size
-		if( remaining < 1 ) return out_pep;
-		out_pep.palette_size = *bytes_ref++;
-		remaining--;
-
-		uint16_t palette_count = out_pep.palette_size ? out_pep.palette_size : 256;
-
-		// palette
-		const uint8_t channel_bits = 1 << out_pep.channel_bits;
-		const uint8_t mask = ( 1 << channel_bits ) - 1;
-		uint32_t palette_bytes;
-		if( channel_bits == 8 )
-		{
-			palette_bytes = palette_count * ( only_rgb ? 3 : 4 );
-		}
-		else
-		{
-			uint16_t channels = only_rgb ? 3 : 4;
-			palette_bytes = ( channel_bits * channels * palette_count + 7 ) >> 3;
-		}
-
-		if( remaining < palette_bytes || remaining - palette_bytes < bytes_size ) return out_pep;
-
-		if( channel_bits == 8 )
-		{
-			for( uint16_t index = 0; index < palette_count; index++ )
-			{
-				uint8_t* color = ( uint8_t* )( &( out_pep.palette[ index ] ) );
-				color[ 0 ] = *bytes_ref++;
-				color[ 1 ] = *bytes_ref++;
-				color[ 2 ] = *bytes_ref++;
-				color[ 3 ] = only_rgb ? 0xff : *bytes_ref++;
-			}
-		}
-		else
-		{
-			uint32_t bit_buffer = 0;
-			uint8_t bit_count = 0;
-
-			for( uint16_t index = 0; index < palette_count; index++ )
-			{
-				uint8_t channels = only_rgb ? 3 : 4;
-				uint8_t channel_values[ 4 ];
-
-				for( uint8_t c = 0; c < channels; c++ )
-				{
-					while( bit_count < channel_bits )
-					{
-						bit_buffer = ( bit_buffer << 8 ) | *bytes_ref++;
-						bit_count += 8;
-					}
-					bit_count -= channel_bits;
-					channel_values[ c ] = ( bit_buffer >> bit_count ) & mask;
-
-					uint8_t scaled = channel_values[ c ] << ( 8 - channel_bits );
-					if( channel_bits < 8 )
-					{
-						scaled |= ( scaled >> channel_bits );
-						if( channel_bits < 4 )
-						{
-							scaled |= ( scaled >> ( 2 * channel_bits ) );
-						}
-					}
-					channel_values[ c ] = scaled;
-				}
-
-				uint8_t* color = ( uint8_t* )( &( out_pep.palette[ index ] ) );
-				color[ 0 ] = channel_values[ 0 ];
-				color[ 1 ] = channel_values[ 1 ];
-				color[ 2 ] = channel_values[ 2 ];
-				color[ 3 ] = only_rgb ? 0xff : channel_values[ 3 ];
-			}
-		}
-	}
-
-	// copy image data
-	out_pep.bytes = ( uint8_t* )PEP_MALLOC( bytes_size );
-	if( out_pep.bytes )
-	{
-		memcpy( out_pep.bytes, bytes_ref, bytes_size );
-	}
-
-	return out_pep;
-}
-
-#pragma endregion serialization
-
-////////////////////////////////////////////////////////////////
-#pragma region - file
-
-// For both save/load, file_path should end in ".pep":
-// e.g. "texture.pep", "assets/image.pep"
-
-// Saves pep into a file.
-// Returns 0 on failure, 1 on success
-uint8_t pep_save( const pep* const in_pep, const char* const file_path )
-{
-	if( !in_pep || !file_path )
-	{
-		return 0;
-	}
-
-	uint32_t bytes_size = 0;
-	uint8_t* bytes = pep_serialize( in_pep, &bytes_size );
-
-	if( !bytes || bytes_size == 0 )
-	{
-		return 0;
-	}
-
-	FILE * file = fopen( file_path, "wb" );
-	if( !file )
-	{
-		PEP_FREE( bytes );
-		return 0;
-	}
-
-	size_t written = fwrite( bytes, 1, bytes_size, file );
-
-	fclose( file );
-	PEP_FREE( bytes );
-
-	#ifdef PEP_DEBUG
-		printf( "pep: %lld\nfile: %zu\nmodel: %d\n", in_pep->bytes_size, written, in_pep->model );
-	#endif
-
-	return written == bytes_size;
-}
-
-// Loads .pep file into returned pep struct
-pep pep_load( const char* const file_path )
-{
-	pep out_pep = { 0 };
-
-	if( !file_path )
-	{
-		return out_pep;
-	}
-
-	FILE * file = fopen( file_path, "rb" );
-	if( !file )
-	{
-		return out_pep;
-	}
-
-	fseek( file, 0, SEEK_END );
-	long file_size = ftell( file );
-	fseek( file, 0, SEEK_SET );
-
-	if( file_size <= 0 )
-	{
-		fclose( file );
-		return out_pep;
-	}
-
-	uint8_t* bytes = ( uint8_t* )PEP_MALLOC( file_size );
-
-	size_t read = fread( bytes, 1, file_size, file );
-	fclose( file );
-
-	if( read != ( size_t ) file_size )
-	{
-		PEP_FREE( bytes );
-		return out_pep;
-	}
-
-	out_pep = pep_deserialize( bytes, ( uint32_t )read );
-	PEP_FREE( bytes );
-
-	#ifdef PEP_DEBUG
-		printf( "\npep: %lld\nfile: %ld\n", out_pep.bytes_size, file_size );
-	#endif
-
-	return out_pep;
-}
-
-#pragma endregion file
-
-#ifdef _MSC_VER
-	#pragma warning( pop )
-#endif
-
-#endif // PEP_IMPLEMENTATION
-
-
-#pragma endregion definitions
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/libraries/raylib/raylib/src/external/rlsw.h b/src/libraries/raylib/raylib/src/external/rlsw.h
index 6b69d68..8f7ab44 100644
--- a/src/libraries/raylib/raylib/src/external/rlsw.h
+++ b/src/libraries/raylib/raylib/src/external/rlsw.h
@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   rlsw v1.6 - An OpenGL 1.1-style software renderer implementation
+*   rlsw v1.5 - An OpenGL 1.1-style software renderer implementation
 *
 *   DESCRIPTION:
 *       rlsw is a custom OpenGL 1.1-style implementation on software, intended to provide all
@@ -51,14 +51,13 @@
 *       rlsw capabilities could be customized defining some internal
 *       values before library inclusion (default values listed):
 *
-*           #define RLSW_FRAMEBUFFER_OUTPUT_BGRA      true
-*           #define RLSW_FRAMEBUFFER_COLOR_TYPE       R8G8B8A8
-*           #define RLSW_FRAMEBUFFER_DEPTH_TYPE       D32
-*           #define RLSW_MAX_PROJECTION_STACK_SIZE    2
-*           #define RLSW_MAX_MODELVIEW_STACK_SIZE     8
-*           #define RLSW_MAX_TEXTURE_STACK_SIZE       2
-*           #define RLSW_MAX_TEXTURES                 128
-*           #define RLSW_DOUBLE_BUFFERING             0
+*           #define SW_FRAMEBUFFER_OUTPUT_BGRA      true
+*           #define SW_FRAMEBUFFER_COLOR_TYPE       R8G8B8A8
+*           #define SW_FRAMEBUFFER_DEPTH_TYPE       D32
+*           #define SW_MAX_PROJECTION_STACK_SIZE    2
+*           #define SW_MAX_MODELVIEW_STACK_SIZE     8
+*           #define SW_MAX_TEXTURE_STACK_SIZE       2
+*           #define SW_MAX_TEXTURES                 128
 *
 *
 *   LICENSE: MIT
@@ -88,60 +87,11 @@
 #ifndef RLSW_H
 #define RLSW_H
 
-#define RLSW_VERSION  "1.6"
+#define RLSW_VERSION  "1.5"
 
 #include <stdbool.h>
 #include <stdint.h>
 
-//----------------------------------------------------------------------------------
-// RLSW Configuration
-//----------------------------------------------------------------------------------
-#ifndef RLSW_FRAMEBUFFER_OUTPUT_BGRA
-    #define RLSW_FRAMEBUFFER_OUTPUT_BGRA    true
-#endif
-#ifndef RLSW_FRAMEBUFFER_COLOR_TYPE
-    #define RLSW_FRAMEBUFFER_COLOR_TYPE     R8G8B8A8    // Or R5G6B5, R3G3B2, etc; see `sw_pixelformat_t`
-#endif
-#ifndef RLSW_FRAMEBUFFER_DEPTH_TYPE
-    #define RLSW_FRAMEBUFFER_DEPTH_TYPE     D32         // Or D16, D8
-#endif
-#ifndef RLSW_MAX_PROJECTION_STACK_SIZE
-    #define RLSW_MAX_PROJECTION_STACK_SIZE  2
-#endif
-#ifndef RLSW_MAX_MODELVIEW_STACK_SIZE
-    #define RLSW_MAX_MODELVIEW_STACK_SIZE   8
-#endif
-#ifndef RLSW_MAX_TEXTURE_STACK_SIZE
-    #define RLSW_MAX_TEXTURE_STACK_SIZE     2
-#endif
-#ifndef RLSW_MAX_FRAMEBUFFERS
-    #define RLSW_MAX_FRAMEBUFFERS           8
-#endif
-#ifndef RLSW_MAX_TEXTURES
-    #define RLSW_MAX_TEXTURES               128
-#endif
-#ifndef RLSW_DOUBLE_BUFFERING
-    #define RLSW_DOUBLE_BUFFERING           0
-#endif
-
-// Enable the use of a lookup table for uint8_t to float conversion
-// Requires an additional 1KB of global memory
-// Disabled when SIMD intrinsics are enabled
-#ifndef RLSW_USE_COLOR_LUT
-    #if RLSW_USE_SIMD_INTRINSICS
-        #define RLSW_USE_COLOR_LUT          false
-    #else
-        #define RLSW_USE_COLOR_LUT          true
-    #endif
-#endif
-
-// Full NPOT texture support (enabled by default)
-// When disabled, SW_REPEAT requires POT on its axis (fast bitmask wrap)
-// SW_CLAMP remains supported for any dimension, per-axis
-#ifndef RLSW_SUPPORT_NPOT_TEXTURE
-#   define RLSW_SUPPORT_NPOT_TEXTURE true
-#endif
-
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -171,6 +121,49 @@
     #endif
 #endif
 
+#ifndef SW_FRAMEBUFFER_OUTPUT_BGRA
+    #define SW_FRAMEBUFFER_OUTPUT_BGRA      true
+#endif
+
+#ifndef SW_FRAMEBUFFER_COLOR_TYPE
+    #define SW_FRAMEBUFFER_COLOR_TYPE       R8G8B8A8    // Or R5G6B5, R3G3B2, etc; see `sw_pixelformat_t`
+#endif
+
+#ifndef SW_FRAMEBUFFER_DEPTH_TYPE
+    #define SW_FRAMEBUFFER_DEPTH_TYPE       D32         // Or D16, D8
+#endif
+
+#ifndef SW_MAX_PROJECTION_STACK_SIZE
+    #define SW_MAX_PROJECTION_STACK_SIZE    2
+#endif
+
+#ifndef SW_MAX_MODELVIEW_STACK_SIZE
+    #define SW_MAX_MODELVIEW_STACK_SIZE     8
+#endif
+
+#ifndef SW_MAX_TEXTURE_STACK_SIZE
+    #define SW_MAX_TEXTURE_STACK_SIZE       2
+#endif
+
+#ifndef SW_MAX_FRAMEBUFFERS
+    #define SW_MAX_FRAMEBUFFERS             8
+#endif
+
+#ifndef SW_MAX_TEXTURES
+    #define SW_MAX_TEXTURES                 128
+#endif
+
+// Enables the use of a lookup table for uint8_t to float conversion
+// Requires an additional 1KB of global memory
+// Disabled when SIMD intrinsics are enabled
+#ifndef SW_USE_COLOR_LUT
+    #if RLSW_USE_SIMD_INTRINSICS
+        #define SW_USE_COLOR_LUT            false
+    #else
+        #define SW_USE_COLOR_LUT            true
+    #endif
+#endif
+
 //----------------------------------------------------------------------------------
 // OpenGL Compatibility Types
 //----------------------------------------------------------------------------------
@@ -207,7 +200,6 @@ typedef double              GLclampd;
 #define GL_RENDERER                         0x1F01
 #define GL_VERSION                          0x1F02
 #define GL_EXTENSIONS                       0x1F03
-#define GL_SHADING_LANGUAGE_VERSION         0x8B8C
 
 //#define GL_ATTRIB_STACK_DEPTH             0x0BB0
 //#define GL_CLIENT_ATTRIB_STACK_DEPTH      0x0BB1
@@ -515,7 +507,6 @@ typedef enum {
     SW_RENDERER = GL_RENDERER,
     SW_VERSION = GL_VERSION,
     SW_EXTENSIONS = GL_EXTENSIONS,
-    SW_SHADING_LANGUAGE_VERSION = GL_SHADING_LANGUAGE_VERSION,
     SW_COLOR_CLEAR_VALUE = GL_COLOR_CLEAR_VALUE,
     SW_DEPTH_CLEAR_VALUE = GL_DEPTH_CLEAR_VALUE,
     SW_CURRENT_COLOR = GL_CURRENT_COLOR,
@@ -679,7 +670,6 @@ SWAPI bool swResize(int w, int h);
 SWAPI void swReadPixels(int x, int y, int w, int h, SWformat format, SWtype type, void *pixels);
 SWAPI void swBlitPixels(int xDst, int yDst, int wDst, int hDst, int xSrc, int ySrc, int wSrc, int hSrc, SWformat format, SWtype type, void *pixels);
 SWAPI void *swGetColorBuffer(int *width, int *height); // Restored for ESP-IDF compatibility
-SWAPI void swSwapColorBuffers(void); // Swap software renderer color/back buffers by pointer only
 
 SWAPI void swEnable(SWstate state);
 SWAPI void swDisable(SWstate state);
@@ -773,8 +763,8 @@ SWAPI void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWatta
 
 // Simple log system to avoid printf() calls if required
 // NOTE: Avoiding those calls, also avoids const strings memory usage
-#define RLSW_SUPPORT_LOG_INFO
-#if defined(RLSW_SUPPORT_LOG_INFO)
+#define SW_SUPPORT_LOG_INFO
+#if defined(SW_SUPPORT_LOG_INFO) //&& defined(_DEBUG)      // WARNING: LOG() output required for this tool
     #include <stdio.h>
     #define SW_LOG(...) printf(__VA_ARGS__)
 #else
@@ -789,18 +779,6 @@ SWAPI void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWatta
     #define SW_ALIGN(x) // Do nothing if not available
 #endif
 
-#if defined(NDEBUG)
-    #if defined(_MSC_VER)
-        #define SW_INLINE __forceinline
-    #elif defined(__GNUC__) || defined(__clang__)
-        #define SW_INLINE inline __attribute__((always_inline))
-    #else
-        #define SW_INLINE inline
-    #endif
-#else
-    #define SW_INLINE inline
-#endif
-
 #if defined(_M_X64) || defined(__x86_64__)
     #define SW_ARCH_X86_64
 #elif defined(_M_IX86) || defined(__i386__)
@@ -866,15 +844,6 @@ SWAPI void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWatta
     #endif
 #endif
 
-// ESP-DSP acceleration: ESP-IDF ships an optimized math library that includes
-// `dspm_mult_4x4x4_f32` (4x4 matrix multiply) and `dspm_mult_4x4x1_f32` (matrix * vector)
-// These are S3-tuned hand-vectorized kernels that beat the scalar versions for both throughput and code-size
-// Detection is opt-in to keep the dependency optional: define SW_USE_ESP_DSP from your build system
-#if defined(ESP_PLATFORM) && defined(SW_USE_ESP_DSP)
-    #define SW_HAS_ESP_DSP
-    #include "dspm_mult.h"
-#endif
-
 #ifdef __cplusplus
     #define SW_CURLY_INIT(name) name
 #else
@@ -889,43 +858,41 @@ SWAPI void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWatta
 #define SW_DEG2RAD  (SW_PI/180.0f)
 #define SW_RAD2DEG  (180.0f/SW_PI)
 
-// When clipping a convex polygon against a plane, at most one vertex is added
+// When clipping a convex polygon against a plane, at most one vertex is added.
 // Starting from a quadrilateral (4 vertices), clipped sequentially against
 // the frustum (6 planes) then the scissor rectangle (4 planes):
-// 4 + 6 + 4 = 14 vertices maximum
-#define SW_MAX_CLIPPED_POLYGON_VERTICES     14
-#define SW_CLIP_EPSILON                     1e-4f
+// 4 + 6 + 4 = 14 vertices maximum.
+#define SW_MAX_CLIPPED_POLYGON_VERTICES 14
+#define SW_CLIP_EPSILON                 1e-4f
 
-#define SW_HANDLE_NULL                      0u
-#define SW_POOL_SLOT_LIVE                   0x80u   // bit7 of the generation byte
-#define SW_POOL_SLOT_VER_MASK               0x7Fu   // bits6:0 = anti-ABA counter
+#define SW_HANDLE_NULL          0u
+#define SW_POOL_SLOT_LIVE       0x80u   // bit7 of the generation byte
+#define SW_POOL_SLOT_VER_MASK   0x7Fu   // bits6:0 = anti-ABA counter
 
-#define SW_CONCAT(a, b)                     a##b
-#define SW_CONCATX(a, b)                    SW_CONCAT(a, b)
+#define SW_CONCAT(a, b) a##b
+#define SW_CONCATX(a, b) SW_CONCAT(a, b)
 
-#define SW_FRAMEBUFFER_COLOR8_GET(c,p,o)    SW_CONCATX(sw_pixel_read_color8_, RLSW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o))
-#define SW_FRAMEBUFFER_COLOR_GET(c,p,o)     SW_CONCATX(sw_pixel_read_color_, RLSW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o))
-#define SW_FRAMEBUFFER_COLOR_SET(p,c,o)     SW_CONCATX(sw_pixel_write_color_, RLSW_FRAMEBUFFER_COLOR_TYPE)((p),(c),(o))
+#define SW_FRAMEBUFFER_COLOR8_GET(c,p,o) SW_CONCATX(sw_pixel_read_color8_, SW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o))
+#define SW_FRAMEBUFFER_COLOR_GET(c,p,o) SW_CONCATX(sw_pixel_read_color_, SW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o))
+#define SW_FRAMEBUFFER_COLOR_SET(p,c,o) SW_CONCATX(sw_pixel_write_color_, SW_FRAMEBUFFER_COLOR_TYPE)((p),(c),(o))
 
-#define SW_FRAMEBUFFER_DEPTH_GET(p,o)       SW_CONCATX(sw_pixel_read_depth_, RLSW_FRAMEBUFFER_DEPTH_TYPE)((p),(o))
-#define SW_FRAMEBUFFER_DEPTH_SET(p,d,o)     SW_CONCATX(sw_pixel_write_depth_, RLSW_FRAMEBUFFER_DEPTH_TYPE)((p),(d),(o))
+#define SW_FRAMEBUFFER_DEPTH_GET(p,o) SW_CONCATX(sw_pixel_read_depth_, SW_FRAMEBUFFER_DEPTH_TYPE)((p),(o))
+#define SW_FRAMEBUFFER_DEPTH_SET(p,d,o) SW_CONCATX(sw_pixel_write_depth_, SW_FRAMEBUFFER_DEPTH_TYPE)((p),(d),(o))
 
-#define SW_FRAMEBUFFER_COLOR_FORMAT         SW_CONCATX(SW_PIXELFORMAT_COLOR_, RLSW_FRAMEBUFFER_COLOR_TYPE)
-#define SW_FRAMEBUFFER_DEPTH_FORMAT         SW_CONCATX(SW_PIXELFORMAT_DEPTH_, RLSW_FRAMEBUFFER_DEPTH_TYPE)
+#define SW_FRAMEBUFFER_COLOR_FORMAT SW_CONCATX(SW_PIXELFORMAT_COLOR_, SW_FRAMEBUFFER_COLOR_TYPE)
+#define SW_FRAMEBUFFER_DEPTH_FORMAT SW_CONCATX(SW_PIXELFORMAT_DEPTH_, SW_FRAMEBUFFER_DEPTH_TYPE)
 
-#define SW_FRAMEBUFFER_COLOR_SIZE           SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_COLOR_FORMAT]
-#define SW_FRAMEBUFFER_DEPTH_SIZE           SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_DEPTH_FORMAT]
+#define SW_FRAMEBUFFER_COLOR_SIZE SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_COLOR_FORMAT]
+#define SW_FRAMEBUFFER_DEPTH_SIZE SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_DEPTH_FORMAT]
 
-#define SW_STATE_NONE                             0     /* Pseudo state used for the rasterizer variant with no pipeline state enabled */
-#define SW_STATE_SCISSOR_TEST               (1 << 0)
-#define SW_STATE_COLOR_INTERP               (1 << 1)
-#define SW_STATE_TEXTURE_2D                 (1 << 2)
-#define SW_STATE_DEPTH_TEST                 (1 << 3)
-#define SW_STATE_CULL_FACE                  (1 << 4)
-#define SW_STATE_BLEND                      (1 << 5)
+#define SW_STATE_SCISSOR_TEST   (1 << 0)
+#define SW_STATE_TEXTURE_2D     (1 << 1)
+#define SW_STATE_DEPTH_TEST     (1 << 2)
+#define SW_STATE_CULL_FACE      (1 << 3)
+#define SW_STATE_BLEND          (1 << 4)
 
-#define SW_BLEND_FLAG_NOOP                  (1 << 0)
-#define SW_BLEND_FLAG_NEEDS_ALPHA           (1 << 1)
+#define SW_BLEND_FLAG_NOOP          (1 << 0)
+#define SW_BLEND_FLAG_NEEDS_ALPHA   (1 << 1)
 
 //----------------------------------------------------------------------------------
 // Module Types and Structures Definition
@@ -964,7 +931,6 @@ typedef enum {
 } sw_pixel_alpha_t;
 
 // Forward declarations
-typedef struct sw_texture sw_texture_t;
 typedef struct sw_vertex sw_vertex_t;
 
 // Pixel getter functions
@@ -975,9 +941,6 @@ typedef void (*sw_pixel_read_color_f)(float *SW_RESTRICT, const void *SW_RESTRIC
 typedef void (*sw_pixel_write_color8_f)(void *SW_RESTRICT, const uint8_t *SW_RESTRICT, uint32_t);
 typedef void (*sw_pixel_write_color_f)(void *SW_RESTRICT, const float *SW_RESTRICT, uint32_t);
 
-// Texture sampler function
-typedef void (*sw_texture_sampler_f)(float *SW_RESTRICT, const sw_texture_t *SW_RESTRICT, float, float);
-
 // Color blending function
 typedef void (*sw_blend_f)(float *SW_RESTRICT, const float *SW_RESTRICT);
 
@@ -995,7 +958,7 @@ typedef struct sw_vertex {
     float texcoord[2];          // Texture coordinates
 } sw_vertex_t;
 
-typedef struct sw_texture {
+typedef struct {
     void *pixels;                       // Texture pixels
     sw_pixel_read_color8_f readColor8;  // Texel read RGBA8
     sw_pixel_read_color_f readColor;    // Texel read RGBA32F
@@ -1014,9 +977,6 @@ typedef struct sw_texture {
 
 typedef struct {
     sw_texture_t color;         // Default framebuffer color texture
-#if RLSW_DOUBLE_BUFFERING
-    sw_texture_t backColor; // Back buffer for multicore.
-#endif
     sw_texture_t depth;         // Default framebuffer depth texture
 } sw_default_framebuffer_t;
 
@@ -1069,23 +1029,19 @@ typedef struct {
     float pointRadius;                                          // Rasterized point radius
     float lineWidth;                                            // Rasterized line width
 
-    sw_matrix_t stackProjection[RLSW_MAX_PROJECTION_STACK_SIZE];  // Projection matrix stack for push/pop operations
-    sw_matrix_t stackModelview[RLSW_MAX_MODELVIEW_STACK_SIZE];    // Modelview matrix stack for push/pop operations
-    sw_matrix_t stackTexture[RLSW_MAX_TEXTURE_STACK_SIZE];        // Texture matrix stack for push/pop operations
+    sw_matrix_t stackProjection[SW_MAX_PROJECTION_STACK_SIZE];  // Projection matrix stack for push/pop operations
+    sw_matrix_t stackModelview[SW_MAX_MODELVIEW_STACK_SIZE];    // Modelview matrix stack for push/pop operations
+    sw_matrix_t stackTexture[SW_MAX_TEXTURE_STACK_SIZE];        // Texture matrix stack for push/pop operations
     uint32_t stackProjectionCounter;                            // Counter for matrix stack operations
     uint32_t stackModelviewCounter;                             // Counter for matrix stack operations
     uint32_t stackTextureCounter;                               // Counter for matrix stack operations
     SWmatrix currentMatrixMode;                                 // Current matrix mode (e.g., sw_MODELVIEW, sw_PROJECTION)
     sw_matrix_t *currentMatrix;                                 // Pointer to the currently used matrix according to the mode
     sw_matrix_t matMVP;                                         // Model view projection matrix, calculated and used internally
-#ifdef SW_HAS_ESP_DSP
-    float matMVP_rm[16];                                        // Row-major MVP, kept in sync for esp-dsp dspm_mult_4x4x1_f32 vertex transform
-#endif
     bool isDirtyMVP;                                            // Indicates if the MVP matrix should be rebuilt
 
     sw_handle_t boundFramebufferId;                             // Framebuffer currently bound
     sw_texture_t *colorBuffer;                                  // Color buffer currently bound
-    // NOTE: don't need backBuffer because it's already in the sw_default_framebuffer_t struct.
     sw_texture_t *depthBuffer;                                  // Depth buffer currently bound
     sw_pool_t framebufferPool;                                  // Framebuffer object pool
 
@@ -1109,7 +1065,7 @@ typedef struct {
 //----------------------------------------------------------------------------------
 static sw_context_t RLSW = { 0 };
 
-#if RLSW_USE_COLOR_LUT
+#if SW_USE_COLOR_LUT
 static float SW_LUT_UINT8_TO_FLOAT[256] = { 0 };
 #endif
 
@@ -1173,16 +1129,9 @@ static const int SW_PRIMITIVE_VERTEX_COUNT[] =
 // Internal Functions Definitions
 //----------------------------------------------------------------------------------
 
-// Common helper macros
-//----------------------------------------------------------------------------------
-#define SW_VEC_OP(expr, i_name, count) do {                 \
-    for (int i_name = 0; i_name < (count); i_name++) expr;  \
-} while (0)
-//----------------------------------------------------------------------------------
-
 // Math helper functions
 //----------------------------------------------------------------------------------
-static SW_INLINE void sw_matrix_id(sw_matrix_t dst)
+static inline void sw_matrix_id(sw_matrix_t dst)
 {
     dst[0]  = 1, dst[1]  = 0, dst[2]  = 0, dst[3]  = 0;
     dst[4]  = 0, dst[5]  = 1, dst[6]  = 0, dst[7]  = 0;
@@ -1190,16 +1139,8 @@ static SW_INLINE void sw_matrix_id(sw_matrix_t dst)
     dst[12] = 0, dst[13] = 0, dst[14] = 0, dst[15] = 1;
 }
 
-static void sw_matrix_mul_rst(float *SW_RESTRICT dst, const float *SW_RESTRICT left, const float *SW_RESTRICT right)
+static inline void sw_matrix_mul_rst(float *SW_RESTRICT dst, const float *SW_RESTRICT left, const float *SW_RESTRICT right)
 {
-#ifdef SW_HAS_ESP_DSP
-    // dspm_mult_4x4x4_f32 treats its operands as row-major. rlsw stores matrices
-    // column-major, so passing them flat is equivalent to passing transposes:
-    // dspm_mult(L^T, R^T) computes (L^T)*(R^T) = (R*L)^T, written back into a
-    // flat array gives the same bit pattern as the column-major product (R*L)
-    // -- exactly the semantic the scalar fallback below has
-    dspm_mult_4x4x4_f32(left, right, dst);
-#else
     float l00 = left[0],  l01 = left[1],  l02 = left[2],  l03 = left[3];
     float l10 = left[4],  l11 = left[5],  l12 = left[6],  l13 = left[7];
     float l20 = left[8],  l21 = left[9],  l22 = left[10], l23 = left[11];
@@ -1224,31 +1165,30 @@ static void sw_matrix_mul_rst(float *SW_RESTRICT dst, const float *SW_RESTRICT l
     dst[7]  = l10*right[3] + l11*right[7] + l12*right[11] + l13*right[15];
     dst[11] = l20*right[3] + l21*right[7] + l22*right[11] + l23*right[15];
     dst[15] = l30*right[3] + l31*right[7] + l32*right[11] + l33*right[15];
-#endif
 }
 
-static SW_INLINE void sw_matrix_mul(sw_matrix_t dst, const sw_matrix_t left, const sw_matrix_t right)
+static inline void sw_matrix_mul(sw_matrix_t dst, const sw_matrix_t left, const sw_matrix_t right)
 {
     float result[16];
     sw_matrix_mul_rst(result, left, right);
     for (int i = 0; i < 16; i++) dst[i] = result[i];
 }
 
-static SW_INLINE int sw_clamp_int(int v, int min, int max)
+static inline int sw_clamp_int(int v, int min, int max)
 {
     if (v < min) return min;
     if (v > max) return max;
     return v;
 }
 
-static SW_INLINE int sw_clamp(float v, float min, float max)
+static inline int sw_clamp(float v, float min, float max)
 {
     if (v < min) return min;
     if (v > max) return max;
     return v;
 }
 
-static SW_INLINE float sw_saturate(float x)
+static inline float sw_saturate(float x)
 {
     union { float f; uint32_t u; } fb;
     fb.f = x;
@@ -1265,48 +1205,22 @@ static SW_INLINE float sw_saturate(float x)
     return x;
 }
 
-static SW_INLINE float sw_fract(float x)
+static inline float sw_fract(float x)
 {
     return (x - floorf(x));
 }
 
-static SW_INLINE float sw_rcp(float x)
-{
-#if defined(__XTENSA__)
-    // Xtensa architecture optimization
-    // Fast reciprocal: 1-ULP accurate in ~7 instructions using the
-    // hardware `recip0.s` seed + two Newton-Raphson refinement steps
-    // All work stays in FPU registers — no `__divsf3` software call
-    // Hot-path divisions in the rasterizer (span/triangle setup, perspective divide, etc.) call this
-    // On non-Xtensa targets it transparently expands to `1.0f / x`, so generated code is identical to before
-    float result, temp;
-    __asm__(
-        "recip0.s %0, %2\n"
-        "const.s  %1, 1\n"
-        "msub.s   %1, %2, %0\n"
-        "madd.s   %0, %0, %1\n"
-        "const.s  %1, 1\n"
-        "msub.s   %1, %2, %0\n"
-        "maddn.s  %0, %0, %1\n"
-        : "=&f"(result), "=&f"(temp) : "f"(x)
-    );
-    return result;
-#else
-    return 1.0f/x;
-#endif
-}
-
-static SW_INLINE uint8_t sw_luminance8(const uint8_t *color)
+static inline uint8_t sw_luminance8(const uint8_t *color)
 {
     return (uint8_t)((color[0]*77 + color[1]*150 + color[2]*29) >> 8);
 }
 
-static SW_INLINE float sw_luminance(const float *color)
+static inline float sw_luminance(const float *color)
 {
     return color[0]*0.299f + color[1]*0.587f + color[2]*0.114f;
 }
 
-static void sw_lerp_vertex_PCT(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT a, const sw_vertex_t *SW_RESTRICT b, float t)
+static inline void sw_lerp_vertex_PCT(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT a, const sw_vertex_t *SW_RESTRICT b, float t)
 {
     const float tInv = 1.0f - t;
 
@@ -1327,8 +1241,110 @@ static void sw_lerp_vertex_PCT(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *
     out->texcoord[1] = a->texcoord[1]*tInv + b->texcoord[1]*t;
 }
 
+static inline void sw_get_vertex_grad_PCT(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT a, const sw_vertex_t *SW_RESTRICT b, float scale)
+{
+    // Calculate gradients for Position
+    out->position[0] = (b->position[0] - a->position[0])*scale;
+    out->position[1] = (b->position[1] - a->position[1])*scale;
+    out->position[2] = (b->position[2] - a->position[2])*scale;
+    out->position[3] = (b->position[3] - a->position[3])*scale;
+
+    // Calculate gradients for Color
+    out->color[0] = (b->color[0] - a->color[0])*scale;
+    out->color[1] = (b->color[1] - a->color[1])*scale;
+    out->color[2] = (b->color[2] - a->color[2])*scale;
+    out->color[3] = (b->color[3] - a->color[3])*scale;
+
+    // Calculate gradients for Texture coordinates
+    out->texcoord[0] = (b->texcoord[0] - a->texcoord[0])*scale;
+    out->texcoord[1] = (b->texcoord[1] - a->texcoord[1])*scale;
+}
+
+static inline void sw_add_vertex_grad_PCT(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT gradients)
+{
+    // Add gradients to Position
+    out->position[0] += gradients->position[0];
+    out->position[1] += gradients->position[1];
+    out->position[2] += gradients->position[2];
+    out->position[3] += gradients->position[3];
+
+    // Add gradients to Color
+    out->color[0] += gradients->color[0];
+    out->color[1] += gradients->color[1];
+    out->color[2] += gradients->color[2];
+    out->color[3] += gradients->color[3];
+
+    // Add gradients to Texture coordinates
+    out->texcoord[0] += gradients->texcoord[0];
+    out->texcoord[1] += gradients->texcoord[1];
+}
+
+static inline void sw_add_vertex_grad_scaled_PCT(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT gradients, float scale)
+{
+    // Add gradients to Position
+    out->position[0] += gradients->position[0]*scale;
+    out->position[1] += gradients->position[1]*scale;
+    out->position[2] += gradients->position[2]*scale;
+    out->position[3] += gradients->position[3]*scale;
+
+    // Add gradients to Color
+    out->color[0] += gradients->color[0]*scale;
+    out->color[1] += gradients->color[1]*scale;
+    out->color[2] += gradients->color[2]*scale;
+    out->color[3] += gradients->color[3]*scale;
+
+    // Add gradients to Texture coordinates
+    out->texcoord[0] += gradients->texcoord[0]*scale;
+    out->texcoord[1] += gradients->texcoord[1]*scale;
+}
+
+static inline void sw_get_vertex_grad_PC(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT a, const sw_vertex_t *SW_RESTRICT b, float scale)
+{
+    // Calculate gradients for Position
+    out->position[0] = (b->position[0] - a->position[0])*scale;
+    out->position[1] = (b->position[1] - a->position[1])*scale;
+    out->position[2] = (b->position[2] - a->position[2])*scale;
+    out->position[3] = (b->position[3] - a->position[3])*scale;
+
+    // Calculate gradients for Color
+    out->color[0] = (b->color[0] - a->color[0])*scale;
+    out->color[1] = (b->color[1] - a->color[1])*scale;
+    out->color[2] = (b->color[2] - a->color[2])*scale;
+    out->color[3] = (b->color[3] - a->color[3])*scale;
+}
+
+static inline void sw_add_vertex_grad_PC(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT gradients)
+{
+    // Add gradients to Position
+    out->position[0] += gradients->position[0];
+    out->position[1] += gradients->position[1];
+    out->position[2] += gradients->position[2];
+    out->position[3] += gradients->position[3];
+
+    // Add gradients to Color
+    out->color[0] += gradients->color[0];
+    out->color[1] += gradients->color[1];
+    out->color[2] += gradients->color[2];
+    out->color[3] += gradients->color[3];
+}
+
+static inline void sw_add_vertex_grad_scaled_PC(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT gradients, float scale)
+{
+    // Add gradients to Position
+    out->position[0] += gradients->position[0]*scale;
+    out->position[1] += gradients->position[1]*scale;
+    out->position[2] += gradients->position[2]*scale;
+    out->position[3] += gradients->position[3]*scale;
+
+    // Add gradients to Color
+    out->color[0] += gradients->color[0]*scale;
+    out->color[1] += gradients->color[1]*scale;
+    out->color[2] += gradients->color[2]*scale;
+    out->color[3] += gradients->color[3]*scale;
+}
+
 // Half conversion functions
-static SW_INLINE uint16_t sw_float_to_half_ui(uint32_t ui)
+static inline uint16_t sw_float_to_half_ui(uint32_t ui)
 {
     int32_t s = (ui >> 16) & 0x8000;
     int32_t em = ui & 0x7fffffff;
@@ -1348,7 +1364,7 @@ static SW_INLINE uint16_t sw_float_to_half_ui(uint32_t ui)
     return (uint16_t)(s | h);
 }
 
-static SW_INLINE uint32_t sw_half_to_float_ui(uint16_t h)
+static inline uint32_t sw_half_to_float_ui(uint16_t h)
 {
     uint32_t s = (unsigned)(h & 0x8000) << 16;
     int32_t em = h & 0x7fff;
@@ -1366,35 +1382,35 @@ static SW_INLINE uint32_t sw_half_to_float_ui(uint16_t h)
     return s | r;
 }
 
-static SW_INLINE sw_half_t sw_float_to_half(float i)
+static inline sw_half_t sw_float_to_half(float i)
 {
     union { float f; uint32_t i; } v;
     v.f = i;
     return sw_float_to_half_ui(v.i);
 }
 
-static SW_INLINE float sw_half_to_float(sw_half_t y)
+static inline float sw_half_to_float(sw_half_t y)
 {
     union { float f; uint32_t i; } v;
     v.i = sw_half_to_float_ui(y);
     return v.f;
 }
 
-static SW_INLINE uint8_t sw_expand_1to8(uint32_t v) { return v? 255 : 0; }
-static SW_INLINE uint8_t sw_expand_2to8(uint32_t v) { return (uint8_t)(v*85); }
-static SW_INLINE uint8_t sw_expand_3to8(uint32_t v) { return (uint8_t)((v << 5) | (v << 2) | (v >> 1)); }
-static SW_INLINE uint8_t sw_expand_4to8(uint32_t v) { return (uint8_t)((v << 4) | v); }
-static SW_INLINE uint8_t sw_expand_5to8(uint32_t v) { return (uint8_t)((v << 3) | (v >> 2)); }
-static SW_INLINE uint8_t sw_expand_6to8(uint32_t v) { return (uint8_t)((v << 2) | (v >> 4)); }
+static inline uint8_t sw_expand_1to8(uint32_t v) { return v? 255 : 0; }
+static inline uint8_t sw_expand_2to8(uint32_t v) { return (uint8_t)(v*85); }
+static inline uint8_t sw_expand_3to8(uint32_t v) { return (uint8_t)((v << 5) | (v << 2) | (v >> 1)); }
+static inline uint8_t sw_expand_4to8(uint32_t v) { return (uint8_t)((v << 4) | v); }
+static inline uint8_t sw_expand_5to8(uint32_t v) { return (uint8_t)((v << 3) | (v >> 2)); }
+static inline uint8_t sw_expand_6to8(uint32_t v) { return (uint8_t)((v << 2) | (v >> 4)); }
 
-static SW_INLINE uint32_t sw_compress_8to1(uint8_t v) { return v >> 7; }
-static SW_INLINE uint32_t sw_compress_8to2(uint8_t v) { return v >> 6; }
-static SW_INLINE uint32_t sw_compress_8to3(uint8_t v) { return v >> 5; }
-static SW_INLINE uint32_t sw_compress_8to4(uint8_t v) { return v >> 4; }
-static SW_INLINE uint32_t sw_compress_8to5(uint8_t v) { return v >> 3; }
-static SW_INLINE uint32_t sw_compress_8to6(uint8_t v) { return v >> 2; }
+static inline uint32_t sw_compress_8to1(uint8_t v) { return v >> 7; }
+static inline uint32_t sw_compress_8to2(uint8_t v) { return v >> 6; }
+static inline uint32_t sw_compress_8to3(uint8_t v) { return v >> 5; }
+static inline uint32_t sw_compress_8to4(uint8_t v) { return v >> 4; }
+static inline uint32_t sw_compress_8to5(uint8_t v) { return v >> 3; }
+static inline uint32_t sw_compress_8to6(uint8_t v) { return v >> 2; }
 
-static SW_INLINE void sw_color8_to_color(float *SW_RESTRICT dst, const uint8_t *SW_RESTRICT src)
+static inline void sw_color8_to_color(float *SW_RESTRICT dst, const uint8_t *SW_RESTRICT src)
 {
 #if defined(SW_HAS_NEON)
     uint8x8_t bytes = vreinterpret_u8_u32(vld1_dup_u32((const uint32_t *)src));
@@ -1425,7 +1441,7 @@ static SW_INLINE void sw_color8_to_color(float *SW_RESTRICT dst, const uint8_t *
     vfloat32m1_t vnorm = __riscv_vfmul_vf_f32m1(vsrc_f32, SW_INV_255, vl); // Multiply by 1/255.0 to normalize
     __riscv_vse32_v_f32m1(dst, vnorm, vl); // Store result
 
-#elif RLSW_USE_COLOR_LUT
+#elif SW_USE_COLOR_LUT
     dst[0] = SW_LUT_UINT8_TO_FLOAT[src[0]];
     dst[1] = SW_LUT_UINT8_TO_FLOAT[src[1]];
     dst[2] = SW_LUT_UINT8_TO_FLOAT[src[2]];
@@ -1439,7 +1455,7 @@ static SW_INLINE void sw_color8_to_color(float *SW_RESTRICT dst, const uint8_t *
 #endif
 }
 
-static SW_INLINE void sw_color_to_color8(uint8_t *SW_RESTRICT dst, const float *SW_RESTRICT src)
+static inline void sw_color_to_color8(uint8_t *SW_RESTRICT dst, const float *SW_RESTRICT src)
 {
 #if defined(SW_HAS_NEON)
     float32x4_t fvals = vmulq_f32(vld1q_f32(src), vdupq_n_f32(255.0f));
@@ -1572,27 +1588,27 @@ static bool sw_pool_free(sw_pool_t *pool, sw_handle_t handle)
 
 // Validity check helper functions
 //-------------------------------------------------------------------------------------------
-static SW_INLINE bool sw_is_texture_valid(sw_handle_t id)
+static inline bool sw_is_texture_valid(sw_handle_t id)
 {
     return sw_pool_valid(&RLSW.texturePool, id);
 }
 
-static SW_INLINE bool sw_is_texture_complete(sw_texture_t *tex)
+static inline bool sw_is_texture_complete(sw_texture_t *tex)
 {
     return (tex != NULL) && (tex->pixels != NULL);
 }
 
-static SW_INLINE bool sw_is_texture_filter_valid(int filter)
+static inline bool sw_is_texture_filter_valid(int filter)
 {
     return ((filter == SW_NEAREST) || (filter == SW_LINEAR));
 }
 
-static SW_INLINE bool sw_is_texture_wrap_valid(int wrap)
+static inline bool sw_is_texture_wrap_valid(int wrap)
 {
     return ((wrap == SW_REPEAT) || (wrap == SW_CLAMP));
 }
 
-static bool sw_is_draw_mode_valid(int mode)
+static inline bool sw_is_draw_mode_valid(int mode)
 {
     bool result = false;
 
@@ -1608,7 +1624,7 @@ static bool sw_is_draw_mode_valid(int mode)
     return result;
 }
 
-static bool sw_is_poly_mode_valid(int mode)
+static inline bool sw_is_poly_mode_valid(int mode)
 {
     bool result = false;
 
@@ -1623,12 +1639,12 @@ static bool sw_is_poly_mode_valid(int mode)
     return result;
 }
 
-static SW_INLINE bool sw_is_face_valid(int face)
+static inline bool sw_is_face_valid(int face)
 {
     return (face == SW_FRONT || face == SW_BACK);
 }
 
-static SW_INLINE bool sw_is_ready_to_render(void)
+static inline bool sw_is_ready_to_render(void)
 {
     return (swCheckFramebufferStatus() == SW_FRAMEBUFFER_COMPLETE);
 }
@@ -1636,7 +1652,7 @@ static SW_INLINE bool sw_is_ready_to_render(void)
 
 // Pixel management functions
 //-------------------------------------------------------------------------------------------
-static int sw_pixel_get_format(SWformat format, SWtype type)
+static inline int sw_pixel_get_format(SWformat format, SWtype type)
 {
     int channels = 0;
     int bitsPerChannel = 8; // Default: 8 bits per channel
@@ -1714,7 +1730,7 @@ static int sw_pixel_get_format(SWformat format, SWtype type)
     return SW_PIXELFORMAT_UNKNOWN;
 }
 
-static bool sw_pixel_is_depth_format(sw_pixelformat_t format)
+static inline bool sw_pixel_is_depth_format(sw_pixelformat_t format)
 {
     switch (format)
     {
@@ -1727,7 +1743,7 @@ static bool sw_pixel_is_depth_format(sw_pixelformat_t format)
     return false;
 }
 
-static void sw_pixel_read_color8_GRAYSCALE(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_GRAYSCALE(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t gray = ((const uint8_t *)pixels)[offset];
     color[0] = gray;
@@ -1736,7 +1752,7 @@ static void sw_pixel_read_color8_GRAYSCALE(uint8_t *SW_RESTRICT color, const voi
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_GRAYALPHA(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_GRAYALPHA(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint8_t *src = &((const uint8_t *)pixels)[offset*2];
     color[0] = src[0];
@@ -1745,7 +1761,7 @@ static void sw_pixel_read_color8_GRAYALPHA(uint8_t *SW_RESTRICT color, const voi
     color[3] = src[1];
 }
 
-static void sw_pixel_read_color8_R3G3B2(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R3G3B2(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t pixel = ((const uint8_t *)pixels)[offset];
     color[0] = sw_expand_3to8((pixel >> 5) & 0x07);
@@ -1754,7 +1770,7 @@ static void sw_pixel_read_color8_R3G3B2(uint8_t *SW_RESTRICT color, const void *
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R5G6B5(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R5G6B5(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint16_t pixel = ((const uint16_t *)pixels)[offset];
     color[0] = sw_expand_5to8((pixel >> 11) & 0x1F);
@@ -1763,7 +1779,7 @@ static void sw_pixel_read_color8_R5G6B5(uint8_t *SW_RESTRICT color, const void *
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R8G8B8(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R8G8B8(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint8_t *src = &((const uint8_t *)pixels)[offset*3];
     color[0] = src[0];
@@ -1772,7 +1788,7 @@ static void sw_pixel_read_color8_R8G8B8(uint8_t *SW_RESTRICT color, const void *
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R5G5B5A1(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R5G5B5A1(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint16_t pixel = ((const uint16_t *)pixels)[offset];
     color[0] = sw_expand_5to8((pixel >> 11) & 0x1F);
@@ -1781,7 +1797,7 @@ static void sw_pixel_read_color8_R5G5B5A1(uint8_t *SW_RESTRICT color, const void
     color[3] = sw_expand_1to8( pixel        & 0x01);
 }
 
-static void sw_pixel_read_color8_R4G4B4A4(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R4G4B4A4(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint16_t pixel = ((const uint16_t *)pixels)[offset];
     color[0] = sw_expand_4to8((pixel >> 12) & 0x0F);
@@ -1790,7 +1806,7 @@ static void sw_pixel_read_color8_R4G4B4A4(uint8_t *SW_RESTRICT color, const void
     color[3] = sw_expand_4to8( pixel        & 0x0F);
 }
 
-static void sw_pixel_read_color8_R8G8B8A8(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R8G8B8A8(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint8_t *src = &((const uint8_t *)pixels)[offset*4];
     color[0] = src[0];
@@ -1799,7 +1815,7 @@ static void sw_pixel_read_color8_R8G8B8A8(uint8_t *SW_RESTRICT color, const void
     color[3] = src[3];
 }
 
-static void sw_pixel_read_color8_R32(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R32(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t gray = (uint8_t)(((const float *)pixels)[offset]*255.0f);
     color[0] = gray;
@@ -1808,7 +1824,7 @@ static void sw_pixel_read_color8_R32(uint8_t *SW_RESTRICT color, const void *SW_
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R32G32B32(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R32G32B32(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const float *src = &((const float *)pixels)[offset*3];
     color[0] = (uint8_t)(src[0]*255.0f);
@@ -1817,7 +1833,7 @@ static void sw_pixel_read_color8_R32G32B32(uint8_t *SW_RESTRICT color, const voi
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R32G32B32A32(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R32G32B32A32(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const float *src = &((const float *)pixels)[offset*4];
     color[0] = (uint8_t)(src[0]*255.0f);
@@ -1826,7 +1842,7 @@ static void sw_pixel_read_color8_R32G32B32A32(uint8_t *SW_RESTRICT color, const
     color[3] = (uint8_t)(src[3]*255.0f);
 }
 
-static void sw_pixel_read_color8_R16(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R16(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t gray = (uint8_t)(sw_half_to_float(((const uint16_t *)pixels)[offset])*255.0f);
     color[0] = gray;
@@ -1835,7 +1851,7 @@ static void sw_pixel_read_color8_R16(uint8_t *SW_RESTRICT color, const void *SW_
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R16G16B16(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R16G16B16(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint16_t *src = &((const uint16_t *)pixels)[offset*3];
     color[0] = (uint8_t)(sw_half_to_float(src[0])*255.0f);
@@ -1844,7 +1860,7 @@ static void sw_pixel_read_color8_R16G16B16(uint8_t *SW_RESTRICT color, const voi
     color[3] = 255;
 }
 
-static void sw_pixel_read_color8_R16G16B16A16(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color8_R16G16B16A16(uint8_t *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint16_t *src = &((const uint16_t *)pixels)[offset*4];
     color[0] = (uint8_t)(sw_half_to_float(src[0])*255.0f);
@@ -1853,7 +1869,7 @@ static void sw_pixel_read_color8_R16G16B16A16(uint8_t *SW_RESTRICT color, const
     color[3] = (uint8_t)(sw_half_to_float(src[3])*255.0f);
 }
 
-static sw_pixel_read_color8_f sw_pixel_get_read_color8_func(sw_pixelformat_t format)
+static inline sw_pixel_read_color8_f sw_pixel_get_read_color8_func(sw_pixelformat_t format)
 {
     switch (format)
     {
@@ -1883,19 +1899,19 @@ static sw_pixel_read_color8_f sw_pixel_get_read_color8_func(sw_pixelformat_t for
     return NULL;
 }
 
-static void sw_pixel_write_color8_GRAYSCALE(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_GRAYSCALE(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     ((uint8_t *)pixels)[offset] = sw_luminance8(color);
 }
 
-static void sw_pixel_write_color8_GRAYALPHA(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_GRAYALPHA(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t *dst = &((uint8_t *)pixels)[offset*2];
     dst[0] = sw_luminance8(color);
     dst[1] = color[3];
 }
 
-static void sw_pixel_write_color8_R3G3B2(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R3G3B2(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t pixel = (sw_compress_8to3(color[0]) << 5)
                   | (sw_compress_8to3(color[1]) << 2)
@@ -1903,7 +1919,7 @@ static void sw_pixel_write_color8_R3G3B2(void *SW_RESTRICT pixels, const uint8_t
     ((uint8_t *)pixels)[offset] = pixel;
 }
 
-static void sw_pixel_write_color8_R5G6B5(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R5G6B5(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t pixel = (sw_compress_8to5(color[0]) << 11)
                    | (sw_compress_8to6(color[1]) <<  5)
@@ -1911,7 +1927,7 @@ static void sw_pixel_write_color8_R5G6B5(void *SW_RESTRICT pixels, const uint8_t
     ((uint16_t *)pixels)[offset] = pixel;
 }
 
-static void sw_pixel_write_color8_R8G8B8(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R8G8B8(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t *dst = &((uint8_t *)pixels)[offset*3];
     dst[0] = color[0];
@@ -1919,7 +1935,7 @@ static void sw_pixel_write_color8_R8G8B8(void *SW_RESTRICT pixels, const uint8_t
     dst[2] = color[2];
 }
 
-static void sw_pixel_write_color8_R5G5B5A1(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R5G5B5A1(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t pixel = (sw_compress_8to5(color[0]) << 11)
                    | (sw_compress_8to5(color[1]) <<  6)
@@ -1928,7 +1944,7 @@ static void sw_pixel_write_color8_R5G5B5A1(void *SW_RESTRICT pixels, const uint8
     ((uint16_t *)pixels)[offset] = pixel;
 }
 
-static void sw_pixel_write_color8_R4G4B4A4(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R4G4B4A4(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t pixel = (sw_compress_8to4(color[0]) << 12)
                    | (sw_compress_8to4(color[1]) <<  8)
@@ -1937,7 +1953,7 @@ static void sw_pixel_write_color8_R4G4B4A4(void *SW_RESTRICT pixels, const uint8
     ((uint16_t *)pixels)[offset] = pixel;
 }
 
-static void sw_pixel_write_color8_R8G8B8A8(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R8G8B8A8(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t *dst = &((uint8_t *)pixels)[offset*4];
     dst[0] = color[0];
@@ -1946,12 +1962,12 @@ static void sw_pixel_write_color8_R8G8B8A8(void *SW_RESTRICT pixels, const uint8
     dst[3] = color[3];
 }
 
-static void sw_pixel_write_color8_R32(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R32(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     ((float *)pixels)[offset] = sw_luminance8(color)*SW_INV_255;
 }
 
-static void sw_pixel_write_color8_R32G32B32(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R32G32B32(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     float *dst = &((float *)pixels)[offset*3];
     dst[0] = color[0]*SW_INV_255;
@@ -1959,7 +1975,7 @@ static void sw_pixel_write_color8_R32G32B32(void *SW_RESTRICT pixels, const uint
     dst[2] = color[2]*SW_INV_255;
 }
 
-static void sw_pixel_write_color8_R32G32B32A32(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R32G32B32A32(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     float *dst = &((float *)pixels)[offset*4];
     dst[0] = color[0]*SW_INV_255;
@@ -1968,12 +1984,12 @@ static void sw_pixel_write_color8_R32G32B32A32(void *SW_RESTRICT pixels, const u
     dst[3] = color[3]*SW_INV_255;
 }
 
-static void sw_pixel_write_color8_R16(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R16(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     ((uint16_t *)pixels)[offset] = sw_float_to_half(sw_luminance8(color)*SW_INV_255);
 }
 
-static void sw_pixel_write_color8_R16G16B16(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R16G16B16(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t *dst = &((uint16_t *)pixels)[offset*3];
     dst[0] = sw_float_to_half(color[0]*SW_INV_255);
@@ -1981,7 +1997,7 @@ static void sw_pixel_write_color8_R16G16B16(void *SW_RESTRICT pixels, const uint
     dst[2] = sw_float_to_half(color[2]*SW_INV_255);
 }
 
-static void sw_pixel_write_color8_R16G16B16A16(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color8_R16G16B16A16(void *SW_RESTRICT pixels, const uint8_t *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t *dst = &((uint16_t *)pixels)[offset*4];
     dst[0] = sw_float_to_half(color[0]*SW_INV_255);
@@ -1990,7 +2006,7 @@ static void sw_pixel_write_color8_R16G16B16A16(void *SW_RESTRICT pixels, const u
     dst[3] = sw_float_to_half(color[3]*SW_INV_255);
 }
 
-static sw_pixel_write_color8_f sw_pixel_get_write_color8_func(sw_pixelformat_t format)
+static inline sw_pixel_write_color8_f sw_pixel_get_write_color8_func(sw_pixelformat_t format)
 {
     switch (format)
     {
@@ -2020,7 +2036,7 @@ static sw_pixel_write_color8_f sw_pixel_get_write_color8_func(sw_pixelformat_t f
     return NULL;
 }
 
-static void sw_pixel_read_color_GRAYSCALE(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_GRAYSCALE(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     float gray = ((const uint8_t *)pixels)[offset]*SW_INV_255;
     color[0] = gray;
@@ -2029,7 +2045,7 @@ static void sw_pixel_read_color_GRAYSCALE(float *SW_RESTRICT color, const void *
     color[3] = 1.0f;
 }
 
-static void sw_pixel_read_color_GRAYALPHA(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_GRAYALPHA(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint8_t *src = &((const uint8_t *)pixels)[offset*2];
     float gray = src[0]*SW_INV_255;
@@ -2039,47 +2055,47 @@ static void sw_pixel_read_color_GRAYALPHA(float *SW_RESTRICT color, const void *
     color[3] = src[1]*SW_INV_255;
 }
 
-static void sw_pixel_read_color_R3G3B2(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R3G3B2(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t unpack[4];
     sw_pixel_read_color8_R3G3B2(unpack, pixels, offset);
     sw_color8_to_color(color, unpack);
 }
 
-static void sw_pixel_read_color_R5G6B5(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R5G6B5(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t unpack[4];
     sw_pixel_read_color8_R5G6B5(unpack, pixels, offset);
     sw_color8_to_color(color, unpack);
 }
 
-static void sw_pixel_read_color_R8G8B8(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R8G8B8(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t unpack[4];
     sw_pixel_read_color8_R8G8B8(unpack, pixels, offset);
     sw_color8_to_color(color, unpack);
 }
 
-static void sw_pixel_read_color_R5G5B5A1(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R5G5B5A1(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t unpack[4];
     sw_pixel_read_color8_R5G5B5A1(unpack, pixels, offset);
     sw_color8_to_color(color, unpack);
 }
 
-static void sw_pixel_read_color_R4G4B4A4(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R4G4B4A4(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     uint8_t unpack[4];
     sw_pixel_read_color8_R4G4B4A4(unpack, pixels, offset);
     sw_color8_to_color(color, unpack);
 }
 
-static void sw_pixel_read_color_R8G8B8A8(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R8G8B8A8(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     sw_color8_to_color(color, &((const uint8_t *)pixels)[offset*4]);
 }
 
-static void sw_pixel_read_color_R32(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R32(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     float val = ((const float *)pixels)[offset];
     color[0] = val;
@@ -2088,7 +2104,7 @@ static void sw_pixel_read_color_R32(float *SW_RESTRICT color, const void *SW_RES
     color[3] = 1.0f;
 }
 
-static void sw_pixel_read_color_R32G32B32(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R32G32B32(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const float *src = &((const float *)pixels)[offset*3];
     color[0] = src[0];
@@ -2097,7 +2113,7 @@ static void sw_pixel_read_color_R32G32B32(float *SW_RESTRICT color, const void *
     color[3] = 1.0f;
 }
 
-static void sw_pixel_read_color_R32G32B32A32(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R32G32B32A32(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const float *src = &((const float *)pixels)[offset*4];
     color[0] = src[0];
@@ -2106,7 +2122,7 @@ static void sw_pixel_read_color_R32G32B32A32(float *SW_RESTRICT color, const voi
     color[3] = src[3];
 }
 
-static void sw_pixel_read_color_R16(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R16(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     float val = sw_half_to_float(((const uint16_t *)pixels)[offset]);
     color[0] = val;
@@ -2115,7 +2131,7 @@ static void sw_pixel_read_color_R16(float *SW_RESTRICT color, const void *SW_RES
     color[3] = 1.0f;
 }
 
-static void sw_pixel_read_color_R16G16B16(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R16G16B16(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint16_t *src = &((const uint16_t *)pixels)[offset*3];
     color[0] = sw_half_to_float(src[0]);
@@ -2124,7 +2140,7 @@ static void sw_pixel_read_color_R16G16B16(float *SW_RESTRICT color, const void *
     color[3] = 1.0f;
 }
 
-static void sw_pixel_read_color_R16G16B16A16(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
+static inline void sw_pixel_read_color_R16G16B16A16(float *SW_RESTRICT color, const void *SW_RESTRICT pixels, uint32_t offset)
 {
     const uint16_t *src = &((const uint16_t *)pixels)[offset*4];
     color[0] = sw_half_to_float(src[0]);
@@ -2133,7 +2149,7 @@ static void sw_pixel_read_color_R16G16B16A16(float *SW_RESTRICT color, const voi
     color[3] = sw_half_to_float(src[3]);
 }
 
-static sw_pixel_read_color_f sw_pixel_get_read_color_func(sw_pixelformat_t format)
+static inline sw_pixel_read_color_f sw_pixel_get_read_color_func(sw_pixelformat_t format)
 {
     switch (format)
     {
@@ -2163,64 +2179,64 @@ static sw_pixel_read_color_f sw_pixel_get_read_color_func(sw_pixelformat_t forma
     return NULL;
 }
 
-static void sw_pixel_write_color_GRAYSCALE(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_GRAYSCALE(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     ((uint8_t *)pixels)[offset] = (uint8_t)(sw_luminance(color)*255.0f);
 }
 
-static void sw_pixel_write_color_GRAYALPHA(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_GRAYALPHA(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t *dst = &((uint8_t *)pixels)[offset*2];
     dst[0] = (uint8_t)(sw_luminance(color)*255.0f);
     dst[1] = (uint8_t)(color[3]*255.0f);
 }
 
-static void sw_pixel_write_color_R3G3B2(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R3G3B2(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t color8[4];
     sw_color_to_color8(color8, color);
     sw_pixel_write_color8_R3G3B2(pixels, color8, offset);
 }
 
-static void sw_pixel_write_color_R5G6B5(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R5G6B5(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t color8[4];
     sw_color_to_color8(color8, color);
     sw_pixel_write_color8_R5G6B5(pixels, color8, offset);
 }
 
-static void sw_pixel_write_color_R8G8B8(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R8G8B8(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t color8[4];
     sw_color_to_color8(color8, color);
     sw_pixel_write_color8_R8G8B8(pixels, color8, offset);
 }
 
-static void sw_pixel_write_color_R5G5B5A1(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R5G5B5A1(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t color8[4];
     sw_color_to_color8(color8, color);
     sw_pixel_write_color8_R5G5B5A1(pixels, color8, offset);
 }
 
-static void sw_pixel_write_color_R4G4B4A4(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R4G4B4A4(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint8_t color8[4];
     sw_color_to_color8(color8, color);
     sw_pixel_write_color8_R4G4B4A4(pixels, color8, offset);
 }
 
-static void sw_pixel_write_color_R8G8B8A8(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R8G8B8A8(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     sw_color_to_color8(&((uint8_t *)pixels)[offset*4], color);
 }
 
-static void sw_pixel_write_color_R32(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R32(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     ((float *)pixels)[offset] = sw_luminance(color);
 }
 
-static void sw_pixel_write_color_R32G32B32(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R32G32B32(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     float *dst = &((float *)pixels)[offset*3];
     dst[0] = color[0];
@@ -2228,7 +2244,7 @@ static void sw_pixel_write_color_R32G32B32(void *SW_RESTRICT pixels, const float
     dst[2] = color[2];
 }
 
-static void sw_pixel_write_color_R32G32B32A32(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R32G32B32A32(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     float *dst = &((float *)pixels)[offset*4];
     dst[0] = color[0];
@@ -2237,12 +2253,12 @@ static void sw_pixel_write_color_R32G32B32A32(void *SW_RESTRICT pixels, const fl
     dst[3] = color[3];
 }
 
-static void sw_pixel_write_color_R16(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R16(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     ((uint16_t *)pixels)[offset] = sw_float_to_half(sw_luminance(color));
 }
 
-static void sw_pixel_write_color_R16G16B16(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R16G16B16(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t *dst = &((uint16_t *)pixels)[offset*3];
     dst[0] = sw_float_to_half(color[0]);
@@ -2250,7 +2266,7 @@ static void sw_pixel_write_color_R16G16B16(void *SW_RESTRICT pixels, const float
     dst[2] = sw_float_to_half(color[2]);
 }
 
-static void sw_pixel_write_color_R16G16B16A16(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
+static inline void sw_pixel_write_color_R16G16B16A16(void *SW_RESTRICT pixels, const float *SW_RESTRICT color, uint32_t offset)
 {
     uint16_t *dst = &((uint16_t *)pixels)[offset*4];
     dst[0] = sw_float_to_half(color[0]);
@@ -2259,7 +2275,7 @@ static void sw_pixel_write_color_R16G16B16A16(void *SW_RESTRICT pixels, const fl
     dst[3] = sw_float_to_half(color[3]);
 }
 
-static sw_pixel_write_color_f sw_pixel_get_write_color_func(sw_pixelformat_t format)
+static inline sw_pixel_write_color_f sw_pixel_get_write_color_func(sw_pixelformat_t format)
 {
     switch (format)
     {
@@ -2289,32 +2305,32 @@ static sw_pixel_write_color_f sw_pixel_get_write_color_func(sw_pixelformat_t for
     return NULL;
 }
 
-static float sw_pixel_read_depth_D8(const void *pixels, uint32_t offset)
+static inline float sw_pixel_read_depth_D8(const void *pixels, uint32_t offset)
 {
     return (float)((uint8_t *)pixels)[offset]*SW_INV_255;
 }
 
-static float sw_pixel_read_depth_D16(const void *pixels, uint32_t offset)
+static inline float sw_pixel_read_depth_D16(const void *pixels, uint32_t offset)
 {
     return (float)((uint16_t *)pixels)[offset]/UINT16_MAX;
 }
 
-static float sw_pixel_read_depth_D32(const void *pixels, uint32_t offset)
+static inline float sw_pixel_read_depth_D32(const void *pixels, uint32_t offset)
 {
     return ((float *)pixels)[offset];
 }
 
-static void sw_pixel_write_depth_D8(void *pixels, float depth, uint32_t offset)
+static inline void sw_pixel_write_depth_D8(void *pixels, float depth, uint32_t offset)
 {
     ((uint8_t *)pixels)[offset] = (uint8_t)(depth*UINT8_MAX);
 }
 
-static void sw_pixel_write_depth_D16(void *pixels, float depth, uint32_t offset)
+static inline void sw_pixel_write_depth_D16(void *pixels, float depth, uint32_t offset)
 {
     ((uint16_t *)pixels)[offset] = (uint16_t)(depth*UINT16_MAX);
 }
 
-static void sw_pixel_write_depth_D32(void *pixels, float depth, uint32_t offset)
+static inline void sw_pixel_write_depth_D32(void *pixels, float depth, uint32_t offset)
 {
     ((float *)pixels)[offset] = depth;
 }
@@ -2322,20 +2338,12 @@ static void sw_pixel_write_depth_D32(void *pixels, float depth, uint32_t offset)
 
 // Texture functionality
 //-------------------------------------------------------------------------------------------
-static bool sw_texture_alloc(sw_texture_t *texture, const void *data, int w, int h, sw_pixelformat_t format)
+static inline bool sw_texture_alloc(sw_texture_t *texture, const void *data, int w, int h, sw_pixelformat_t format)
 {
     bool isDepth = sw_pixel_is_depth_format(format);
     int bpp = SW_PIXELFORMAT_SIZE[format];
     int newSize = w*h*bpp;
 
-    if (texture->pixels == NULL)
-    {
-        texture->minFilter = SW_NEAREST;
-        texture->magFilter = SW_NEAREST;
-        texture->sWrap = SW_CLAMP;
-        texture->tWrap = SW_CLAMP;
-    }
-
     if (newSize > texture->allocSz)
     {
         void *ptr = SW_REALLOC(texture->pixels, newSize);
@@ -2391,34 +2399,27 @@ static bool sw_texture_alloc(sw_texture_t *texture, const void *data, int w, int
     return true;
 }
 
-static void sw_texture_free(sw_texture_t *texture)
+static inline void sw_texture_free(sw_texture_t *texture)
 {
     SW_FREE(texture->pixels);
 }
 
-static void sw_texture_sample_nearest(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex, float u, float v)
+static inline void sw_texture_sample_nearest(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex, float u, float v)
 {
-    int x, y;
+    u = (tex->sWrap == SW_REPEAT)? sw_fract(u) : sw_saturate(u);
+    v = (tex->tWrap == SW_REPEAT)? sw_fract(v) : sw_saturate(v);
 
-#if RLSW_SUPPORT_NPOT_TEXTURE
-    if (tex->sWrap == SW_REPEAT) x = (int)(sw_fract(u)*tex->width);
-    else x = (int)(sw_saturate(u)*tex->width);
-
-    if (tex->tWrap == SW_REPEAT) y = (int)(sw_fract(v)*tex->height);
-    else y = (int)(sw_saturate(v)*tex->height);
-#else
-    if (tex->sWrap == SW_REPEAT) x = (int)(u*tex->width) & tex->wMinus1;
-    else x = (int)(sw_saturate(u)*tex->width);
-
-    if (tex->tWrap == SW_REPEAT) y = (int)(v*tex->height) & tex->hMinus1;
-    else y = (int)(sw_saturate(v)*tex->height);
-#endif
+    int x = u*tex->width;
+    int y = v*tex->height;
 
     tex->readColor(color, tex->pixels, y*tex->width + x);
 }
 
-static void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex, float u, float v)
+static inline void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex, float u, float v)
 {
+    // TODO: With a bit more cleverness the number of operations can
+    // be clearly reduced, but for now it works fine
+
     float xf = (u*tex->width) - 0.5f;
     float yf = (v*tex->height) - 0.5f;
 
@@ -2431,36 +2432,28 @@ static void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_texture_
     int x1 = x0 + 1;
     int y1 = y0 + 1;
 
-    if (tex->sWrap == SW_REPEAT)
+    // NOTE: If the textures are POT, avoid the division for SW_REPEAT
+
+    if (tex->sWrap == SW_CLAMP)
+    {
+        x0 = (x0 > tex->wMinus1)? tex->wMinus1 : x0;
+        x1 = (x1 > tex->wMinus1)? tex->wMinus1 : x1;
+    }
+    else
     {
-    #if RLSW_SUPPORT_NPOT_TEXTURE
         x0 = (x0%tex->width + tex->width)%tex->width;
         x1 = (x1%tex->width + tex->width)%tex->width;
-    #else
-        x0 = x0 & tex->wMinus1;
-        x1 = x1 & tex->wMinus1;
-    #endif
-    }
-    else
-    {
-        x0 = sw_clamp_int(x0, 0, tex->wMinus1);
-        x1 = sw_clamp_int(x1, 0, tex->wMinus1);
     }
 
-    if (tex->tWrap == SW_REPEAT)
+    if (tex->tWrap == SW_CLAMP)
     {
-    #if RLSW_SUPPORT_NPOT_TEXTURE
-        y0 = (y0%tex->height + tex->height)%tex->height;
-        y1 = (y1%tex->height + tex->height)%tex->height;
-    #else
-        y0 = y0 & tex->hMinus1;
-        y1 = y1 & tex->hMinus1;
-    #endif
+        y0 = (y0 > tex->hMinus1)? tex->hMinus1 : y0;
+        y1 = (y1 > tex->hMinus1)? tex->hMinus1 : y1;
     }
     else
     {
-        y0 = sw_clamp_int(y0, 0, tex->hMinus1);
-        y1 = sw_clamp_int(y1, 0, tex->hMinus1);
+        y0 = (y0%tex->height + tex->height)%tex->height;
+        y1 = (y1%tex->height + tex->height)%tex->height;
     }
 
     float c00[4], c10[4], c01[4], c11[4];
@@ -2477,8 +2470,8 @@ static void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_texture_
     }
 }
 
-// Resolves which sample function to use from the texel-to-pixel derivative magnitude
-static sw_texture_sampler_f sw_texture_pick_sampler(const sw_texture_t *tex, const float dTdx[2], const float dTdy[2])
+static inline void sw_texture_sample(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex,
+                                     float u, float v, float dUdx, float dUdy, float dVdx, float dVdy)
 {
     // NOTE: Commented there is the previous method used
     // There was no need to compute the square root because
@@ -2487,31 +2480,31 @@ static sw_texture_sampler_f sw_texture_pick_sampler(const sw_texture_t *tex, con
     //float dv = sqrtf(dVdx*dVdx + dVdy*dVdy);
     //float L = (du > dv)? du : dv;
 
-    float dU2 = dTdx[0]*dTdx[0] + dTdy[0]*dTdy[0];
-    float dV2 = dTdx[1]*dTdx[1] + dTdy[1]*dTdy[1];
+    // Calculate the derivatives for each axis
+    float dU2 = dUdx*dUdx + dUdy*dUdy;
+    float dV2 = dVdx*dVdx + dVdy*dVdy;
     float L2 = (dU2 > dV2)? dU2 : dV2;
 
     SWfilter filter = (L2 > 1.0f)? tex->minFilter : tex->magFilter;
-    return (filter == SW_LINEAR)? sw_texture_sample_linear : sw_texture_sample_nearest;
+
+    switch (filter)
+    {
+        case SW_NEAREST: sw_texture_sample_nearest(color, tex, u, v); break;
+        case SW_LINEAR: sw_texture_sample_linear(color, tex, u, v); break;
+        default: break;
+    }
 }
 //-------------------------------------------------------------------------------------------
 
 // Framebuffer management functions
 //-------------------------------------------------------------------------------------------
-static bool sw_default_framebuffer_alloc(sw_default_framebuffer_t *fb, int w, int h)
+static inline bool sw_default_framebuffer_alloc(sw_default_framebuffer_t *fb, int w, int h)
 {
     if (!sw_texture_alloc(&fb->color, NULL, w, h, SW_FRAMEBUFFER_COLOR_FORMAT))
     {
         return false;
     }
 
-#if RLSW_DOUBLE_BUFFERING
-    if (!sw_texture_alloc(&fb->backColor, NULL, w, h, SW_FRAMEBUFFER_COLOR_FORMAT))
-    {
-        return false;
-    }
-#endif
-
     if (!sw_texture_alloc(&fb->depth, NULL, w, h, SW_FRAMEBUFFER_DEPTH_FORMAT))
     {
         return false;
@@ -2520,16 +2513,13 @@ static bool sw_default_framebuffer_alloc(sw_default_framebuffer_t *fb, int w, in
     return true;
 }
 
-static void sw_default_framebuffer_free(sw_default_framebuffer_t *fb)
+static inline void sw_default_framebuffer_free(sw_default_framebuffer_t *fb)
 {
     sw_texture_free(&fb->color);
     sw_texture_free(&fb->depth);
-#if RLSW_DOUBLE_BUFFERING
-    sw_texture_free(&fb->backColor);
-#endif
 }
 
-static void sw_framebuffer_fill_color(sw_texture_t *colorBuffer, const float color[4])
+static inline void sw_framebuffer_fill_color(sw_texture_t *colorBuffer, const float color[4])
 {
     // NOTE: MSVC doesn't support VLA, so the largest possible size is allocated: 16 bytes
     //uint8_t pixel[SW_FRAMEBUFFER_COLOR_SIZE] = { 0 };
@@ -2568,7 +2558,7 @@ static void sw_framebuffer_fill_color(sw_texture_t *colorBuffer, const float col
     }
 }
 
-static void sw_framebuffer_fill_depth(sw_texture_t *depthBuffer, float depth)
+static inline void sw_framebuffer_fill_depth(sw_texture_t *depthBuffer, float depth)
 {
     // NOTE: MSVC doesn't support VLA, so the largest possible size is allocated: 4 bytes
     //uint8_t pixel[SW_FRAMEBUFFER_DEPTH_SIZE] = { 0 };
@@ -2607,14 +2597,14 @@ static void sw_framebuffer_fill_depth(sw_texture_t *depthBuffer, float depth)
     }
 }
 
-static void sw_framebuffer_output_fast(void *dst, const sw_texture_t *buffer)
+static inline void sw_framebuffer_output_fast(void *dst, const sw_texture_t *buffer)
 {
     int width = buffer->width;
     int height = buffer->height;
 
     uint8_t *d = (uint8_t *)dst;
 
-#if RLSW_FRAMEBUFFER_OUTPUT_BGRA && (SW_FRAMEBUFFER_COLOR_FORMAT == SW_PIXELFORMAT_COLOR_R8G8B8A8)
+#if SW_FRAMEBUFFER_OUTPUT_BGRA && (SW_FRAMEBUFFER_COLOR_FORMAT == SW_PIXELFORMAT_COLOR_R8G8B8A8)
     for (int y = height - 1; y >= 0; y--)
     {
         const uint8_t *src = (uint8_t *)(buffer->pixels) + y*width*4;
@@ -2626,7 +2616,7 @@ static void sw_framebuffer_output_fast(void *dst, const sw_texture_t *buffer)
             d[3] = src[3];
         }
     }
-#elif RLSW_FRAMEBUFFER_OUTPUT_BGRA && (SW_FRAMEBUFFER_COLOR_FORMAT == SW_PIXELFORMAT_COLOR_R8G8B8)
+#elif SW_FRAMEBUFFER_OUTPUT_BGRA && (SW_FRAMEBUFFER_COLOR_FORMAT == SW_PIXELFORMAT_COLOR_R8G8B8)
     for (int y = height - 1; y >= 0; y--)
     {
         const uint8_t *src = (uint8_t *)(buffer->pixels) + y*width*3;
@@ -2648,7 +2638,7 @@ static void sw_framebuffer_output_fast(void *dst, const sw_texture_t *buffer)
 #endif
 }
 
-static void sw_framebuffer_output_copy(void *dst, const sw_texture_t *buffer, int x, int y, int w, int h, sw_pixelformat_t format)
+static inline void sw_framebuffer_output_copy(void *dst, const sw_texture_t *buffer, int x, int y, int w, int h, sw_pixelformat_t format)
 {
     int stride = buffer->width;
     int dstPixelSize = SW_PIXELFORMAT_SIZE[format];
@@ -2667,7 +2657,7 @@ static void sw_framebuffer_output_copy(void *dst, const sw_texture_t *buffer, in
             uint8_t color[4];
             SW_FRAMEBUFFER_COLOR8_GET(color, line, 0);
 
-            #if RLSW_FRAMEBUFFER_OUTPUT_BGRA
+            #if SW_FRAMEBUFFER_OUTPUT_BGRA
             if (format == SW_PIXELFORMAT_COLOR_R8G8B8A8 || format == SW_PIXELFORMAT_COLOR_R8G8B8)
             {
                 uint8_t tmp = color[0]; color[0] = color[2]; color[2] = tmp;
@@ -2684,7 +2674,7 @@ static void sw_framebuffer_output_copy(void *dst, const sw_texture_t *buffer, in
     }
 }
 
-static void sw_framebuffer_output_blit(void *dst, const sw_texture_t *buffer,
+static inline void sw_framebuffer_output_blit(void *dst, const sw_texture_t *buffer,
     int xDst, int yDst, int wDst, int hDst, int xSrc, int ySrc, int wSrc, int hSrc, sw_pixelformat_t format)
 {
     const uint8_t *srcBase = buffer->pixels;
@@ -2713,7 +2703,7 @@ static void sw_framebuffer_output_blit(void *dst, const sw_texture_t *buffer,
             uint8_t color[4];
             SW_FRAMEBUFFER_COLOR8_GET(color, pixel, 0);
 
-            #if RLSW_FRAMEBUFFER_OUTPUT_BGRA
+            #if SW_FRAMEBUFFER_OUTPUT_BGRA
             if (format == SW_PIXELFORMAT_COLOR_R8G8B8A8 || format == SW_PIXELFORMAT_COLOR_R8G8B8)
             {
                 uint8_t tmp = color[0]; color[0] = color[2]; color[2] = tmp;
@@ -2812,7 +2802,7 @@ static const sw_blend_f SW_BLEND_TABLE[SW_BLEND_FACTOR_COUNT][SW_BLEND_FACTOR_CO
 #undef GEN_TABLE_ROW
 
 // Maps a GL blend factor enum to its compact table index
-static int sw_blend_factor_index(SWfactor f)
+static inline int sw_blend_factor_index(SWfactor f)
 {
     switch (f)
     {
@@ -2862,7 +2852,7 @@ static uint32_t sw_blend_compute_flags(SWfactor src, SWfactor dst)
 
 // Projection helper functions
 //-------------------------------------------------------------------------------------------
-static void sw_project_ndc_to_screen(float ndc[4])
+static inline void sw_project_ndc_to_screen(float ndc[4])
 {
     ndc[0] = RLSW.vpCenter[0] + ndc[0]*RLSW.vpHalf[0] + 0.5f;
     ndc[1] = RLSW.vpCenter[1] + ndc[1]*RLSW.vpHalf[1] + 0.5f;
@@ -2988,303 +2978,335 @@ static bool sw_polygon_clip(sw_vertex_t polygon[SW_MAX_CLIPPED_POLYGON_VERTICES]
     return (n >= 3);
 }
 
-// Rasterizer variant generation macros
-//-------------------------------------------------------------------------------------------
-// Argument count (1-4)
-#define SW_NARGS_(_1,_2,_3,_4,N,...) N
-#define SW_NARGS(...) SW_NARGS_(__VA_ARGS__,4,3,2,1)
-
-// State tokens -> OR'd SW_STATE_xxx flags
-#define SW_OR1(a)       (SW_STATE_##a)
-#define SW_OR2(a,b)     (SW_STATE_##a | SW_STATE_##b)
-#define SW_OR3(a,b,c)   (SW_STATE_##a | SW_STATE_##b | SW_STATE_##c)
-#define SW_OR4(a,b,c,d) (SW_STATE_##a | SW_STATE_##b | SW_STATE_##c | SW_STATE_##d)
-#define SW_FLAGS_(N, ...) SW_CONCATX(SW_OR, N)(__VA_ARGS__)
-#define SW_FLAGS(...)     SW_FLAGS_(SW_NARGS(__VA_ARGS__), __VA_ARGS__)
-
-// State tokens -> function name suffix
-#define SW_CAT1(a)       a
-#define SW_CAT2(a,b)     a##_##b
-#define SW_CAT3(a,b,c)   a##_##b##_##c
-#define SW_CAT4(a,b,c,d) a##_##b##_##c##_##d
-#define SW_NAME_(N, ...) SW_CONCATX(SW_CAT, N)(__VA_ARGS__)
-#define SW_NAME(...)     SW_NAME_(SW_NARGS(__VA_ARGS__), __VA_ARGS__)
-
-// Forward decl for one variant; SIG is a parenthesized param list
-#define SW_RASTER_FWD(PREFIX, SIG, ...) \
-    static void SW_CONCATX(PREFIX, SW_NAME(__VA_ARGS__)) SIG;
-
-// Dispatch table entry for one variant
-#define SW_RASTER_ENTRY(PREFIX, ...) \
-    [SW_FLAGS(__VA_ARGS__)] = SW_CONCATX(PREFIX, SW_NAME(__VA_ARGS__)),
-
-// Variant lists: X(STATES...) invoked once per specialization
-// Triangle/quad: COLOR_INTERP, TEXTURE_2D, DEPTH_TEST, BLEND
-#define SW_RASTER_VARIANTS_4(X, ...)                            \
-    X(__VA_ARGS__, NONE)                                        \
-    X(__VA_ARGS__, COLOR_INTERP)                                \
-    X(__VA_ARGS__, TEXTURE_2D)                                  \
-    X(__VA_ARGS__, DEPTH_TEST)                                  \
-    X(__VA_ARGS__, BLEND)                                       \
-    X(__VA_ARGS__, COLOR_INTERP, TEXTURE_2D)                    \
-    X(__VA_ARGS__, COLOR_INTERP, DEPTH_TEST)                    \
-    X(__VA_ARGS__, COLOR_INTERP, BLEND)                         \
-    X(__VA_ARGS__, TEXTURE_2D, DEPTH_TEST)                      \
-    X(__VA_ARGS__, TEXTURE_2D, BLEND)                           \
-    X(__VA_ARGS__, DEPTH_TEST, BLEND)                           \
-    X(__VA_ARGS__, COLOR_INTERP, TEXTURE_2D, DEPTH_TEST)        \
-    X(__VA_ARGS__, COLOR_INTERP, TEXTURE_2D, BLEND)             \
-    X(__VA_ARGS__, COLOR_INTERP, DEPTH_TEST, BLEND)             \
-    X(__VA_ARGS__, TEXTURE_2D, DEPTH_TEST, BLEND)               \
-    X(__VA_ARGS__, COLOR_INTERP, TEXTURE_2D, DEPTH_TEST, BLEND)
-
-// Variant lists: X(STATES...) invoked once per specialization
-// Line: COLOR_INTERP, DEPTH_TEST, BLEND
-#define SW_RASTER_VARIANTS_3(X, ...)                \
-    X(__VA_ARGS__, NONE)                            \
-    X(__VA_ARGS__, COLOR_INTERP)                    \
-    X(__VA_ARGS__, DEPTH_TEST)                      \
-    X(__VA_ARGS__, BLEND)                           \
-    X(__VA_ARGS__, COLOR_INTERP, DEPTH_TEST)        \
-    X(__VA_ARGS__, COLOR_INTERP, BLEND)             \
-    X(__VA_ARGS__, DEPTH_TEST, BLEND)               \
-    X(__VA_ARGS__, COLOR_INTERP, DEPTH_TEST, BLEND)
-
-// Point: DEPTH_TEST, BLEND
-#define SW_RASTER_VARIANTS_2(X, ...)    \
-    X(__VA_ARGS__, NONE)                \
-    X(__VA_ARGS__, DEPTH_TEST)          \
-    X(__VA_ARGS__, BLEND)               \
-    X(__VA_ARGS__, DEPTH_TEST, BLEND)
-//-------------------------------------------------------------------------------------------
-
 // Triangle rasterizer variant dispatch
 //-------------------------------------------------------------------------------------------
-#define SW_RASTER_TRIANGLE_STATE_MASK SW_FLAGS(COLOR_INTERP, TEXTURE_2D, DEPTH_TEST, BLEND)
+#ifndef RLSW_TEMPLATE_RASTER_TRIANGLE_EXPANDING
+#define RLSW_TEMPLATE_RASTER_TRIANGLE_EXPANDING
 
-#define SW_RASTER_TRIANGLE_STATES NONE
-#include __FILE__ // IWYU pragma: keep
-#undef SW_RASTER_TRIANGLE_STATES
+    // State mask to apply before indexing the dispatch table
+    #define SW_RASTER_TRIANGLE_STATE_MASK \
+        (SW_STATE_TEXTURE_2D | SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    // Single source of truth for all rasterizer specializations
+    // X(NAME, STATE_FLAGS)
+    #define SW_RASTER_VARIANTS(X)                                                       \
+        X(BASE,            0)                                                           \
+        X(TEX,             SW_STATE_TEXTURE_2D)                                         \
+        X(DEPTH,           SW_STATE_DEPTH_TEST)                                         \
+        X(BLEND,           SW_STATE_BLEND)                                              \
+        X(TEX_DEPTH,       SW_STATE_TEXTURE_2D | SW_STATE_DEPTH_TEST)                   \
+        X(TEX_BLEND,       SW_STATE_TEXTURE_2D | SW_STATE_BLEND)                        \
+        X(DEPTH_BLEND,     SW_STATE_DEPTH_TEST | SW_STATE_BLEND)                        \
+        X(TEX_DEPTH_BLEND, SW_STATE_TEXTURE_2D | SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_TRIANGLE_STATES TEXTURE_2D
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    // Forward declarations because clangd does not follow #include __FILE__ to avoid infinite recursion
+    // These declarations make all variants visible to static analysis tools without affecting compilation
+    #define SW_FWD_DECL(NAME, _FLAGS) \
+        static void sw_raster_triangle_##NAME(const sw_vertex_t*, const sw_vertex_t*, const sw_vertex_t*);
+    SW_RASTER_VARIANTS(SW_FWD_DECL) // NOLINT
+    #undef SW_FWD_DECL
 
-#define SW_RASTER_TRIANGLE_STATES DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    // Specialization generation via self-inclusion
 
-#define SW_RASTER_TRIANGLE_STATES BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE BASE
+    #include __FILE__ // IWYU pragma: keep
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, TEXTURE_2D
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE TEX
+    #define SW_ENABLE_TEXTURE
+    #include __FILE__
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE DEPTH
+    #define SW_ENABLE_DEPTH_TEST
+    #include __FILE__
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE BLEND
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES TEXTURE_2D, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE TEX_DEPTH
+    #define SW_ENABLE_TEXTURE
+    #define SW_ENABLE_DEPTH_TEST
+    #include __FILE__
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES TEXTURE_2D, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE TEX_BLEND
+    #define SW_ENABLE_TEXTURE
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE DEPTH_BLEND
+    #define SW_ENABLE_DEPTH_TEST
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, TEXTURE_2D, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    #define RLSW_TEMPLATE_RASTER_TRIANGLE TEX_DEPTH_BLEND
+    #define SW_ENABLE_TEXTURE
+    #define SW_ENABLE_DEPTH_TEST
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+    // Dispatch table (auto-generated from SW_RASTER_VARIANTS)
+    #define SW_TABLE_ENTRY(NAME, FLAGS) [FLAGS] = sw_raster_triangle_##NAME,
+    static const sw_raster_triangle_f SW_RASTER_TRIANGLE_TABLE[] = {
+        SW_RASTER_VARIANTS(SW_TABLE_ENTRY)
+    };
+    #undef SW_TABLE_ENTRY
 
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, TEXTURE_2D, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
+#undef SW_RASTER_VARIANTS
+#undef RLSW_TEMPLATE_RASTER_TRIANGLE_EXPANDING
 
-#define SW_RASTER_TRIANGLE_STATES TEXTURE_2D, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
-
-#define SW_RASTER_TRIANGLE_STATES COLOR_INTERP, TEXTURE_2D, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_TRIANGLE_STATES
-
-// Forward declarations for static analyzer like clangd that do not handle self-inclusion correctly
-SW_RASTER_VARIANTS_4(SW_RASTER_FWD, sw_raster_triangle_, (const sw_vertex_t*, const sw_vertex_t*, const sw_vertex_t*)) // NOLINT
-
-static const sw_raster_triangle_f SW_RASTER_TRIANGLE_TABLE[] = {
-    SW_RASTER_VARIANTS_4(SW_RASTER_ENTRY, sw_raster_triangle_)
-};
+#endif // RLSW_TEMPLATE_RASTER_TRIANGLE_EXPANDING
 //-------------------------------------------------------------------------------------------
 
 // Quad rasterizer variant dispatch
 //-------------------------------------------------------------------------------------------
-#define SW_RASTER_QUAD_STATE_MASK SW_FLAGS(COLOR_INTERP, TEXTURE_2D, DEPTH_TEST, BLEND)
+#ifndef RLSW_TEMPLATE_RASTER_QUAD_EXPANDING
+#define RLSW_TEMPLATE_RASTER_QUAD_EXPANDING
 
-#define SW_RASTER_QUAD_STATES NONE
-#include __FILE__ // IWYU pragma: keep
-#undef SW_RASTER_QUAD_STATES
+    // State mask to apply before indexing the dispatch table
+    #define SW_RASTER_QUAD_STATE_MASK \
+        (SW_STATE_TEXTURE_2D | SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    // Single source of truth for all rasterizer specializations
+    // X(NAME, STATE_FLAGS)
+    #define SW_RASTER_VARIANTS(X)                                                       \
+        X(BASE,            0)                                                           \
+        X(TEX,             SW_STATE_TEXTURE_2D)                                         \
+        X(DEPTH,           SW_STATE_DEPTH_TEST)                                         \
+        X(BLEND,           SW_STATE_BLEND)                                              \
+        X(TEX_DEPTH,       SW_STATE_TEXTURE_2D | SW_STATE_DEPTH_TEST)                   \
+        X(TEX_BLEND,       SW_STATE_TEXTURE_2D | SW_STATE_BLEND)                        \
+        X(DEPTH_BLEND,     SW_STATE_DEPTH_TEST | SW_STATE_BLEND)                        \
+        X(TEX_DEPTH_BLEND, SW_STATE_TEXTURE_2D | SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_QUAD_STATES TEXTURE_2D
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    // Forward declarations because clangd does not follow #include __FILE__ to avoid infinite recursion
+    // These declarations make all variants visible to static analysis tools without affecting compilation
+    #define SW_FWD_DECL(NAME, _FLAGS) \
+        static void sw_raster_quad_##NAME(const sw_vertex_t *v0, const sw_vertex_t *v1, const sw_vertex_t *v2, const sw_vertex_t *v3);
+    SW_RASTER_VARIANTS(SW_FWD_DECL) // NOLINT
+    #undef SW_FWD_DECL
 
-#define SW_RASTER_QUAD_STATES DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    // Specialization generation via self-inclusion
 
-#define SW_RASTER_QUAD_STATES BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD BASE
+    #include __FILE__ // IWYU pragma: keep
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, TEXTURE_2D
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD TEX
+    #define SW_ENABLE_TEXTURE
+    #include __FILE__
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD DEPTH
+    #define SW_ENABLE_DEPTH_TEST
+    #include __FILE__
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD BLEND
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES TEXTURE_2D, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD TEX_DEPTH
+    #define SW_ENABLE_TEXTURE
+    #define SW_ENABLE_DEPTH_TEST
+    #include __FILE__
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES TEXTURE_2D, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD TEX_BLEND
+    #define SW_ENABLE_TEXTURE
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD DEPTH_BLEND
+    #define SW_ENABLE_DEPTH_TEST
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, TEXTURE_2D, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    #define RLSW_TEMPLATE_RASTER_QUAD TEX_DEPTH_BLEND
+    #define SW_ENABLE_TEXTURE
+    #define SW_ENABLE_DEPTH_TEST
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef SW_ENABLE_TEXTURE
+    #undef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, TEXTURE_2D, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+    // Dispatch table (auto-generated from SW_RASTER_VARIANTS)
+    #define SW_TABLE_ENTRY(NAME, FLAGS) [FLAGS] = sw_raster_quad_##NAME,
+    static const sw_raster_quad_f SW_RASTER_QUAD_TABLE[] = {
+        SW_RASTER_VARIANTS(SW_TABLE_ENTRY)
+    };
+    #undef SW_TABLE_ENTRY
 
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
+#undef SW_RASTER_VARIANTS
+#undef RLSW_TEMPLATE_RASTER_QUAD_EXPANDING
 
-#define SW_RASTER_QUAD_STATES TEXTURE_2D, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
-
-#define SW_RASTER_QUAD_STATES COLOR_INTERP, TEXTURE_2D, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_QUAD_STATES
-
-// Forward declarations for static analyzer like clangd that do not handle self-inclusion correctly
-SW_RASTER_VARIANTS_4(SW_RASTER_FWD, sw_raster_quad_, (const sw_vertex_t*, const sw_vertex_t*, const sw_vertex_t*, const sw_vertex_t*)) // NOLINT
-
-static const sw_raster_quad_f SW_RASTER_QUAD_TABLE[] = {
-    SW_RASTER_VARIANTS_4(SW_RASTER_ENTRY, sw_raster_quad_)
-};
+#endif // RLSW_TEMPLATE_RASTER_QUAD_EXPANDING
 //-------------------------------------------------------------------------------------------
 
 // Line rasterizer variant dispatch
 //-------------------------------------------------------------------------------------------
-#define SW_RASTER_LINE_STATE_MASK SW_FLAGS(COLOR_INTERP, DEPTH_TEST, BLEND)
+#ifndef RLSW_TEMPLATE_RASTER_LINE_EXPANDING
+#define RLSW_TEMPLATE_RASTER_LINE_EXPANDING
 
-#define SW_RASTER_LINE_STATES NONE
-#include __FILE__ // IWYU pragma: keep
-#undef SW_RASTER_LINE_STATES
+    // State mask to apply before indexing the dispatch table
+    #define SW_RASTER_LINE_STATE_MASK \
+        (SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_LINE_STATES COLOR_INTERP
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    // Single source of truth for all rasterizer specializations
+    // X(NAME, STATE_FLAGS)
+    #define SW_RASTER_VARIANTS(X)                                                       \
+        X(BASE,            0)                                                           \
+        X(DEPTH,           SW_STATE_DEPTH_TEST)                                         \
+        X(BLEND,           SW_STATE_BLEND)                                              \
+        X(DEPTH_BLEND,     SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_LINE_STATES DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    // Forward declarations because clangd does not follow #include __FILE__ to avoid infinite recursion
+    // These declarations make all variants visible to static analysis tools without affecting compilation
+    #define SW_FWD_DECL(NAME, _FLAGS)                                                       \
+        static void sw_raster_line_##NAME(const sw_vertex_t *v0, const sw_vertex_t *v1);    \
+        static void sw_raster_line_thick_##NAME(const sw_vertex_t *v0, const sw_vertex_t *v1);
+    SW_RASTER_VARIANTS(SW_FWD_DECL) // NOLINT
+    #undef SW_FWD_DECL
 
-#define SW_RASTER_LINE_STATES BLEND
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    // Specialization generation via self-inclusion
 
-#define SW_RASTER_LINE_STATES COLOR_INTERP, DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    #define RLSW_TEMPLATE_RASTER_LINE BASE
+    #include __FILE__ // IWYU pragma: keep
+    #undef RLSW_TEMPLATE_RASTER_LINE
 
-#define SW_RASTER_LINE_STATES COLOR_INTERP, BLEND
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    #define RLSW_TEMPLATE_RASTER_LINE DEPTH
+    #define SW_ENABLE_DEPTH_TEST
+    #include __FILE__
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_LINE
 
-#define SW_RASTER_LINE_STATES DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    #define RLSW_TEMPLATE_RASTER_LINE BLEND
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef RLSW_TEMPLATE_RASTER_LINE
 
-#define SW_RASTER_LINE_STATES COLOR_INTERP, DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_LINE_STATES
+    #define RLSW_TEMPLATE_RASTER_LINE DEPTH_BLEND
+    #define SW_ENABLE_DEPTH_TEST
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_LINE
 
-// Forward declarations for static analyzer like clangd that do not handle self-inclusion correctly
-SW_RASTER_VARIANTS_3(SW_RASTER_FWD, sw_raster_line_, (const sw_vertex_t*, const sw_vertex_t*)) // NOLINT
+    // Dispatch table (auto-generated from SW_RASTER_VARIANTS)
+    #define SW_TABLE_ENTRY0(NAME, FLAGS) [FLAGS] = sw_raster_line_##NAME,
+    #define SW_TABLE_ENTRY1(NAME, FLAGS) [FLAGS] = sw_raster_line_thick_##NAME,
+    static const sw_raster_line_f SW_RASTER_LINE_TABLE[] = {  SW_RASTER_VARIANTS(SW_TABLE_ENTRY0) };
+    static const sw_raster_line_f SW_RASTER_LINE_THICK_TABLE[] = { SW_RASTER_VARIANTS(SW_TABLE_ENTRY1) };
+    #undef SW_TABLE_ENTRY0
+    #undef SW_TABLE_ENTRY1
 
-static const sw_raster_line_f SW_RASTER_LINE_TABLE[] = {
-    SW_RASTER_VARIANTS_3(SW_RASTER_ENTRY, sw_raster_line_)
-};
+#undef SW_RASTER_VARIANTS
+#undef RLSW_TEMPLATE_RASTER_LINE_EXPANDING
+
+#endif // RLSW_TEMPLATE_RASTER_LINE_EXPANDING
 //-------------------------------------------------------------------------------------------
 
 // Point rasterizer variant dispatch
 //-------------------------------------------------------------------------------------------
-#define SW_RASTER_POINT_STATE_MASK SW_FLAGS(DEPTH_TEST, BLEND)
+#ifndef RLSW_TEMPLATE_RASTER_POINT_EXPANDING
+#define RLSW_TEMPLATE_RASTER_POINT_EXPANDING
 
-#define SW_RASTER_POINT_STATES NONE
-#include __FILE__ // IWYU pragma: keep
-#undef SW_RASTER_POINT_STATES
+    // State mask to apply before indexing the dispatch table
+    #define SW_RASTER_POINT_STATE_MASK \
+        (SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_POINT_STATES DEPTH_TEST
-#include __FILE__
-#undef SW_RASTER_POINT_STATES
+    // Single source of truth for all rasterizer specializations
+    // X(NAME, STATE_FLAGS)
+    #define SW_RASTER_VARIANTS(X)                                                       \
+        X(BASE,            0)                                                           \
+        X(DEPTH,           SW_STATE_DEPTH_TEST)                                         \
+        X(BLEND,           SW_STATE_BLEND)                                              \
+        X(DEPTH_BLEND,     SW_STATE_DEPTH_TEST | SW_STATE_BLEND)
 
-#define SW_RASTER_POINT_STATES BLEND
-#include __FILE__
-#undef SW_RASTER_POINT_STATES
+    // Forward declarations because clangd does not follow #include __FILE__ to avoid infinite recursion
+    // These declarations make all variants visible to static analysis tools without affecting compilation
+    #define SW_FWD_DECL(NAME, _FLAGS) \
+        static void sw_raster_point_##NAME(const sw_vertex_t *v);
+    SW_RASTER_VARIANTS(SW_FWD_DECL) // NOLINT
+    #undef SW_FWD_DECL
 
-#define SW_RASTER_POINT_STATES DEPTH_TEST, BLEND
-#include __FILE__
-#undef SW_RASTER_POINT_STATES
+    // Specialization generation via self-inclusion
 
-// Forward declarations for static analyzer like clangd that do not handle self-inclusion correctly
-SW_RASTER_VARIANTS_2(SW_RASTER_FWD, sw_raster_point_, (const sw_vertex_t*)) // NOLINT
+    #define RLSW_TEMPLATE_RASTER_POINT BASE
+    #include __FILE__ // IWYU pragma: keep
+    #undef RLSW_TEMPLATE_RASTER_POINT
 
-static const sw_raster_point_f SW_RASTER_POINT_TABLE[] = {
-    SW_RASTER_VARIANTS_2(SW_RASTER_ENTRY, sw_raster_point_)
-};
+    #define RLSW_TEMPLATE_RASTER_POINT DEPTH
+    #define SW_ENABLE_DEPTH_TEST
+    #include __FILE__
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_POINT
+
+    #define RLSW_TEMPLATE_RASTER_POINT BLEND
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef RLSW_TEMPLATE_RASTER_POINT
+
+    #define RLSW_TEMPLATE_RASTER_POINT DEPTH_BLEND
+    #define SW_ENABLE_DEPTH_TEST
+    #define SW_ENABLE_BLEND
+    #include __FILE__
+    #undef SW_ENABLE_BLEND
+    #undef SW_ENABLE_DEPTH_TEST
+    #undef RLSW_TEMPLATE_RASTER_POINT
+
+    // Dispatch table (auto-generated from SW_RASTER_VARIANTS)
+    #define SW_TABLE_ENTRY(NAME, FLAGS) [FLAGS] = sw_raster_point_##NAME,
+    static const sw_raster_point_f SW_RASTER_POINT_TABLE[] = {
+        SW_RASTER_VARIANTS(SW_TABLE_ENTRY)
+    };
+    #undef SW_TABLE_ENTRY
+
+#undef SW_RASTER_VARIANTS
+#undef RLSW_TEMPLATE_RASTER_POINT_EXPANDING
+
+#endif // RLSW_TEMPLATE_RASTER_POINT_EXPANDING
 //-------------------------------------------------------------------------------------------
 
 // Triangle rendering logic
 //-------------------------------------------------------------------------------------------
-static bool sw_triangle_face_culling(void)
+static inline bool sw_triangle_face_culling(void)
 {
     // NOTE: Face culling is done before clipping to avoid unnecessary computations
     // To handle triangles crossing the w=0 plane correctly,
@@ -3344,7 +3366,7 @@ static void sw_triangle_clip_and_project(void)
 
             // Calculation of the reciprocal of W for normalization
             // as well as perspective-correct attributes
-            const float wRcp = sw_rcp(v->position[3]);
+            const float wRcp = 1.0f/v->position[3];
 
             // Division of XYZ coordinates by weight
             v->position[0] *= wRcp;
@@ -3393,7 +3415,7 @@ static void sw_triangle_render(uint32_t state)
 
 // Quad rendering logic
 //-------------------------------------------------------------------------------------------
-static bool sw_quad_face_culling(void)
+static inline bool sw_quad_face_culling(void)
 {
     // NOTE: Face culling is done before clipping to avoid unnecessary computations
     // To handle quads crossing the w=0 plane correctly,
@@ -3438,8 +3460,8 @@ static bool sw_quad_face_culling(void)
     // winding in the projected space when all w > 0
     // A value of 0 for sgnArea means P0, P1, P2 are collinear in (x, y, w)
     // space, which corresponds to a degenerate triangle projection
-    // Such quads might also be degenerate or non-planar
-    // They are typically not culled by this test (0 < 0 is false, 0 > 0 is false)
+    // Such quads might also be degenerate or non-planar. They are typically
+    // not culled by this test (0 < 0 is false, 0 > 0 is false)
     // and should be handled by the clipper if necessary
 
     return (RLSW.cullFace == SW_FRONT)? (sgnArea < 0.0f) : (sgnArea > 0.0f); // Cull if winding is "clockwise" : "counter-clockwise"
@@ -3459,7 +3481,7 @@ static void sw_quad_clip_and_project(void)
 
             // Calculation of the reciprocal of W for normalization
             // as well as perspective-correct attributes
-            const float wRcp = sw_rcp(v->position[3]);
+            const float wRcp = 1.0f/v->position[3];
 
             // Division of XYZ coordinates by weight
             v->position[0] *= wRcp;
@@ -3556,7 +3578,7 @@ static void sw_quad_render(uint32_t state)
 
 // Line rendering logic
 //-------------------------------------------------------------------------------------------
-static bool sw_line_clip_coord(float q, float p, float *t0, float *t1)
+static inline bool sw_line_clip_coord(float q, float p, float *t0, float *t1)
 {
     if (fabsf(p) < SW_CLIP_EPSILON)
     {
@@ -3637,8 +3659,8 @@ static bool sw_line_clip_and_project(sw_vertex_t *v0, sw_vertex_t *v1)
     if (!sw_line_clip(v0, v1)) return false;
 
     // Convert clip coordinates to NDC
-    v0->position[3] = sw_rcp(v0->position[3]);
-    v1->position[3] = sw_rcp(v1->position[3]);
+    v0->position[3] = 1.0f/v0->position[3];
+    v1->position[3] = 1.0f/v1->position[3];
     for (int i = 0; i < 3; i++)
     {
         v0->position[i] *= v0->position[3];
@@ -3662,8 +3684,17 @@ static bool sw_line_clip_and_project(sw_vertex_t *v0, sw_vertex_t *v1)
 static void sw_line_render(uint32_t state, sw_vertex_t *vertices)
 {
     if (!sw_line_clip_and_project(&vertices[0], &vertices[1])) return;
+
     state &= SW_RASTER_LINE_STATE_MASK;
-    SW_RASTER_LINE_TABLE[state](&vertices[0], &vertices[1]);
+
+    if (RLSW.lineWidth >= 2.0f)
+    {
+        SW_RASTER_LINE_THICK_TABLE[state](&vertices[0], &vertices[1]);
+    }
+    else
+    {
+        SW_RASTER_LINE_TABLE[state](&vertices[0], &vertices[1]);
+    }
 }
 //-------------------------------------------------------------------------------------------
 
@@ -3678,7 +3709,7 @@ static bool sw_point_clip_and_project(sw_vertex_t *v)
             if ((v->position[i] < -v->position[3]) || (v->position[i] > v->position[3])) return false;
         }
 
-        v->position[3] = sw_rcp(v->position[3]);
+        v->position[3] = 1.0f/v->position[3];
         v->position[0] *= v->position[3];
         v->position[1] *= v->position[3];
         v->position[2] *= v->position[3];
@@ -3713,12 +3744,12 @@ static void sw_point_render(uint32_t state, sw_vertex_t *v)
 
 // Polygon modes rendering logic
 //-------------------------------------------------------------------------------------------
-static void sw_poly_point_render(uint32_t state)
+static inline void sw_poly_point_render(uint32_t state)
 {
     for (int i = 0; i < RLSW.primitive.vertexCount; i++) sw_point_render(state, &RLSW.primitive.buffer[i]);
 }
 
-static void sw_poly_line_render(uint32_t state)
+static inline void sw_poly_line_render(uint32_t state)
 {
     const sw_vertex_t *vertices = RLSW.primitive.buffer;
     int cm1 = RLSW.primitive.vertexCount - 1;
@@ -3733,7 +3764,7 @@ static void sw_poly_line_render(uint32_t state)
     sw_line_render(state, verts);
 }
 
-static void sw_poly_fill_render(uint32_t state)
+static inline void sw_poly_fill_render(uint32_t state)
 {
     switch (RLSW.drawMode)
     {
@@ -3750,7 +3781,8 @@ static void sw_poly_fill_render(uint32_t state)
 //-------------------------------------------------------------------------------------------
 static void sw_immediate_begin(SWdraw mode)
 {
-    // NOTE: Any checks to ensure command recording can start must be performed before calling this function
+    // NOTE: Any checks to ensure command recording can start
+    //       must be performed before calling this function.
 
     // Recalculate the MVP if this is needed
     if (RLSW.isDirtyMVP)
@@ -3759,19 +3791,6 @@ static void sw_immediate_begin(SWdraw mode)
             RLSW.stackModelview[RLSW.stackModelviewCounter - 1],
             RLSW.stackProjection[RLSW.stackProjectionCounter - 1]);
 
-#ifdef SW_HAS_ESP_DSP
-        // Pre-transpose to row-major so dspm_mult_4x4x1_f32(matMVP_rm, v, out)
-        // computes M*v directly in the per-vertex hot path; 16 scalar copies
-        // per MVP update vs saving ~20 cycles per vertex transform
-        for (int i = 0; i < 4; i++)
-        {
-            for (int j = 0; j < 4; j++)
-            {
-                RLSW.matMVP_rm[4*i + j] = RLSW.matMVP[4*j + i];
-            }
-        }
-#endif
-
         RLSW.isDirtyMVP = false;
     }
 
@@ -3799,6 +3818,8 @@ static void sw_immediate_set_color(const float color[4])
     RLSW.primitive.color[1] = color[1];
     RLSW.primitive.color[2] = color[2];
     RLSW.primitive.color[3] = color[3];
+
+    RLSW.primitive.hasColorAlpha |= (color[3] < 1.0f);
 }
 
 static void sw_immediate_set_texcoord(const float texcoord[2])
@@ -3821,25 +3842,16 @@ static void sw_immediate_push_vertex(const float position[4])
     sw_vertex_t *vertex = &RLSW.primitive.buffer[RLSW.primitive.vertexCount++];
 
     // Calculate clip coordinates
-#ifdef SW_HAS_ESP_DSP
-    // dspm_mult_4x4x1_f32 declares its inputs non-const; rlsw treats them as
-    // read-only and the cast is safe (the kernel only loads from B)
-    dspm_mult_4x4x1_f32(RLSW.matMVP_rm, (float *)position, vertex->position);
-#else
     const float *m = RLSW.matMVP;
     vertex->position[0] = m[0]*position[0] + m[4]*position[1] + m[8]*position[2] + m[12]*position[3];
     vertex->position[1] = m[1]*position[0] + m[5]*position[1] + m[9]*position[2] + m[13]*position[3];
     vertex->position[2] = m[2]*position[0] + m[6]*position[1] + m[10]*position[2] + m[14]*position[3];
     vertex->position[3] = m[3]*position[0] + m[7]*position[1] + m[11]*position[2] + m[15]*position[3];
-#endif
 
     // Copy the attributes in the current vertex
     for (int i = 0; i < 4; i++) vertex->color[i] = RLSW.primitive.color[i];
     for (int i = 0; i < 2; i++) vertex->texcoord[i] = RLSW.primitive.texcoord[i];
 
-    // Track whether any vertex in this primitive has alpha < 1.0
-    RLSW.primitive.hasColorAlpha |= (vertex->color[3] < 1.0f);
-
     // Immediate rendering of the primitive if the required number is reached
     if (RLSW.primitive.vertexCount == SW_PRIMITIVE_VERTEX_COUNT[RLSW.drawMode])
     {
@@ -3855,18 +3867,6 @@ static void sw_immediate_push_vertex(const float position[4])
             }
         }
 
-        // Determine whether colors should be interpolated
-        const float *ref = RLSW.primitive.buffer[0].color;
-        for (int i = 1; i < RLSW.primitive.vertexCount; ++i)
-        {
-            const float *c = RLSW.primitive.buffer[i].color;
-            if (c[0] != ref[0] || c[1] != ref[1] || c[2] != ref[2] || c[3] != ref[3])
-            {
-                state |= SW_STATE_COLOR_INTERP;
-                break;
-            }
-        }
-
         switch (RLSW.polyMode)
         {
             case SW_FILL: sw_poly_fill_render(state); break;
@@ -3897,13 +3897,13 @@ bool swInit(int w, int h)
         return false;
     }
 
-    if (!sw_pool_init(&RLSW.framebufferPool, RLSW_MAX_FRAMEBUFFERS, sizeof(sw_framebuffer_t)))
+    if (!sw_pool_init(&RLSW.framebufferPool, SW_MAX_FRAMEBUFFERS, sizeof(sw_framebuffer_t)))
     {
         swClose();
         return false;
     }
 
-    if (!sw_pool_init(&RLSW.texturePool, RLSW_MAX_TEXTURES, sizeof(sw_texture_t)))
+    if (!sw_pool_init(&RLSW.texturePool, SW_MAX_TEXTURES, sizeof(sw_texture_t)))
     {
         swClose();
         return false;
@@ -3950,7 +3950,7 @@ bool swInit(int w, int h)
     RLSW.polyMode = SW_FILL;
     RLSW.cullFace = SW_BACK;
 
-#if RLSW_USE_COLOR_LUT
+#if SW_USE_COLOR_LUT
     for (int i = 0; i < 256; i++) SW_LUT_UINT8_TO_FLOAT[i] = (float)i*SW_INV_255;
 #endif
 
@@ -4062,22 +4062,6 @@ void *swGetColorBuffer(int *width, int *height)
     return RLSW.framebuffer.color.pixels;
 }
 
-
-void swSwapColorBuffers(void)
-{
-#if RLSW_DOUBLE_BUFFERING
-    sw_texture_t tmp = RLSW.framebuffer.color;
-    RLSW.framebuffer.color = RLSW.framebuffer.backColor;
-    RLSW.framebuffer.backColor = tmp;
-
-    // Only needs to know about current colorBuffer.
-    RLSW.colorBuffer = &RLSW.framebuffer.color;
-#else
-    SW_LOG("WARNING: RLSW: swSwapColorBuffers not enabled (Define RLSW_DOUBLE_BUFFERING=1)\n");
-#endif
-}
-
-
 void swEnable(SWstate state)
 {
     switch (state)
@@ -4180,7 +4164,6 @@ const char *swGetString(SWget name)
         case SW_RENDERER: result = "RLSW OpenGL Software Renderer"; break;
         case SW_VERSION: result = RLSW_VERSION; break;
         case SW_EXTENSIONS: result = "None"; break;
-        case SW_SHADING_LANGUAGE_VERSION: result = "Not supported"; break;
         default: RLSW.errCode = SW_INVALID_ENUM; break;
     }
 
@@ -4227,8 +4210,8 @@ void swScissor(int x, int y, int width, int height)
 
     RLSW.scClipMin[0] = (2.0f*(float)RLSW.scMin[0]/(float)RLSW.vpSize[0]) - 1.0f;
     RLSW.scClipMax[0] = (2.0f*(float)RLSW.scMax[0]/(float)RLSW.vpSize[0]) - 1.0f;
-    RLSW.scClipMin[1] = (2.0f*(float)RLSW.scMin[1]/(float)RLSW.vpSize[1]) - 1.0f;
-    RLSW.scClipMax[1] = (2.0f*(float)RLSW.scMax[1]/(float)RLSW.vpSize[1]) - 1.0f;
+    RLSW.scClipMax[1] = 1.0f - (2.0f*(float)RLSW.scMin[1]/(float)RLSW.vpSize[1]);
+    RLSW.scClipMin[1] = 1.0f - (2.0f*(float)RLSW.scMax[1]/(float)RLSW.vpSize[1]);
 }
 
 void swClearColor(float r, float g, float b, float a)
@@ -4253,8 +4236,6 @@ void swClear(uint32_t bitmask)
         sw_framebuffer_fill_color(RLSW.colorBuffer, RLSW.clearColor);
     }
 
-    // Don't clear back buffer, it might be locked by another core.
-
     if ((bitmask & (SW_DEPTH_BUFFER_BIT)) && (RLSW.depthBuffer != NULL) && (RLSW.depthBuffer->pixels != NULL))
     {
         sw_framebuffer_fill_depth(RLSW.depthBuffer, RLSW.clearDepth);
@@ -4326,7 +4307,7 @@ void swPushMatrix(void)
     {
         case SW_PROJECTION:
         {
-            if (RLSW.stackProjectionCounter >= RLSW_MAX_PROJECTION_STACK_SIZE)
+            if (RLSW.stackProjectionCounter >= SW_MAX_PROJECTION_STACK_SIZE)
             {
                 RLSW.errCode = SW_STACK_OVERFLOW;
                 return;
@@ -4344,7 +4325,7 @@ void swPushMatrix(void)
         } break;
         case SW_MODELVIEW:
         {
-            if (RLSW.stackModelviewCounter >= RLSW_MAX_MODELVIEW_STACK_SIZE)
+            if (RLSW.stackModelviewCounter >= SW_MAX_MODELVIEW_STACK_SIZE)
             {
                 RLSW.errCode = SW_STACK_OVERFLOW;
                 return;
@@ -4362,7 +4343,7 @@ void swPushMatrix(void)
         } break;
         case SW_TEXTURE:
         {
-            if (RLSW.stackTextureCounter >= RLSW_MAX_TEXTURE_STACK_SIZE)
+            if (RLSW.stackTextureCounter >= SW_MAX_TEXTURE_STACK_SIZE)
             {
                 RLSW.errCode = SW_STACK_OVERFLOW;
                 return;
@@ -5092,25 +5073,11 @@ void swTexParameteri(int param, int value)
         case SW_TEXTURE_WRAP_S:
         {
             if (!sw_is_texture_wrap_valid(value)) { RLSW.errCode = SW_INVALID_ENUM; return; }
-        #if !RLSW_SUPPORT_NPOT_TEXTURE
-            if (value == SW_REPEAT && (RLSW.boundTexture->width & RLSW.boundTexture->wMinus1) != 0)
-            {
-                RLSW.errCode = SW_INVALID_OPERATION;
-                return;
-            }
-        #endif
             RLSW.boundTexture->sWrap = (SWwrap)value;
         } break;
         case SW_TEXTURE_WRAP_T:
         {
             if (!sw_is_texture_wrap_valid(value)) { RLSW.errCode = SW_INVALID_ENUM; return; }
-        #if !RLSW_SUPPORT_NPOT_TEXTURE
-            if (value == SW_REPEAT && (RLSW.boundTexture->height & RLSW.boundTexture->hMinus1) != 0)
-            {
-                RLSW.errCode = SW_INVALID_OPERATION;
-                return;
-            }
-        #endif
             RLSW.boundTexture->tWrap = (SWwrap)value;
         } break;
         default: RLSW.errCode = SW_INVALID_ENUM; break;
@@ -5186,7 +5153,6 @@ void swBindFramebuffer(uint32_t id)
 
     RLSW.boundFramebufferId = id;
     RLSW.colorBuffer = sw_pool_get(&RLSW.texturePool, fb->colorAttachment);
-    // No back buffer available for binding rendertextures.
     RLSW.depthBuffer = sw_pool_get(&RLSW.texturePool, fb->depthAttachment);
 }
 
@@ -5277,222 +5243,197 @@ void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWattachget
 
 // Triangle rasterization functions
 //-------------------------------------------------------------------------------------------
-#ifdef SW_RASTER_TRIANGLE_STATES
+#ifdef RLSW_TEMPLATE_RASTER_TRIANGLE
 
-#define SW_RASTER_TRIANGLE_FLAGS SW_FLAGS(SW_RASTER_TRIANGLE_STATES)
-#define SW_RASTER_TRIANGLE_SPAN  SW_CONCATX(sw_raster_triangle_span_, SW_NAME(SW_RASTER_TRIANGLE_STATES))
-#define SW_RASTER_TRIANGLE       SW_CONCATX(sw_raster_triangle_, SW_NAME(SW_RASTER_TRIANGLE_STATES))
-#define SW_SPAN_CTX              SW_CONCATX(sw_span_ctx_, SW_NAME(SW_RASTER_TRIANGLE_STATES))
+// Options:
+//  - RLSW_TEMPLATE_RASTER_TRIANGLE     -> Contains the suffix name
+//  - SW_ENABLE_DEPTH_TEST
+//  - SW_ENABLE_TEXTURE
+//  - SW_ENABLE_BLEND
 
-// True when a perspective-correct interpolation pass is needed (color or UVs);
-// lets SPAN skip all w-tracking and block subdivision otherwise
-#define SW_RASTER_TRIANGLE_NEEDS_PERSPECTIVE \
-    (((SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP) || ((SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D))
+#define SW_RASTER_TRIANGLE_SPAN SW_CONCATX(sw_raster_triangle_span_, RLSW_TEMPLATE_RASTER_TRIANGLE)
+#define SW_RASTER_TRIANGLE      SW_CONCATX(sw_raster_triangle_, RLSW_TEMPLATE_RASTER_TRIANGLE)
 
-#define SW_GRAD SW_CONCATX(sw_grad_, SW_NAME(SW_RASTER_TRIANGLE_STATES))
-#define SW_VADD SW_CONCATX(sw_vadd_, SW_NAME(SW_RASTER_TRIANGLE_STATES))
-#define SW_VMAD SW_CONCATX(sw_vmad_, SW_NAME(SW_RASTER_TRIANGLE_STATES))
-
-// Per-triangle constants reused by every scanline: attribute x-derivatives
-// (constant across a planar triangle) plus whatever is fixed once and for
-// all when its interpolation is disabled (flat color, resolved sampler)
-typedef struct
-{
-#if SW_RASTER_TRIANGLE_NEEDS_PERSPECTIVE
-    float dWdx;
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-    float dZdx;
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-    float dCdx[4];
+#ifdef SW_ENABLE_TEXTURE
+    #define SW_GET_GRAD         sw_get_vertex_grad_PCT
+    #define SW_ADD_GRAD         sw_add_vertex_grad_PCT
+    #define SW_ADD_GRAD_SCALED  sw_add_vertex_grad_scaled_PCT
 #else
-    float flatColor[4];
+    #define SW_GET_GRAD         sw_get_vertex_grad_PC
+    #define SW_ADD_GRAD         sw_add_vertex_grad_PC
+    #define SW_ADD_GRAD_SCALED  sw_add_vertex_grad_scaled_PC
 #endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-    float dTdx[2];
-    float dTdy[2];
-    sw_texture_sampler_f sample;
-#endif
-} SW_SPAN_CTX;
 
-static SW_INLINE void SW_GRAD(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT a, const sw_vertex_t *SW_RESTRICT b, float scale)
+static void SW_RASTER_TRIANGLE_SPAN(const sw_vertex_t *start, const sw_vertex_t *end, float dUdy, float dVdy)
 {
-    SW_VEC_OP(out->position[i] = (b->position[i] - a->position[i])*scale, i, 4);
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-    SW_VEC_OP(out->color[i] = (b->color[i] - a->color[i])*scale, i, 4);
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-    SW_VEC_OP(out->texcoord[i] = (b->texcoord[i] - a->texcoord[i])*scale, i, 2);
-#endif
-}
-
-static SW_INLINE void SW_VADD(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT inc)
-{
-    SW_VEC_OP(out->position[i] += inc->position[i], i, 4);
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-    SW_VEC_OP(out->color[i] += inc->color[i], i, 4);
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-    SW_VEC_OP(out->texcoord[i] += inc->texcoord[i], i, 2);
-#endif
-}
-
-static SW_INLINE void SW_VMAD(sw_vertex_t *SW_RESTRICT out, const sw_vertex_t *SW_RESTRICT inc, float scale)
-{
-    SW_VEC_OP(out->position[i] += inc->position[i]*scale, i, 4);
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-    SW_VEC_OP(out->color[i] += inc->color[i]*scale, i, 4);
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-    SW_VEC_OP(out->texcoord[i] += inc->texcoord[i]*scale, i, 2);
-#endif
-}
-
-static void SW_RASTER_TRIANGLE_SPAN(const sw_vertex_t *start, const sw_vertex_t *end, const SW_SPAN_CTX *ctx)
-{
-    // Skip rows outside the framebuffer; can only trigger on FP rounding at
-    // clip boundaries since triangles are already clipped to the viewport
-    int y = (int)start->position[1];
-    if (y < 0 || y >= RLSW.colorBuffer->height) return;
-
     // Gets the start/end coordinates and skip empty lines
     int xStart = (int)start->position[0];
     int xEnd = (int)end->position[0];
     if (xStart == xEnd) return;
 
-    // Intercept the span bounds to ensure to not write before the framebuffer
-    int xLoopStart = (xStart >= 0)? xStart : 0;
-    int xLoopEnd = (xEnd <= RLSW.colorBuffer->width)? xEnd : RLSW.colorBuffer->width;
-    if (xLoopStart >= xLoopEnd) return; // Nothing to draw
+    // Compute the inverse horizontal distance along the X axis
+    float dxRcp = 1.0f/(end->position[0] - start->position[0]);
+
+    // Compute the interpolation steps along the X axis
+    float dWdx = (end->position[3] - start->position[3])*dxRcp;
+    float dCdx[4] = {
+        (end->color[0] - start->color[0])*dxRcp,
+        (end->color[1] - start->color[1])*dxRcp,
+        (end->color[2] - start->color[2])*dxRcp,
+        (end->color[3] - start->color[3])*dxRcp
+    };
+#ifdef SW_ENABLE_DEPTH_TEST
+    float dZdx = (end->position[2] - start->position[2])*dxRcp;
+#endif
+#ifdef SW_ENABLE_TEXTURE
+    float dUdx = (end->texcoord[0] - start->texcoord[0])*dxRcp;
+    float dVdx = (end->texcoord[1] - start->texcoord[1])*dxRcp;
+#endif
 
     // Compute the subpixel distance to traverse before the first pixel
-    // Also step further into them to move away from the colorbuffer edge
     float xSubstep = 1.0f - sw_fract(start->position[0]);
-    float dxStart = (float)(xLoopStart - xStart);
-    float xOffset = xSubstep + dxStart;
-
-    // Pre-calculate the starting pointers for the framebuffer row
-    int baseOffset = y*RLSW.colorBuffer->width + xLoopStart;
-    uint8_t *cPtr = (uint8_t *)(RLSW.colorBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE;
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-    uint8_t *dPtr = (uint8_t *)(RLSW.depthBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE;
-#endif
 
     // Initializing the interpolation starting values
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-    float z = start->position[2] + ctx->dZdx*xOffset;
+    float w = start->position[3] + dWdx*xSubstep;
+    float color[4] = {
+        start->color[0] + dCdx[0]*xSubstep,
+        start->color[1] + dCdx[1]*xSubstep,
+        start->color[2] + dCdx[2]*xSubstep,
+        start->color[3] + dCdx[3]*xSubstep
+    };
+#ifdef SW_ENABLE_DEPTH_TEST
+    float z = start->position[2] + dZdx*xSubstep;
 #endif
-#if SW_RASTER_TRIANGLE_NEEDS_PERSPECTIVE
-    float w = start->position[3] + ctx->dWdx*xOffset;
+#ifdef SW_ENABLE_TEXTURE
+    float u = start->texcoord[0] + dUdx*xSubstep;
+    float v = start->texcoord[1] + dVdx*xSubstep;
 #endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-    float color[4];
-    SW_VEC_OP(color[i] = start->color[i] + ctx->dCdx[i]*xOffset, i, 4);
-#else
-    // Flat: constant across the whole triangle, computed once for the whole span
-    const float *srcColor = ctx->flatColor;
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-    float texcoord[2];
-    SW_VEC_OP(texcoord[i] = start->texcoord[i] + ctx->dTdx[i]*xOffset, i, 2);
+
+    // Pre-calculate the starting pointers for the framebuffer row
+    int y = (int)start->position[1];
+    int baseOffset = y*RLSW.colorBuffer->width + xStart;
+    uint8_t *cPtr = (uint8_t *)(RLSW.colorBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE;
+#ifdef SW_ENABLE_DEPTH_TEST
+    uint8_t *dPtr = (uint8_t *)(RLSW.depthBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE;
 #endif
 
 #define SW_AFFINE_BLOCK 16
 
-    int x = xLoopStart;
-    while (x < xLoopEnd)
+    int x = xStart;
+    while (x < xEnd)
     {
-    #if SW_RASTER_TRIANGLE_NEEDS_PERSPECTIVE
         // Clamp last block to remaining pixels
         int blockEnd = x + SW_AFFINE_BLOCK;
-        if (blockEnd > xLoopEnd) blockEnd = xLoopEnd;
+        if (blockEnd > xEnd) blockEnd = xEnd;
         float blockLenF = (float)(blockEnd - x);
-        float blockLenRcp = sw_rcp(blockLenF);
+        float blockLenRcp = 1.0f/blockLenF;
 
         // Only 2 '1/w' here; none inside the pixel loop
-        float wRcpA = sw_rcp(w);
-        float wB = w + ctx->dWdx*blockLenF;
-        float wRcpB = sw_rcp(wB);
-    #else
-        // Nothing perspective-correct to interpolate: one block covers the whole span
-        int blockEnd = xLoopEnd;
-    #endif
+        float wRcpA = 1.0f/w;
+        float wB = w + dWdx*blockLenF;
+        float wRcpB = 1.0f/wB;
 
-    #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
         // Perspective-correct color at both block endpoints, then affine gradient
-        float srcColor[4], dSrcColor[4];
-        SW_VEC_OP(srcColor[i] = color[i]*wRcpA, i, 4);
-        SW_VEC_OP(dSrcColor[i] = ((color[i] + ctx->dCdx[i]*blockLenF)*wRcpB - srcColor[i])*blockLenRcp, i, 4);
-    #endif
+        float srcColor[4] = {
+            color[0]*wRcpA,
+            color[1]*wRcpA,
+            color[2]*wRcpA,
+            color[3]*wRcpA
+        };
+        float dSrcColordx[4] = {
+            ((color[0] + dCdx[0]*blockLenF)*wRcpB - srcColor[0])*blockLenRcp,
+            ((color[1] + dCdx[1]*blockLenF)*wRcpB - srcColor[1])*blockLenRcp,
+            ((color[2] + dCdx[2]*blockLenF)*wRcpB - srcColor[2])*blockLenRcp,
+            ((color[3] + dCdx[3]*blockLenF)*wRcpB - srcColor[3])*blockLenRcp
+        };
 
-    #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
+    #ifdef SW_ENABLE_TEXTURE
         // Perspective-correct UVs at both endpoints, then affine gradient
-        float tcAffine[2], dTcAffine[2];
-        SW_VEC_OP(tcAffine[i] = texcoord[i]*wRcpA, i, 2);
-        SW_VEC_OP(dTcAffine[i] = ((texcoord[i] + ctx->dTdx[i]*blockLenF)*wRcpB - tcAffine[i])*blockLenRcp, i, 2);
+        float uAffine  = u*wRcpA;
+        float vAffine  = v*wRcpA;
+        float dUaffine = ((u + dUdx*blockLenF)*wRcpB - uAffine)*blockLenRcp;
+        float dVaffine = ((v + dVdx*blockLenF)*wRcpB - vAffine)*blockLenRcp;
     #endif
 
         // Inner span pixel loop
         for (; x < blockEnd; x++)
         {
-        #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-            float depth = SW_FRAMEBUFFER_DEPTH_GET(dPtr, 0);
-            if (z <= depth)
+            #ifdef SW_ENABLE_DEPTH_TEST
             {
+                float depth = SW_FRAMEBUFFER_DEPTH_GET(dPtr, 0);
+                if (z > depth) goto discard;
                 SW_FRAMEBUFFER_DEPTH_SET(dPtr, z, 0);
-        #endif
-
-            #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-                float finalColor[4];
-                ctx->sample(finalColor, RLSW.boundTexture, tcAffine[0], tcAffine[1]);
-                SW_VEC_OP(finalColor[i] *= srcColor[i], i, 4);
-                #define SW_FINAL_COLOR finalColor
-            #else
-                #define SW_FINAL_COLOR srcColor
+            }
             #endif
 
-            #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_BLEND
+            #ifdef SW_ENABLE_TEXTURE
             {
-                float dstColor[4];
-                SW_FRAMEBUFFER_COLOR_GET(dstColor, cPtr, 0);
-                RLSW.blendFunc(dstColor, SW_FINAL_COLOR);
-                SW_FRAMEBUFFER_COLOR_SET(cPtr, dstColor, 0);
+                float texColor[4];
+                sw_texture_sample(texColor, RLSW.boundTexture, uAffine, vAffine, dUdx, dUdy, dVdx, dVdy);
+                float finalColor[4] = {
+                    srcColor[0]*texColor[0],
+                    srcColor[1]*texColor[1],
+                    srcColor[2]*texColor[2],
+                    srcColor[3]*texColor[3]
+                };
+                #ifdef SW_ENABLE_BLEND
+                {
+                    float dstColor[4];
+                    SW_FRAMEBUFFER_COLOR_GET(dstColor, cPtr, 0);
+                    RLSW.blendFunc(dstColor, finalColor);
+                    SW_FRAMEBUFFER_COLOR_SET(cPtr, dstColor, 0);
+                }
+                #else
+                    SW_FRAMEBUFFER_COLOR_SET(cPtr, finalColor, 0);
+                #endif
             }
             #else
-                SW_FRAMEBUFFER_COLOR_SET(cPtr, SW_FINAL_COLOR, 0);
+            {
+                #ifdef SW_ENABLE_BLEND
+                {
+                    float dstColor[4];
+                    SW_FRAMEBUFFER_COLOR_GET(dstColor, cPtr, 0);
+                    RLSW.blendFunc(dstColor, srcColor);
+                    SW_FRAMEBUFFER_COLOR_SET(cPtr, dstColor, 0);
+                }
+                #else
+                    SW_FRAMEBUFFER_COLOR_SET(cPtr, srcColor, 0);
+                #endif
+            }
             #endif
 
-            #undef SW_FINAL_COLOR
-
-        #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-            }
-        #endif
-
-            // Advance unconditionally: depth test only guards the write above
+        discard:
+            srcColor[0] += dSrcColordx[0];
+            srcColor[1] += dSrcColordx[1];
+            srcColor[2] += dSrcColordx[2];
+            srcColor[3] += dSrcColordx[3];
             cPtr += SW_FRAMEBUFFER_COLOR_SIZE;
-        #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-            dPtr += SW_FRAMEBUFFER_DEPTH_SIZE;
-            z += ctx->dZdx;
-        #endif
-        #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-            SW_VEC_OP(srcColor[i] += dSrcColor[i], i, 4);
-        #endif
-        #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-            SW_VEC_OP(tcAffine[i] += dTcAffine[i], i, 2);
-        #endif
+
+            #ifdef SW_ENABLE_DEPTH_TEST
+            {
+                z += dZdx;
+                dPtr += SW_FRAMEBUFFER_DEPTH_SIZE;
+            }
+            #endif
+
+            #ifdef SW_ENABLE_TEXTURE
+            {
+                uAffine += dUaffine;
+                vAffine += dVaffine;
+            }
+            #endif
         }
 
-#if SW_RASTER_TRIANGLE_NEEDS_PERSPECTIVE
         // Advance perspective-space accumulators by the full block width
         w = wB;
-    #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-        SW_VEC_OP(color[i] += ctx->dCdx[i]*blockLenF, i, 4);
-    #endif
-    #if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-        SW_VEC_OP(texcoord[i] += ctx->dTdx[i]*blockLenF, i, 2);
-    #endif
-#endif
+        color[0] += dCdx[0]*blockLenF;
+        color[1] += dCdx[1]*blockLenF;
+        color[2] += dCdx[2]*blockLenF;
+        color[3] += dCdx[3]*blockLenF;
+        #ifdef SW_ENABLE_TEXTURE
+        u += dUdx*blockLenF;
+        v += dVdx*blockLenF;
+        #endif
     }
 
 #undef SW_AFFINE_BLOCK
@@ -5505,62 +5446,28 @@ static void SW_RASTER_TRIANGLE(const sw_vertex_t *v0, const sw_vertex_t *v1, con
     if (v1->position[1] > v2->position[1]) { const sw_vertex_t *tmp = v1; v1 = v2; v2 = tmp; }
     if (v0->position[1] > v1->position[1]) { const sw_vertex_t *tmp = v0; v0 = v1; v1 = tmp; }
 
-    // Extracting Y coordinates from the sorted vertices
-    float y0 = v0->position[1];
-    float y1 = v1->position[1];
-    float y2 = v2->position[1];
+    // Extracting coordinates from the sorted vertices
+    float x0 = v0->position[0], y0 = v0->position[1];
+    float x1 = v1->position[0], y1 = v1->position[1];
+    float x2 = v2->position[0], y2 = v2->position[1];
 
     // Compute height differences
     float h02 = y2 - y0;
     float h01 = y1 - y0;
     float h12 = y2 - y1;
 
-    if (h02 < 1e-6f) return; // Degenerate (zero screen height): nothing to rasterize
+    if (h02 < 1e-6f) return;
 
     // Inverse edge dy for per-edge dV/dy (scanline interpolation)
-    float h02Rcp = sw_rcp(h02);
-    float h01Rcp = (h01 > 1e-6f)? sw_rcp(h01) : 0.0f;
-    float h12Rcp = (h12 > 1e-6f)? sw_rcp(h12) : 0.0f;
-
-    // D = twice the signed screen area; also the shared denominator of the
-    // barycentric plane solve used below for whole-triangle x/y derivatives
-    float e1x = v1->position[0] - v0->position[0];
-    float e2x = v2->position[0] - v0->position[0];
-    float D = e1x*h02 - e2x*h01;
-    if (fabsf(D) < 1e-9f) return; // Degenerate (zero screen area): nothing to rasterize
-    float DRcp = sw_rcp(D);
-
-    // Whole-triangle xy-derivatives of an affine attribute (constant for every scanline)
-    #define SW_DADX(A0, A1, A2) ((((A1)-(A0))*h02 - ((A2)-(A0))*h01)*DRcp)
-    #define SW_DADY(A0, A1, A2) ((((A2)-(A0))*e1x - ((A1)-(A0))*e2x)*DRcp)
-
-    SW_SPAN_CTX ctx;
-#if SW_RASTER_TRIANGLE_NEEDS_PERSPECTIVE
-    ctx.dWdx = SW_DADX(v0->position[3], v1->position[3], v2->position[3]);
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_DEPTH_TEST
-    ctx.dZdx = SW_DADX(v0->position[2], v1->position[2], v2->position[2]);
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_COLOR_INTERP
-    SW_VEC_OP(ctx.dCdx[i] = SW_DADX(v0->color[i], v1->color[i], v2->color[i]), i, 4);
-#else
-    float flatWRcp = sw_rcp(v0->position[3]);
-    SW_VEC_OP(ctx.flatColor[i] = v0->color[i]*flatWRcp, i, 4);
-#endif
-#if (SW_RASTER_TRIANGLE_FLAGS) & SW_STATE_TEXTURE_2D
-    SW_VEC_OP(ctx.dTdx[i] = SW_DADX(v0->texcoord[i], v1->texcoord[i], v2->texcoord[i]), i, 2);
-    SW_VEC_OP(ctx.dTdy[i] = SW_DADY(v0->texcoord[i], v1->texcoord[i], v2->texcoord[i]), i, 2);
-    ctx.sample = sw_texture_pick_sampler(RLSW.boundTexture, ctx.dTdx, ctx.dTdy);
-#endif
-
-    #undef SW_DADX
-    #undef SW_DADY
+    float h02Rcp = 1.0f/h02;
+    float h01Rcp = (h01 > 1e-6f)? 1.0f/h01 : 0.0f;
+    float h12Rcp = (h12 > 1e-6f)? 1.0f/h12 : 0.0f;
 
     // Compute gradients for each side of the triangle
     sw_vertex_t dVXdy02, dVXdy01, dVXdy12;
-    SW_GRAD(&dVXdy02, v0, v2, h02Rcp);
-    SW_GRAD(&dVXdy01, v0, v1, h01Rcp);
-    SW_GRAD(&dVXdy12, v1, v2, h12Rcp);
+    SW_GET_GRAD(&dVXdy02, v0, v2, h02Rcp);
+    SW_GET_GRAD(&dVXdy01, v0, v1, h01Rcp);
+    SW_GET_GRAD(&dVXdy12, v1, v2, h12Rcp);
 
     // Y subpixel correction
     float y0Substep = 1.0f - sw_fract(y0);
@@ -5568,8 +5475,8 @@ static void SW_RASTER_TRIANGLE(const sw_vertex_t *v0, const sw_vertex_t *v1, con
 
     // Get a copy of vertices for interpolation and apply substep correction
     sw_vertex_t lVert = *v0, rVert = *v0;
-    SW_VMAD(&lVert, &dVXdy02, y0Substep);
-    SW_VMAD(&rVert, &dVXdy01, y0Substep);
+    SW_ADD_GRAD_SCALED(&lVert, &dVXdy02, y0Substep);
+    SW_ADD_GRAD_SCALED(&rVert, &dVXdy01, y0Substep);
 
     // Y bounds (vertical clipping)
     int yTop = (int)y0;
@@ -5583,14 +5490,14 @@ static void SW_RASTER_TRIANGLE(const sw_vertex_t *v0, const sw_vertex_t *v1, con
         bool longSideIsLeft = (lVert.position[0] < rVert.position[0]);
         const sw_vertex_t *a = longSideIsLeft? &lVert : &rVert;
         const sw_vertex_t *b = longSideIsLeft? &rVert : &lVert;
-        SW_RASTER_TRIANGLE_SPAN(a, b, &ctx);
-        SW_VADD(&lVert, &dVXdy02);
-        SW_VADD(&rVert, &dVXdy01);
+        SW_RASTER_TRIANGLE_SPAN(a, b, dVXdy02.texcoord[0], dVXdy02.texcoord[1]);
+        SW_ADD_GRAD(&lVert, &dVXdy02);
+        SW_ADD_GRAD(&rVert, &dVXdy01);
     }
 
     // Get a copy of next right for interpolation and apply substep correction
     rVert = *v1;
-    SW_VMAD(&rVert, &dVXdy12, y1Substep);
+    SW_ADD_GRAD_SCALED(&rVert, &dVXdy12, y1Substep);
 
     // Scanline for the lower part of the triangle
     for (int y = yMid; y < yBot; y++)
@@ -5599,21 +5506,30 @@ static void SW_RASTER_TRIANGLE(const sw_vertex_t *v0, const sw_vertex_t *v1, con
         bool longSideIsLeft = (lVert.position[0] < rVert.position[0]);
         const sw_vertex_t *a = longSideIsLeft? &lVert : &rVert;
         const sw_vertex_t *b = longSideIsLeft? &rVert : &lVert;
-        SW_RASTER_TRIANGLE_SPAN(a, b, &ctx);
-        SW_VADD(&lVert, &dVXdy02);
-        SW_VADD(&rVert, &dVXdy12);
+        SW_RASTER_TRIANGLE_SPAN(a, b, dVXdy02.texcoord[0], dVXdy02.texcoord[1]);
+        SW_ADD_GRAD(&lVert, &dVXdy02);
+        SW_ADD_GRAD(&rVert, &dVXdy12);
     }
 }
 
-#endif // SW_RASTER_TRIANGLE_STATES
+#undef SW_GET_GRAD
+#undef SW_ADD_GRAD
+#undef SW_ADD_GRAD_SCALED
+
+#endif // RLSW_TEMPLATE_RASTER_TRIANGLE
 //-------------------------------------------------------------------------------------------
 
 // Quad rasterization functions
 //-------------------------------------------------------------------------------------------
-#ifdef SW_RASTER_QUAD_STATES
+#ifdef RLSW_TEMPLATE_RASTER_QUAD
 
-#define SW_RASTER_QUAD_FLAGS SW_FLAGS(SW_RASTER_QUAD_STATES)
-#define SW_RASTER_QUAD       SW_CONCATX(sw_raster_quad_, SW_NAME(SW_RASTER_QUAD_STATES))
+// Options:
+//  - RLSW_TEMPLATE_RASTER_QUAD     -> Contains the suffix name
+//  - SW_ENABLE_DEPTH_TEST
+//  - SW_ENABLE_TEXTURE
+//  - SW_ENABLE_BLEND
+
+#define SW_RASTER_QUAD SW_CONCATX(sw_raster_quad_, RLSW_TEMPLATE_RASTER_QUAD)
 
 // NOTE: This function should only render affine axis-aligned quads
 //       No perspective divide is applied after interpolation
@@ -5625,18 +5541,14 @@ static void SW_RASTER_QUAD(const sw_vertex_t *a, const sw_vertex_t *b,
     // For axis-aligned quads x+y and x-y uniquely identify each corner
     const sw_vertex_t *verts[4] = { a, b, c, d };
     const sw_vertex_t *tl = verts[0], *tr = verts[0], *br = verts[0], *bl = verts[0];
-    float tlSum = tl->position[0] + tl->position[1];
-    float trDiff = tr->position[0] - tr->position[1];
-    float brSum = br->position[0] + br->position[1];
-    float blDiff = bl->position[0] - bl->position[1];
     for (int i = 1; i < 4; i++)
     {
         float sum  = verts[i]->position[0] + verts[i]->position[1];
         float diff = verts[i]->position[0] - verts[i]->position[1];
-        if (sum  < tlSum)  { tl = verts[i]; tlSum = sum; }
-        if (diff > trDiff) { tr = verts[i]; trDiff = diff; }
-        if (sum  > brSum)  { br = verts[i]; brSum = sum; }
-        if (diff < blDiff) { bl = verts[i]; blDiff = diff; }
+        if (sum  < tl->position[0] + tl->position[1]) tl = verts[i];
+        if (diff > tr->position[0] - tr->position[1]) tr = verts[i];
+        if (sum  > br->position[0] + br->position[1]) br = verts[i];
+        if (diff < bl->position[0] - bl->position[1]) bl = verts[i];
     }
 
     int xMin = (int)tl->position[0];
@@ -5644,167 +5556,168 @@ static void SW_RASTER_QUAD(const sw_vertex_t *a, const sw_vertex_t *b,
     int xMax = (int)br->position[0];
     int yMax = (int)br->position[1];
 
-    // Exit early if no pixels to draw.  Use these later for loop boundaries
-    int yLoopMin = (yMin >= 0)? yMin : 0;
-    int xLoopMin = (xMin >= 0)? xMin : 0;
-    int yLoopMax = (yMax <= RLSW.colorBuffer->height)? yMax : RLSW.colorBuffer->height;
-    int xLoopMax = (xMax <= RLSW.colorBuffer->width)?  xMax : RLSW.colorBuffer->width;
-
-    if (yLoopMin >= yLoopMax || xLoopMin >= xLoopMax) return;
-
     float w = (float)(xMax - xMin);
     float h = (float)(yMax - yMin);
     if ((w <= 0) || (h <= 0)) return;
 
-    // Per-quad setup, independent of pipeline state
-    float wRcp = sw_rcp(w);
-    float hRcp = sw_rcp(h);
+    float wRcp = 1.0f/w;
+    float hRcp = 1.0f/h;
+
+    // Subpixel corrections
     float xSubstep = 1.0f - sw_fract(tl->position[0]);
     float ySubstep = 1.0f - sw_fract(tl->position[1]);
-    // Distance the in-bounds boundary is from the quad's edges, only on the left and top
-    float dxMin = (float)(xLoopMin - xMin);
-    float dyMin = (float)(yLoopMin - yMin);
-    int stride = RLSW.colorBuffer->width;
-    uint8_t *cPixels = RLSW.colorBuffer->pixels;
-#if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
-    uint8_t *dPixels = RLSW.depthBuffer->pixels;
-#endif
 
-#if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
     // Gradients along X (tl->tr) and Y (tl->bl)
+    float dCdx[4] = {
+        (tr->color[0] - tl->color[0])*wRcp,
+        (tr->color[1] - tl->color[1])*wRcp,
+        (tr->color[2] - tl->color[2])*wRcp,
+        (tr->color[3] - tl->color[3])*wRcp,
+    };
+    float dCdy[4] = {
+        (bl->color[0] - tl->color[0])*hRcp,
+        (bl->color[1] - tl->color[1])*hRcp,
+        (bl->color[2] - tl->color[2])*hRcp,
+        (bl->color[3] - tl->color[3])*hRcp,
+    };
+
+#ifdef SW_ENABLE_DEPTH_TEST
     float dZdx = (tr->position[2] - tl->position[2])*wRcp;
     float dZdy = (bl->position[2] - tl->position[2])*hRcp;
     float zRow = tl->position[2] + dZdx*xSubstep + dZdy*ySubstep;
-    // Correct start by how far it's clipped outside the framebuffer
-    zRow += dZdy*dyMin + dZdx*dxMin;
 #endif
 
-#if (SW_RASTER_QUAD_FLAGS) & SW_STATE_COLOR_INTERP
-    float dCdx[4], dCdy[4], cRow[4];
-    SW_VEC_OP(dCdx[i] = (tr->color[i] - tl->color[i])*wRcp, i, 4);
-    SW_VEC_OP(dCdy[i] = (bl->color[i] - tl->color[i])*hRcp, i, 4);
-    SW_VEC_OP(cRow[i] = tl->color[i] + dCdx[i]*xSubstep + dCdy[i]*ySubstep, i, 4);
-    SW_VEC_OP(cRow[i] += dCdx[i]*dxMin + dCdy[i]*dyMin, i, 4);
-#else
-    const float *flatColor = tl->color;
+#ifdef SW_ENABLE_TEXTURE
+    float dUdx = (tr->texcoord[0] - tl->texcoord[0])*wRcp;
+    float dVdx = (tr->texcoord[1] - tl->texcoord[1])*wRcp;
+    float dUdy = (bl->texcoord[0] - tl->texcoord[0])*hRcp;
+    float dVdy = (bl->texcoord[1] - tl->texcoord[1])*hRcp;
+    float uRow = tl->texcoord[0] + dUdx*xSubstep + dUdy*ySubstep;
+    float vRow = tl->texcoord[1] + dVdx*xSubstep + dVdy*ySubstep;
 #endif
 
-#if (SW_RASTER_QUAD_FLAGS) & SW_STATE_TEXTURE_2D
-    float dTdx[2], dTdy[2], tcRow[2];
-    SW_VEC_OP(dTdx[i] = (tr->texcoord[i] - tl->texcoord[i])*wRcp, i, 2);
-    SW_VEC_OP(dTdy[i] = (bl->texcoord[i] - tl->texcoord[i])*hRcp, i, 2);
-    SW_VEC_OP(tcRow[i] = tl->texcoord[i] + dTdx[i]*xSubstep + dTdy[i]*ySubstep, i, 2);
-    SW_VEC_OP(tcRow[i] += dTdy[i]*dyMin + dTdx[i]*dxMin, i, 2);
+    float cRow[4] = {
+        tl->color[0] + dCdx[0]*xSubstep + dCdy[0]*ySubstep,
+        tl->color[1] + dCdx[1]*xSubstep + dCdy[1]*ySubstep,
+        tl->color[2] + dCdx[2]*xSubstep + dCdy[2]*ySubstep,
+        tl->color[3] + dCdx[3]*xSubstep + dCdy[3]*ySubstep,
+    };
 
-    // Constant across the whole quad: resolved once, called directly per pixel
-    sw_texture_sampler_f sample = sw_texture_pick_sampler(RLSW.boundTexture, dTdx, dTdy);
+    int stride = RLSW.colorBuffer->width;
+    uint8_t *cPixels = RLSW.colorBuffer->pixels;
+#ifdef SW_ENABLE_DEPTH_TEST
+    uint8_t *dPixels = RLSW.depthBuffer->pixels;
 #endif
 
-    for (int y = yLoopMin; y < yLoopMax; y++)
+    for (int y = yMin; y < yMax; y++)
     {
-        int baseOffset = y*stride + xLoopMin;
+        int baseOffset = y*stride + xMin;
         uint8_t *cPtr = cPixels + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE;
-    #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
+    #ifdef SW_ENABLE_DEPTH_TEST
         uint8_t *dPtr = dPixels + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE;
         float z = zRow;
     #endif
-    #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_TEXTURE_2D
-        float tc[2] = { tcRow[0], tcRow[1] };
+    #ifdef SW_ENABLE_TEXTURE
+        float u = uRow;
+        float v = vRow;
     #endif
-    #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_COLOR_INTERP
         float color[4] = { cRow[0], cRow[1], cRow[2], cRow[3] };
-    #endif
 
-        for (int x = xLoopMin; x < xLoopMax; x++)
+        for (int x = xMin; x < xMax; x++)
         {
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_COLOR_INTERP
-            #define SW_QUAD_BASE_COLOR color
-        #else
-            #define SW_QUAD_BASE_COLOR flatColor
-        #endif
+            float srcColor[4] = { color[0], color[1], color[2], color[3] };
 
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_TEXTURE_2D
-            // Mutable copy: about to be modulated by the sampled texel below
-            float srcColor[4];
-            SW_VEC_OP(srcColor[i] = SW_QUAD_BASE_COLOR[i], i, 4);
-        #else
-            // Never mutated past this point: alias directly, no copy needed
-            const float *srcColor = SW_QUAD_BASE_COLOR;
-        #endif
-
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
-            float depth = SW_FRAMEBUFFER_DEPTH_GET(dPtr, 0);
-            if (z <= depth)
+            #ifdef SW_ENABLE_DEPTH_TEST
             {
+                float depth = SW_FRAMEBUFFER_DEPTH_GET(dPtr, 0);
+                if (z > depth) goto discard;
                 SW_FRAMEBUFFER_DEPTH_SET(dPtr, z, 0);
-        #endif
-
-            #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_TEXTURE_2D
-                float texColor[4];
-                sample(texColor, RLSW.boundTexture, tc[0], tc[1]);
-                SW_VEC_OP(srcColor[i] *= texColor[i], i, 4);
+            }
             #endif
 
-            #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_BLEND
+            #ifdef SW_ENABLE_TEXTURE
+            {
+                float texColor[4];
+                sw_texture_sample(texColor, RLSW.boundTexture, u, v, dUdx, dUdy, dVdx, dVdy);
+                srcColor[0] *= texColor[0];
+                srcColor[1] *= texColor[1];
+                srcColor[2] *= texColor[2];
+                srcColor[3] *= texColor[3];
+            }
+            #endif
+
+            #ifdef SW_ENABLE_BLEND
+            {
                 float dstColor[4];
                 SW_FRAMEBUFFER_COLOR_GET(dstColor, cPtr, 0);
                 RLSW.blendFunc(dstColor, srcColor);
                 SW_FRAMEBUFFER_COLOR_SET(cPtr, dstColor, 0);
+            }
             #else
+            {
                 SW_FRAMEBUFFER_COLOR_SET(cPtr, srcColor, 0);
+            }
             #endif
 
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
+        discard:
+            color[0] += dCdx[0];
+            color[1] += dCdx[1];
+            color[2] += dCdx[2];
+            color[3] += dCdx[3];
+
+            #ifdef SW_ENABLE_DEPTH_TEST
+            {
+                z += dZdx;
+                dPtr += SW_FRAMEBUFFER_DEPTH_SIZE;
             }
-        #endif
+            #endif
 
-            // Move one pixel over without touching the original "start offset"
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_COLOR_INTERP
-            SW_VEC_OP(color[i] += dCdx[i], i, 4);
-        #endif
-
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
-            z += dZdx;
-            dPtr += SW_FRAMEBUFFER_DEPTH_SIZE;
-        #endif
-
-        #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_TEXTURE_2D
-            SW_VEC_OP(tc[i] += dTdx[i], i, 2);
-        #endif
+            #ifdef SW_ENABLE_TEXTURE
+            {
+                u += dUdx;
+                v += dVdx;
+            }
+            #endif
 
             cPtr += SW_FRAMEBUFFER_COLOR_SIZE;
         }
 
-        // The for loop is clamped to the right side of the screen
-        // However, these cursor start vars are still on the left
-        // That's fine, advancing to the next row
-    #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_DEPTH_TEST
-        zRow += dZdy;
-    #endif
-    #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_COLOR_INTERP
-        SW_VEC_OP(cRow[i] += dCdy[i], i, 4);
-    #endif
-    #if (SW_RASTER_QUAD_FLAGS) & SW_STATE_TEXTURE_2D
-        SW_VEC_OP(tcRow[i] += dTdy[i], i, 2);
-    #endif
-    }
+        cRow[0] += dCdy[0];
+        cRow[1] += dCdy[1];
+        cRow[2] += dCdy[2];
+        cRow[3] += dCdy[3];
 
-#undef SW_QUAD_BASE_COLOR
+        #ifdef SW_ENABLE_DEPTH_TEST
+        {
+            zRow += dZdy;
+        }
+        #endif
+
+        #ifdef SW_ENABLE_TEXTURE
+        {
+            uRow += dUdy;
+            vRow += dVdy;
+        }
+        #endif
+    }
 }
 
-#endif // SW_RASTER_QUAD_STATES
+#endif // RLSW_TEMPLATE_RASTER_QUAD
 //-------------------------------------------------------------------------------------------
 
-// Line rasterization functions
+// Quad rasterization functions
 //-------------------------------------------------------------------------------------------
-#ifdef SW_RASTER_LINE_STATES
+#ifdef RLSW_TEMPLATE_RASTER_LINE
 
-#define SW_RASTER_LINE_FLAGS SW_FLAGS(SW_RASTER_LINE_STATES)
-#define SW_RASTER_LINE_THIN  SW_CONCATX(sw_raster_line_thin_, SW_NAME(SW_RASTER_LINE_STATES))
-#define SW_RASTER_LINE       SW_CONCATX(sw_raster_line_, SW_NAME(SW_RASTER_LINE_STATES))
+// Options:
+//  - RLSW_TEMPLATE_RASTER_LINE     -> Contains the suffix name
+//  - SW_ENABLE_DEPTH_TEST
+//  - SW_ENABLE_BLEND
 
-// Renders a single-pixel-wide line; internal building block for SW_RASTER_LINE
-static void SW_RASTER_LINE_THIN(const sw_vertex_t *v0, const sw_vertex_t *v1)
+#define SW_RASTER_LINE       SW_CONCATX(sw_raster_line_, RLSW_TEMPLATE_RASTER_LINE)
+#define SW_RASTER_LINE_THICK SW_CONCATX(sw_raster_line_thick_, RLSW_TEMPLATE_RASTER_LINE)
+
+static void SW_RASTER_LINE(const sw_vertex_t *v0, const sw_vertex_t *v1)
 {
     // Convert from pixel-center convention (n+0.5) to pixel-origin convention (n)
     float x0 = v0->position[0] - 0.5f;
@@ -5830,33 +5743,38 @@ static void SW_RASTER_LINE_THIN(const sw_vertex_t *v0, const sw_vertex_t *v1)
         substep = (dy >= 0.0f)? (1.0f - sw_fract(y0)) : sw_fract(y0);
     }
 
-    // Line setup, independent of pipeline state
-    float stepRcp = sw_rcp(steps);
-    float xInc = dx*stepRcp;
-    float yInc = dy*stepRcp;
-    int numPixels = (int)(steps - substep) + 1;
-    const int fbWidth = RLSW.colorBuffer->width;
-    uint8_t *cPixels = RLSW.colorBuffer->pixels;
-#if (SW_RASTER_LINE_FLAGS) & SW_STATE_DEPTH_TEST
-    uint8_t *dPixels = RLSW.depthBuffer->pixels;
+    // Compute per pixel increments
+    float xInc = dx/steps;
+    float yInc = dy/steps;
+    float stepRcp = 1.0f/steps;
+#ifdef SW_ENABLE_DEPTH_TEST
+    float zInc = (v1->position[2] - v0->position[2])*stepRcp;
 #endif
+    float rInc = (v1->color[0] - v0->color[0])*stepRcp;
+    float gInc = (v1->color[1] - v0->color[1])*stepRcp;
+    float bInc = (v1->color[2] - v0->color[2])*stepRcp;
+    float aInc = (v1->color[3] - v0->color[3])*stepRcp;
 
     // Initializing the interpolation starting values
     float x = x0 + xInc*substep;
     float y = y0 + yInc*substep;
-#if (SW_RASTER_LINE_FLAGS) & SW_STATE_DEPTH_TEST
-    float zInc = (v1->position[2] - v0->position[2])*stepRcp;
+#ifdef SW_ENABLE_DEPTH_TEST
     float z = v0->position[2] + zInc*substep;
 #endif
-#if (SW_RASTER_LINE_FLAGS) & SW_STATE_COLOR_INTERP
-    float cInc[4], color[4];
-    SW_VEC_OP(cInc[i] = (v1->color[i] - v0->color[i])*stepRcp, i, 4);
-    SW_VEC_OP(color[i] = v0->color[i] + cInc[i]*substep, i, 4);
-#else
-    // Flat: constant across the whole line, computed once for the whole loop
-    const float *srcColor = v0->color;
+    float r = v0->color[0] + rInc*substep;
+    float g = v0->color[1] + gInc*substep;
+    float b = v0->color[2] + bInc*substep;
+    float a = v0->color[3] + aInc*substep;
+
+    // Start line rasterization
+    const int fbWidth = RLSW.colorBuffer->width;
+    uint8_t *cPixels = RLSW.colorBuffer->pixels;
+#ifdef SW_ENABLE_DEPTH_TEST
+    uint8_t *dPixels = RLSW.depthBuffer->pixels;
 #endif
 
+    int numPixels = (int)(steps - substep) + 1;
+
     for (int i = 0; i < numPixels; i++)
     {
         int px = x;
@@ -5864,56 +5782,53 @@ static void SW_RASTER_LINE_THIN(const sw_vertex_t *v0, const sw_vertex_t *v1)
 
         int baseOffset = py*fbWidth + px;
         uint8_t *cPtr = cPixels + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE;
-    #if (SW_RASTER_LINE_FLAGS) & SW_STATE_DEPTH_TEST
+    #ifdef SW_ENABLE_DEPTH_TEST
         uint8_t *dPtr = dPixels + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE;
     #endif
 
-    #if (SW_RASTER_LINE_FLAGS) & SW_STATE_DEPTH_TEST
-        // TODO: Implement different depth funcs?
-        float depth = SW_FRAMEBUFFER_DEPTH_GET(dPtr, 0);
-        if (z <= depth)
+        #ifdef SW_ENABLE_DEPTH_TEST
         {
+            // TODO: Implement different depth funcs?
+            float depth = SW_FRAMEBUFFER_DEPTH_GET(dPtr, 0);
+            if (z > depth) goto discard;
+
             // TODO: Implement depth mask
             SW_FRAMEBUFFER_DEPTH_SET(dPtr, z, 0);
-    #endif
-
-        #if (SW_RASTER_LINE_FLAGS) & SW_STATE_COLOR_INTERP
-            const float *srcColor = color;
+        }
         #endif
 
-        #if (SW_RASTER_LINE_FLAGS) & SW_STATE_BLEND
+        float srcColor[4] = {r, g, b, a};
+
+        #ifdef SW_ENABLE_BLEND
+        {
             float dstColor[4];
             SW_FRAMEBUFFER_COLOR_GET(dstColor, cPtr, 0);
             RLSW.blendFunc(dstColor, srcColor);
             SW_FRAMEBUFFER_COLOR_SET(cPtr, dstColor, 0);
+        }
         #else
+        {
             SW_FRAMEBUFFER_COLOR_SET(cPtr, srcColor, 0);
+        }
         #endif
 
-    #if (SW_RASTER_LINE_FLAGS) & SW_STATE_DEPTH_TEST
-        }
-    #endif
-
-        // Advance unconditionally: depth test only guards the write above
+    discard:
         x += xInc;
         y += yInc;
-    #if (SW_RASTER_LINE_FLAGS) & SW_STATE_DEPTH_TEST
-        z += zInc;
-    #endif
-    #if (SW_RASTER_LINE_FLAGS) & SW_STATE_COLOR_INTERP
-        SW_VEC_OP(color[i] += cInc[i], i, 4);
-    #endif
+        #ifdef SW_ENABLE_DEPTH_TEST
+        {
+            z += zInc;
+        }
+        #endif
+        r += rInc;
+        g += gInc;
+        b += bInc;
+        a += aInc;
     }
 }
 
-static void SW_RASTER_LINE(const sw_vertex_t *v0, const sw_vertex_t *v1)
+static void SW_RASTER_LINE_THICK(const sw_vertex_t *v0, const sw_vertex_t *v1)
 {
-    if (RLSW.lineWidth < 2.0f)
-    {
-        SW_RASTER_LINE_THIN(v0, v1);
-        return;
-    }
-
     sw_vertex_t tv0, tv1;
 
     int x0 = (int)v0->position[0];
@@ -5924,7 +5839,7 @@ static void SW_RASTER_LINE(const sw_vertex_t *v0, const sw_vertex_t *v1)
     int dx = x1 - x0;
     int dy = y1 - y0;
 
-    SW_RASTER_LINE_THIN(v0, v1);
+    SW_RASTER_LINE(v0, v1);
 
     if ((dx != 0) && (abs(dy/dx) < 1))
     {
@@ -5935,11 +5850,11 @@ static void SW_RASTER_LINE(const sw_vertex_t *v0, const sw_vertex_t *v1)
             tv0 = *v0, tv1 = *v1;
             tv0.position[1] -= i;
             tv1.position[1] -= i;
-            SW_RASTER_LINE_THIN(&tv0, &tv1);
+            SW_RASTER_LINE(&tv0, &tv1);
             tv0 = *v0, tv1 = *v1;
             tv0.position[1] += i;
             tv1.position[1] += i;
-            SW_RASTER_LINE_THIN(&tv0, &tv1);
+            SW_RASTER_LINE(&tv0, &tv1);
         }
     }
     else if (dy != 0)
@@ -5951,31 +5866,35 @@ static void SW_RASTER_LINE(const sw_vertex_t *v0, const sw_vertex_t *v1)
             tv0 = *v0, tv1 = *v1;
             tv0.position[0] -= i;
             tv1.position[0] -= i;
-            SW_RASTER_LINE_THIN(&tv0, &tv1);
+            SW_RASTER_LINE(&tv0, &tv1);
             tv0 = *v0, tv1 = *v1;
             tv0.position[0] += i;
             tv1.position[0] += i;
-            SW_RASTER_LINE_THIN(&tv0, &tv1);
+            SW_RASTER_LINE(&tv0, &tv1);
         }
     }
 }
 
-#endif // SW_RASTER_LINE_STATES
+#endif // RLSW_TEMPLATE_RASTER_LINE
 //-------------------------------------------------------------------------------------------
 
 // Point rasterization functions
 //-------------------------------------------------------------------------------------------
-#ifdef SW_RASTER_POINT_STATES
+#ifdef RLSW_TEMPLATE_RASTER_POINT
 
-#define SW_RASTER_POINT_FLAGS SW_FLAGS(SW_RASTER_POINT_STATES)
-#define SW_RASTER_POINT_PIXEL SW_CONCATX(sw_raster_point_pixel_, SW_NAME(SW_RASTER_POINT_STATES))
-#define SW_RASTER_POINT       SW_CONCATX(sw_raster_point_, SW_NAME(SW_RASTER_POINT_STATES))
+// Options:
+//  - RLSW_TEMPLATE_RASTER_POINT    -> Contains the suffix name
+//  - SW_ENABLE_DEPTH_TEST
+//  - SW_ENABLE_BLEND
+
+#define SW_RASTER_POINT_PIXEL SW_CONCATX(sw_raster_point_pixel_, RLSW_TEMPLATE_RASTER_POINT)
+#define SW_RASTER_POINT       SW_CONCATX(sw_raster_point_, RLSW_TEMPLATE_RASTER_POINT)
 
 static void SW_RASTER_POINT_PIXEL(int x, int y, float z, const float color[4])
 {
     int offset = y*RLSW.colorBuffer->width + x;
 
-    #if (SW_RASTER_POINT_FLAGS) & SW_STATE_DEPTH_TEST
+    #ifdef SW_ENABLE_DEPTH_TEST
     {
         uint8_t *dPtr = (uint8_t *)(RLSW.depthBuffer->pixels) + offset*SW_FRAMEBUFFER_DEPTH_SIZE;
 
@@ -5990,7 +5909,7 @@ static void SW_RASTER_POINT_PIXEL(int x, int y, float z, const float color[4])
 
     uint8_t *cPtr = (uint8_t *)(RLSW.colorBuffer->pixels) + offset*SW_FRAMEBUFFER_COLOR_SIZE;
 
-    #if (SW_RASTER_POINT_FLAGS) & SW_STATE_BLEND
+    #ifdef SW_ENABLE_BLEND
     {
         float dstColor[4];
         SW_FRAMEBUFFER_COLOR_GET(dstColor, cPtr, 0);
@@ -6021,5 +5940,5 @@ static void SW_RASTER_POINT(const sw_vertex_t *v)
     }
 }
 
-#endif // SW_RASTER_POINT_STATES
+#endif // RLSW_TEMPLATE_RASTER_POINT
 //-------------------------------------------------------------------------------------------
diff --git a/src/libraries/raylib/raylib/src/external/rprand.h b/src/libraries/raylib/raylib/src/external/rprand.h
index b713954..cdef03c 100644
--- a/src/libraries/raylib/raylib/src/external/rprand.h
+++ b/src/libraries/raylib/raylib/src/external/rprand.h
@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   rprand v1.1 - A simple and easy-to-use pseudo-random numbers generator (PRNG)
+*   rprand v1.0 - A simple and easy-to-use pseudo-random numbers generator (PRNG)
 *
 *   FEATURES:
 *       - Pseudo-random values generation, 32 bits: [0..4294967295]
@@ -118,7 +118,6 @@ extern "C" {                // Prevents name mangling of functions
 //----------------------------------------------------------------------------------
 RPRANDAPI void rprand_set_seed(unsigned long long seed);        // Set rprand_state for Xoshiro128**, seed is 64bit
 RPRANDAPI int rprand_get_value(int min, int max);               // Get random value within a range, min and max included
-RPRANDAPI int rprand_get_value_raw(void);                       // Get random value, Xoshiro128** generator (uses global rprand_state)
 
 RPRANDAPI int *rprand_load_sequence(unsigned int count, int min, int max); // Load pseudo-random numbers sequence with no duplicates
 RPRANDAPI void rprand_unload_sequence(int *sequence);           // Unload pseudo-random numbers sequence
@@ -187,13 +186,6 @@ int rprand_get_value(int min, int max)
     return value;
 }
 
-int rprand_get_value_raw(void)
-{
-    int value = rprand_xoshiro();
-
-    return value;
-}
-
 // Load pseudo-random numbers sequence with no duplicates, min and max included
 int *rprand_load_sequence(unsigned int count, int min, int max)
 {
diff --git a/src/libraries/raylib/raylib/src/external/tinyobj_loader_c.h b/src/libraries/raylib/raylib/src/external/tinyobj_loader_c.h
index 8d077d6..88b2acb 100644
--- a/src/libraries/raylib/raylib/src/external/tinyobj_loader_c.h
+++ b/src/libraries/raylib/raylib/src/external/tinyobj_loader_c.h
@@ -1020,12 +1020,7 @@ static int parseLine(Command *command, const char *p, unsigned int p_len,
                      int triangulate) {
   char linebuf[4096];
   const char *token;
-  
-  // @raysan5: 
-  // WARNING: If -DNDEBUG is set when compiling, assertions will not 
-  // be present in the compiled binary, replacing by a runtime check
-  //assert(p_len < 4095);
-  if (p_len > 4095) return 0;
+  assert(p_len < 4095);
 
   memcpy(linebuf, p, p_len);
   linebuf[p_len] = '\0';
@@ -1107,12 +1102,8 @@ static int parseLine(Command *command, const char *p, unsigned int p_len,
       tinyobj_vertex_index_t i1;
       tinyobj_vertex_index_t i2 = f[1];
 
-      // @raysan5: 
-      // WARNING: If -DNDEBUG is set when compiling, assertions will not 
-      // be present in the compiled binary, replacing by a runtime check
-      //assert(3 * num_f < TINYOBJ_MAX_FACES_PER_F_LINE);
-      if (3*num_f > TINYOBJ_MAX_FACES_PER_F_LINE) return 0;
-      
+      assert(3 * num_f < TINYOBJ_MAX_FACES_PER_F_LINE);
+
       for (k = 2; k < num_f; k++) {
         i1 = i2;
         i2 = f[k];
@@ -1128,13 +1119,7 @@ static int parseLine(Command *command, const char *p, unsigned int p_len,
 
     } else {
       unsigned int k = 0;
-      
-      // @raysan5: 
-      // WARNING: If -DNDEBUG is set when compiling, assertions will not 
-      // be present in the compiled binary, replacing by a runtime check
-      //assert(num_f < TINYOBJ_MAX_FACES_PER_F_LINE);
-      if (num_f > TINYOBJ_MAX_FACES_PER_F_LINE) return 0;     
-      
+      assert(num_f < TINYOBJ_MAX_FACES_PER_F_LINE);
       for (k = 0; k < num_f; k++) {
         command->f[k] = f[k];
       }
diff --git a/src/libraries/raylib/raylib/src/external/win32_clipboard.h b/src/libraries/raylib/raylib/src/external/win32_clipboard.h
index ea0a34b..5c30fbd 100644
--- a/src/libraries/raylib/raylib/src/external/win32_clipboard.h
+++ b/src/libraries/raylib/raylib/src/external/win32_clipboard.h
@@ -4,14 +4,14 @@
 
 #ifndef WIN32_CLIPBOARD_
 #define WIN32_CLIPBOARD_
-unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned int *dataSize);
+unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned long long int *dataSize);
 #endif // WIN32_CLIPBOARD_
 
 #ifdef WIN32_CLIPBOARD_IMPLEMENTATION
 #include <stdio.h>
 #include <stdbool.h>
 #include <stdlib.h>
-#include <limits.h>
+#include <assert.h>
 
 // NOTE: These search for architecture is taken from "windows.h", and it's necessary to avoid including windows.h
 // and still make it compile on msvc, because import indirectly importing "winnt.h" (e.g. <minwindef.h>) can cause problems is these are not defined
@@ -213,7 +213,7 @@ static int GetPixelDataOffset(BITMAPINFOHEADER bih); // Get pixel data offset fr
 //----------------------------------------------------------------------------------
 // Module Functions Definition
 //----------------------------------------------------------------------------------
-unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned int *dataSize)
+unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned long long int *dataSize)
 {
     unsigned char *bmpData = NULL;
 
@@ -228,7 +228,7 @@ unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned int
                 *width = bmpInfoHeader->biWidth;
                 *height = bmpInfoHeader->biHeight;
                 SIZE_T clipDataSize = GlobalSize(clipHandle);
-                if ((clipDataSize >= sizeof(BITMAPINFOHEADER)) && (clipDataSize < INT_MAX))
+                if (clipDataSize >= sizeof(BITMAPINFOHEADER))
                 {
                     int pixelOffset = GetPixelDataOffset(*bmpInfoHeader);
 
@@ -236,7 +236,7 @@ unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned int
                     //------------------------------------------------------------------------
                     BITMAPFILEHEADER bmpFileHeader = { 0 };
                     SIZE_T bmpFileSize = sizeof(bmpFileHeader) + clipDataSize;
-                    *dataSize = (unsigned int)bmpFileSize;
+                    *dataSize = bmpFileSize;
 
                     bmpFileHeader.bfType = 0x4D42; // BMP fil type constant
                     bmpFileHeader.bfSize = (DWORD)bmpFileSize; // Up to 4GB works fine
@@ -254,7 +254,7 @@ unsigned char *Win32GetClipboardImageData(int *width, int *height, unsigned int
                 }
                 else
                 {
-                    TRACELOG(LOG_WARNING, "Clipboard data is not supported (>2GB?)");
+                    TRACELOG(LOG_WARNING, "Clipboard data is malformed");
                     GlobalUnlock(clipHandle);
                     CloseClipboard();
                 }
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_android.c b/src/libraries/raylib/raylib/src/platforms/rcore_android.c
index 2851658..f501fba 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_android.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_android.c
@@ -473,7 +473,8 @@ void SetWindowFocused(void)
 // Get native window handle
 void *GetWindowHandle(void)
 {
-    return (void *)platform.app->window; // Type: ANativeWindow*
+    TRACELOG(LOG_WARNING, "GetWindowHandle() not implemented on target platform");
+    return NULL;
 }
 
 // Get number of monitors
@@ -615,13 +616,13 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     // Set cursor position in the middle
@@ -655,30 +656,21 @@ double GetTime(void)
     double time = 0.0;
     struct timespec ts = { 0 };
     clock_gettime(CLOCK_MONOTONIC, &ts);
-    unsigned long long nanoSeconds = (unsigned long long)ts.tv_sec*1000000000LLU + (unsigned long long)ts.tv_nsec;
+    unsigned long long int nanoSeconds = (unsigned long long int)ts.tv_sec*1000000000LLU + (unsigned long long int)ts.tv_nsec;
 
-    time = (double)(nanoSeconds - CORE.Time.base)*1e-9; // Elapsed time since InitTimer()
+    time = (double)(nanoSeconds - CORE.Time.base)*1e-9;  // Elapsed time since InitTimer()
 
     return time;
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if the provided URL is safe
+// A user could craft a malicious string performing another action
+// Avoid calling this function with user input non-validated strings
 void OpenURL(const char *url)
 {
     // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else
     {
         JNIEnv *env = NULL;
@@ -726,6 +718,7 @@ void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float d
 void SetMousePosition(int x, int y)
 {
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 }
 
 // Set mouse cursor
@@ -757,12 +750,12 @@ void PollInputEvents(void)
     for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) CORE.Input.Keyboard.keyRepeatInFrame[i] = 0;
 
     // Reset last gamepad button/axis registered state
-    CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
+    CORE.Input.Gamepad.lastButtonPressed = 0;       // GAMEPAD_BUTTON_UNKNOWN
     //CORE.Input.Gamepad.axisCount = 0;
 
     for (int i = 0; i < MAX_GAMEPADS; i++)
     {
-        if (CORE.Input.Gamepad.ready[i]) // Check if gamepad is available
+        if (CORE.Input.Gamepad.ready[i])     // Check if gamepad is available
         {
             // Register previous gamepad states
             for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++)
@@ -801,7 +794,6 @@ void PollInputEvents(void)
         if (platform.app->destroyRequested != 0)
         {
             CORE.Window.shouldClose = true;
-            break;
         }
     }
 }
@@ -1281,28 +1273,27 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event)
         int32_t keycode = AKeyEvent_getKeyCode(event);
         //int32_t AKeyEvent_getMetaState(event);
 
-        // Handle gamepad button presses and releases. AOSP stamps the
-        // KEYBOARD source bit on every key event from a gamepad, so
-        // discriminate on the keycode rather than gating on source bits.
-        if (FLAG_IS_SET(source, AINPUT_SOURCE_JOYSTICK) ||
-            FLAG_IS_SET(source, AINPUT_SOURCE_GAMEPAD))
+        // Handle gamepad button presses and releases
+        // NOTE: Skip gamepad handling if this is a keyboard event, as some devices
+        // report both AINPUT_SOURCE_KEYBOARD and AINPUT_SOURCE_GAMEPAD flags
+        if ((FLAG_IS_SET(source, AINPUT_SOURCE_JOYSTICK) ||
+             FLAG_IS_SET(source, AINPUT_SOURCE_GAMEPAD)) &&
+            !FLAG_IS_SET(source, AINPUT_SOURCE_KEYBOARD))
         {
+            // Assuming a single gamepad, "detected" on its input event
+            CORE.Input.Gamepad.ready[0] = true;
+
             GamepadButton button = AndroidTranslateGamepadButton(keycode);
 
-            if (button != GAMEPAD_BUTTON_UNKNOWN)
+            if (button == GAMEPAD_BUTTON_UNKNOWN) return 1;
+
+            if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN)
             {
-                // Assuming a single gamepad, "detected" on its input event
-                CORE.Input.Gamepad.ready[0] = true;
-
-                if (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN)
-                {
-                    CORE.Input.Gamepad.currentButtonState[0][button] = 1;
-                }
-                else CORE.Input.Gamepad.currentButtonState[0][button] = 0;  // Key up
-
-                return 1; // Handled gamepad button
+                CORE.Input.Gamepad.currentButtonState[0][button] = 1;
             }
-            // Unknown keycode: fall through to the keyboard handler below.
+            else CORE.Input.Gamepad.currentButtonState[0][button] = 0;  // Key up
+
+            return 1; // Handled gamepad button
         }
 
         KeyboardKey key = ((keycode > 0) && (keycode < KEYCODE_MAP_SIZE))? mapKeycode[keycode] : KEY_NULL;
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_glfw.c b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_glfw.c
index 7958201..9b6881d 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_glfw.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_glfw.c
@@ -111,12 +111,6 @@
 //----------------------------------------------------------------------------------
 typedef struct {
     GLFWwindow *handle;                 // GLFW window handle (graphic device)
-#if defined(__linux__) && defined(_GLFW_X11)
-    // Local storage for the window handle returned by glfwGetX11Window
-    // This is needed as X11 handles are integers and may not fit inside a pointer depending on platform
-    // Storing the handle locally and returning a pointer in GetWindowHandle allows the code to work regardless of pointer width
-    Window windowHandleX11;             // Underlying type: unsigned long (XID, Window)
-#endif
 } PlatformData;
 
 //----------------------------------------------------------------------------------
@@ -151,7 +145,7 @@ static void CharCallback(GLFWwindow *window, unsigned int codepoint);
 static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods);  // GLFW3 Mouse Button Callback, runs on mouse button pressed
 static void MouseCursorPosCallback(GLFWwindow *window, double x, double y);             // GLFW3 Cursor Position Callback, runs on mouse move
 static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset);    // GLFW3 Scrolling Callback, runs on mouse wheel
-static void CursorEnterCallback(GLFWwindow *window, int entered);                       // GLFW3 Cursor Enter Callback, cursor enters client area
+static void CursorEnterCallback(GLFWwindow *window, int enter);                         // GLFW3 Cursor Enter Callback, cursor enters client area
 static void JoystickCallback(int jid, int event);                                       // GLFW3 Joystick Connected/Disconnected Callback
 
 // Memory allocator wrappers [used by glfwInitAllocator()]
@@ -287,14 +281,8 @@ void ToggleBorderlessWindowed(void)
                 CORE.Window.screen.height = mode->height;
 
                 // Set screen position and size
-            #if defined(_WIN32)
-                // NOTE: To prevent the fullscreen window from always staying on top, don't pass a monitor at this point.
-                glfwSetWindowMonitor(platform.handle, NULL, CORE.Window.position.x, CORE.Window.position.y,
-                    CORE.Window.screen.width, CORE.Window.screen.height, mode->refreshRate);
-            #else
                 glfwSetWindowMonitor(platform.handle, monitors[monitor], CORE.Window.position.x, CORE.Window.position.y,
                     CORE.Window.screen.width, CORE.Window.screen.height, mode->refreshRate);
-            #endif
 
                 // Refocus window
                 glfwFocusWindow(platform.handle);
@@ -767,13 +755,18 @@ void SetWindowFocused(void)
     glfwFocusWindow(platform.handle);
 }
 
+#if defined(__linux__) && defined(_GLFW_X11)
+// Local storage for the window handle returned by glfwGetX11Window
+// This is needed as X11 handles are integers and may not fit inside a pointer depending on platform
+// Storing the handle locally and returning a pointer in GetWindowHandle allows the code to work regardless of pointer width
+static XID X11WindowHandle;
+#endif
 // Get native window handle
 void *GetWindowHandle(void)
 {
-    void *handle = NULL;
-
 #if defined(_WIN32)
-    handle = glfwGetWin32Window(platform.handle); // Type: HWND
+    // NOTE: Returned handle is: void *HWND (windows.h)
+    return glfwGetWin32Window(platform.handle);
 #endif
 #if defined(__linux__)
     #if defined(_GLFW_WAYLAND)
@@ -781,27 +774,29 @@ void *GetWindowHandle(void)
             int platformID = glfwGetPlatform();
             if (platformID == GLFW_PLATFORM_WAYLAND)
             {
-                handle = (void *)glfwGetWaylandWindow(platform.handle); // Type: struct wl_surface*
+                return glfwGetWaylandWindow(platform.handle);
             }
             else
             {
-                platform.windowHandleX11 = glfwGetX11Window(platform.handle); // Type: Window (unsigned long)
-                handle = &platform.windowHandleX11;
+                X11WindowHandle = glfwGetX11Window(platform.handle);
+                return &X11WindowHandle;
             }
         #else
-            handle = (void *)glfwGetWaylandWindow(platform.handle);
+            return glfwGetWaylandWindow(platform.handle);
         #endif
     #elif defined(_GLFW_X11)
-        // Store the window handle locally and return a pointer to the variable instead
-        platform.windowHandleX11 = glfwGetX11Window(platform.handle);
-        handle = &platform.windowHandleX11;
+        // Store the window handle localy and return a pointer to the variable instead
+        // Reasoning detailed in the declaration of X11WindowHandle
+        X11WindowHandle = glfwGetX11Window(platform.handle);
+        return &X11WindowHandle;
     #endif
 #endif
 #if defined(__APPLE__)
-    handle = (void *)glfwGetCocoaWindow(platform.handle); // Type: NSWindow*
+    // NOTE: Returned handle is: (objc_object *)
+    return (void *)glfwGetCocoaWindow(platform.handle);
 #endif
 
-    return handle;
+    return NULL;
 }
 
 // Get number of monitors
@@ -845,7 +840,7 @@ int GetCurrentMonitor(void)
             // this is probably an overengineered solution for a side case
             // trying to match SDL behaviour
 
-            unsigned int closestDist = 0xFFFFFFFFu;
+            int closestDist = 0x7FFFFFFF;
 
             // Window center position
             int wcx = 0;
@@ -889,14 +884,7 @@ int GetCurrentMonitor(void)
 
                     int dx = wcx - xclosest;
                     int dy = wcy - yclosest;
-
-                    // Unsigned to dodge signed overflow UB; (-x)^2 == x^2 mod 2^32 so sign drops out.
-                    // If |dx| or |dy| >= 65536, dist wraps and the wrong monitor may win.
-                    // Not a concern for realistic monitor layouts.
-                    unsigned int ux = (unsigned int)dx;
-                    unsigned int uy = (unsigned int)dy;
-                    unsigned int dist = ux*ux + uy*uy;
-
+                    int dist = (dx*dx) + (dy*dy);
                     if (dist < closestDist)
                     {
                         index = i;
@@ -1030,8 +1018,6 @@ const char *GetMonitorName(int monitor)
 // Get window position XY on monitor
 Vector2 GetWindowPosition(void)
 {
-    glfwGetWindowPos(platform.handle, &CORE.Window.position.x, &CORE.Window.position.y);
-
     return (Vector2){ (float)CORE.Window.position.x, (float)CORE.Window.position.y };
 }
 
@@ -1057,6 +1043,11 @@ const char *GetClipboardText(void)
     return glfwGetClipboardString(platform.handle);
 }
 
+#if SUPPORT_CLIPBOARD_IMAGE && defined(__linux__) && defined(_GLFW_X11)
+    #include <X11/Xlib.h>
+    #include <X11/Xatom.h>
+#endif
+
 // Get clipboard image
 Image GetClipboardImage(void)
 {
@@ -1064,47 +1055,43 @@ Image GetClipboardImage(void)
 
 #if SUPPORT_CLIPBOARD_IMAGE && SUPPORT_MODULE_RTEXTURES
 #if defined(_WIN32)
-
-    unsigned int dataSize = 0;
+    unsigned long long int dataSize = 0;
     void *bmpData = NULL;
     int width = 0;
     int height = 0;
 
-    bmpData = (void *)Win32GetClipboardImageData(&width, &height, &dataSize);
+    bmpData  = (void *)Win32GetClipboardImageData(&width, &height, &dataSize);
 
     if (bmpData == NULL) TRACELOG(LOG_WARNING, "Clipboard image: Couldn't get clipboard data.");
-    else
-    {
-        image = LoadImageFromMemory(".bmp", (const unsigned char *)bmpData, (int)dataSize);
-
-        RL_FREE(bmpData);
-    }
+    else image = LoadImageFromMemory(".bmp", (const unsigned char *)bmpData, (int)dataSize);
 
 #elif defined(__linux__) && defined(_GLFW_X11)
+
     // REF: https://github.com/ColleagueRiley/Clipboard-Copy-Paste/blob/main/x11.c
+    Display *dpy = XOpenDisplay(NULL);
+    if (!dpy) return image;
 
-    static Atom clipboard = 0;
-    static Atom targetType = 0;
-    static Atom property = 0;
+    Window root = DefaultRootWindow(dpy);
+    Window win = XCreateSimpleWindow(
+        dpy,      // The connection to the X Server
+        root,     // The 'Parent' window (usually the desktop/root)
+        0, 0,     // X and Y position on the screen
+        1, 1,     // Width and Height (1x1 pixel)
+        0,        // Border width
+        0,        // Border color
+        0         // Background color
+    );
 
-    Display *display = glfwGetX11Display();
-    XID window = glfwGetX11Window(platform.handle);
+    Atom clipboard = XInternAtom(dpy, "CLIPBOARD", False);
+    Atom targetType = XInternAtom(dpy, "image/png", False); // Ask for PNG
+    Atom property = XInternAtom(dpy, "RAYLIB_CLIPBOARD_MANAGER", False);
 
-    // Lazy-load X11 atoms
-    if (clipboard == 0)
-    {
-        clipboard = XInternAtom(display, "CLIPBOARD", False);
-        targetType = XInternAtom(display, "image/png", False);
-        property = XInternAtom(display, "RAYLIB_CLIPBOARD_MANAGER", False);
-    }
-
-    XConvertSelection(display, clipboard, targetType, property, window, CurrentTime);
-    XSync(display, 0);
+    // Request the data: "Convert whatever is in CLIPBOARD to image/png and put it in RAYLIB_CLIPBOARD_MANAGER"
+    XConvertSelection(dpy, clipboard, targetType, property, win, CurrentTime);
 
+    // Wait for the SelectionNotify event
     XEvent ev = { 0 };
-
-    // Keep calling until we get SelectionNotify
-    while (XCheckTypedEvent(display, SelectionNotify, &ev) == False);
+    XNextEvent(dpy, &ev);
 
     Atom actualType = { 0 };
     int actualFormat = 0;
@@ -1112,8 +1099,9 @@ Image GetClipboardImage(void)
     unsigned long bytesAfter = 0;
     unsigned char *data = NULL;
 
-    XGetWindowProperty(display, window, property, 0, ~0L, False, AnyPropertyType,
-                       &actualType, &actualFormat, &nitems, &bytesAfter, &data);
+    // Read the data from our ghost window's property
+    XGetWindowProperty(dpy, win, property, 0, ~0L, False, AnyPropertyType,
+        &actualType, &actualFormat, &nitems, &bytesAfter, &data);
 
     if (data != NULL)
     {
@@ -1121,9 +1109,11 @@ Image GetClipboardImage(void)
         XFree(data);
     }
 
+    XDestroyWindow(dpy, win);
+    XCloseDisplay(dpy);
 #else
     TRACELOG(LOG_WARNING, "GetClipboardImage() not implemented on target platform");
-#endif // _WIN32
+#endif // defined(_WIN32)
 #else
     TRACELOG(LOG_WARNING, "Clipboard image: SUPPORT_CLIPBOARD_IMAGE requires SUPPORT_MODULE_RTEXTURES to work properly");
 #endif // SUPPORT_CLIPBOARD_IMAGE
@@ -1139,7 +1129,7 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
@@ -1147,7 +1137,7 @@ void HideCursor(void)
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
@@ -1161,7 +1151,7 @@ void EnableCursor(void)
     CORE.Input.Mouse.cursorLocked = false;
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     // Reset mouse position within the window area before disabling cursor
@@ -1194,25 +1184,17 @@ double GetTime(void)
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if you control the URL given
+// A user could craft a malicious string performing another action
+// Only call this function yourself not with user input or make sure to check the string yourself
+// REF: https://github.com/raysan5/raylib/issues/686
 void OpenURL(const char *url)
 {
     // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else
     {
-        char *cmd = (char *)RL_CALLOC(strlen(url) + 16, sizeof(char));
+        char *cmd = (char *)RL_CALLOC(strlen(url) + 32, sizeof(char));
 #if defined(_WIN32)
         sprintf(cmd, "explorer \"%s\"", url);
 #endif
@@ -1222,9 +1204,7 @@ void OpenURL(const char *url)
 #if defined(__APPLE__)
         sprintf(cmd, "open '%s'", url);
 #endif
-        // TODO: Replace system() call by custom process
         int result = system(cmd);
-
         if (result == -1) TRACELOG(LOG_WARNING, "OpenURL() child process could not be created");
         RL_FREE(cmd);
     }
@@ -1250,6 +1230,7 @@ void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float d
 void SetMousePosition(int x, int y)
 {
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 
     // NOTE: emscripten not implemented
     glfwSetCursorPos(platform.handle, CORE.Input.Mouse.currentPosition.x, CORE.Input.Mouse.currentPosition.y);
@@ -1338,7 +1319,7 @@ void PollInputEvents(void)
             // Register previous gamepad states
             for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) CORE.Input.Gamepad.previousButtonState[i][k] = CORE.Input.Gamepad.currentButtonState[i][k];
 
-            // Get current gamepad state using internal GLFW mapping, instead of the immediate joystick API
+            // Get current gamepad state
             // NOTE: There is no callback available, getting it manually
             GLFWgamepadstate state = { 0 };
             int result = glfwGetGamepadState(i, &state); // This remaps all gamepads so they have their buttons mapped like an xbox controller
@@ -1353,7 +1334,7 @@ void PollInputEvents(void)
 
             for (int k = 0; (buttons != NULL) && (k < MAX_GAMEPAD_BUTTONS); k++)
             {
-                int button = -1; // GamepadButton enum values assigned
+                int button = -1;        // GamepadButton enum values assigned
 
                 switch (k)
                 {
@@ -1379,7 +1360,7 @@ void PollInputEvents(void)
                     default: break;
                 }
 
-                if (button != -1) // Check for valid button
+                if (button != -1)   // Check for valid button
                 {
                     if (buttons[k] == GLFW_PRESS)
                     {
@@ -1421,10 +1402,10 @@ void PollInputEvents(void)
     if ((CORE.Window.eventWaiting) ||
         (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) && !FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN)))
     {
-        glfwWaitEvents(); // Wait for in input events before continue (drawing is paused)
+        glfwWaitEvents();     // Wait for in input events before continue (drawing is paused)
         CORE.Time.previous = GetTime();
     }
-    else glfwPollEvents(); // Poll input events: keyboard/mouse/window events (callbacks) -> Update keys state
+    else glfwPollEvents();      // Poll input events: keyboard/mouse/window events (callbacks) -> Update keys state
 
     CORE.Window.shouldClose = glfwWindowShouldClose(platform.handle);
 
@@ -1705,14 +1686,6 @@ int InitPlatform(void)
             return -1;
         }
 
-#if defined(__APPLE__)
-        // AppKit can constrain the requested window size to the visible work area during creation
-        int windowWidth = 0;
-        int windowHeight = 0;
-        glfwGetWindowSize(platform.handle, &windowWidth, &windowHeight);
-        if ((windowWidth > 0) && (windowHeight > 0)) CORE.Window.screen = (Size){ windowWidth, windowHeight };
-#endif
-
         // NOTE: Not considering scale factor now, considered below
         CORE.Window.render.width = CORE.Window.screen.width;
         CORE.Window.render.height = CORE.Window.screen.height;
@@ -1859,7 +1832,7 @@ int InitPlatform(void)
         {
           CORE.Input.Gamepad.ready[i] = true;
           CORE.Input.Gamepad.axisCount[i] = GLFW_GAMEPAD_AXIS_LAST + 1;
-          snprintf(CORE.Input.Gamepad.name[i], MAX_GAMEPAD_NAME_LENGTH, "%s", glfwGetJoystickName(i));
+          strncpy(CORE.Input.Gamepad.name[i], glfwGetJoystickName(i), MAX_GAMEPAD_NAME_LENGTH - 1);
         }
     }
     //----------------------------------------------------------------------------
@@ -2074,7 +2047,7 @@ static void WindowDropCallback(GLFWwindow *window, int count, const char **paths
         for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++)
         {
             CORE.Window.dropFilepaths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
-            snprintf(CORE.Window.dropFilepaths[i], MAX_FILEPATH_LENGTH, "%s", paths[i]);
+            strncpy(CORE.Window.dropFilepaths[i], paths[i], MAX_FILEPATH_LENGTH - 1);
         }
     }
 }
@@ -2197,18 +2170,10 @@ static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffs
 }
 
 // GLFW3: Cursor ennter callback, when cursor enters the window
-static void CursorEnterCallback(GLFWwindow *window, int entered)
+static void CursorEnterCallback(GLFWwindow *window, int enter)
 {
-    if (entered)
-    {
-        // NOTE: Mouse position updated by MouseCursorPosCallback()
-        CORE.Input.Mouse.cursorOnScreen = true;
-    }
-    else
-    {
-        CORE.Input.Mouse.cursorOnScreen = false;
-        CORE.Input.Mouse.currentPosition = (Vector2){ 0 };
-    }
+    if (enter) CORE.Input.Mouse.cursorOnScreen = true;
+    else CORE.Input.Mouse.cursorOnScreen = false;
 }
 
 // GLFW3: Joystick connected/disconnected callback
@@ -2221,7 +2186,7 @@ static void JoystickCallback(int jid, int event)
             // WARNING: If glfwGetJoystickName() is longer than MAX_GAMEPAD_NAME_LENGTH,
             // only copy up to (MAX_GAMEPAD_NAME_LENGTH -1) to destination string
             memset(CORE.Input.Gamepad.name[jid], 0, MAX_GAMEPAD_NAME_LENGTH);
-            snprintf(CORE.Input.Gamepad.name[jid], MAX_GAMEPAD_NAME_LENGTH, "%s", glfwGetJoystickName(jid));
+            strncpy(CORE.Input.Gamepad.name[jid], glfwGetJoystickName(jid), MAX_GAMEPAD_NAME_LENGTH - 1);
         }
         else if (event == GLFW_DISCONNECTED)
         {
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_rgfw.c b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_rgfw.c
index ceacf53..1a4831b 100755
--- a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_rgfw.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_rgfw.c
@@ -76,7 +76,7 @@
 
 void ShowCursor(void);
 void CloseWindow(void);
-double GetTimeSeconds(void);
+double get_time_seconds(void);
 
 #if defined(__unix__) || defined(__linux__)
     #define _XTYPEDEF_FONT
@@ -178,15 +178,12 @@ typedef struct {
     RGFW_monitor *monitor;
     mg_gamepads minigamepad;
 
-#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
-    RGFW_surface *surface;
-    u8 *surfacePixels;
-    i32 surfaceWidth;
-    i32 surfaceHeight;
-#endif
-#if defined(__linux__) && defined(RGFW_X11)
-    Window windowHandleX11;             // Underlying type: unsigned long
-#endif
+    #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+        RGFW_surface *surface;
+        u8 *surfacePixels;
+        i32 surfaceWidth;
+        i32 surfaceHeight;
+    #endif
 } PlatformData;
 
 //----------------------------------------------------------------------------------
@@ -310,113 +307,113 @@ static PlatformData platform = { 0 };   // Platform specific
 
 static const unsigned short RGFW_keyConvertTable[] = {
     [RGFW_keyNULL] = KEY_NULL,
-    [RGFW_keyApostrophe] = KEY_APOSTROPHE,
-    [RGFW_keyComma] = KEY_COMMA,
-    [RGFW_keyMinus] = KEY_MINUS,
-    [RGFW_keyPeriod] = KEY_PERIOD,
-    [RGFW_keySlash] = KEY_SLASH,
-    [RGFW_key0] = KEY_ZERO,
-    [RGFW_key1] = KEY_ONE,
-    [RGFW_key2] = KEY_TWO,
-    [RGFW_key3] = KEY_THREE,
-    [RGFW_key4] = KEY_FOUR,
-    [RGFW_key5] = KEY_FIVE,
-    [RGFW_key6] = KEY_SIX,
-    [RGFW_key7] = KEY_SEVEN,
-    [RGFW_key8] = KEY_EIGHT,
-    [RGFW_key9] = KEY_NINE,
-    [RGFW_keySemicolon] = KEY_SEMICOLON,
-    [RGFW_keyEquals] = KEY_EQUAL,
-    [RGFW_keyA] = KEY_A,
-    [RGFW_keyB] = KEY_B,
-    [RGFW_keyC] = KEY_C,
-    [RGFW_keyD] = KEY_D,
-    [RGFW_keyE] = KEY_E,
-    [RGFW_keyF] = KEY_F,
-    [RGFW_keyG] = KEY_G,
-    [RGFW_keyH] = KEY_H,
-    [RGFW_keyI] = KEY_I,
-    [RGFW_keyJ] = KEY_J,
-    [RGFW_keyK] = KEY_K,
-    [RGFW_keyL] = KEY_L,
-    [RGFW_keyM] = KEY_M,
-    [RGFW_keyN] = KEY_N,
-    [RGFW_keyO] = KEY_O,
-    [RGFW_keyP] = KEY_P,
-    [RGFW_keyQ] = KEY_Q,
-    [RGFW_keyR] = KEY_R,
-    [RGFW_keyS] = KEY_S,
-    [RGFW_keyT] = KEY_T,
-    [RGFW_keyU] = KEY_U,
-    [RGFW_keyV] = KEY_V,
-    [RGFW_keyW] = KEY_W,
-    [RGFW_keyX] = KEY_X,
-    [RGFW_keyY] = KEY_Y,
-    [RGFW_keyZ] = KEY_Z,
-    [RGFW_keyBracket] = KEY_LEFT_BRACKET,
-    [RGFW_keyBackSlash] = KEY_BACKSLASH,
-    [RGFW_keyCloseBracket] = KEY_RIGHT_BRACKET,
-    [RGFW_keyBacktick] = KEY_GRAVE,
-    [RGFW_keySpace] = KEY_SPACE,
-    [RGFW_keyEscape] = KEY_ESCAPE,
-    [RGFW_keyReturn] = KEY_ENTER,
-    [RGFW_keyTab] = KEY_TAB,
-    [RGFW_keyBackSpace] = KEY_BACKSPACE,
-    [RGFW_keyInsert] = KEY_INSERT,
-    [RGFW_keyDelete] = KEY_DELETE,
-    [RGFW_keyRight] = KEY_RIGHT,
-    [RGFW_keyLeft] = KEY_LEFT,
-    [RGFW_keyDown] = KEY_DOWN,
-    [RGFW_keyUp] = KEY_UP,
-    [RGFW_keyPageUp] = KEY_PAGE_UP,
-    [RGFW_keyPageDown] = KEY_PAGE_DOWN,
-    [RGFW_keyHome] = KEY_HOME,
-    [RGFW_keyEnd] = KEY_END,
-    [RGFW_keyCapsLock] = KEY_CAPS_LOCK,
-    [RGFW_keyScrollLock] = KEY_SCROLL_LOCK,
-    [RGFW_keyNumLock] = KEY_NUM_LOCK,
-    [RGFW_keyPrintScreen] = KEY_PRINT_SCREEN,
-    [RGFW_keyPause] = KEY_PAUSE,
-    [RGFW_keyF1] = KEY_F1,
-    [RGFW_keyF2] = KEY_F2,
-    [RGFW_keyF3] = KEY_F3,
-    [RGFW_keyF4] = KEY_F4,
-    [RGFW_keyF5] = KEY_F5,
-    [RGFW_keyF6] = KEY_F6,
-    [RGFW_keyF7] = KEY_F7,
-    [RGFW_keyF8] = KEY_F8,
-    [RGFW_keyF9] = KEY_F9,
-    [RGFW_keyF10] = KEY_F10,
-    [RGFW_keyF11] = KEY_F11,
-    [RGFW_keyF12] = KEY_F12,
-    [RGFW_keyShiftL] = KEY_LEFT_SHIFT,
-    [RGFW_keyControlL] = KEY_LEFT_CONTROL,
-    [RGFW_keyAltL] = KEY_LEFT_ALT,
-    [RGFW_keySuperL] = KEY_LEFT_SUPER,
+    [RGFW_apostrophe] = KEY_APOSTROPHE,
+    [RGFW_comma] = KEY_COMMA,
+    [RGFW_minus] = KEY_MINUS,
+    [RGFW_period] = KEY_PERIOD,
+    [RGFW_slash] = KEY_SLASH,
+    [RGFW_0] = KEY_ZERO,
+    [RGFW_1] = KEY_ONE,
+    [RGFW_2] = KEY_TWO,
+    [RGFW_3] = KEY_THREE,
+    [RGFW_4] = KEY_FOUR,
+    [RGFW_5] = KEY_FIVE,
+    [RGFW_6] = KEY_SIX,
+    [RGFW_7] = KEY_SEVEN,
+    [RGFW_8] = KEY_EIGHT,
+    [RGFW_9] = KEY_NINE,
+    [RGFW_semicolon] = KEY_SEMICOLON,
+    [RGFW_equals] = KEY_EQUAL,
+    [RGFW_a] = KEY_A,
+    [RGFW_b] = KEY_B,
+    [RGFW_c] = KEY_C,
+    [RGFW_d] = KEY_D,
+    [RGFW_e] = KEY_E,
+    [RGFW_f] = KEY_F,
+    [RGFW_g] = KEY_G,
+    [RGFW_h] = KEY_H,
+    [RGFW_i] = KEY_I,
+    [RGFW_j] = KEY_J,
+    [RGFW_k] = KEY_K,
+    [RGFW_l] = KEY_L,
+    [RGFW_m] = KEY_M,
+    [RGFW_n] = KEY_N,
+    [RGFW_o] = KEY_O,
+    [RGFW_p] = KEY_P,
+    [RGFW_q] = KEY_Q,
+    [RGFW_r] = KEY_R,
+    [RGFW_s] = KEY_S,
+    [RGFW_t] = KEY_T,
+    [RGFW_u] = KEY_U,
+    [RGFW_v] = KEY_V,
+    [RGFW_w] = KEY_W,
+    [RGFW_x] = KEY_X,
+    [RGFW_y] = KEY_Y,
+    [RGFW_z] = KEY_Z,
+    [RGFW_bracket] = KEY_LEFT_BRACKET,
+    [RGFW_backSlash] = KEY_BACKSLASH,
+    [RGFW_closeBracket] = KEY_RIGHT_BRACKET,
+    [RGFW_backtick] = KEY_GRAVE,
+    [RGFW_space] = KEY_SPACE,
+    [RGFW_escape] = KEY_ESCAPE,
+    [RGFW_return] = KEY_ENTER,
+    [RGFW_tab] = KEY_TAB,
+    [RGFW_backSpace] = KEY_BACKSPACE,
+    [RGFW_insert] = KEY_INSERT,
+    [RGFW_delete] = KEY_DELETE,
+    [RGFW_right] = KEY_RIGHT,
+    [RGFW_left] = KEY_LEFT,
+    [RGFW_down] = KEY_DOWN,
+    [RGFW_up] = KEY_UP,
+    [RGFW_pageUp] = KEY_PAGE_UP,
+    [RGFW_pageDown] = KEY_PAGE_DOWN,
+    [RGFW_home] = KEY_HOME,
+    [RGFW_end] = KEY_END,
+    [RGFW_capsLock] = KEY_CAPS_LOCK,
+    [RGFW_scrollLock] = KEY_SCROLL_LOCK,
+    [RGFW_numLock] = KEY_NUM_LOCK,
+    [RGFW_printScreen] = KEY_PRINT_SCREEN,
+    [RGFW_pause] = KEY_PAUSE,
+    [RGFW_F1] = KEY_F1,
+    [RGFW_F2] = KEY_F2,
+    [RGFW_F3] = KEY_F3,
+    [RGFW_F4] = KEY_F4,
+    [RGFW_F5] = KEY_F5,
+    [RGFW_F6] = KEY_F6,
+    [RGFW_F7] = KEY_F7,
+    [RGFW_F8] = KEY_F8,
+    [RGFW_F9] = KEY_F9,
+    [RGFW_F10] = KEY_F10,
+    [RGFW_F11] = KEY_F11,
+    [RGFW_F12] = KEY_F12,
+    [RGFW_shiftL] = KEY_LEFT_SHIFT,
+    [RGFW_controlL] = KEY_LEFT_CONTROL,
+    [RGFW_altL] = KEY_LEFT_ALT,
+    [RGFW_superL] = KEY_LEFT_SUPER,
     // #ifndef RGFW_MACOS
-    [RGFW_keyShiftR] = KEY_RIGHT_SHIFT,
-    [RGFW_keyControlR] = KEY_RIGHT_CONTROL,
-    [RGFW_keyAltR] = KEY_RIGHT_ALT,
-    [RGFW_keySuperR] = KEY_RIGHT_SUPER,
+    [RGFW_shiftR] = KEY_RIGHT_SHIFT,
+    [RGFW_controlR] = KEY_RIGHT_CONTROL,
+    [RGFW_altR] = KEY_RIGHT_ALT,
+    [RGFW_superR] = KEY_RIGHT_SUPER,
     // #endif
-    [RGFW_keyMenu] = KEY_KB_MENU,
-    [RGFW_keyPad0] = KEY_KP_0,
-    [RGFW_keyPad1] = KEY_KP_1,
-    [RGFW_keyPad2] = KEY_KP_2,
-    [RGFW_keyPad3] = KEY_KP_3,
-    [RGFW_keyPad4] = KEY_KP_4,
-    [RGFW_keyPad5] = KEY_KP_5,
-    [RGFW_keyPad6] = KEY_KP_6,
-    [RGFW_keyPad7] = KEY_KP_7,
-    [RGFW_keyPad8] = KEY_KP_8,
-    [RGFW_keyPad9] = KEY_KP_9,
-    [RGFW_keyPadPeriod] = KEY_KP_DECIMAL,
-    [RGFW_keyPadSlash] = KEY_KP_DIVIDE,
-    [RGFW_keyPadMultiply] = KEY_KP_MULTIPLY,
-    [RGFW_keyPadMinus] = KEY_KP_SUBTRACT,
-    [RGFW_keyPadPlus] = KEY_KP_ADD,
-    [RGFW_keyPadReturn] = KEY_KP_ENTER,
-    [RGFW_keyPadEqual] = KEY_KP_EQUAL,
+    [RGFW_menu] = KEY_KB_MENU,
+    [RGFW_kp0] = KEY_KP_0,
+    [RGFW_kp1] = KEY_KP_1,
+    [RGFW_kp2] = KEY_KP_2,
+    [RGFW_kp3] = KEY_KP_3,
+    [RGFW_kp4] = KEY_KP_4,
+    [RGFW_kp5] = KEY_KP_5,
+    [RGFW_kp6] = KEY_KP_6,
+    [RGFW_kp7] = KEY_KP_7,
+    [RGFW_kp8] = KEY_KP_8,
+    [RGFW_kp9] = KEY_KP_9,
+    [RGFW_kpPeriod] = KEY_KP_DECIMAL,
+    [RGFW_kpSlash] = KEY_KP_DIVIDE,
+    [RGFW_kpMultiply] = KEY_KP_MULTIPLY,
+    [RGFW_kpMinus] = KEY_KP_SUBTRACT,
+    [RGFW_kpPlus] = KEY_KP_ADD,
+    [RGFW_kpReturn] = KEY_KP_ENTER,
+    [RGFW_kpEqual] = KEY_KP_EQUAL,
 };
 
 static int mg_buttonConvertTable[] = {
@@ -456,299 +453,14 @@ static int mg_axisConvertTable[] = {
     [MG_AXIS_HAT_DPAD_DOWN] = -1,
 };
 
-static KeyboardKey ConvertScancodeToKey(u32 keycode);
-void RemapMouseToTouch(int touchAction);
-
-// ---------------------------------------------------------------------------------
-// RGFW Callbacks (instead of the older polling)
-// ---------------------------------------------------------------------------------
-static void RGFW_cb_mousenotifyfunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    CORE.Input.Mouse.cursorOnScreen = e->mouse.inWindow;
-}
-/*
-static void RGFW_cb_windowclosefunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    // Don't want to close here, raylib handles it
-    //RGFW_window_setShouldClose(platform.window, true);
-}
-*/
-static void RGFW_cb_dropfunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    if (CORE.Window.dropFileCount == 0)
-    {
-        CORE.Window.dropFilepaths = (char **)RL_CALLOC(1024, sizeof(char *));
-
-        CORE.Window.dropFilepaths[CORE.Window.dropFileCount] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
-        snprintf(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], MAX_FILEPATH_LENGTH, "%s", e->drop.value->data);
-
-        CORE.Window.dropFileCount++;
-    }
-    else if (CORE.Window.dropFileCount < 1024)
-    {
-        CORE.Window.dropFilepaths[CORE.Window.dropFileCount] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
-        snprintf(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], MAX_FILEPATH_LENGTH, "%s", e->drop.value->data);
-
-        CORE.Window.dropFileCount++;
-    }
-    else TRACELOG(LOG_WARNING, "FILE: Maximum drag and drop files at once is limited to 1024 files!");
-}
-static void RGFW_cb_windowresizefunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    CORE.Window.resizedLastFrame = true;
-
-    #if defined(__APPLE__)
-        if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
-        {
-            RGFW_monitor *currentMonitor = RGFW_window_getMonitor(platform.window);
-            SetupViewport(platform.window->w*currentMonitor->pixelRatio, platform.window->h*currentMonitor->pixelRatio);
-            CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
-
-            CORE.Window.screen.width = platform.window->w;
-            CORE.Window.screen.height = platform.window->h;
-            CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
-            CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
-        }
-        else
-        {
-            SetupViewport(platform.window->w, platform.window->h);
-            CORE.Window.screen.width = platform.window->w;
-            CORE.Window.screen.height = platform.window->h;
-            CORE.Window.render.width = CORE.Window.screen.width;
-            CORE.Window.render.height = CORE.Window.screen.height;
-        }
-
-        CORE.Window.currentFbo.width = CORE.Window.render.width;
-        CORE.Window.currentFbo.height = CORE.Window.render.height;
-    #elif defined(PLATFORM_WEB_RGFW)
-        // do nothing but prevent other behavior
-    #else
-        SetupViewport(platform.window->w, platform.window->h);
-
-        // Consider content scaling if required
-        if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
-        {
-            Vector2 scaleDpi = GetWindowScaleDPI();
-            CORE.Window.screen.width = (int)(platform.window->w/scaleDpi.x);
-            CORE.Window.screen.height = (int)(platform.window->h/scaleDpi.y);
-            CORE.Window.screenScale = MatrixScale(scaleDpi.x, scaleDpi.y, 1.0f);
-        }
-        else
-        {
-            CORE.Window.screen.width = platform.window->w;
-            CORE.Window.screen.height = platform.window->h;
-        }
-
-        CORE.Window.currentFbo.width = CORE.Window.screen.width;
-        CORE.Window.currentFbo.height = CORE.Window.screen.height;
-    #endif
-
-    #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
-        #if defined(__APPLE__)
-            RGFW_monitor *currentMonitor = RGFW_window_getMonitor(platform.window);
-            CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
-            SetupViewport(platform.window->w*currentMonitor->pixelRatio, platform.window->h*currentMonitor->pixelRatio);
-
-            CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
-            CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
-            CORE.Window.currentFbo.width = CORE.Window.render.width;
-            CORE.Window.currentFbo.height = CORE.Window.render.height;
-        #endif
-        platform.surfaceWidth = CORE.Window.currentFbo.width;
-        platform.surfaceHeight = CORE.Window.currentFbo.height;
-
-        // in software mode we dont have the viewport so we need to reverse the highdpi changes
-        if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
-        {
-            Vector2 scaleDpi = GetWindowScaleDPI();
-            platform.surfaceWidth *= scaleDpi.x;
-            platform.surfaceHeight *= scaleDpi.y;
-        }
-
-        if (platform.surfacePixels != NULL)
-        {
-            RL_FREE(platform.surfacePixels);
-            platform.surfacePixels = RL_MALLOC(platform.surfaceWidth*platform.surfaceHeight*4);
-        }
-
-        if (platform.surface != NULL)
-        {
-            RGFW_surface_free(platform.surface);
-            platform.surface = RGFW_window_createSurface(platform.window, platform.surfacePixels, platform.surfaceWidth, platform.surfaceHeight, RGFW_formatBGRA8);
-            swResize(platform.surfaceWidth, platform.surfaceHeight);
-        }
-    #endif
-}
-static void RGFW_cb_windowmaximizefunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);  // The window was maximized
-}
-static void RGFW_cb_windowminimizefunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);  // The window was iconified
-}
-static void RGFW_cb_windowrestorefunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    if (RGFW_window_isMaximized(platform.window))
-        FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED); // The window was restored
-    if (RGFW_window_isMinimized(platform.window))
-        FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED); // The window was restored
-}
-static void RGFW_cb_windowmovefunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    CORE.Window.position.x = platform.window->x;
-    CORE.Window.position.y = platform.window->y;
-}
-static void RGFW_cb_keycharfunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    // NOTE: event.text.text data comes an UTF-8 text sequence but registering codepoints (int)
-    // Check if there is space available in the queue
-    if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
-    {
-        // Add character (codepoint) to the queue
-        CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = e->keyChar.value;
-        CORE.Input.Keyboard.charPressedQueueCount++;
-    }
-}
-static void RGFW_cb_scrollfunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    CORE.Input.Mouse.currentWheelMove.x += e->delta.x;
-    CORE.Input.Mouse.currentWheelMove.y += e->delta.y;
-}
-static void RGFW_cb_mousebuttonfunc(const RGFW_event *e)
-{
-    if (e->common.win != platform.window) return;
-
-    int btn = e->button.value;
-    if (btn == RGFW_mouseLeft) btn = 1;
-    else if (btn == RGFW_mouseRight) btn = 2;
-    else if (btn == RGFW_mouseMiddle) btn = 3;
-
-    // pressed or released
-    if (e->button.state){
-        CORE.Input.Mouse.currentButtonState[btn - 1] = 1;
-        CORE.Input.Touch.currentTouchState[btn - 1] = 1;
-
-        // simulate touch with the mouse
-        RemapMouseToTouch(1);
-    } else
-    {
-        CORE.Input.Mouse.currentButtonState[btn - 1] = 0;
-        CORE.Input.Touch.currentTouchState[btn - 1] = 0;
-
-        // simulate touch with the mouse
-        RemapMouseToTouch(0);
-    }
-}
-static void RGFW_cb_mouserawmotionfunc(const RGFW_event *e)
-{
-    if (!RGFW_window_isRawMouseMode(platform.window))
-    {
-        // if not raw, use non-raw motion. this prevents the doubled events
-        return;
-    }
-
-    float mouseX = 0.0f;
-    float mouseY = 0.0f;
-    mouseX = e->delta.x;
-    mouseY = e->delta.y;
-
-    #if defined(__EMSCRIPTEN__)
-        double canvasWidth = 0.0;
-        double canvasHeight = 0.0;
-        emscripten_get_element_css_size("#canvas", &canvasWidth, &canvasHeight);
-        mouseX *= ((float)GetScreenWidth()/(float)canvasWidth);
-        mouseY *= ((float)GetScreenHeight()/(float)canvasHeight);
-    #endif
-
-    CORE.Input.Mouse.currentPosition.x += mouseX;
-    CORE.Input.Mouse.currentPosition.y += mouseY;
-
-    // simulate touch with the mouse
-    CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
-    RemapMouseToTouch(2);
-}
-static void RGFW_cb_mousemotionfunc(const RGFW_event *e)
-{
-    if (RGFW_window_isRawMouseMode(platform.window))
-    {
-        // if raw, use raw motion. this prevents the doubled events
-        return;
-    }
-
-    float mouseX = 0.0f;
-    float mouseY = 0.0f;
-    mouseX = e->mouse.x;
-    mouseY = e->mouse.y;
-
-    #if defined(__EMSCRIPTEN__)
-        double canvasWidth = 0.0;
-        double canvasHeight = 0.0;
-        emscripten_get_element_css_size("#canvas", &canvasWidth, &canvasHeight);
-        mouseX *= ((float)GetScreenWidth()/(float)canvasWidth);
-        mouseY *= ((float)GetScreenHeight()/(float)canvasHeight);
-    #endif
-
-    CORE.Input.Mouse.currentPosition.x = mouseX;
-    CORE.Input.Mouse.currentPosition.y = mouseY;
-
-    // simulate touch with the mouse
-    CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
-    RemapMouseToTouch(2);
-}
-static void RGFW_cb_keyfunc(const RGFW_keyEvent* e)
-{
-    if (e->win != platform.window) return;
-
-    KeyboardKey key = ConvertScancodeToKey(e->value);
-    if (key == KEY_NULL) return;
-
-    // pressed or released
-    if (e->state)
-    {
-        // If key was up, add it to the key pressed queue
-        if ((CORE.Input.Keyboard.currentKeyState[key] == 0) && (CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE))
-        {
-            CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
-            CORE.Input.Keyboard.keyPressedQueueCount++;
-        }
-
-        CORE.Input.Keyboard.currentKeyState[key] = 1;
-
-        if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey]) RGFW_window_setShouldClose(platform.window, true);
-    }
-    else
-    {
-        CORE.Input.Keyboard.currentKeyState[key] = 0;
-    }
-}
-
 //----------------------------------------------------------------------------------
 // Module Internal Functions Declaration
 //----------------------------------------------------------------------------------
 int InitPlatform(void);          // Initialize platform (graphics, inputs and more)
 bool InitGraphicsDevice(void);   // Initialize graphics device
 
+static KeyboardKey ConvertScancodeToKey(u32 keycode);
+
 //----------------------------------------------------------------------------------
 // Module Functions Declaration
 //----------------------------------------------------------------------------------
@@ -761,9 +473,10 @@ bool InitGraphicsDevice(void);   // Initialize graphics device
 // Check if application should close
 bool WindowShouldClose(void)
 {
-    if (CORE.Window.shouldClose == false) CORE.Window.shouldClose = RGFW_window_shouldClose(platform.window);
+    if (CORE.Window.shouldClose == false)
+        CORE.Window.shouldClose = RGFW_window_shouldClose(platform.window);
     if (CORE.Window.ready) return CORE.Window.shouldClose;
-    return true;
+    else return true;
 }
 
 // Toggle fullscreen mode
@@ -778,7 +491,7 @@ void ToggleFullscreen(void)
         CORE.Window.previousPosition.y = currentPosition.y;
         CORE.Window.previousScreen = CORE.Window.screen;
 
-        RGFW_monitor *currentMonitor = RGFW_window_getMonitor(platform.window);
+        RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
         RGFW_monitor_scaleToWindow(currentMonitor, platform.window);
         RGFW_window_setFullscreen(platform.window, 1);
     }
@@ -923,7 +636,7 @@ void SetWindowState(unsigned int flags)
     }
     if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
     {
-        RGFW_glHints *hints = RGFW_getGlobalHints_OpenGL();
+        RGFW_glHints* hints = RGFW_getGlobalHints_OpenGL();
         hints->samples = 4;
         RGFW_setGlobalHints_OpenGL(hints);
     }
@@ -999,7 +712,7 @@ void ClearWindowState(unsigned int flags)
     }
     if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
     {
-        RGFW_glHints *hints = RGFW_getGlobalHints_OpenGL();
+        RGFW_glHints* hints = RGFW_getGlobalHints_OpenGL();
         hints->samples = 0;
         RGFW_setGlobalHints_OpenGL(hints);
     }
@@ -1094,11 +807,11 @@ void SetWindowSize(int width, int height)
         Vector2 scaleDpi = GetWindowScaleDPI();
 
         #if defined(__APPLE__)
-            RGFW_monitor *currentMonitor = RGFW_window_getMonitor(platform.window);
+            RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
             CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
 
-            CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
-            CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
+            CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio;
+            CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio;
             CORE.Window.currentFbo.width = CORE.Window.render.width;
             CORE.Window.currentFbo.height = CORE.Window.render.height;
         #else
@@ -1138,25 +851,15 @@ void SetWindowFocused(void)
 // Get native window handle
 void *GetWindowHandle(void)
 {
-    void *handle = NULL;
+    if (platform.window == NULL) return NULL;
 
-    if (platform.window != NULL)
-    {
-#if defined(_WIN32)
-        handle = (void *)platform.window->src.window; // Type: HWND
-#elif defined(__linux__)
-    #if defined(RGFW_X11)
-        platform.windowHandleX11 = platform.window->src.window; // Type: Window (unsigned long)
-        handle = &platform.window->src.window;
-    #elif defined(RGFW_WAYLAND)
-        handle = (void *)platform.window->src.surface; // Type: struct wl_surface*
-    #endif
-#elif defined(__APPLE__)
-        handle = (void *)platform.window->src.window; // Type: id, NSWindow*
+#if defined(RGFW_WASM)
+    return (void *)&platform.window->src.ctx;
+#elif defined(RGFW_WAYLAND)
+    return (void *)platform.window->src.surface;
+#else
+    return (void *)platform.window->src.window;
 #endif
-    }
-
-    return handle;
 }
 
 // Get number of monitors
@@ -1321,20 +1024,15 @@ Image GetClipboardImage(void)
 #if SUPPORT_CLIPBOARD_IMAGE && SUPPORT_MODULE_RTEXTURES
 #if defined(_WIN32)
 
-    unsigned int dataSize = 0;
-    void *fileData = NULL;
+    unsigned long long int dataSize = 0; // moved into _WIN32 scope until other platforms gain support
+    void *fileData = NULL; // moved into _WIN32 scope until other platforms gain support
 
     int width = 0;
     int height = 0;
-    fileData = (void *)Win32GetClipboardImageData(&width, &height, &dataSize);
+    fileData  = (void *)Win32GetClipboardImageData(&width, &height, &dataSize);
 
     if (fileData == NULL) TRACELOG(LOG_WARNING, "Clipboard image: Couldn't get clipboard data");
-    else
-    {
-        image = LoadImageFromMemory(".bmp", (const unsigned char *)fileData, (int)dataSize);
-
-        RL_FREE(fileData);
-    }
+    else image = LoadImageFromMemory(".bmp", (const unsigned char *)fileData, dataSize);
 
 #elif defined(__linux__) && defined(DRGFW_X11)
 
@@ -1384,7 +1082,7 @@ Image GetClipboardImage(void)
     XCloseDisplay(dpy);
 #else
     TRACELOG(LOG_WARNING, "Clipboard image: PLATFORM_DESKTOP_RGFW doesn't implement GetClipboardImage() for this OS");
-#endif // _WIN32
+#endif // defined(_WIN32)
 #else
     TRACELOG(LOG_WARNING, "Clipboard image: SUPPORT_CLIPBOARD_IMAGE requires SUPPORT_MODULE_RTEXTURES to work properly");
 #endif // SUPPORT_CLIPBOARD_IMAGE
@@ -1399,14 +1097,14 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     RGFW_window_showMouse(platform.window, false);
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     RGFW_window_captureRawMouse(platform.window, false);
@@ -1418,7 +1116,7 @@ void EnableCursor(void)
     CORE.Input.Mouse.cursorLocked = true;
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     RGFW_window_captureRawMouse(platform.window, true);
@@ -1434,16 +1132,16 @@ void SwapScreenBuffer(void)
     {
         if (platform.surface)
         {
-            // Copy rlsw pixel data to the surface framebuffer
-            rlCopyFramebuffer(0, 0, platform.surfaceWidth, platform.surfaceHeight, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, platform.surfacePixels);
+            // copy rlsw pixel data to the surface framebuffer
+            swReadPixels(0, 0, platform.surfaceWidth, platform.surfaceHeight, SW_RGBA, SW_UNSIGNED_BYTE, platform.surfacePixels);
 
             // Mac wants a different pixel order. I cant seem to get this to work any other way
             #if defined(__APPLE__)
                 unsigned char temp = 0;
                 unsigned char *p = NULL;
-                for (int i = 0; i < (platform.surfaceWidth*platform.surfaceHeight); i += 1)
+                for (int i = 0; i < (platform.surfaceWidth * platform.surfaceHeight); i += 1)
                 {
-                    p = platform.surfacePixels + (i*4);
+                    p = platform.surfacePixels + (i * 4);
                     temp = p[0];
                     p[0] = p[2];
                     p[2] = temp;
@@ -1470,31 +1168,21 @@ double GetTime(void)
 {
     // CORE.Time.base is nanoseconds as integer
     double baseTime = (double)CORE.Time.base*1e-9;
-    double time = GetTimeSeconds() - baseTime;
+    double time = get_time_seconds() - baseTime;
 
     return time;
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if you control the URL given
+// A user could craft a malicious string performing another action
 void OpenURL(const char *url)
 {
-    // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    // Security check to (partially) avoid malicious code on target platform
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else
     {
-        char *cmd = (char *)RL_CALLOC(strlen(url) + 16, sizeof(char));
+        char *cmd = (char *)RL_CALLOC(strlen(url) + 32, sizeof(char));
 #if defined(_WIN32)
         sprintf(cmd, "explorer \"%s\"", url);
 #endif
@@ -1531,6 +1219,7 @@ void SetMousePosition(int x, int y)
 {
     RGFW_window_moveMouse(platform.window, x, y);
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 }
 
 // Set mouse cursor
@@ -1586,6 +1275,9 @@ void PollInputEvents(void)
     // Map touch position to mouse position for convenience
     CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
 
+    int touchAction = -1;       // 0-TOUCH_ACTION_UP, 1-TOUCH_ACTION_DOWN, 2-TOUCH_ACTION_MOVE
+    bool realTouch = false;     // Flag to differentiate real touch gestures from mouse ones
+
     // Register previous keys states
     // NOTE: Android supports up to 260 keys
     for (int i = 0; i < MAX_KEYBOARD_KEYS; i++)
@@ -1617,82 +1309,359 @@ void PollInputEvents(void)
         CORE.Time.previous = GetTime();
     }
 
-    //-----------------------------------------------------------------------------
-    // Using RGFW callbacks instead of polling
-    RGFW_pollEvents();
-    //-----------------------------------------------------------------------------
-
-    mg_event gamepad_event = { 0 };
-    while (mg_gamepads_check_event(&platform.minigamepad, &gamepad_event))
+    RGFW_event rgfw_event;
+    while (RGFW_window_checkEvent(platform.window, &rgfw_event))
     {
-        int gamepadIndex = gamepad_event.gamepad->index;
-
-        switch (gamepad_event.type)
+        // All input events can be processed after polling
+        switch (rgfw_event.type)
         {
+            case RGFW_mouseEnter: CORE.Input.Mouse.cursorOnScreen = true; break;
+            case RGFW_mouseLeave: CORE.Input.Mouse.cursorOnScreen = false; break;
+            case RGFW_quit:
+                RGFW_window_setShouldClose(platform.window, true);
+                return;
+            case RGFW_dataDrop:      // Dropped file
+            {
+                for (int i = 0; i < rgfw_event.drop.count; i++)
+                {
+                    if (CORE.Window.dropFileCount == 0)
+                    {
+                        // When a new file is dropped, reserve a fixed number of slots for all possible dropped files
+                        // at the moment limiting the number of drops at once to 1024 files but this behaviour should probably be reviewed
+                        // TODO: Pointers should probably be reallocated for any new file added...
+                        CORE.Window.dropFilepaths = (char **)RL_CALLOC(1024, sizeof(char *));
+
+                        CORE.Window.dropFilepaths[CORE.Window.dropFileCount] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
+                        strcpy(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], rgfw_event.drop.files[i]);
+
+                        CORE.Window.dropFileCount++;
+                    }
+                    else if (CORE.Window.dropFileCount < 1024)
+                    {
+                        CORE.Window.dropFilepaths[CORE.Window.dropFileCount] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
+                        strcpy(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], rgfw_event.drop.files[i]);
+
+                        CORE.Window.dropFileCount++;
+                    }
+                    else TRACELOG(LOG_WARNING, "FILE: Maximum drag and drop files at once is limited to 1024 files!");
+                }
+            } break;
+
+            // Window events are also polled (Minimized, maximized, close...)
+            case RGFW_windowResized:
+            {
+                // set flag that the window was resized
+                CORE.Window.resizedLastFrame = true;
+                
+                #if defined(__APPLE__)
+                    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
+                    {
+                        RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
+                        SetupViewport(platform.window->w * currentMonitor->pixelRatio, platform.window->h * currentMonitor->pixelRatio);
+                        CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
+
+                        CORE.Window.screen.width = platform.window->w;
+                        CORE.Window.screen.height = platform.window->h;
+                        CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio;
+                        CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio;
+                    }
+                    else
+                    {
+                        SetupViewport(platform.window->w, platform.window->h);
+                        CORE.Window.screen.width = platform.window->w;
+                        CORE.Window.screen.height = platform.window->h;
+                        CORE.Window.render.width = CORE.Window.screen.width;
+                        CORE.Window.render.height = CORE.Window.screen.height;
+                    }
+
+                    CORE.Window.currentFbo.width = CORE.Window.render.width;
+                    CORE.Window.currentFbo.height = CORE.Window.render.height;
+                #elif defined(PLATFORM_WEB_RGFW)
+                    // do nothing but prevent other behavior
+                #else
+                    SetupViewport(platform.window->w, platform.window->h);
+
+                    // Consider content scaling if required
+                    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
+                    {
+                        Vector2 scaleDpi = GetWindowScaleDPI();
+                        CORE.Window.screen.width = (int)(platform.window->w/scaleDpi.x);
+                        CORE.Window.screen.height = (int)(platform.window->h/scaleDpi.y);
+                        CORE.Window.screenScale = MatrixScale(scaleDpi.x, scaleDpi.y, 1.0f);
+
+                        // Mouse scale does not seem to be needed
+                        //SetMouseScale(1.0f/scaleDpi.x, 1.0f/scaleDpi.y);
+                    }
+                    else
+                    {
+                        CORE.Window.screen.width = platform.window->w;
+                        CORE.Window.screen.height = platform.window->h;
+                    }
+
+                    CORE.Window.currentFbo.width = CORE.Window.screen.width;
+                    CORE.Window.currentFbo.height = CORE.Window.screen.height;
+                #endif
+
+                #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+                    #if defined(__APPLE__)
+                        RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
+                        CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
+                        SetupViewport(platform.window->w * currentMonitor->pixelRatio, platform.window->h * currentMonitor->pixelRatio);
+
+                        CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio;
+                        CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio;
+                        CORE.Window.currentFbo.width = CORE.Window.render.width;
+                        CORE.Window.currentFbo.height = CORE.Window.render.height;
+                    #endif
+                    platform.surfaceWidth = CORE.Window.currentFbo.width;
+                    platform.surfaceHeight = CORE.Window.currentFbo.height;
+
+                    // in software mode we dont have the viewport so we need to reverse the highdpi changes
+                    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
+                    {
+                        Vector2 scaleDpi = GetWindowScaleDPI();
+                        platform.surfaceWidth *= scaleDpi.x;
+                        platform.surfaceHeight *= scaleDpi.y;
+                    }
+
+                    if (platform.surfacePixels != NULL)
+                    {
+                        RL_FREE(platform.surfacePixels);
+                        platform.surfacePixels = RL_MALLOC(platform.surfaceWidth * platform.surfaceHeight * 4);
+                    }
+
+                    if (platform.surface != NULL)
+                    {
+                        RGFW_surface_free(platform.surface);
+                        platform.surface = RGFW_window_createSurface(platform.window, platform.surfacePixels, platform.surfaceWidth, platform.surfaceHeight, RGFW_formatBGRA8);
+                        swResize(platform.surfaceWidth, platform.surfaceHeight);
+                    }
+                #endif
+            } break;
+            case RGFW_windowMaximized:
+            {
+                FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);  // The window was maximized
+            } break;
+            case RGFW_windowMinimized:
+            {
+                FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);  // The window was iconified
+            } break;
+            case RGFW_windowRestored:
+            {
+                if (RGFW_window_isMaximized(platform.window))
+                    FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);           // The window was restored
+                if (RGFW_window_isMinimized(platform.window))
+                    FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);           // The window was restored
+            } break;
+            case RGFW_windowMoved:
+            {
+                CORE.Window.position.x = platform.window->x;
+                CORE.Window.position.y = platform.window->x;
+            } break;
+
+            // Keyboard events
+            case RGFW_keyPressed:
+            {
+                KeyboardKey key = ConvertScancodeToKey(rgfw_event.key.value);
+                if (key != KEY_NULL)
+                {
+                    // If key was up, add it to the key pressed queue
+                    if ((CORE.Input.Keyboard.currentKeyState[key] == 0) && (CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE))
+                    {
+                        CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
+                        CORE.Input.Keyboard.keyPressedQueueCount++;
+                    }
+
+                    CORE.Input.Keyboard.currentKeyState[key] = 1;
+
+                    if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey]) RGFW_window_setShouldClose(platform.window, true);
+                }
+            } break;
+            case RGFW_keyReleased:
+            {
+                KeyboardKey key = ConvertScancodeToKey(rgfw_event.key.value);
+                if (key != KEY_NULL) CORE.Input.Keyboard.currentKeyState[key] = 0;
+            } break;
+
+            case RGFW_keyChar:
+            {
+                // NOTE: event.text.text data comes an UTF-8 text sequence but registering codepoints (int)
+                // Check if there is space available in the queue
+                if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
+                {
+                    // Add character (codepoint) to the queue
+                    CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = rgfw_event.keyChar.value;
+                    CORE.Input.Keyboard.charPressedQueueCount++;
+                }
+            } break;
+
+            // Check mouse events
+            case RGFW_mouseScroll:
+            {
+                CORE.Input.Mouse.currentWheelMove.x += rgfw_event.scroll.x;
+                CORE.Input.Mouse.currentWheelMove.y += rgfw_event.scroll.y;
+            } break;
+            case RGFW_mouseButtonPressed:
+            {
+                int btn = rgfw_event.button.value;
+                if (btn == RGFW_mouseLeft) btn = 1;
+                else if (btn == RGFW_mouseRight) btn = 2;
+                else if (btn == RGFW_mouseMiddle) btn = 3;
+
+                CORE.Input.Mouse.currentButtonState[btn - 1] = 1;
+                CORE.Input.Touch.currentTouchState[btn - 1] = 1;
+
+                touchAction = 1;
+            } break;
+            case RGFW_mouseButtonReleased:
+            {
+                int btn = rgfw_event.button.value;
+                if (btn == RGFW_mouseLeft) btn = 1;
+                else if (btn == RGFW_mouseRight) btn = 2;
+                else if (btn == RGFW_mouseMiddle) btn = 3;
+
+                CORE.Input.Mouse.currentButtonState[btn - 1] = 0;
+                CORE.Input.Touch.currentTouchState[btn - 1] = 0;
+
+                touchAction = 0;
+            } break;
+            case RGFW_mousePosChanged:
+            {
+                float mouseX = 0.0f;
+                float mouseY = 0.0f;
+                if (RGFW_window_isCaptured(platform.window))
+                {
+                    mouseX = (float)rgfw_event.mouse.vecX;
+                    mouseY = (float)rgfw_event.mouse.vecY;
+                }
+                else
+                {
+                    mouseX = (float)rgfw_event.mouse.x;
+                    mouseY = (float)rgfw_event.mouse.y;
+                }
+
+#if defined(__EMSCRIPTEN__)
+                double canvasWidth = 0.0;
+                double canvasHeight = 0.0;
+                emscripten_get_element_css_size("#canvas", &canvasWidth, &canvasHeight);
+                mouseX *= ((float)GetScreenWidth()/(float)canvasWidth);
+                mouseY *= ((float)GetScreenHeight()/(float)canvasHeight);
+#endif
+                if (RGFW_window_isCaptured(platform.window))
+                {
+                    CORE.Input.Mouse.currentPosition.x += mouseX;
+                    CORE.Input.Mouse.currentPosition.y += mouseY;
+                }
+                else
+                {
+                    CORE.Input.Mouse.currentPosition.x = mouseX;
+                    CORE.Input.Mouse.currentPosition.y = mouseY;
+                }
+
+                CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
+                touchAction = 2;
+            } break;
+            default: break;
+        }
+
+#if SUPPORT_GESTURES_SYSTEM
+        if (touchAction > -1)
+        {
+            // Process mouse events as touches to be able to use mouse-gestures
+            GestureEvent gestureEvent = { 0 };
+
+            // Register touch actions
+            gestureEvent.touchAction = touchAction;
+
+            // Assign a pointer ID
+            gestureEvent.pointId[0] = 0;
+
+            // Register touch points count
+            gestureEvent.pointCount = 1;
+
+            // Register touch points position, only one point registered
+            if (touchAction == 2 || realTouch) gestureEvent.position[0] = CORE.Input.Touch.position[0];
+            else gestureEvent.position[0] = GetMousePosition();
+
+            // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
+            gestureEvent.position[0].x /= (float)GetScreenWidth();
+            gestureEvent.position[0].y /= (float)GetScreenHeight();
+
+            // Gesture data is sent to gestures-system for processing
+            ProcessGestureEvent(gestureEvent);
+
+            touchAction = -1;
+        }
+#endif
+    }
+    //-----------------------------------------------------------------------------
+
+    mg_event gamepad_event;
+    while (mg_gamepads_check_event(&platform.minigamepad, &gamepad_event)) {
+        int gamepadIndex = gamepad_event.gamepad->index;
+        switch (gamepad_event.type) {
             case MG_EVENT_BUTTON_PRESS:
-            {
-                int button = mg_buttonConvertTable[gamepad_event.button];
-                if (button >= 0)
                 {
-                    CORE.Input.Gamepad.currentButtonState[gamepadIndex][button] = 1;
-                    CORE.Input.Gamepad.lastButtonPressed = button;
-                }
-            } break;
+                    int button = mg_buttonConvertTable[gamepad_event.button];
+                    if (button >= 0)
+                    {
+                        CORE.Input.Gamepad.currentButtonState[gamepadIndex][button] = 1;
+                        CORE.Input.Gamepad.lastButtonPressed = button;
+                    }
+                } break;
             case MG_EVENT_BUTTON_RELEASE:
-            {
-                int button = mg_buttonConvertTable[gamepad_event.button];
-                if (button >= 0)
                 {
-                    CORE.Input.Gamepad.currentButtonState[gamepadIndex][button] = 0;
-                    if (CORE.Input.Gamepad.lastButtonPressed == button) CORE.Input.Gamepad.lastButtonPressed = 0;
-                }
-            } break;
+                    int button = mg_buttonConvertTable[gamepad_event.button];
+                    if (button >= 0)
+                    {
+                        CORE.Input.Gamepad.currentButtonState[gamepadIndex][button] = 0;
+                        if (CORE.Input.Gamepad.lastButtonPressed == button) CORE.Input.Gamepad.lastButtonPressed = 0;
+                    }
+                } break;
             case MG_EVENT_AXIS_MOVE:
-            {
-                int axis = mg_axisConvertTable[gamepad_event.axis];
+                {
+                    int axis = mg_axisConvertTable[gamepad_event.axis];
 
-                switch (axis) {
-                    case GAMEPAD_AXIS_LEFT_X:
-                    case GAMEPAD_AXIS_LEFT_Y:
-                    case GAMEPAD_AXIS_RIGHT_X:
-                    case GAMEPAD_AXIS_RIGHT_Y:
-                    {
-                        CORE.Input.Gamepad.axisState[gamepadIndex][axis] = platform.minigamepad.gamepads[gamepadIndex].axes[gamepad_event.axis].value;
-                    } break;
-                    case GAMEPAD_AXIS_LEFT_TRIGGER:
-                    case GAMEPAD_AXIS_RIGHT_TRIGGER:
-                    {
-                        CORE.Input.Gamepad.axisState[gamepadIndex][axis] = platform.minigamepad.gamepads[gamepadIndex].axes[gamepad_event.axis].value;
+                    switch (axis) {
+                        case GAMEPAD_AXIS_LEFT_X:
+                        case GAMEPAD_AXIS_LEFT_Y:
+                        case GAMEPAD_AXIS_RIGHT_X:
+                        case GAMEPAD_AXIS_RIGHT_Y:
+                                CORE.Input.Gamepad.axisState[gamepadIndex][axis] = platform.minigamepad.gamepads[gamepadIndex].axes[gamepad_event.axis].value;
+                            break;
+                        case GAMEPAD_AXIS_LEFT_TRIGGER:
+                        case GAMEPAD_AXIS_RIGHT_TRIGGER:
+                                CORE.Input.Gamepad.axisState[gamepadIndex][axis] = platform.minigamepad.gamepads[gamepadIndex].axes[gamepad_event.axis].value;
 
-                        // Trigger button press when axis is all the way
-                        int button = (axis == GAMEPAD_AXIS_LEFT_TRIGGER) ? GAMEPAD_BUTTON_LEFT_TRIGGER_2 : GAMEPAD_BUTTON_RIGHT_TRIGGER_2;
-                        int pressed = (platform.minigamepad.gamepads[gamepadIndex].axes[gamepad_event.axis].value >= 1.0f);
+                                /* trigger button press when axis is all the way */
+                                int button = (axis == GAMEPAD_AXIS_LEFT_TRIGGER) ? GAMEPAD_BUTTON_LEFT_TRIGGER_2 : GAMEPAD_BUTTON_RIGHT_TRIGGER_2;
+                                int pressed = (platform.minigamepad.gamepads[gamepadIndex].axes[gamepad_event.axis].value >= 1.0f);
 
-                        CORE.Input.Gamepad.currentButtonState[gamepadIndex][button] = pressed;
-                        if (pressed) CORE.Input.Gamepad.lastButtonPressed = button;
-                        else if (CORE.Input.Gamepad.lastButtonPressed == button) CORE.Input.Gamepad.lastButtonPressed = 0;
-                    } break;
-                    default: break;
-                }
-            } break;
+                                CORE.Input.Gamepad.currentButtonState[gamepadIndex][button] = pressed;
+                                if (pressed) CORE.Input.Gamepad.lastButtonPressed = button;
+                                else if (CORE.Input.Gamepad.lastButtonPressed == button) CORE.Input.Gamepad.lastButtonPressed = 0;
+                            break;
+                    }
+                } break;
             case MG_EVENT_GAMEPAD_CONNECT:
-            {
                 CORE.Input.Gamepad.ready[gamepadIndex] = true;
                 CORE.Input.Gamepad.axisState[gamepadIndex][GAMEPAD_AXIS_LEFT_TRIGGER] = -1.0f;
                 CORE.Input.Gamepad.axisState[gamepadIndex][GAMEPAD_AXIS_RIGHT_TRIGGER] = -1.0f;
 
                 int axisCount = 0;
-                for (int i = 0; i < MG_AXIS_COUNT; i += 1)
-                {
-                    if (platform.minigamepad.gamepads[gamepadIndex].axes[i].supported) axisCount += 1;
-                    else break;
+                for (int i = 0; i < MG_AXIS_COUNT; i += 1) {
+                    if (platform.minigamepad.gamepads[gamepadIndex].axes[i].supported) {
+                        axisCount += 1;
+                    } else {
+                        break;
+                    }
                 }
-
                 CORE.Input.Gamepad.axisCount[gamepadIndex] = axisCount;
-                snprintf(CORE.Input.Gamepad.name[gamepadIndex], MAX_GAMEPAD_NAME_LENGTH, "%s", platform.minigamepad.gamepads[gamepadIndex].name);
-
-            } break;
-            case MG_EVENT_GAMEPAD_DISCONNECT: CORE.Input.Gamepad.ready[gamepadIndex] = false; break;
+                strcpy(CORE.Input.Gamepad.name[gamepadIndex], platform.minigamepad.gamepads[gamepadIndex].name);
+                break;
+            case MG_EVENT_GAMEPAD_DISCONNECT:
+                CORE.Input.Gamepad.ready[gamepadIndex] = false;
+                break;
             default: break;
         }
     }
@@ -1708,62 +1677,10 @@ int InitPlatform(void)
     // Initialize RGFW internal global state, only required systems
     unsigned int flags = RGFW_windowCenter | RGFW_windowAllowDND;
 
-    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) FLAG_SET(flags, RGFW_windowNoBorder);
-    if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) FLAG_SET(flags, RGFW_windowNoResize);
-    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT)) FLAG_SET(flags, RGFW_windowTransparent);
-    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) FLAG_SET(flags, RGFW_windowHide);
-    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_SET(flags, RGFW_windowMaximize);
-    if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) FLAG_SET(flags, RGFW_windowFocusOnShow | RGFW_windowFocus);
-
-    if ((CORE.Window.screen.width == 0) || (CORE.Window.screen.height == 0))
-    {
-        FLAG_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE);
-    }
-
     // Check window creation flags
-
-    // Init window in fullscreen mode if requested
-    // NOTE: Keeping original screen size for toggle
     if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE))
     {
         FLAG_SET(flags, RGFW_windowFullscreen);
-        int result = RGFW_init();
-        if (result != 0)
-        {
-            TRACELOG(LOG_WARNING, "RGFW: Failed to initialize RGFW");
-            return -1;
-        }
-
-        // NOTE: Fullscreen applications default to the primary monitor
-        RGFW_monitor *monitor = RGFW_getPrimaryMonitor();
-        if (!monitor)
-        {
-            TRACELOG(LOG_WARNING, "RGFW: Failed to get primary monitor");
-            return -1;
-        }
-
-        // Default display resolution to that of the current mode
-        CORE.Window.display.width = monitor->mode.w;
-        CORE.Window.display.height = monitor->mode.h;
-
-        // Check if user requested some screen size
-        if ((CORE.Window.screen.width == 0) || (CORE.Window.screen.height == 0))
-        {
-            // Set some default screen size in case user decides to exit fullscreen mode
-            CORE.Window.previousScreen.width = 800;
-            CORE.Window.previousScreen.height = 450;
-            CORE.Window.previousPosition.x = (CORE.Window.display.width - CORE.Window.previousScreen.width)/2;
-            CORE.Window.previousPosition.y = (CORE.Window.display.height - CORE.Window.previousScreen.height)/2;
-
-            // Set screen width/height to the display width/height
-            if (CORE.Window.screen.width == 0) CORE.Window.screen.width = CORE.Window.display.width;
-            if (CORE.Window.screen.height == 0) CORE.Window.screen.height = CORE.Window.display.height;
-        }
-        else
-        {
-            CORE.Window.previousScreen = CORE.Window.screen;
-            CORE.Window.screen = CORE.Window.display;
-        }
     }
 
     if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE))
@@ -1771,17 +1688,17 @@ int InitPlatform(void)
         FLAG_SET(flags, RGFW_windowedFullscreen);
     }
 
-    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
-    {
-        #if !defined(__APPLE__)
-            CORE.Window.screen.width = CORE.Window.screen.width*GetWindowScaleDPI().x;
-            CORE.Window.screen.height = CORE.Window.screen.height*GetWindowScaleDPI().y;
-        #endif
-    }
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) FLAG_SET(flags, RGFW_windowNoBorder);
+    if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) FLAG_SET(flags, RGFW_windowNoResize);
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT)) FLAG_SET(flags, RGFW_windowTransparent);
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) FLAG_SET(flags, RGFW_windowFullscreen);
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) FLAG_SET(flags, RGFW_windowHide);
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_SET(flags, RGFW_windowMaximize);
 
     // NOTE: Some OpenGL context attributes must be set before window creation
     // Check selection OpenGL version
-    RGFW_glHints *hints = RGFW_getGlobalHints_OpenGL();
+
+    RGFW_glHints* hints = RGFW_getGlobalHints_OpenGL();
     if (rlGetVersion() == RL_OPENGL_21)
     {
         hints->major = 2;
@@ -1803,9 +1720,20 @@ int InitPlatform(void)
         hints->minor = 1;
         hints->renderer = RGFW_glSoftware;
     }
-    if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT)) hints->samples = 4;
-    RGFW_setGlobalHints_OpenGL(hints);
 
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT)) hints->samples = 4;
+
+    if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) FLAG_SET(flags, RGFW_windowFocusOnShow | RGFW_windowFocus);
+
+    if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
+    {
+        #if !defined(__APPLE__)
+            CORE.Window.screen.width = CORE.Window.screen.width * GetWindowScaleDPI().x;
+            CORE.Window.screen.height = CORE.Window.screen.height * GetWindowScaleDPI().y;
+        #endif
+    }
+
+    RGFW_setGlobalHints_OpenGL(hints);
     platform.window = RGFW_createWindow((CORE.Window.title != 0)? CORE.Window.title : " ", 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, flags | RGFW_windowOpenGL);
 
 #ifndef PLATFORM_WEB_RGFW
@@ -1856,11 +1784,11 @@ int InitPlatform(void)
         Vector2 scaleDpi = GetWindowScaleDPI();
 
         #if defined(__APPLE__)
-            RGFW_monitor *currentMonitor = RGFW_window_getMonitor(platform.window);
+            RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
             CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
 
-            CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
-            CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
+            CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio;
+            CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio;
             CORE.Window.currentFbo.width = CORE.Window.render.width;
             CORE.Window.currentFbo.height = CORE.Window.render.height;
         #else
@@ -1874,11 +1802,11 @@ int InitPlatform(void)
     #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
         // apple always scales for retina
         #if defined(__APPLE__)
-            RGFW_monitor *currentMonitor = RGFW_window_getMonitor(platform.window);
+            RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
             CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
 
-            CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
-            CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
+            CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio;
+            CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio;
             CORE.Window.currentFbo.width = CORE.Window.render.width;
             CORE.Window.currentFbo.height = CORE.Window.render.height;
         #endif
@@ -1886,7 +1814,7 @@ int InitPlatform(void)
         platform.surfaceWidth = CORE.Window.currentFbo.width;
         platform.surfaceHeight = CORE.Window.currentFbo.height;
 
-        platform.surfacePixels = RL_MALLOC(platform.surfaceWidth*platform.surfaceHeight*4);
+        platform.surfacePixels = RL_MALLOC(platform.surfaceWidth * platform.surfaceHeight * 4);
         if (platform.surfacePixels == NULL)
         {
             TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize software pixel buffer");
@@ -1904,25 +1832,6 @@ int InitPlatform(void)
         }
     #endif
 
-    // Set callbacks
-    RGFW_setEventCallback(RGFW_mouseEnter, RGFW_cb_mousenotifyfunc);
-    RGFW_setEventCallback(RGFW_mouseLeave, RGFW_cb_mousenotifyfunc);
-    // RGFW_setEventCallback(RGFW_windowClose, RGFW_cb_windowclosefunc); // do not close here. let raylib handle it
-    RGFW_setEventCallback(RGFW_dataDrop, RGFW_cb_dropfunc);
-    RGFW_setEventCallback(RGFW_windowResized, RGFW_cb_windowresizefunc);
-    RGFW_setEventCallback(RGFW_windowMaximized, RGFW_cb_windowmaximizefunc);
-    RGFW_setEventCallback(RGFW_windowMinimized, RGFW_cb_windowminimizefunc);
-    RGFW_setEventCallback(RGFW_windowRestored, RGFW_cb_windowrestorefunc);
-    RGFW_setEventCallback(RGFW_windowMoved, RGFW_cb_windowmovefunc);
-    RGFW_setEventCallback(RGFW_keyChar, RGFW_cb_keycharfunc);
-    RGFW_setEventCallback(RGFW_mouseScroll, RGFW_cb_scrollfunc);
-    RGFW_setEventCallback(RGFW_mouseButtonPressed, RGFW_cb_mousebuttonfunc);
-    RGFW_setEventCallback(RGFW_mouseButtonReleased, RGFW_cb_mousebuttonfunc);
-    RGFW_setEventCallback(RGFW_mouseRawMotion, RGFW_cb_mouserawmotionfunc);
-    RGFW_setEventCallback(RGFW_mouseMotion, RGFW_cb_mousemotionfunc);
-    RGFW_setEventCallback(RGFW_keyPressed, (RGFW_genericFunc)RGFW_cb_keyfunc);
-    RGFW_setEventCallback(RGFW_keyReleased, (RGFW_genericFunc)RGFW_cb_keyfunc);
-
     TRACELOG(LOG_INFO, "DISPLAY: Device initialized successfully %s",
         FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)? "(HighDPI)" : "");
     TRACELOG(LOG_INFO, "    > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
@@ -2044,39 +1953,8 @@ static KeyboardKey ConvertScancodeToKey(u32 keycode)
     return (KeyboardKey)RGFW_keyConvertTable[keycode];
 }
 
-// assign mouse to touches
-// 0-TOUCH_ACTION_UP, 1-TOUCH_ACTION_DOWN, 2-TOUCH_ACTION_MOVE
-void RemapMouseToTouch(int touchAction)
-{
-    #if SUPPORT_GESTURES_SYSTEM
-        if (touchAction < 0) return;
-
-        GestureEvent gestureEvent = { 0 };
-
-        // Register touch actions
-        gestureEvent.touchAction = touchAction;
-
-        // Assign a pointer ID
-        gestureEvent.pointId[0] = 0;
-
-        // Register touch points count
-        gestureEvent.pointCount = 1;
-
-        // Register touch points position, only one point registered
-        if (touchAction == 2 /*|| realTouch*/) gestureEvent.position[0] = CORE.Input.Touch.position[0];
-        else gestureEvent.position[0] = GetMousePosition();
-
-        // Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
-        gestureEvent.position[0].x /= (float)GetScreenWidth();
-        gestureEvent.position[0].y /= (float)GetScreenHeight();
-
-        // Gesture data is sent to gestures-system for processing
-        ProcessGestureEvent(gestureEvent);
-    #endif
-}
-
 // Helper functions for Time
-double GetTimeSeconds(void)
+double get_time_seconds(void)
 {
     double currentTime = 0.0;
 
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_sdl.c b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_sdl.c
index d2d1ef8..2774217 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_sdl.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_sdl.c
@@ -56,13 +56,6 @@
     #include "SDL3/SDL.h"
 #elif defined(USING_SDL2_PROJECT)
     #include "SDL2/SDL.h"
-
-    // WARNING: On Linux, this header includes Xlib.h, which defines Font
-    // To prevent a conflict with raylib's own Font type, we temporarily
-    // rename it to FontX11
-    #define Font FontX11
-    #include "SDL2/SDL_syswm.h"     // Required to get window handlers
-    #undef Font
 #else
     #include "SDL.h"
 #endif
@@ -108,13 +101,6 @@ typedef struct {
     SDL_GameController *gamepad[MAX_GAMEPADS];
     SDL_JoystickID gamepadId[MAX_GAMEPADS]; // Joystick instance ids, they do not start from 0
     SDL_Cursor *cursor;
-
-#if defined(__linux__)
-    // Local storage for the window handle (X11)
-    // NOTE: On SDL is not possible to know windowing backend at compile time, so,
-    // just in case, avoiding X11 specific types here
-    unsigned long windowHandleX11;          // Underlying type for: XID, Window
-#endif
 } PlatformData;
 
 //----------------------------------------------------------------------------------
@@ -470,11 +456,12 @@ bool WindowShouldClose(void)
 void ToggleFullscreen(void)
 {
     const int monitor = SDL_GetWindowDisplayIndex(platform.window);
+    const int monitorCount = SDL_GetNumVideoDisplays();
 
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE))
@@ -495,11 +482,12 @@ void ToggleFullscreen(void)
 void ToggleBorderlessWindowed(void)
 {
     const int monitor = SDL_GetWindowDisplayIndex(platform.window);
+    const int monitorCount = SDL_GetNumVideoDisplays();
 
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE))
@@ -551,11 +539,12 @@ void SetWindowState(unsigned int flags)
     if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
     {
         const int monitor = SDL_GetWindowDisplayIndex(platform.window);
+        const int monitorCount = SDL_GetNumVideoDisplays();
 
     #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
         if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
     #else
-        if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+        if ((monitor >= 0) && (monitor < monitorCount))
     #endif
         {
             SDL_SetWindowFullscreen(platform.window, SDL_WINDOW_FULLSCREEN);
@@ -612,11 +601,12 @@ void SetWindowState(unsigned int flags)
     if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
     {
         const int monitor = SDL_GetWindowDisplayIndex(platform.window);
+        const int monitorCount = SDL_GetNumVideoDisplays();
 
     #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
         if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
     #else
-        if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+        if ((monitor >= 0) && (monitor < monitorCount))
     #endif
         {
             SDL_SetWindowFullscreen(platform.window, SDL_WINDOW_FULLSCREEN_DESKTOP);
@@ -833,10 +823,11 @@ void SetWindowPosition(int x, int y)
 // Set monitor for the current window
 void SetWindowMonitor(int monitor)
 {
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         // NOTE 1: SDL started supporting moving exclusive fullscreen windows between displays on SDL3,
@@ -864,7 +855,7 @@ void SetWindowMonitor(int monitor)
                 // ending up positioned partly outside the target display
                 // NOTE 2: The workaround for that is, previously to moving the window,
                 // setting the window size to the target display size, so they match
-                // NOTE 3: It wasn't done here because it can not be assumed that changing
+                // NOTE 3: It wasn't done here because it can not bee assumed that changing
                 // the window size automatically is acceptable behavior by the user
                 SDL_SetWindowPosition(platform.window, usableBounds.x, usableBounds.y);
                 CORE.Window.position.x = usableBounds.x;
@@ -929,82 +920,40 @@ void SetWindowFocused(void)
 }
 
 // Get native window handle
-// NOTE: Handle type depends on OS and windowing system
 void *GetWindowHandle(void)
 {
-    void *handle = NULL;
-
-#if defined(USING_SDL3_PROJECT)
-    // REF: https://github.com/libsdl-org/SDL/blob/main/include/SDL3/SDL_video.h#L1590
-    SDL_PropertiesID props = SDL_GetWindowProperties(platform.window);
-    #if defined(_WIN32)
-    handle = (void *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL); // Type: HWND
-    #elif defined(__linux__)
-    unsigned long windowId = (unsigned long)SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0); // Type: unsigned long (XID, Window)
-    if (windowId != 0)
-    {
-        // X11 window ID
-        platform.windowHandleX11 = windowId;
-        handle = &platform.windowHandleX11;
-    }
-    else
-    {
-        // Wayland, get display surface pointer
-        // NOTE: Alternative SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER
-        handle = (void *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, NULL); // Type: struct wl_surface*
-    }
-    #elif defined(__APPLE__)
-    handle = (void *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, NULL); // Type: NSWindow*
-    #endif
-#elif defined(USING_SDL2_PROJECT)
-    SDL_SysWMinfo wmInfo = { 0 };
-    SDL_VERSION(&wmInfo.version);
-    if (SDL_GetWindowWMInfo(platform.window, &wmInfo))
-    {
-    #if defined(_WIN32)
-        handle = (void *)wmInfo.info.win.window; // Type: HWND
-    #elif defined(__linux__)
-        if (wmInfo.subsystem == SDL_SYSWM_X11)
-        {
-            // X11, get window ID (unsigned long)
-            platform.windowHandleX11 = (unsigned long)wmInfo.info.x11.window;
-            handle = &platform.windowHandleX11;
-        }
-        else if (wmInfo.subsystem == SDL_SYSWM_WAYLAND)
-        {
-            // Wayland, get display surface pointer
-            // NOTE: Alternative: wmInfo.info.wl.display
-            handle = (void *)wmInfo.info.wl.surface; // Type: struct wl_surface*
-        }
-    #elif defined(__APPLE__)
-        handle = (void *)wmInfo.info.cocoa.window; // Type: NSWindow*
-    #endif
-    }
-#endif
-
-    return handle;
+    return (void *)platform.window;
 }
 
 // Get number of monitors
 int GetMonitorCount(void)
 {
-    return SDL_GetNumVideoDisplays();
+    int monitorCount = 0;
+
+    monitorCount = SDL_GetNumVideoDisplays();
+
+    return monitorCount;
 }
 
 // Get current monitor where window is placed
 int GetCurrentMonitor(void)
 {
+    int currentMonitor = 0;
+
     // Be aware that this returns an ID in SDL3 and a Index in SDL2
-    return SDL_GetWindowDisplayIndex(platform.window);
+    currentMonitor = SDL_GetWindowDisplayIndex(platform.window);
+
+    return currentMonitor;
 }
 
 // Get selected monitor position
 Vector2 GetMonitorPosition(int monitor)
 {
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         SDL_Rect displayBounds;
@@ -1028,10 +977,11 @@ int GetMonitorWidth(int monitor)
 {
     int width = 0;
 
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         SDL_DisplayMode mode;
@@ -1048,10 +998,11 @@ int GetMonitorHeight(int monitor)
 {
     int height = 0;
 
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         SDL_DisplayMode mode;
@@ -1068,10 +1019,11 @@ int GetMonitorPhysicalWidth(int monitor)
 {
     int width = 0;
 
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         float ddpi = 0.0f;
@@ -1091,10 +1043,11 @@ int GetMonitorPhysicalHeight(int monitor)
 {
     int height = 0;
 
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         float ddpi = 0.0f;
@@ -1114,10 +1067,11 @@ int GetMonitorRefreshRate(int monitor)
 {
     int refresh = 0;
 
+    const int monitorCount = SDL_GetNumVideoDisplays();
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         SDL_DisplayMode mode;
@@ -1132,10 +1086,12 @@ int GetMonitorRefreshRate(int monitor)
 // Get the human-readable, UTF-8 encoded name of the selected monitor
 const char *GetMonitorName(int monitor)
 {
+    const int monitorCount = SDL_GetNumVideoDisplays();
+
 #if defined(USING_VERSION_SDL3) // SDL3 Migration: Monitor is an id instead of index now, returns 0 on failure
     if (SDL_GetDisplayProperties(monitor) != 0) // Returns 0 on failure, so a value other than zero indicates that the monitor id is valid
 #else
-    if ((monitor >= 0) && (monitor < SDL_GetNumVideoDisplays()))
+    if ((monitor >= 0) && (monitor < monitorCount))
 #endif
     {
         return SDL_GetDisplayName(monitor);
@@ -1188,7 +1144,7 @@ const char *GetClipboardText(void)
 
     char *clipboard = SDL_GetClipboardText();
 
-    int clipboardSize = snprintf(buffer, MAX_CLIPBOARD_BUFFER_LENGTH, "%s", clipboard);
+    int clipboardSize = snprintf(buffer, sizeof(buffer), "%s", clipboard);
     if (clipboardSize >= MAX_CLIPBOARD_BUFFER_LENGTH)
     {
         char *truncate = buffer + MAX_CLIPBOARD_BUFFER_LENGTH - 4;
@@ -1240,14 +1196,12 @@ Image GetClipboardImage(void)
 
     for (int i = 0; i < SDL_arraysize(imageFormats); i++)
     {
+        // NOTE: This pointer should be free with SDL_free() at some point
         fileData = SDL_GetClipboardData(imageFormats[i], &dataSize);
 
         if (fileData)
         {
             image = LoadImageFromMemory(imageExtensions[i], fileData, (int)dataSize);
-
-            SDL_free(fileData);
-
             if (IsImageValid(image))
             {
                 TRACELOG(LOG_INFO, "Clipboard: Got image from clipboard successfully: %s", imageExtensions[i]);
@@ -1273,7 +1227,7 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
 #if defined(USING_VERSION_SDL3)
@@ -1284,7 +1238,7 @@ void HideCursor(void)
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     SDL_SetRelativeMouseMode(SDL_FALSE);
@@ -1293,7 +1247,7 @@ void EnableCursor(void)
     CORE.Input.Mouse.cursorLocked = false;
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     SDL_SetRelativeMouseMode(SDL_TRUE);
@@ -1328,22 +1282,14 @@ double GetTime(void)
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if the provided URL is safe
+// A user could craft a malicious string performing another action
+// Avoid calling this function with user input non-validated strings
+// REF: https://github.com/raysan5/raylib/issues/686
 void OpenURL(const char *url)
 {
     // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else SDL_OpenURL(url);
 }
 
@@ -1396,6 +1342,7 @@ void SetMousePosition(int x, int y)
     SDL_WarpMouseInWindow(platform.window, x, y);
 
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 }
 
 // Set mouse cursor
@@ -1506,9 +1453,9 @@ void PollInputEvents(void)
                     // Event memory is now managed by SDL, so it should not be freed in SDL_EVENT_DROP_FILE,
                     // in case data needs to be hold onto the text in SDL_EVENT_TEXT_EDITING and SDL_EVENT_TEXT_INPUT events,
                     // a copy is required, SDL_TEXTINPUTEVENT_TEXT_SIZE is no longer necessary and has been removed
-                    snprintf(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], MAX_FILEPATH_LENGTH, "%s", event.drop.data);
+                    strncpy(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], event.drop.data, MAX_FILEPATH_LENGTH - 1);
                 #else
-                    snprintf(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], MAX_FILEPATH_LENGTH, "%s", event.drop.file);
+                    strncpy(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], event.drop.file, MAX_FILEPATH_LENGTH - 1);
                     SDL_free(event.drop.file);
                 #endif
 
@@ -1519,9 +1466,9 @@ void PollInputEvents(void)
                     CORE.Window.dropFilepaths[CORE.Window.dropFileCount] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
 
                 #if defined(USING_VERSION_SDL3)
-                    snprintf(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], MAX_FILEPATH_LENGTH, "%s", event.drop.data);
+                    strncpy(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], event.drop.data, MAX_FILEPATH_LENGTH - 1);
                 #else
-                    snprintf(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], MAX_FILEPATH_LENGTH, "%s", event.drop.file);
+                    strncpy(CORE.Window.dropFilepaths[CORE.Window.dropFileCount], event.drop.file, MAX_FILEPATH_LENGTH - 1);
                     SDL_free(event.drop.file);
                 #endif
 
@@ -1637,7 +1584,7 @@ void PollInputEvents(void)
             } break;
             #endif
 
-            // Check keyboard events
+            // Keyboard events
             case SDL_KEYDOWN:
             {
             #if defined(USING_VERSION_SDL3)
@@ -1665,8 +1612,10 @@ void PollInputEvents(void)
                 if (CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey]) CORE.Window.shouldClose = true;
 
             } break;
+
             case SDL_KEYUP:
             {
+
             #if defined(USING_VERSION_SDL3)
                 KeyboardKey key = ConvertScancodeToKey(event.key.scancode);
             #else
@@ -1674,6 +1623,7 @@ void PollInputEvents(void)
             #endif
                 if (key != KEY_NULL) CORE.Input.Keyboard.currentKeyState[key] = 0;
             } break;
+
             case SDL_TEXTINPUT:
             {
                 // NOTE: event.text.text data comes an UTF-8 text sequence but register codepoints (int)
@@ -1682,6 +1632,7 @@ void PollInputEvents(void)
                 if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
                 {
                     // Add character (codepoint) to the queue
+
                 #if defined(USING_VERSION_SDL3)
                     size_t textLen = strlen(event.text.text);
                     unsigned int codepoint = (unsigned int)SDL_StepUTF8(&event.text.text, &textLen);
@@ -1724,13 +1675,8 @@ void PollInputEvents(void)
             } break;
             case SDL_MOUSEWHEEL:
             {
-#if defined(USING_VERSION_SDL3)
-                CORE.Input.Mouse.currentWheelMove.x = event.wheel.x;
-                CORE.Input.Mouse.currentWheelMove.y = event.wheel.y;
-#else
-                CORE.Input.Mouse.currentWheelMove.x = event.wheel.preciseX;
-                CORE.Input.Mouse.currentWheelMove.y = event.wheel.preciseY;
-#endif
+                CORE.Input.Mouse.currentWheelMove.x = (float)event.wheel.x;
+                CORE.Input.Mouse.currentWheelMove.y = (float)event.wheel.y;
             } break;
             case SDL_MOUSEMOTION:
             {
@@ -1750,7 +1696,6 @@ void PollInputEvents(void)
                 touchAction = 2;
             } break;
 
-            // Check Touch events
             case SDL_FINGERDOWN:
             {
                 UpdateTouchPointsSDL(event.tfinger);
@@ -1770,21 +1715,24 @@ void PollInputEvents(void)
                 realTouch = true;
             } break;
 
-            // Check Gamepad events
+            // Check gamepad events
             case SDL_JOYDEVICEADDED:
             {
                 int jid = event.jdevice.which; // Joystick device index
 
-                // Check if already added at InitPlatform
+                // check if already added at InitPlatform
                 for (int i = 0; i < MAX_GAMEPADS; i++)
                 {
-                    if (jid == platform.gamepadId[i]) return;
+                    if (jid == platform.gamepadId[i])
+                    {
+                        return;
+                    }
                 }
 
                 int nextAvailableSlot = 0;
                 while (nextAvailableSlot < MAX_GAMEPADS && CORE.Input.Gamepad.ready[nextAvailableSlot])
                 {
-                    nextAvailableSlot++;
+                    ++nextAvailableSlot;
                 }
 
                 if ((nextAvailableSlot < MAX_GAMEPADS) && !CORE.Input.Gamepad.ready[nextAvailableSlot])
@@ -1800,8 +1748,8 @@ void PollInputEvents(void)
                         CORE.Input.Gamepad.axisState[nextAvailableSlot][GAMEPAD_AXIS_RIGHT_TRIGGER] = -1.0f;
                         memset(CORE.Input.Gamepad.name[nextAvailableSlot], 0, MAX_GAMEPAD_NAME_LENGTH);
                         const char *controllerName = SDL_GameControllerNameForIndex(nextAvailableSlot);
-                        if (controllerName != NULL) snprintf(CORE.Input.Gamepad.name[nextAvailableSlot], MAX_GAMEPAD_NAME_LENGTH, "%s", controllerName);
-                        else memcpy(CORE.Input.Gamepad.name[nextAvailableSlot], "noname", 6);
+                        if (controllerName != NULL) strncpy(CORE.Input.Gamepad.name[nextAvailableSlot], controllerName, MAX_GAMEPAD_NAME_LENGTH - 1);
+                        else strncpy(CORE.Input.Gamepad.name[nextAvailableSlot], "noname", 6);
                     }
                     else TRACELOG(LOG_WARNING, "PLATFORM: Unable to open game controller [ERROR: %s]", SDL_GetError());
                 }
@@ -2152,20 +2100,11 @@ int InitPlatform(void)
         platform.gamepadId[i] = -1; // Set all gamepad initial instance ids as invalid to not conflict with instance id zero
     }
 
-#if defined(USING_VERSION_SDL3)
-    int numJoysticks;
-    SDL_JoystickID *joysticks = SDL_GetJoysticks(&numJoysticks);
-#else
     int numJoysticks = SDL_NumJoysticks();
-#endif
 
     for (int i = 0; (i < numJoysticks) && (i < MAX_GAMEPADS); i++)
     {
-#if defined(USING_VERSION_SDL3)
-        platform.gamepad[i] = SDL_OpenGamepad(joysticks[i]);
-#else
         platform.gamepad[i] = SDL_GameControllerOpen(i);
-#endif
         platform.gamepadId[i] = SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(platform.gamepad[i]));
 
         if (platform.gamepad[i])
@@ -2174,12 +2113,7 @@ int InitPlatform(void)
             CORE.Input.Gamepad.axisCount[i] = SDL_JoystickNumAxes(SDL_GameControllerGetJoystick(platform.gamepad[i]));
             CORE.Input.Gamepad.axisState[i][GAMEPAD_AXIS_LEFT_TRIGGER] = -1.0f;
             CORE.Input.Gamepad.axisState[i][GAMEPAD_AXIS_RIGHT_TRIGGER] = -1.0f;
-#if defined(USING_VERSION_SDL3)
-            const char *joystickName = SDL_GetJoystickNameForID(joysticks[i]);
-#else
-            const char *joystickName = SDL_GameControllerNameForIndex(i);
-#endif
-            snprintf(CORE.Input.Gamepad.name[i], MAX_GAMEPAD_NAME_LENGTH, "%s", joystickName);
+            strncpy(CORE.Input.Gamepad.name[i], SDL_GameControllerNameForIndex(i), MAX_GAMEPAD_NAME_LENGTH - 1);
             CORE.Input.Gamepad.name[i][MAX_GAMEPAD_NAME_LENGTH - 1] = '\0';
         }
         else TRACELOG(LOG_WARNING, "PLATFORM: Unable to open game controller [ERROR: %s]", SDL_GetError());
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_win32.c b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_win32.c
index 28c133f..3f2dcd8 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_desktop_win32.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_desktop_win32.c
@@ -566,100 +566,100 @@ static KeyboardKey GetKeyFromWparam(WPARAM wparam)
         case 'X': return KEY_X;
         case 'Y': return KEY_Y;
         case 'Z': return KEY_Z;
-        //case VK_LWIN: return KEY_;
-        //case VK_RWIN: return KEY_;
-        //case VK_APPS: return KEY_;
-        //case VK_SLEEP: return KEY_;
-        //case VK_NUMPAD0: return KEY_;
-        //case VK_NUMPAD1: return KEY_;
-        //case VK_NUMPAD2: return KEY_;
-        //case VK_NUMPAD3: return KEY_;
-        //case VK_NUMPAD4: return KEY_;
-        //case VK_NUMPAD5: return KEY_;
-        //case VK_NUMPAD6: return KEY_;
-        //case VK_NUMPAD7: return KEY_;
-        //case VK_NUMPAD8: return KEY_;
-        //case VK_NUMPAD9: return KEY_;
-        //case VK_MULTIPLY: return KEY_;
-        //case VK_ADD: return KEY_;
-        //case VK_SEPARATOR: return KEY_;
-        //case VK_SUBTRACT: return KEY_;
-        //case VK_DECIMAL: return KEY_;
-        //case VK_DIVIDE: return KEY_;
-        //case VK_F1: return KEY_;
-        //case VK_F2: return KEY_;
-        //case VK_F3: return KEY_;
-        //case VK_F4: return KEY_;
-        //case VK_F5: return KEY_;
-        //case VK_F6: return KEY_;
-        //case VK_F7: return KEY_;
-        //case VK_F8: return KEY_;
-        //case VK_F9: return KEY_;
-        //case VK_F10: return KEY_;
-        //case VK_F11: return KEY_;
-        //case VK_F12: return KEY_;
-        //case VK_F13: return KEY_;
-        //case VK_F14: return KEY_;
-        //case VK_F15: return KEY_;
-        //case VK_F16: return KEY_;
-        //case VK_F17: return KEY_;
-        //case VK_F18: return KEY_;
-        //case VK_F19: return KEY_;
-        //case VK_F20: return KEY_;
-        //case VK_F21: return KEY_;
-        //case VK_F22: return KEY_;
-        //case VK_F23: return KEY_;
-        //case VK_F24: return KEY_;
-        //case VK_NUMLOCK: return KEY_;
-        //case VK_SCROLL: return KEY_;
-        //case VK_LSHIFT: return KEY_;
-        //case VK_RSHIFT: return KEY_;
-        //case VK_LCONTROL: return KEY_;
-        //case VK_RCONTROL: return KEY_;
-        //case VK_LMENU: return KEY_;
-        //case VK_RMENU: return KEY_;
-        //case VK_BROWSER_BACK: return KEY_;
-        //case VK_BROWSER_FORWARD: return KEY_;
-        //case VK_BROWSER_REFRESH: return KEY_;
-        //case VK_BROWSER_STOP: return KEY_;
-        //case VK_BROWSER_SEARCH: return KEY_;
-        //case VK_BROWSER_FAVORITES: return KEY_;
-        //case VK_BROWSER_HOME: return KEY_;
-        //case VK_VOLUME_MUTE: return KEY_;
-        //case VK_VOLUME_DOWN: return KEY_;
-        //case VK_VOLUME_UP: return KEY_;
-        //case VK_MEDIA_NEXT_TRACK: return KEY_;
-        //case VK_MEDIA_PREV_TRACK: return KEY_;
-        //case VK_MEDIA_STOP: return KEY_;
-        //case VK_MEDIA_PLAY_PAUSE: return KEY_;
-        //case VK_LAUNCH_MAIL: return KEY_;
-        //case VK_LAUNCH_MEDIA_SELECT: return KEY_;
-        //case VK_LAUNCH_APP1: return KEY_;
-        //case VK_LAUNCH_APP2: return KEY_;
-        //case VK_OEM_1: return KEY_;
-        //case VK_OEM_PLUS: return KEY_;
-        //case VK_OEM_COMMA: return KEY_;
-        //case VK_OEM_MINUS: return KEY_;
-        //case VK_OEM_PERIOD: return KEY_;
-        //case VK_OEM_2: return KEY_;
-        //case VK_OEM_3: return KEY_;
-        //case VK_OEM_4: return KEY_;
-        //case VK_OEM_5: return KEY_;
-        //case VK_OEM_6: return KEY_;
-        //case VK_OEM_7: return KEY_;
-        //case VK_OEM_8: return KEY_;
-        //case VK_OEM_102: return KEY_;
-        //case VK_PROCESSKEY: return KEY_;
-        //case VK_PACKET: return KEY_;
-        //case VK_ATTN: return KEY_;
-        //case VK_CRSEL: return KEY_;
-        //case VK_EXSEL: return KEY_;
-        //case VK_EREOF: return KEY_;
-        //case VK_PLAY: return KEY_;
-        //case VK_ZOOM: return KEY_;
-        //case VK_NONAME: return KEY_;
-        //case VK_PA1: return KEY_;
-        //case VK_OEM_CLEAR: return KEY_;
+        /* case VK_LWIN: return KEY_; */
+        /* case VK_RWIN: return KEY_; */
+        /* case VK_APPS: return KEY_; */
+        /* case VK_SLEEP: return KEY_; */
+        /* case VK_NUMPAD0: return KEY_; */
+        /* case VK_NUMPAD1: return KEY_; */
+        /* case VK_NUMPAD2: return KEY_; */
+        /* case VK_NUMPAD3: return KEY_; */
+        /* case VK_NUMPAD4: return KEY_; */
+        /* case VK_NUMPAD5: return KEY_; */
+        /* case VK_NUMPAD6: return KEY_; */
+        /* case VK_NUMPAD7: return KEY_; */
+        /* case VK_NUMPAD8: return KEY_; */
+        /* case VK_NUMPAD9: return KEY_; */
+        /* case VK_MULTIPLY: return KEY_; */
+        /* case VK_ADD: return KEY_; */
+        /* case VK_SEPARATOR: return KEY_; */
+        /* case VK_SUBTRACT: return KEY_; */
+        /* case VK_DECIMAL: return KEY_; */
+        /* case VK_DIVIDE: return KEY_; */
+        /* case VK_F1: return KEY_; */
+        /* case VK_F2: return KEY_; */
+        /* case VK_F3: return KEY_; */
+        /* case VK_F4: return KEY_; */
+        /* case VK_F5: return KEY_; */
+        /* case VK_F6: return KEY_; */
+        /* case VK_F7: return KEY_; */
+        /* case VK_F8: return KEY_; */
+        /* case VK_F9: return KEY_; */
+        /* case VK_F10: return KEY_; */
+        /* case VK_F11: return KEY_; */
+        /* case VK_F12: return KEY_; */
+        /* case VK_F13: return KEY_; */
+        /* case VK_F14: return KEY_; */
+        /* case VK_F15: return KEY_; */
+        /* case VK_F16: return KEY_; */
+        /* case VK_F17: return KEY_; */
+        /* case VK_F18: return KEY_; */
+        /* case VK_F19: return KEY_; */
+        /* case VK_F20: return KEY_; */
+        /* case VK_F21: return KEY_; */
+        /* case VK_F22: return KEY_; */
+        /* case VK_F23: return KEY_; */
+        /* case VK_F24: return KEY_; */
+        /* case VK_NUMLOCK: return KEY_; */
+        /* case VK_SCROLL: return KEY_; */
+        /* case VK_LSHIFT: return KEY_; */
+        /* case VK_RSHIFT: return KEY_; */
+        /* case VK_LCONTROL: return KEY_; */
+        /* case VK_RCONTROL: return KEY_; */
+        /* case VK_LMENU: return KEY_; */
+        /* case VK_RMENU: return KEY_; */
+        /* case VK_BROWSER_BACK: return KEY_; */
+        /* case VK_BROWSER_FORWARD: return KEY_; */
+        /* case VK_BROWSER_REFRESH: return KEY_; */
+        /* case VK_BROWSER_STOP: return KEY_; */
+        /* case VK_BROWSER_SEARCH: return KEY_; */
+        /* case VK_BROWSER_FAVORITES: return KEY_; */
+        /* case VK_BROWSER_HOME: return KEY_; */
+        /* case VK_VOLUME_MUTE: return KEY_; */
+        /* case VK_VOLUME_DOWN: return KEY_; */
+        /* case VK_VOLUME_UP: return KEY_; */
+        /* case VK_MEDIA_NEXT_TRACK: return KEY_; */
+        /* case VK_MEDIA_PREV_TRACK: return KEY_; */
+        /* case VK_MEDIA_STOP: return KEY_; */
+        /* case VK_MEDIA_PLAY_PAUSE: return KEY_; */
+        /* case VK_LAUNCH_MAIL: return KEY_; */
+        /* case VK_LAUNCH_MEDIA_SELECT: return KEY_; */
+        /* case VK_LAUNCH_APP1: return KEY_; */
+        /* case VK_LAUNCH_APP2: return KEY_; */
+        /* case VK_OEM_1: return KEY_; */
+        /* case VK_OEM_PLUS: return KEY_; */
+        /* case VK_OEM_COMMA: return KEY_; */
+        /* case VK_OEM_MINUS: return KEY_; */
+        /* case VK_OEM_PERIOD: return KEY_; */
+        /* case VK_OEM_2: return KEY_; */
+        /* case VK_OEM_3: return KEY_; */
+        /* case VK_OEM_4: return KEY_; */
+        /* case VK_OEM_5: return KEY_; */
+        /* case VK_OEM_6: return KEY_; */
+        /* case VK_OEM_7: return KEY_; */
+        /* case VK_OEM_8: return KEY_; */
+        /* case VK_OEM_102: return KEY_; */
+        /* case VK_PROCESSKEY: return KEY_; */
+        /* case VK_PACKET: return KEY_; */
+        /* case VK_ATTN: return KEY_; */
+        /* case VK_CRSEL: return KEY_; */
+        /* case VK_EXSEL: return KEY_; */
+        /* case VK_EREOF: return KEY_; */
+        /* case VK_PLAY: return KEY_; */
+        /* case VK_ZOOM: return KEY_; */
+        /* case VK_NONAME: return KEY_; */
+        /* case VK_PA1: return KEY_; */
+        /* case VK_OEM_CLEAR: return KEY_; */
         default: return KEY_NULL;
     }
 }
@@ -1023,7 +1023,7 @@ void SetWindowFocused(void)
 // Get native window handle
 void *GetWindowHandle(void)
 {
-    return (void *)platform.hwnd;
+    return platform.hwnd;
 }
 
 int GetMonitorCount(void)
@@ -1129,37 +1129,12 @@ const char *GetClipboardText(void)
     return NULL;
 }
 
-#if SUPPORT_CLIPBOARD_IMAGE && SUPPORT_MODULE_RTEXTURES
-    #define WIN32_CLIPBOARD_IMPLEMENTATION
-    #define WINUSER_ALREADY_INCLUDED
-    #define WINBASE_ALREADY_INCLUDED
-    #define WINGDI_ALREADY_INCLUDED
-    #include "../external/win32_clipboard.h"
-#endif
-
 // Get clipboard image
 Image GetClipboardImage(void)
 {
     Image image = { 0 };
 
-#if SUPPORT_CLIPBOARD_IMAGE && SUPPORT_MODULE_RTEXTURES
-    unsigned int dataSize = 0;
-    void *fileData = NULL;
-    int width = 0;
-    int height = 0;
-
-    fileData = (void *)Win32GetClipboardImageData(&width, &height, &dataSize);
-
-    if (fileData == NULL) TRACELOG(LOG_WARNING, "Clipboard image: Couldn't get clipboard data.");
-    else 
-    {
-        image = LoadImageFromMemory(".bmp", (const unsigned char*)fileData, (int)dataSize);
-
-        RL_FREE(fileData);
-    }
-#else
-    TRACELOG(LOG_WARNING, "Clipboard image: SUPPORT_CLIPBOARD_IMAGE requires SUPPORT_MODULE_RTEXTURES to work properly");
-#endif // SUPPORT_CLIPBOARD_IMAGE
+    TRACELOG(LOG_WARNING, "GetClipboardText not implemented");
 
     return image;
 }
@@ -1171,7 +1146,7 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     // NOTE: Using SetCursor() instead of ShowCursor() because
@@ -1180,7 +1155,7 @@ void HideCursor(void)
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     if (CORE.Input.Mouse.cursorLocked)
@@ -1272,28 +1247,18 @@ double GetTime(void)
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if the provided URL is safe
+// A user could craft a malicious string performing another action
+// Avoid calling this function with user input non-validated strings
+// REF: https://github.com/raysan5/raylib/issues/686
 void OpenURL(const char *url)
 {
-    // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    // Security check to (partially) avoid malicious code on target platform
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else
     {
-        int len = strlen(url) + 16;
-        char *cmd = (char *)RL_CALLOC(len, sizeof(char));
-        snprintf(cmd, len, "explorer \"%s\"", url);
-
+        char *cmd = (char *)RL_CALLOC(strlen(url) + 32, sizeof(char));
+        sprintf(cmd, "explorer \"%s\"", url);
         int result = system(cmd);
         if (result == -1) TRACELOG(LOG_WARNING, "OpenURL() child process could not be created");
         RL_FREE(cmd);
@@ -1324,8 +1289,8 @@ void SetMousePosition(int x, int y)
     if (!CORE.Input.Mouse.cursorLocked)
     {
         CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
-
-        TRACELOG(LOG_WARNING, "SetMousePosition not implemented at platform level");
+        CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
+        TRACELOG(LOG_WARNING, "SetMousePosition not implemented");
     }
     else TRACELOG(LOG_WARNING, "INPUT: MOUSE: Cursor not enabled");
 }
@@ -1561,6 +1526,7 @@ int InitPlatform(void)
         if (hr < 0) TRACELOG(LOG_ERROR, "%s failed, hresult=0x%lx", "SetProcessDpiAwareness", (DWORD)hr);
     }
 */
+
     HINSTANCE hInstance = GetModuleHandleW(0);
 
     // Define window class
@@ -1809,9 +1775,9 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lpara
             // WARNING: Don't trust the docs, they say this message can not be obtained if not calling DefWindowProc()
             // in response to WM_WINDOWPOSCHANGED but looks like when a window is created,
             // this message can be obtained without getting WM_WINDOWPOSCHANGED
-
+            
 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
-            // WARNING: Waiting two frames before resizing because software-renderer backend is initilized with swInit() later
+            // WARNING: Waiting two frames before resizing because software-renderer backend is initilized with swInit() later 
             // than InitPlatform(), that triggers WM_SIZE, so avoid crashing
             if (CORE.Time.frameCounter > 2) HandleWindowResize(hwnd, &platform.appScreenWidth, &platform.appScreenHeight);
 #else
@@ -2068,7 +2034,7 @@ static void HandleKey(WPARAM wparam, LPARAM lparam, char state)
     {
         CORE.Input.Keyboard.currentKeyState[key] = state;
 
-        if ((key == CORE.Input.Keyboard.exitKey) && (state == 1)) CORE.Window.shouldClose = true;
+        if ((key == KEY_ESCAPE) && (state == 1)) CORE.Window.shouldClose = true;
     }
     else TRACELOG(LOG_WARNING, "INPUT: Unknown (or currently unhandled) virtual keycode %d (0x%x)", wparam, wparam);
 
@@ -2087,11 +2053,8 @@ static void HandleMouseButton(int button, char state)
 static void HandleRawInput(LPARAM lparam)
 {
     RAWINPUT input = { 0 };
-    UINT inputSize = 0;
-
-    if (GetRawInputData((HRAWINPUT)lparam, RID_INPUT, NULL, &inputSize, sizeof(RAWINPUTHEADER)) != 0) return;
-    if (inputSize > sizeof(input)) return;
 
+    UINT inputSize = sizeof(input);
     UINT size = GetRawInputData((HRAWINPUT)lparam, RID_INPUT, &input, &inputSize, sizeof(RAWINPUTHEADER));
 
     if (size == (UINT)-1) TRACELOG(LOG_ERROR, "WIN32: Failed to get raw input data [ERROR: %lu]", GetLastError());
@@ -2247,7 +2210,7 @@ static unsigned SanitizeFlags(int mode, unsigned flags)
 //
 // This design takes care of many odd corner cases. For example, in case of restoring
 // a window that was previously maximized AND minimized and those two flags need to be removed,
-// ShowWindow with SW_RESTORE twice need to be actually calleed. Another example is
+// ShowWindow with SW_RESTORE twice need to bee actually calleed. Another example is
 // wheen having a maximized window, if the undecorated flag is modified then the window style
 // needs to be updated, but updating the style would mean the window size would change
 // causing the window to lose its Maximized state which would mean the window size
@@ -2308,4 +2271,4 @@ static bool IsWglExtensionAvailable(HDC hdc, const char *extension)
     }
 
     return result;
-}
+}
\ No newline at end of file
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_drm.c b/src/libraries/raylib/raylib/src/platforms/rcore_drm.c
index 9fa2ea0..98c35f7 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_drm.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_drm.c
@@ -79,11 +79,7 @@
     #include <poll.h>       // Required for: drmHandleEvent() poll
     #include <errno.h>      // Required for: EBUSY, EAGAIN
 
-    // NOTE: Some drivers rotate more buffers than others, mesa uses 3 but the
-    // ARM Mali blob on RK3326 uses 4. A buffer beyond this count can not get a
-    // framebuffer and the display stops updating for good, so this must not be
-    // lower than any driver in use
-    #define MAX_DRM_CACHED_BUFFERS  4
+    #define MAX_DRM_CACHED_BUFFERS  3
 #endif
 
 #ifndef EGL_OPENGL_ES3_BIT
@@ -114,9 +110,6 @@ typedef struct {
     drmModeCrtc *crtc;                  // CRT Controller
     int modeIndex;                      // Index of the used mode of connector->modes
     uint32_t prevFB;                    // Previous DRM framebufer (during frame swapping)
-#if defined(SUPPORT_DRM_CACHE)
-    bool fbCacheFullReported;           // Framebuffer cache exhaustion already reported
-#endif
 
 #if !defined(GRAPHICS_API_OPENGL_SOFTWARE)
     struct gbm_device *gbmDevice;       // GBM device
@@ -273,12 +266,9 @@ static void PollKeyboardEvents(void);           // Process evdev keyboard events
 static void PollGamepadEvents(void);            // Process evdev gamepad events
 static void PollMouseEvents(void);              // Process evdev mouse events
 
-// Not used by software rendering.
-#if !defined(GRAPHICS_API_OPENGL_SOFTWARE)
 static int FindMatchingConnectorMode(const drmModeConnector *connector, const drmModeModeInfo *mode);                               // Search matching DRM mode in connector's mode list
 static int FindExactConnectorMode(const drmModeConnector *connector, uint width, uint height, uint fps, bool allowInterlaced);      // Search exactly matching DRM connector mode in connector's list
 static int FindNearestConnectorMode(const drmModeConnector *connector, uint width, uint height, uint fps, bool allowInterlaced);    // Search the nearest matching DRM connector mode in connector's list
-#endif
 
 static void SetupFramebuffer(int width, int height); // Setup main framebuffer (required by InitPlatform())
 
@@ -571,13 +561,13 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     // Set cursor position in the middle
@@ -587,7 +577,7 @@ void EnableCursor(void)
     CORE.Input.Mouse.cursorLocked = false;
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     // Set cursor position in the middle
@@ -631,18 +621,7 @@ static uint32_t GetOrCreateFbForBo(struct gbm_bo *bo)
     }
 
     // Create new entry if cache not full
-    if (fbCacheCount >= MAX_DRM_CACHED_BUFFERS)
-    {
-        // NOTE: Once this happens no page flip is ever scheduled again and the
-        // screen freezes while the game keeps running, so say it out loud once
-        if (!platform.fbCacheFullReported)
-        {
-            platform.fbCacheFullReported = true;
-            TRACELOG(LOG_WARNING, "DISPLAY: DRM: Framebuffer cache full (%i buffers), display will stop updating", MAX_DRM_CACHED_BUFFERS);
-        }
-
-        return 0; // FB cache full
-    }
+    if (fbCacheCount >= MAX_DRM_CACHED_BUFFERS) return 0; // FB cache full
 
     uint32_t handle = gbm_bo_get_handle(bo).u32;
     uint32_t stride = gbm_bo_get_stride(bo);
@@ -1024,16 +1003,17 @@ double GetTime(void)
     double time = 0.0;
     struct timespec ts = { 0 };
     clock_gettime(CLOCK_MONOTONIC, &ts);
-    unsigned long long nanoSeconds = (unsigned long long)ts.tv_sec*1000000000LLU + (unsigned long long)ts.tv_nsec;
+    unsigned long long int nanoSeconds = (unsigned long long int)ts.tv_sec*1000000000LLU + (unsigned long long int)ts.tv_nsec;
 
-    time = (double)(nanoSeconds - CORE.Time.base)*1e-9; // Elapsed time since InitTimer()
+    time = (double)(nanoSeconds - CORE.Time.base)*1e-9;  // Elapsed time since InitTimer()
 
     return time;
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
+// NOTE: This function is only safe to use if the provided URL is safe
+// A user could craft a malicious string performing another action
+// Avoid calling this function with user input non-validated strings
 void OpenURL(const char *url)
 {
     TRACELOG(LOG_WARNING, "OpenURL() not implemented on target platform");
@@ -1060,6 +1040,7 @@ void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float d
 void SetMousePosition(int x, int y)
 {
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 }
 
 // Set mouse cursor
@@ -1089,7 +1070,7 @@ void PollInputEvents(void)
     CORE.Input.Keyboard.charPressedQueueCount = 0;
 
     // Reset last gamepad button/axis registered state
-    CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
+    CORE.Input.Gamepad.lastButtonPressed = 0;       // GAMEPAD_BUTTON_UNKNOWN
     //CORE.Input.Gamepad.axisCount = 0;
 
     // Register previous keys states
@@ -1136,7 +1117,7 @@ void PollInputEvents(void)
     // NOTE: For DRM touchscreen devices, this mapping is disabled to avoid false touch detection
     // CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
 
-    // Handle the mouse/touch/gestures events
+    // Handle the mouse/touch/gestures events:
     PollMouseEvents();
 }
 
@@ -1462,9 +1443,7 @@ int InitPlatform(void)
         return -1;
     }
 
-    // WARNING: Providing framebufferAttribs is not logically necessary,
-    // but it may prevent segfaults on some nvidia drivers
-    if (!eglChooseConfig(platform.device, framebufferAttribs, NULL, 0, &numConfigs))
+    if (!eglChooseConfig(platform.device, NULL, NULL, 0, &numConfigs))
     {
         TRACELOG(LOG_WARNING, "DISPLAY: Failed to get EGL config count: 0x%x", eglGetError());
         return -1;
@@ -1839,7 +1818,7 @@ static void ProcessKeyboard(void)
             if (bufferByteCount == 1) CORE.Input.Keyboard.currentKeyState[CORE.Input.Keyboard.exitKey] = 1;
             else
             {
-                if (keysBuffer[i + 1] == 0x5b) // Special function key
+                if (keysBuffer[i + 1] == 0x5b)    // Special function key
                 {
                     if ((keysBuffer[i + 2] == 0x5b) || (keysBuffer[i + 2] == 0x31) || (keysBuffer[i + 2] == 0x32))
                     {
@@ -1956,8 +1935,7 @@ static void InitEvdevInput(void)
                 (strncmp("mouse", entity->d_name, strlen("mouse")) == 0))       // Search for devices named "mouse*"
             {
                 snprintf(path, MAX_FILEPATH_LENGTH, "%s%s", DEFAULT_EVDEV_PATH, entity->d_name);
-
-                ConfigureEvdevDevice(path); // Configure the device if appropriate
+                ConfigureEvdevDevice(path);                                     // Configure the device if appropriate
             }
         }
 
@@ -2582,7 +2560,6 @@ static void PollMouseEvents(void)
     }
 }
 
-#if !defined(GRAPHICS_API_OPENGL_SOFTWARE)
 // Search matching DRM mode in connector's mode list
 static int FindMatchingConnectorMode(const drmModeConnector *connector, const drmModeModeInfo *mode)
 {
@@ -2671,7 +2648,6 @@ static int FindNearestConnectorMode(const drmModeConnector *connector, uint widt
 
     return nearestIndex;
 }
-#endif
 
 // Compute framebuffer size relative to screen size and display size
 // NOTE: Global variables CORE.Window.render.width/CORE.Window.render.height and CORE.Window.renderOffset.x/CORE.Window.renderOffset.y can be modified
@@ -2751,4 +2727,4 @@ static void SetupFramebuffer(int width, int height)
     }
 }
 
-// EOF
+// EOF
\ No newline at end of file
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_memory.c b/src/libraries/raylib/raylib/src/platforms/rcore_memory.c
index 5d9461c..1512e7b 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_memory.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_memory.c
@@ -91,7 +91,7 @@ bool InitGraphicsDevice(void);          // Initialize graphics device
 // Module Internal Functions Declaration
 //----------------------------------------------------------------------------------
 #if !defined(_WIN32)
-static int kbhit(void);                         // Check if key has been pressed
+static int kbhit(void);                         // Check if a key has been pressed
 static char getch(void) { return getchar(); }   // Get pressed character
 #endif
 
@@ -324,13 +324,13 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     // Set cursor position in the middle
@@ -339,7 +339,7 @@ void EnableCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     // Set cursor position in the middle
@@ -364,18 +364,14 @@ double GetTime(void)
 {
     double time = 0.0;
 #if defined(_WIN32)
-    LARGE_INTEGER currentTicks = { 0 };
-    QueryPerformanceCounter(&currentTicks);
-
-    time = (double)(currentTicks.QuadPart - CORE.Time.base)/(double)platform.timerFrequency.QuadPart;
+    LARGE_INTEGER now = { 0 };
+    QueryPerformanceCounter(&now);
+    return (double)(now.QuadPart - CORE.Time.base)/(double)platform.timerFrequency.QuadPart;
 #elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__EMSCRIPTEN__)
     struct timespec ts = { 0 };
     clock_gettime(CLOCK_MONOTONIC, &ts);
-    unsigned long long nanoSeconds = (unsigned long long)ts.tv_sec*1000000000LLU + (unsigned long long)ts.tv_nsec;
-
-    time = (double)(nanoSeconds - CORE.Time.base)*1e-9; // Elapsed time since InitTimer()
-#elif defined(PICO_RP2350)
-    time = (double)to_ms_since_boot(get_absolute_time())/1000.0;
+    unsigned long long int nanoSeconds = (unsigned long long int)ts.tv_sec*1000000000LLU + (unsigned long long int)ts.tv_nsec;
+    time = (double)(nanoSeconds - CORE.Time.base)*1e-9;  // Elapsed time since InitTimer()
 #endif
     return time;
 }
@@ -420,6 +416,7 @@ void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float d
 void SetMousePosition(int x, int y)
 {
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 }
 
 // Set mouse cursor
@@ -477,7 +474,7 @@ void PollInputEvents(void)
     if (kbhit())
     {
         int key = getch();
-        if (key == 27) CORE.Window.shouldClose = true; // KEY_ESCAPE
+        if (key == 27) CORE.Window.shouldClose = true; // KEY_SCAPE
     }
 }
 
@@ -561,7 +558,7 @@ void ClosePlatform(void)
 // Module Internal Functions Definition
 //----------------------------------------------------------------------------------
 #if !defined(_WIN32)
-// Check if key has been pressed
+// Check if a key has been pressed
 static int kbhit(void)
 {
     struct termios oldt = { 0 };
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_template.c b/src/libraries/raylib/raylib/src/platforms/rcore_template.c
index 1866059..c48484a 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_template.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_template.c
@@ -303,13 +303,13 @@ void ShowCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     CORE.Input.Mouse.cursorHidden = true;
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     // Set cursor position in the middle
@@ -318,7 +318,7 @@ void EnableCursor(void)
     CORE.Input.Mouse.cursorHidden = false;
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     // Set cursor position in the middle
@@ -341,33 +341,23 @@ void SwapScreenBuffer(void)
 double GetTime(void)
 {
     double time = 0.0;
-
     struct timespec ts = { 0 };
     clock_gettime(CLOCK_MONOTONIC, &ts);
-    unsigned long long nanoSeconds = (unsigned long long)ts.tv_sec*1000000000LLU + (unsigned long long)ts.tv_nsec;
-
-    time = (double)(nanoSeconds - CORE.Time.base)*1e-9; // Elapsed time since InitTimer()
+    unsigned long long int nanoSeconds = (unsigned long long int)ts.tv_sec*1000000000LLU + (unsigned long long int)ts.tv_nsec;
+    time = (double)(nanoSeconds - CORE.Time.base)*1e-9;  // Elapsed time since InitTimer()
 
     return time;
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if you control the URL given.
+// A user could craft a malicious string performing another action.
+// Only call this function yourself not with user input or make sure to check the string yourself.
+// Ref: https://github.com/raysan5/raylib/issues/686
 void OpenURL(const char *url)
 {
-    // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    // Security check to (partially) avoid malicious code on target platform
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else
     {
         // TODO: Load url using default browser
@@ -395,6 +385,7 @@ void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float d
 void SetMousePosition(int x, int y)
 {
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 }
 
 // Set mouse cursor
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_web.c b/src/libraries/raylib/raylib/src/platforms/rcore_web.c
index a507583..e7e1741 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_web.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_web.c
@@ -76,6 +76,7 @@ typedef struct {
 
     char canvasId[64];                  // Keep current canvas id where wasm app is running
                                         // NOTE: Useful when trying to run multiple wasms in different canvases in same webpage
+
 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
     unsigned int *pixels;               // Pointer to pixel data buffer (RGBA 32bit format)
 #endif
@@ -912,7 +913,7 @@ void ShowCursor(void)
     }
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     if (!CORE.Input.Mouse.cursorHidden)
@@ -923,7 +924,7 @@ void HideCursor(void)
     }
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     emscripten_exit_pointerlock();
@@ -934,7 +935,7 @@ void EnableCursor(void)
     // NOTE: CORE.Input.Mouse.cursorLocked handled by EmscriptenPointerlockCallback()
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     emscripten_request_pointerlock(platform.canvasId, 1);
@@ -1047,6 +1048,7 @@ void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float d
 void SetMousePosition(int x, int y)
 {
     CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
+    CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
 
     if (CORE.Input.Mouse.cursorLocked) CORE.Input.Mouse.lockedPosition = CORE.Input.Mouse.currentPosition;
 
@@ -1086,7 +1088,7 @@ void PollInputEvents(void)
     CORE.Input.Keyboard.charPressedQueueCount = 0;
 
     // Reset last gamepad button/axis registered state
-    CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
+    CORE.Input.Gamepad.lastButtonPressed = 0;       // GAMEPAD_BUTTON_UNKNOWN
     //CORE.Input.Gamepad.axisCount = 0;
 
     // Keyboard/Mouse input polling (automatically managed by GLFW3 through callback)
@@ -1128,7 +1130,7 @@ void PollInputEvents(void)
         // Register previous gamepad button states
         for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) CORE.Input.Gamepad.previousButtonState[i][k] = CORE.Input.Gamepad.currentButtonState[i][k];
 
-        EmscriptenGamepadEvent gamepadState = { 0 };
+        EmscriptenGamepadEvent gamepadState;
 
         int result = emscripten_get_gamepad_status(i, &gamepadState);
 
@@ -1161,7 +1163,7 @@ void PollInputEvents(void)
                     default: break;
                 }
 
-                if (button + 1 != 0) // Check for valid button
+                if (button + 1 != 0)   // Check for valid button
                 {
                     if (gamepadState.digitalButton[j] == 1)
                     {
@@ -1578,7 +1580,7 @@ static void WindowDropCallback(GLFWwindow *window, int count, const char **paths
         for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++)
         {
             CORE.Window.dropFilepaths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
-            snprintf(CORE.Window.dropFilepaths[i], MAX_FILEPATH_LENGTH, "%s", paths[i]);
+            strncpy(CORE.Window.dropFilepaths[i], paths[i], MAX_FILEPATH_LENGTH - 1);
         }
     }
 }
diff --git a/src/libraries/raylib/raylib/src/platforms/rcore_web_emscripten.c b/src/libraries/raylib/raylib/src/platforms/rcore_web_emscripten.c
index 6e7d40e..186813f 100644
--- a/src/libraries/raylib/raylib/src/platforms/rcore_web_emscripten.c
+++ b/src/libraries/raylib/raylib/src/platforms/rcore_web_emscripten.c
@@ -42,7 +42,6 @@
 **********************************************************************************************/
 
 #include <emscripten/emscripten.h>      // Emscripten functionality for C
-#include <emscripten/dom_pk_codes.h>    // Emscripten physical keyboard codes
 #include <emscripten/html5.h>           // Emscripten HTML5 library
 
 #include <sys/time.h>   // Required for: timespec, nanosleep(), select() - POSIX
@@ -55,9 +54,6 @@
     #define _POSIX_C_SOURCE 199309L     // Required for: CLOCK_MONOTONIC if compiled with c99 without gnu ext.
 #endif
 
-#define DOM_PK_CODE_MAPPED_NUM          128
-#define DOM_PK_CODE_EXTENDED_OFFSET     0xE000
-
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
@@ -74,121 +70,9 @@ extern CoreData CORE;                   // Global CORE state context
 
 static PlatformData platform = { 0 };   // Platform specific data
 
-static const KeyboardKey mapDomCodeToKey[DOM_PK_CODE_MAPPED_NUM] = {
-    [DOM_PK_ESCAPE] = KEY_ESCAPE,
-    [DOM_PK_0] = KEY_ZERO,
-    [DOM_PK_1] = KEY_ONE,
-    [DOM_PK_2] = KEY_TWO,
-    [DOM_PK_3] = KEY_THREE,
-    [DOM_PK_4] = KEY_FOUR,
-    [DOM_PK_5] = KEY_FIVE,
-    [DOM_PK_6] = KEY_SIX,
-    [DOM_PK_7] = KEY_SEVEN,
-    [DOM_PK_8] = KEY_EIGHT,
-    [DOM_PK_9] = KEY_NINE,
-    [DOM_PK_MINUS] = KEY_MINUS,
-    [DOM_PK_EQUAL] = KEY_EQUAL,
-    [DOM_PK_BACKSPACE] = KEY_BACKSPACE,
-    [DOM_PK_TAB] = KEY_TAB,
-    [DOM_PK_Q] = KEY_Q,
-    [DOM_PK_W] = KEY_W,
-    [DOM_PK_E] = KEY_E,
-    [DOM_PK_R] = KEY_R,
-    [DOM_PK_T] = KEY_T,
-    [DOM_PK_Y] = KEY_Y,
-    [DOM_PK_U] = KEY_U,
-    [DOM_PK_I] = KEY_I,
-    [DOM_PK_O] = KEY_O,
-    [DOM_PK_P] = KEY_P,
-    [DOM_PK_BRACKET_LEFT] = KEY_LEFT_BRACKET,
-    [DOM_PK_BRACKET_RIGHT] = KEY_RIGHT_BRACKET,
-    [DOM_PK_ENTER] = KEY_ENTER,
-    [DOM_PK_CONTROL_LEFT] = KEY_LEFT_CONTROL,
-    [DOM_PK_A] = KEY_A,
-    [DOM_PK_S] = KEY_S,
-    [DOM_PK_D] = KEY_D,
-    [DOM_PK_F] = KEY_F,
-    [DOM_PK_G] = KEY_G,
-    [DOM_PK_H] = KEY_H,
-    [DOM_PK_J] = KEY_J,
-    [DOM_PK_K] = KEY_K,
-    [DOM_PK_L] = KEY_L,
-    [DOM_PK_SEMICOLON] = KEY_SEMICOLON,
-    [DOM_PK_QUOTE] = KEY_APOSTROPHE,
-    [DOM_PK_BACKQUOTE] = KEY_GRAVE,
-    [DOM_PK_SHIFT_LEFT] = KEY_LEFT_SHIFT,
-    [DOM_PK_BACKSLASH] = KEY_BACKSLASH,
-    [DOM_PK_Z] = KEY_Z,
-    [DOM_PK_X] = KEY_X,
-    [DOM_PK_C] = KEY_C,
-    [DOM_PK_V] = KEY_V,
-    [DOM_PK_B] = KEY_B,
-    [DOM_PK_N] = KEY_N,
-    [DOM_PK_M] = KEY_M,
-    [DOM_PK_COMMA] = KEY_COMMA,
-    [DOM_PK_PERIOD] = KEY_PERIOD,
-    [DOM_PK_SLASH] = KEY_SLASH,
-    [DOM_PK_SHIFT_RIGHT] = KEY_RIGHT_SHIFT,
-    [DOM_PK_NUMPAD_MULTIPLY] = KEY_KP_MULTIPLY,
-    [DOM_PK_ALT_LEFT] = KEY_LEFT_ALT,
-    [DOM_PK_SPACE] = KEY_SPACE,
-    [DOM_PK_CAPS_LOCK] = KEY_CAPS_LOCK,
-    [DOM_PK_F1] = KEY_F1,
-    [DOM_PK_F2] = KEY_F2,
-    [DOM_PK_F3] = KEY_F3,
-    [DOM_PK_F4] = KEY_F4,
-    [DOM_PK_F5] = KEY_F5,
-    [DOM_PK_F6] = KEY_F6,
-    [DOM_PK_F7] = KEY_F7,
-    [DOM_PK_F8] = KEY_F8,
-    [DOM_PK_F9] = KEY_F9,
-    [DOM_PK_F10] = KEY_F10,
-    [DOM_PK_PAUSE] = KEY_PAUSE,
-    [DOM_PK_SCROLL_LOCK] = KEY_SCROLL_LOCK,
-    [DOM_PK_NUMPAD_7] = KEY_KP_7,
-    [DOM_PK_NUMPAD_8] = KEY_KP_8,
-    [DOM_PK_NUMPAD_9] = KEY_KP_9,
-    [DOM_PK_NUMPAD_SUBTRACT] = KEY_KP_SUBTRACT,
-    [DOM_PK_NUMPAD_4] = KEY_KP_4,
-    [DOM_PK_NUMPAD_5] = KEY_KP_5,
-    [DOM_PK_NUMPAD_6] = KEY_KP_6,
-    [DOM_PK_NUMPAD_ADD] = KEY_KP_ADD,
-    [DOM_PK_NUMPAD_1] = KEY_KP_1,
-    [DOM_PK_NUMPAD_2] = KEY_KP_2,
-    [DOM_PK_NUMPAD_3] = KEY_KP_3,
-    [DOM_PK_NUMPAD_0] = KEY_KP_0,
-    [DOM_PK_NUMPAD_DECIMAL] = KEY_KP_DECIMAL,
-    [DOM_PK_PRINT_SCREEN] = KEY_PRINT_SCREEN,
-    [DOM_PK_F11] = KEY_F11,
-    [DOM_PK_F12] = KEY_F12,
-    [DOM_PK_NUMPAD_EQUAL] = KEY_KP_EQUAL,
-    [DOM_PK_NUMPAD_COMMA] = KEY_KP_DECIMAL
-};
-
-// Emscripten places keys with extended scan codes (right-side modifiers, navigation and some keypad keys) in the 0xE0xx range
-static const KeyboardKey mapDomCodeToKeyExtended[DOM_PK_CODE_MAPPED_NUM] = {
-    [DOM_PK_NUMPAD_ENTER - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_KP_ENTER,
-    [DOM_PK_CONTROL_RIGHT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_RIGHT_CONTROL,
-    [DOM_PK_AUDIO_VOLUME_DOWN - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_VOLUME_DOWN,
-    [DOM_PK_AUDIO_VOLUME_UP - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_VOLUME_UP,
-    [DOM_PK_NUMPAD_DIVIDE - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_KP_DIVIDE,
-    [DOM_PK_ALT_RIGHT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_RIGHT_ALT,
-    [DOM_PK_NUM_LOCK - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_NUM_LOCK,
-    [DOM_PK_HOME - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_HOME,
-    [DOM_PK_ARROW_UP - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_UP,
-    [DOM_PK_PAGE_UP - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_PAGE_UP,
-    [DOM_PK_ARROW_LEFT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_LEFT,
-    [DOM_PK_ARROW_RIGHT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_RIGHT,
-    [DOM_PK_END - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_END,
-    [DOM_PK_ARROW_DOWN - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_DOWN,
-    [DOM_PK_PAGE_DOWN - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_PAGE_DOWN,
-    [DOM_PK_INSERT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_INSERT,
-    [DOM_PK_DELETE - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_DELETE,
-    [DOM_PK_META_LEFT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_LEFT_SUPER,
-    [DOM_PK_META_RIGHT - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_RIGHT_SUPER,
-    [DOM_PK_CONTEXT_MENU - DOM_PK_CODE_EXTENDED_OFFSET] = KEY_KB_MENU
-};
-
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
 static const char cursorLUT[11][12] = {
     "default",     // 0  MOUSE_CURSOR_DEFAULT
     "default",     // 1  MOUSE_CURSOR_ARROW
@@ -226,8 +110,6 @@ static EM_BOOL EmscriptenPointerlockCallback(int eventType, const EmscriptenPoin
 static EM_BOOL EmscriptenTouchCallback(int eventType, const EmscriptenTouchEvent *touchEvent, void *userData);
 static EM_BOOL EmscriptenGamepadCallback(int eventType, const EmscriptenGamepadEvent *gamepadEvent, void *userData);
 
-static KeyboardKey ConvertKeyboardEventToKey(const EmscriptenKeyboardEvent *keyboardEvent);
-
 // JS: Set the canvas id provided by the module configuration
 EM_JS(void, SetCanvasIdJs, (char *out, int outSize), {
     var canvasId = "#" + Module.canvas.id;
@@ -751,7 +633,7 @@ void SetWindowSize(int width, int height)
     // When resizing the canvas, several elements must be considered:
     // - CSS canvas size: Web layout size, logical pixels
     // - Canvas contained framebuffer resolution
-    // - Browser monitor, device pixel ratio (HighDPI)
+    // * Browser monitor, device pixel ratio (HighDPI)
 
     double canvasCssWidth = 0.0;
     double canvasCssHeight = 0.0;
@@ -1009,7 +891,7 @@ void ShowCursor(void)
     }
 }
 
-// Hide mouse cursor
+// Hides mouse cursor
 void HideCursor(void)
 {
     if (!CORE.Input.Mouse.cursorHidden)
@@ -1020,7 +902,7 @@ void HideCursor(void)
     }
 }
 
-// Enable cursor (unlock cursor)
+// Enables cursor (unlock cursor)
 void EnableCursor(void)
 {
     emscripten_exit_pointerlock();
@@ -1031,7 +913,7 @@ void EnableCursor(void)
     // NOTE: CORE.Input.Mouse.cursorLocked handled by EmscriptenPointerlockCallback()
 }
 
-// Disable cursor (lock cursor)
+// Disables cursor (lock cursor)
 void DisableCursor(void)
 {
     emscripten_request_pointerlock(platform.canvasId, 1);
@@ -1080,28 +962,19 @@ void SwapScreenBuffer(void)
 // Get elapsed time measure in seconds since InitTimer()
 double GetTime(void)
 {
-    double time = emscripten_get_now()/1000.0;
+    double time = emscripten_get_now()*1000.0;
 
     return time;
 }
 
 // Open URL with default system browser (if available)
-// WARNING: This function is only safe to use if you control the URL given,
-// a user could craft a malicious string to perform and undesired action
-// NOTE: Some safety checks have been added to mitigate security issues
+// NOTE: This function is only safe to use if the provided URL is safe
+// A user could craft a malicious string performing another action
+// Avoid calling this function with user input non-validated strings
 void OpenURL(const char *url)
 {
-    // Security check to (partially) avoid malicious code
-    if ((strchr(url, '\'') != NULL) || (strchr(url, '\"') != NULL))
-    {
-        // Filter characters: ' and "
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'\"] characters");
-    }
-    else if ((strncmp(url, "http://", 7) != 0) && (strncmp(url, "https://", 8) != 0))
-    {
-        // Only allow URL starting with "http://" or "https://" protocols
-        TRACELOG(LOG_WARNING, "SYSTEM: Provided URL must start with 'http://' or 'https://' protocols");
-    }
+    // Security check to (partially) avoid malicious code on target platform
+    if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
     else emscripten_run_script(TextFormat("window.open('%s', '_blank')", url));
 }
 
@@ -1181,7 +1054,7 @@ void PollInputEvents(void)
     CORE.Input.Keyboard.charPressedQueueCount = 0;
 
     // Reset last gamepad button/axis registered state
-    CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
+    CORE.Input.Gamepad.lastButtonPressed = 0;       // GAMEPAD_BUTTON_UNKNOWN
     //CORE.Input.Gamepad.axisCount = 0;
 
     // Keyboard/Mouse input polling (automatically managed by GLFW3 through callback)
@@ -1252,7 +1125,7 @@ void PollInputEvents(void)
                     default: break;
                 }
 
-                if (button + 1 != 0) // Check for valid button
+                if (button + 1 != 0)   // Check for valid button
                 {
                     if (gamepadState.digitalButton[j] == 1)
                     {
@@ -1509,11 +1382,7 @@ static EM_BOOL EmscriptenFocusCallback(int eventType, const EmscriptenFocusEvent
 
     switch (eventType)
     {
-        case EMSCRIPTEN_EVENT_BLUR:
-        {
-            FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED);
-            memset(CORE.Input.Keyboard.currentKeyState, 0, sizeof(CORE.Input.Keyboard.currentKeyState));
-        } break;
+        case EMSCRIPTEN_EVENT_BLUR: FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); break;
         case EMSCRIPTEN_EVENT_FOCUS: FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); break;
         default: consumed = 0; break;
     }
@@ -1570,81 +1439,58 @@ static void WindowDropCallback(GLFWwindow *window, int count, const char **paths
         for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++)
         {
             CORE.Window.dropFilepaths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
-            snprintf(CORE.Window.dropFilepaths[i], MAX_FILEPATH_LENGTH, "%s", paths[i]);
+            strncpy(CORE.Window.dropFilepaths[i], paths[i], MAX_FILEPATH_LENGTH - 1);
         }
     }
 }
 */
 
-// Emscripten keyboard event to raylib key mapping
-static KeyboardKey ConvertKeyboardEventToKey(const EmscriptenKeyboardEvent *keyboardEvent)
-{
-    DOM_PK_CODE_TYPE code = emscripten_compute_dom_pk_code(keyboardEvent->code);
-    KeyboardKey key = KEY_NULL;
-
-    if ((code > DOM_PK_UNKNOWN) && (code < DOM_PK_CODE_MAPPED_NUM)) key = mapDomCodeToKey[code];
-    else if ((code >= DOM_PK_CODE_EXTENDED_OFFSET) && (code < (DOM_PK_CODE_EXTENDED_OFFSET + DOM_PK_CODE_MAPPED_NUM)))
-    {
-        key = mapDomCodeToKeyExtended[code - DOM_PK_CODE_EXTENDED_OFFSET];
-    }
-
-    return key;
-}
-
 // Emscripten: Called on key events
+// TODO: keyCodes should be mapped to raylib/GLFW3 Key values
 static EM_BOOL EmscriptenKeyboardCallback(int eventType, const EmscriptenKeyboardEvent *keyboardEvent, void *userData)
 {
-    KeyboardKey key = ConvertKeyboardEventToKey(keyboardEvent);
-    EM_BOOL preventDefault = 1;
-
     switch (eventType)
     {
+        case EMSCRIPTEN_EVENT_KEYPRESS:
+        {
+            if (keyboardEvent->repeat) CORE.Input.Keyboard.keyRepeatInFrame[keyboardEvent->keyCode] = 1;
+        } break;
         case EMSCRIPTEN_EVENT_KEYDOWN:
         {
-            if (key != KEY_NULL)
-            {
-                // Check if there is space available in the key queue
-                if ((!keyboardEvent->repeat) && (CORE.Input.Keyboard.currentKeyState[key] == 0) &&
-                    (CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE))
-                {
-                    CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
-                    CORE.Input.Keyboard.keyPressedQueueCount++;
-                }
-
-                CORE.Input.Keyboard.currentKeyState[key] = 1;
-
-                if (keyboardEvent->repeat) CORE.Input.Keyboard.keyRepeatInFrame[key] = 1;
-
-                // Check the exit key to set close window
-                if ((key == CORE.Input.Keyboard.exitKey) && !keyboardEvent->repeat) CORE.Window.shouldClose = true;
-            }
-
-            // Allow printable keydown events so the browser can emit the keypress event used to collect characters
-            preventDefault = ((key == KEY_BACKSPACE) || (key == KEY_TAB) ||
-                (key == KEY_INSERT) || (key == KEY_DELETE) ||
-                (key == KEY_HOME) || (key == KEY_END) ||
-                (key == KEY_PAGE_UP) || (key == KEY_PAGE_DOWN) ||
-                (key == KEY_LEFT) || (key == KEY_RIGHT) ||
-                (key == KEY_UP) || (key == KEY_DOWN) ||
-                ((key >= KEY_F1) && (key <= KEY_F12)) || keyboardEvent->ctrlKey);
+            CORE.Input.Keyboard.currentKeyState[keyboardEvent->keyCode] = 1;
         } break;
         case EMSCRIPTEN_EVENT_KEYUP:
         {
-            if (key != KEY_NULL) CORE.Input.Keyboard.currentKeyState[key] = 0;
-        } break;
-        case EMSCRIPTEN_EVENT_KEYPRESS:
-        {
-            // Check if there is space available in the queue for characters to be added
-            if ((keyboardEvent->charCode > 0) && (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE))
-            {
-                CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = keyboardEvent->charCode;
-                CORE.Input.Keyboard.charPressedQueueCount++;
-            }
+            CORE.Input.Keyboard.currentKeyState[keyboardEvent->keyCode] = 0;
         } break;
         default: break;
     }
 
-    return preventDefault;
+    // TODO: Add char codes
+    //unsigned int charCode
+    // Check if there is space available in the queue for characters to be added
+    /*
+    if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
+    {
+        // Add character to the queue
+        CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = keyboardEvent->charCode;
+        CORE.Input.Keyboard.charPressedQueueCount++;
+    }
+    */
+    /*
+    // Check if there is space available in the key queue
+    if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (eventType == EMSCRIPTEN_EVENT_KEYPRESS))
+    {
+        // Add character to the queue
+        CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = keyboardEvent->keyCode;
+        CORE.Input.Keyboard.keyPressedQueueCount++;
+    }
+
+    // Check the exit key to set close window
+    //if ((keyboardEvent->keyCode == CORE.Input.Keyboard.exitKey) && (eventType == EMSCRIPTEN_EVENT_KEYPRESS)) CORE.Window.shouldClose = true;
+    */
+
+    return 1; // The event was consumed by the callback handler
 }
 
 // Emscripten: Called on mouse input events
@@ -1652,16 +1498,8 @@ static EM_BOOL EmscriptenMouseCallback(int eventType, const EmscriptenMouseEvent
 {
     switch (eventType)
     {
-        case EMSCRIPTEN_EVENT_MOUSEENTER: {
-            // NOTE: Mouse position updated by EmscriptenMouseMoveCallback(),
-            // EmscriptenPointerlockCallback(), and EmscriptenTouchCallback()
-            CORE.Input.Mouse.cursorOnScreen = true;
-        } break;
-        case EMSCRIPTEN_EVENT_MOUSELEAVE:
-        {
-            CORE.Input.Mouse.cursorOnScreen = false;
-            CORE.Input.Mouse.currentPosition = (Vector2){ 0 };
-        } break;
+        case EMSCRIPTEN_EVENT_MOUSEENTER: CORE.Input.Mouse.cursorOnScreen = true; break;
+        case EMSCRIPTEN_EVENT_MOUSELEAVE: CORE.Input.Mouse.cursorOnScreen = false; break;
         case EMSCRIPTEN_EVENT_MOUSEDOWN:
         {
             // NOTE: Emscripten and raylib buttons indices are not aligned
@@ -1708,8 +1546,7 @@ static EM_BOOL EmscriptenMouseCallback(int eventType, const EmscriptenMouseEvent
     if (GetMouseX() != 0 || GetMouseY() != 0) ProcessGestureEvent(gestureEvent);
 #endif
 
-    // Don't prevent default to allow focusing on canvas
-    return 0;
+    return 1; // The event was consumed by the callback handler
 }
 
 // Emscripten: Called on mouse move events
@@ -1723,18 +1560,32 @@ static EM_BOOL EmscriptenMouseMoveCallback(int eventType, const EmscriptenMouseE
     else
     {
         // Get mouse position in canvas CSS pixels
-        float mouseCssX = (float)mouseEvent->targetX;
-        float mouseCssY = (float)mouseEvent->targetY;
+        float mouseCssX = (float)mouseEvent->canvasX;
+        float mouseCssY = (float)mouseEvent->canvasY;
 
         // Get canvas sizes
         double cssWidth = 0.0;
         double cssHeight = 0.0;
         emscripten_get_element_css_size(platform.canvasId, &cssWidth, &cssHeight);
 
-        float normalizedX = mouseCssX/(float)cssWidth;
-        float normalizedY = mouseCssY/(float)cssHeight;
-        CORE.Input.Mouse.currentPosition.x = normalizedX*(float)CORE.Window.screen.width;
-        CORE.Input.Mouse.currentPosition.y = normalizedY*(float)CORE.Window.screen.height;
+        int fbWidth = 0;
+        int fbHeight = 0;
+        emscripten_get_canvas_element_size(platform.canvasId, &fbWidth, &fbHeight);
+
+        // Convert CSS to framebuffer coordinates
+        float scaleX = (float)fbWidth/(float)cssWidth;
+        float scaleY = (float)fbHeight/(float)cssHeight;
+
+        int mouseX = (int)(mouseCssX*scaleX);
+        int mouseY = (int)(mouseCssY*scaleY);
+
+        CORE.Input.Mouse.currentPosition.x = mouseX;//(float)mouseEvent->canvasX;
+        CORE.Input.Mouse.currentPosition.y = mouseY;//(float)mouseEvent->canvasY;
+
+        // Shorter alternative:
+        //double dpr = emscripten_get_device_pixel_ratio();
+        //int mouseX = (int)(e->canvasX*dpr);
+        //int mouseY = (int)(e->canvasY*dpr);
 
         CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
     }
@@ -1771,7 +1622,7 @@ static EM_BOOL EmscriptenMouseWheelCallback(int eventType, const EmscriptenWheel
     if (eventType == EMSCRIPTEN_EVENT_WHEEL)
     {
         CORE.Input.Mouse.currentWheelMove.x = (float)wheelEvent->deltaX;
-        CORE.Input.Mouse.currentWheelMove.y = -(float)wheelEvent->deltaY;
+        CORE.Input.Mouse.currentWheelMove.y = (float)wheelEvent->deltaY;
     }
 
     return 1; // The event was consumed by the callback handler
diff --git a/src/libraries/raylib/raylib/src/raudio.c b/src/libraries/raylib/raylib/src/raudio.c
index ec97bde..f05567c 100644
--- a/src/libraries/raylib/raylib/src/raudio.c
+++ b/src/libraries/raylib/raylib/src/raudio.c
@@ -344,7 +344,7 @@ typedef enum {
 // Audio buffer struct
 struct rAudioBuffer {
     ma_data_converter converter;    // Audio data converter
-    unsigned char *converterResidual;       // Cached residual input frames for use by the converter
+    unsigned char* converterResidual;       // Cached residual input frames for use by the converter
     unsigned int converterResidualCount;    // The number of valid frames sitting in converterResidual
 
     AudioCallback callback;         // Audio buffer callback for buffer filling on audio threads
@@ -378,7 +378,7 @@ struct rAudioProcessor {
     rAudioProcessor *prev;          // Previous audio processor on the list
 };
 
-#define AudioBuffer rAudioBuffer    // WARNING: Renamed to avoid symbol collision with CoreAudio (macOS) AudioBuffer type
+#define AudioBuffer rAudioBuffer    // HACK: To avoid CoreAudio (macOS) symbol collision
 
 // Audio data context
 typedef struct AudioData {
@@ -434,7 +434,6 @@ static const char *GetFileName(const char *filePath);               // Get point
 static const char *GetFileNameWithoutExt(const char *filePath);     // Get filename string without extension (uses static string)
 
 static unsigned char *LoadFileData(const char *fileName, int *dataSize);    // Load file data as byte array (read)
-static void UnloadFileData(unsigned char *data);                     // Unload file data allocated by LoadFileData()
 static bool SaveFileData(const char *fileName, void *data, int dataSize);   // Save data to file from byte array (write)
 static bool SaveFileText(const char *fileName, char *text);         // Save text data to file (write), string must be '\0' terminated
 #endif
@@ -533,9 +532,8 @@ void CloseAudioDevice(void)
 {
     if (AUDIO.System.isReady)
     {
-        // Stop the device first (joins the callback thread) before destroying the mutex it locks
-        ma_device_uninit(&AUDIO.System.device);
         ma_mutex_uninit(&AUDIO.System.lock);
+        ma_device_uninit(&AUDIO.System.device);
         ma_context_uninit(&AUDIO.System.context);
 
         AUDIO.System.isReady = false;
@@ -823,7 +821,7 @@ Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int
             wave.sampleRate = wav.sampleRate;
             wave.sampleSize = 16;
             wave.channels = wav.channels;
-            wave.data = (short *)RL_CALLOC((size_t)wave.frameCount*wave.channels, sizeof(short));
+            wave.data = (short *)RL_MALLOC((size_t)wave.frameCount*wave.channels*sizeof(short));
 
             // NOTE: Forcing conversion to 16bit sample size on reading
             drwav_read_pcm_frames_s16(&wav, wave.frameCount, (drwav_int16 *)wave.data);
@@ -846,7 +844,7 @@ Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int
             wave.sampleSize = 16;       // By default, ogg data is 16 bit per sample (short)
             wave.channels = info.channels;
             wave.frameCount = (unsigned int)stb_vorbis_stream_length_in_samples(oggData);  // NOTE: It returns frames!
-            wave.data = (short *)RL_CALLOC(wave.frameCount*wave.channels, sizeof(short));
+            wave.data = (short *)RL_MALLOC(wave.frameCount*wave.channels*sizeof(short));
 
             // NOTE: Get the number of samples to process (be careful! asking for number of shorts, not bytes!)
             stb_vorbis_get_samples_short_interleaved(oggData, info.channels, (short *)wave.data, wave.frameCount*wave.channels);
@@ -859,7 +857,7 @@ Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int
     else if ((strcmp(fileType, ".mp3") == 0) || (strcmp(fileType, ".MP3") == 0))
     {
         drmp3_config config = { 0 };
-        unsigned long long totalFrameCount = 0;
+        unsigned long long int totalFrameCount = 0;
 
         // NOTE: Forcing conversion to 32bit float sample size on reading
         wave.data = drmp3_open_memory_and_read_pcm_frames_f32(fileData, dataSize, &config, &totalFrameCount, NULL);
@@ -869,7 +867,7 @@ Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int
         {
             wave.channels = config.channels;
             wave.sampleRate = config.sampleRate;
-            wave.frameCount = (unsigned int)totalFrameCount; // WARNING: Potential loss of data
+            wave.frameCount = (int)totalFrameCount;
         }
         else TRACELOG(LOG_WARNING, "WAVE: Failed to load MP3 data");
 
@@ -897,13 +895,13 @@ Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int
 #if SUPPORT_FILEFORMAT_FLAC
     else if ((strcmp(fileType, ".flac") == 0) || (strcmp(fileType, ".FLAC") == 0))
     {
-        unsigned long long totalFrameCount = 0;
+        unsigned long long int totalFrameCount = 0;
 
         // NOTE: Forcing conversion to 16bit sample size on reading
         wave.data = drflac_open_memory_and_read_pcm_frames_s16(fileData, dataSize, &wave.channels, &wave.sampleRate, &totalFrameCount, NULL);
         wave.sampleSize = 16;
 
-        if (wave.data != NULL) wave.frameCount = (unsigned int)totalFrameCount; // WARNING: Potential loss of data
+        if (wave.data != NULL) wave.frameCount = (unsigned int)totalFrameCount;
         else TRACELOG(LOG_WARNING, "WAVE: Failed to load FLAC data");
     }
 #endif
@@ -914,7 +912,7 @@ Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int
     return wave;
 }
 
-// Check if wave data is valid (data loaded and parameters)
+// Checks if wave data is valid (data loaded and parameters)
 bool IsWaveValid(Wave wave)
 {
     bool result = false;
@@ -982,7 +980,7 @@ Sound LoadSoundFromWave(Wave wave)
     return sound;
 }
 
-// Load sound alias, clone sound from existing sound data, clone does not own wave data
+// Clone sound from existing sound data, clone does not own wave data
 // NOTE: Wave data must be unallocated manually and will be shared across all clones
 Sound LoadSoundAlias(Sound source)
 {
@@ -1014,7 +1012,7 @@ Sound LoadSoundAlias(Sound source)
     return sound;
 }
 
-// Check if sound is valid (data loaded and buffers initialized)
+// Checks if a sound is valid (data loaded and buffers initialized)
 bool IsSoundValid(Sound sound)
 {
     bool result = false;
@@ -1049,7 +1047,6 @@ void UnloadSoundAlias(Sound alias)
     {
         UntrackAudioBuffer(alias.stream.buffer);
         ma_data_converter_uninit(&alias.stream.buffer->converter, NULL);
-        RL_FREE(alias.stream.buffer->converterResidual);
         RL_FREE(alias.stream.buffer);
     }
 }
@@ -1155,7 +1152,7 @@ bool ExportWaveAsCode(Wave wave, const char *fileName)
 
     // Get file name from path and convert variable name to uppercase
     char varFileName[256] = { 0 };
-    snprintf(varFileName, 256, "%s", GetFileNameWithoutExt(fileName)); // NOTE: Using function provided by [rcore] module
+    strncpy(varFileName, GetFileNameWithoutExt(fileName), 256 - 1);
     for (int i = 0; varFileName[i] != '\0'; i++) if (varFileName[i] >= 'a' && varFileName[i] <= 'z') { varFileName[i] = varFileName[i] - 32; }
 
     // Add wave information
@@ -1216,7 +1213,7 @@ void StopSound(Sound sound)
     StopAudioBuffer(sound.stream.buffer);
 }
 
-// Check if sound is playing
+// Check if a sound is playing
 bool IsSoundPlaying(Sound sound)
 {
     bool result = false;
@@ -1259,7 +1256,7 @@ void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
         return;
     }
 
-    void *data = RL_CALLOC(frameCount*channels*(sampleSize/8), 1);
+    void *data = RL_MALLOC(frameCount*channels*(sampleSize/8));
 
     frameCount = (ma_uint32)ma_convert_frames(data, frameCount, formatOut, channels, sampleRate, wave->data, frameCountIn, formatIn, wave->channels, wave->sampleRate);
     if (frameCount == 0)
@@ -1752,7 +1749,7 @@ Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data,
     return music;
 }
 
-// Check if music stream is valid (context and buffers initialized)
+// Checks if a music stream is valid (context and buffers initialized)
 bool IsMusicValid(Music music)
 {
     return ((music.ctxData != NULL) &&          // Validate context loaded
@@ -1773,7 +1770,7 @@ void UnloadMusicStream(Music music)
     {
         if (false) { }
 #if SUPPORT_FILEFORMAT_WAV
-        else if (music.ctxType == MUSIC_AUDIO_WAV) { drwav_uninit((drwav *)music.ctxData); RL_FREE(music.ctxData); }
+        else if (music.ctxType == MUSIC_AUDIO_WAV) drwav_uninit((drwav *)music.ctxData);
 #endif
 #if SUPPORT_FILEFORMAT_OGG
         else if (music.ctxType == MUSIC_AUDIO_OGG) stb_vorbis_close((stb_vorbis *)music.ctxData);
@@ -1785,7 +1782,7 @@ void UnloadMusicStream(Music music)
         else if (music.ctxType == MUSIC_AUDIO_QOA) qoaplay_close((qoaplay_desc *)music.ctxData);
 #endif
 #if SUPPORT_FILEFORMAT_FLAC
-        else if (music.ctxType == MUSIC_AUDIO_FLAC) drflac_close((drflac *)music.ctxData);
+        else if (music.ctxType == MUSIC_AUDIO_FLAC) { drflac_close((drflac *)music.ctxData); drflac_free((drflac *)music.ctxData, NULL); }
 #endif
 #if SUPPORT_FILEFORMAT_XM
         else if (music.ctxType == MUSIC_MODULE_XM) jar_xm_free_context((jar_xm_context_t *)music.ctxData);
@@ -2069,7 +2066,7 @@ void SetMusicPitch(Music music, float pitch)
     SetAudioBufferPitch(music.stream.buffer, pitch);
 }
 
-// Set pan for music
+// Set pan for a music
 void SetMusicPan(Music music, float pan)
 {
     SetAudioBufferPan(music.stream.buffer, pan);
@@ -2157,7 +2154,7 @@ AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, un
     return stream;
 }
 
-// Check if an audio stream is valid (buffers initialized)
+// Checks if an audio stream is valid (buffers initialized)
 bool IsAudioStreamValid(AudioStream stream)
 {
     return ((stream.buffer != NULL) &&    // Validate stream buffer
@@ -2661,7 +2658,7 @@ static void MixAudioFrames(float *framesOut, const float *framesIn, ma_uint32 fr
     const float localVolume = buffer->volume;
     const ma_uint32 channels = AUDIO.System.device.playback.channels;
 
-    if (channels == 2) // Consider panning
+    if (channels == 2)  // Consider panning
     {
         const float right = (buffer->pan + 1.0f)/2.0f; // Normalize: [-1..1] -> [0..1]
         const float left = 1.0f - right;
@@ -2828,7 +2825,7 @@ static const char *GetFileNameWithoutExt(const char *filePath)
     static char fileName[MAX_FILENAMEWITHOUTEXT_LENGTH] = { 0 };
     memset(fileName, 0, MAX_FILENAMEWITHOUTEXT_LENGTH);
 
-    if (filePath != NULL) snprintf(fileName, MAX_FILENAMEWITHOUTEXT_LENGTH, "%s", GetFileName(filePath));
+    if (filePath != NULL) strncpy(fileName, GetFileName(filePath), MAX_FILENAMEWITHOUTEXT_LENGTH - 1); // Get filename with extension
 
     int fileNameLength = (int)strlen(fileName); // Get size in bytes
 
@@ -2885,12 +2882,6 @@ static unsigned char *LoadFileData(const char *fileName, int *dataSize)
     return data;
 }
 
-// Unload file data allocated by LoadFileData()
-static void UnloadFileData(unsigned char *data)
-{
-    RL_FREE(data);
-}
-
 // Save data to file from buffer
 static bool SaveFileData(const char *fileName, void *data, int dataSize)
 {
diff --git a/src/libraries/raylib/raylib/src/raylib.h b/src/libraries/raylib/raylib/src/raylib.h
index 0dc2091..bdca643 100644
--- a/src/libraries/raylib/raylib/src/raylib.h
+++ b/src/libraries/raylib/raylib/src/raylib.h
@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   raylib v6.1-dev - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
+*   raylib v6.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
 *
 *   FEATURES:
 *       - NO external dependencies, all required libraries included with raylib
@@ -87,9 +87,9 @@
 #include <stdarg.h>     // Required for: va_list - Only used by TraceLogCallback
 
 #define RAYLIB_VERSION_MAJOR 6
-#define RAYLIB_VERSION_MINOR 1
+#define RAYLIB_VERSION_MINOR 0
 #define RAYLIB_VERSION_PATCH 0
-#define RAYLIB_VERSION  "6.1-dev"
+#define RAYLIB_VERSION  "6.0"
 
 // Function specifiers in case library is build/used as a shared library
 // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
@@ -203,14 +203,12 @@
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
 // Boolean type
-#if !defined(__cplusplus)
 #if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
     #include <stdbool.h>
-#elif !defined(bool)
+#elif !defined(__cplusplus) && !defined(bool)
     typedef enum bool { false = 0, true = !false } bool;
     #define RL_BOOL_TYPE
 #endif
-#endif
 
 // Vector2, 2 components
 typedef struct Vector2 {
@@ -409,7 +407,7 @@ typedef struct BoneInfo {
 
 // Skeleton, animation bones hierarchy
 typedef struct ModelSkeleton {
-    unsigned int boneCount; // Number of bones
+    int boneCount;          // Number of bones
     BoneInfo *bones;        // Bones information (skeleton)
     ModelAnimPose bindPose; // Bones base transformation (Transform[])
 } ModelSkeleton;
@@ -436,7 +434,7 @@ typedef struct Model {
 typedef struct ModelAnimation {
     char name[32];          // Animation name
 
-    unsigned int boneCount; // Number of bones (per pose)
+    int boneCount;          // Number of bones (per pose)
     int keyframeCount;      // Number of animation key frames
     ModelAnimPose *keyframePoses; // Animation sequence keyframe poses [keyframe][pose]
 } ModelAnimation;
@@ -965,10 +963,10 @@ typedef enum {
 
 // Callbacks to hook some internal functions
 // WARNING: These callbacks are intended for advanced users
-typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages
-typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize); // FileIO: Load binary data
-typedef bool (*SaveFileDataCallback)(const char *fileName, const void *data, int dataSize); // FileIO: Save binary data
-typedef char *(*LoadFileTextCallback)(const char *fileName);                  // FileIO: Load text data
+typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args);  // Logging: Redirect trace log messages
+typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize);    // FileIO: Load binary data
+typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize);   // FileIO: Save binary data
+typedef char *(*LoadFileTextCallback)(const char *fileName);            // FileIO: Load text data
 typedef bool (*SaveFileTextCallback)(const char *fileName, const char *text); // FileIO: Save text data
 
 //------------------------------------------------------------------------------------
@@ -996,7 +994,6 @@ RLAPI bool IsWindowMaximized(void);                               // Check if wi
 RLAPI bool IsWindowFocused(void);                                 // Check if window is currently focused
 RLAPI bool IsWindowResized(void);                                 // Check if window has been resized last frame
 RLAPI bool IsWindowState(unsigned int flag);                      // Check if one specific window flag is enabled
-RLAPI bool IsWindowCloseFlagSet();                                // Check if the close flag has been set
 RLAPI void SetWindowState(unsigned int flags);                    // Set window configuration state using flags
 RLAPI void ClearWindowState(unsigned int flags);                  // Clear window configuration state flags
 RLAPI void ToggleFullscreen(void);                                // Toggle window state: fullscreen/windowed, resizes monitor to match window resolution
@@ -1037,23 +1034,23 @@ RLAPI void EnableEventWaiting(void);                              // Enable wait
 RLAPI void DisableEventWaiting(void);                             // Disable waiting for events on EndDrawing(), automatic events polling
 
 // Cursor-related functions
-RLAPI void ShowCursor(void);                                      // Show cursor
-RLAPI void HideCursor(void);                                      // Hide cursor
+RLAPI void ShowCursor(void);                                      // Shows cursor
+RLAPI void HideCursor(void);                                      // Hides cursor
 RLAPI bool IsCursorHidden(void);                                  // Check if cursor is not visible
-RLAPI void EnableCursor(void);                                    // Enable cursor (unlock cursor)
-RLAPI void DisableCursor(void);                                   // Disable cursor (lock cursor)
+RLAPI void EnableCursor(void);                                    // Enables cursor (unlock cursor)
+RLAPI void DisableCursor(void);                                   // Disables cursor (lock cursor)
 RLAPI bool IsCursorOnScreen(void);                                // Check if cursor is on the screen
 
 // Drawing-related functions
-RLAPI void ClearBackground(Color color);                          // Clear background (framebuffer) to color
-RLAPI void BeginDrawing(void);                                    // Begin canvas (framebuffer) drawing
-RLAPI void EndDrawing(void);                                      // End canvas (framebuffer) drawing and swap buffers (double buffering)
+RLAPI void ClearBackground(Color color);                          // Set background color (framebuffer clear color)
+RLAPI void BeginDrawing(void);                                    // Setup canvas (framebuffer) to start drawing
+RLAPI void EndDrawing(void);                                      // End canvas drawing and swap buffers (double buffering)
 RLAPI void BeginMode2D(Camera2D camera);                          // Begin 2D mode with custom camera (2D)
-RLAPI void EndMode2D(void);                                       // End 2D mode with custom camera
+RLAPI void EndMode2D(void);                                       // Ends 2D mode with custom camera
 RLAPI void BeginMode3D(Camera3D camera);                          // Begin 3D mode with custom camera (3D)
-RLAPI void EndMode3D(void);                                       // End 3D mode and returns to default 2D orthographic mode
+RLAPI void EndMode3D(void);                                       // Ends 3D mode and returns to default 2D orthographic mode
 RLAPI void BeginTextureMode(RenderTexture2D target);              // Begin drawing to render texture
-RLAPI void EndTextureMode(void);                                  // End drawing to render texture
+RLAPI void EndTextureMode(void);                                  // Ends drawing to render texture
 RLAPI void BeginShaderMode(Shader shader);                        // Begin custom shader drawing
 RLAPI void EndShaderMode(void);                                   // End custom shader drawing (use default shader)
 RLAPI void BeginBlendMode(int mode);                              // Begin blending mode (alpha, additive, multiplied, subtract, custom)
@@ -1071,7 +1068,7 @@ RLAPI void UnloadVrStereoConfig(VrStereoConfig config);           // Unload VR s
 // NOTE: Shader functionality is not available on OpenGL 1.1
 RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);   // Load shader from files and bind default locations
 RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
-RLAPI bool IsShaderValid(Shader shader);                                   // Check if shader is valid (loaded on GPU)
+RLAPI bool IsShaderValid(Shader shader);                                   // Check if a shader is valid (loaded on GPU)
 RLAPI int GetShaderLocation(Shader shader, const char *uniformName);       // Get shader uniform location
 RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName);  // Get shader attribute location
 RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value
@@ -1081,12 +1078,13 @@ RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture)
 RLAPI void UnloadShader(Shader shader);                                    // Unload shader from GPU memory (VRAM)
 
 // Screen-space-related functions
+#define GetMouseRay GetScreenToWorldRay     // Compatibility hack for previous raylib versions
 RLAPI Ray GetScreenToWorldRay(Vector2 position, Camera camera);         // Get a ray trace from screen position (i.e mouse)
 RLAPI Ray GetScreenToWorldRayEx(Vector2 position, Camera camera, int width, int height); // Get a ray trace from screen position (i.e mouse) in a viewport
-RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);        // Get screen space position for a 3d world space position
-RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get sized screen space position for a 3d world space position
-RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera);    // Get screen space position for a 2d camera world space position
-RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera);    // Get world space position for a 2d camera screen space position
+RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);        // Get the screen space position for a 3d world space position
+RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
+RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera);    // Get the screen space position for a 2d camera world space position
+RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera);    // Get the world space position for a 2d camera screen space position
 RLAPI Matrix GetCameraMatrix(Camera camera);                            // Get camera transform matrix (view matrix)
 RLAPI Matrix GetCameraMatrix2D(Camera2D camera);                        // Get camera 2d transform matrix
 
@@ -1112,7 +1110,7 @@ RLAPI void UnloadRandomSequence(int *sequence);         // Unload random values
 
 // Misc. functions
 RLAPI void TakeScreenshot(const char *fileName);                // Takes a screenshot of current screen (filename extension defines format)
-RLAPI void SetConfigFlags(unsigned int flags);                  // Set up init configuration flags (view FLAGS)
+RLAPI void SetConfigFlags(unsigned int flags);                  // Setup init configuration flags (view FLAGS)
 RLAPI void OpenURL(const char *url);                            // Open URL with default system browser (if available)
 
 // Logging system
@@ -1128,7 +1126,7 @@ RLAPI void MemFree(void *ptr);                                  // Internal memo
 // File system management functions
 RLAPI unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read)
 RLAPI void UnloadFileData(unsigned char *data);                     // Unload file data allocated by LoadFileData()
-RLAPI bool SaveFileData(const char *fileName, const void *data, int dataSize); // Save data to file from byte array (write), returns true on success
+RLAPI bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success
 RLAPI bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success
 RLAPI char *LoadFileText(const char *fileName);                     // Load text data from file (read), returns a '\0' terminated string
 RLAPI void UnloadFileText(char *text);                              // Unload file text data allocated by LoadFileText()
@@ -1141,34 +1139,32 @@ RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback);  // Set custo
 RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback);  // Set custom file text data loader
 RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback);  // Set custom file text data saver
 
-RLAPI int FileRename(const char *fileName, const char *fileRename); // Rename file (if exists), returns 0 on success
-RLAPI int FileRemove(const char *fileName);                         // Remove file (if exists), returns 0 on success
-RLAPI int FileCopy(const char *srcPath, const char *dstPath);       // Copy file from one path to another, dstPath created if it doesn't exist, returns 0 on success
-RLAPI int FileMove(const char *srcPath, const char *dstPath);       // Move file from one directory to another, dstPath created if it doesn't exist, returns 0 on success
-RLAPI int FileTextReplace(const char *fileName, const char *search, const char *replacement); // Replace text in an existing file, returns 0 on success
-RLAPI int FileTextFindIndex(const char *fileName, const char *search); // Find text in existing file, returns -1 if index not found or index otherwise
+RLAPI int FileRename(const char *fileName, const char *fileRename); // Rename file (if exists)
+RLAPI int FileRemove(const char *fileName);                         // Remove file (if exists)
+RLAPI int FileCopy(const char *srcPath, const char *dstPath);       // Copy file from one path to another, dstPath created if it doesn't exist
+RLAPI int FileMove(const char *srcPath, const char *dstPath);       // Move file from one directory to another, dstPath created if it doesn't exist
+RLAPI int FileTextReplace(const char *fileName, const char *search, const char *replacement); // Replace text in an existing file
+RLAPI int FileTextFindIndex(const char *fileName, const char *search); // Find text in existing file
 RLAPI bool FileExists(const char *fileName);                        // Check if file exists
-RLAPI bool DirectoryExists(const char *dirPath);                    // Check if directory path exists
+RLAPI bool DirectoryExists(const char *dirPath);                    // Check if a directory path exists
 RLAPI bool IsFileExtension(const char *fileName, const char *ext);  // Check file extension (recommended include point: .png, .wav)
 RLAPI int GetFileLength(const char *fileName);                      // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
 RLAPI long GetFileModTime(const char *fileName);                    // Get file modification time (last write time)
 RLAPI const char *GetFileExtension(const char *fileName);           // Get pointer to extension for a filename string (includes dot: '.png')
 RLAPI const char *GetFileName(const char *filePath);                // Get pointer to filename for a path string
 RLAPI const char *GetFileNameWithoutExt(const char *filePath);      // Get filename string without extension (uses static string)
-RLAPI const char *GetDirectoryPath(const char *filePath);           // Get full path for a provided fileName with path (uses static string)
-RLAPI const char *GetPrevDirectoryPath(const char *dirPath);        // Get previous directory path for a provided path (uses static string)
+RLAPI const char *GetDirectoryPath(const char *filePath);           // Get full path for a given fileName with path (uses static string)
+RLAPI const char *GetPrevDirectoryPath(const char *dirPath);        // Get previous directory path for a given path (uses static string)
 RLAPI const char *GetWorkingDirectory(void);                        // Get current working directory (uses static string)
 RLAPI const char *GetApplicationDirectory(void);                    // Get the directory of the running application (uses static string)
 RLAPI int MakeDirectory(const char *dirPath);                       // Create directories (including full path requested), returns 0 on success
-RLAPI int ChangeDirectory(const char *dirPath);                     // Change working directory, returns 0 on success
-RLAPI bool IsPathFile(const char *path);                            // Check if provided path points to a file
-RLAPI bool IsPathDirectory(const char *path);                       // Check if provided path points to a directory
-RLAPI bool IsPathAbsolute(const char *path);                        // Check if provided path is an absolute path
+RLAPI bool ChangeDirectory(const char *dirPath);                    // Change working directory, return true on success
+RLAPI bool IsPathFile(const char *path);                            // Check if a given path is a file or a directory
 RLAPI bool IsFileNameValid(const char *fileName);                   // Check if fileName is valid for the platform/OS
 RLAPI FilePathList LoadDirectoryFiles(const char *dirPath);         // Load directory filepaths, files and directories, no subdirs scan
-RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and subdir scan; some filters available: '*.*','FILES*','DIRS*'
+RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and subdir scan; some filters available: "*.*", "FILES*", "DIRS*"
 RLAPI void UnloadDirectoryFiles(FilePathList files);                // Unload filepaths
-RLAPI bool IsFileDropped(void);                                     // Check if file has been dropped into window
+RLAPI bool IsFileDropped(void);                                     // Check if a file has been dropped into window
 RLAPI FilePathList LoadDroppedFiles(void);                          // Load dropped filepaths
 RLAPI void UnloadDroppedFiles(FilePathList files);                  // Unload dropped filepaths
 RLAPI unsigned int GetDirectoryFileCount(const char *dirPath);      // Get the file count in a directory
@@ -1179,10 +1175,10 @@ RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *
 RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize);  // Decompress data (DEFLATE algorithm), memory must be MemFree()
 RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize);               // Encode data to Base64 string (includes NULL terminator), memory must be MemFree()
 RLAPI unsigned char *DecodeDataBase64(const char *text, int *outputSize);                             // Decode Base64 string (expected NULL terminated), memory must be MemFree()
-RLAPI unsigned int ComputeCRC32(const unsigned char *data, int dataSize); // Compute CRC32 hash code
-RLAPI unsigned int *ComputeMD5(const unsigned char *data, int dataSize);  // Compute MD5 hash code, returns static int[4] (16 bytes)
-RLAPI unsigned int *ComputeSHA1(const unsigned char *data, int dataSize); // Compute SHA1 hash code, returns static int[5] (20 bytes)
-RLAPI unsigned int *ComputeSHA256(const unsigned char *data, int dataSize); // Compute SHA256 hash code, returns static int[8] (32 bytes)
+RLAPI unsigned int ComputeCRC32(unsigned char *data, int dataSize); // Compute CRC32 hash code
+RLAPI unsigned int *ComputeMD5(unsigned char *data, int dataSize);  // Compute MD5 hash code, returns static int[4] (16 bytes)
+RLAPI unsigned int *ComputeSHA1(unsigned char *data, int dataSize); // Compute SHA1 hash code, returns static int[5] (20 bytes)
+RLAPI unsigned int *ComputeSHA256(unsigned char *data, int dataSize); // Compute SHA256 hash code, returns static int[8] (32 bytes)
 
 // Automation events functionality
 RLAPI AutomationEventList LoadAutomationEventList(const char *fileName); // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
@@ -1199,23 +1195,23 @@ RLAPI void PlayAutomationEvent(AutomationEvent event);            // Play a reco
 //------------------------------------------------------------------------------------
 
 // Input-related functions: keyboard
-RLAPI bool IsKeyPressed(int key);                             // Check if key has been pressed once
-RLAPI bool IsKeyPressedRepeat(int key);                       // Check if key has been pressed again
-RLAPI bool IsKeyDown(int key);                                // Check if key is being pressed
-RLAPI bool IsKeyReleased(int key);                            // Check if key has been released once
-RLAPI bool IsKeyUp(int key);                                  // Check if key is NOT being pressed
+RLAPI bool IsKeyPressed(int key);                             // Check if a key has been pressed once
+RLAPI bool IsKeyPressedRepeat(int key);                       // Check if a key has been pressed again
+RLAPI bool IsKeyDown(int key);                                // Check if a key is being pressed
+RLAPI bool IsKeyReleased(int key);                            // Check if a key has been released once
+RLAPI bool IsKeyUp(int key);                                  // Check if a key is NOT being pressed
 RLAPI int GetKeyPressed(void);                                // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
 RLAPI int GetCharPressed(void);                               // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
 RLAPI const char *GetKeyName(int key);                        // Get name of a QWERTY key on the current keyboard layout (eg returns string 'q' for KEY_A on an AZERTY keyboard)
 RLAPI void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
 
 // Input-related functions: gamepads
-RLAPI bool IsGamepadAvailable(int gamepad);                   // Check if gamepad is available
+RLAPI bool IsGamepadAvailable(int gamepad);                   // Check if a gamepad is available
 RLAPI const char *GetGamepadName(int gamepad);                // Get gamepad internal name id
-RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Check if gamepad button has been pressed once
-RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Check if gamepad button is being pressed
-RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Check if gamepad button has been released once
-RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Check if gamepad button is NOT being pressed
+RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Check if a gamepad button has been pressed once
+RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Check if a gamepad button is being pressed
+RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Check if a gamepad button has been released once
+RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Check if a gamepad button is NOT being pressed
 RLAPI int GetGamepadButtonPressed(void);                      // Get the last gamepad button pressed
 RLAPI int GetGamepadAxisCount(int gamepad);                   // Get axis count for a gamepad
 RLAPI float GetGamepadAxisMovement(int gamepad, int axis);    // Get movement value for a gamepad axis
@@ -1223,10 +1219,10 @@ RLAPI int SetGamepadMappings(const char *mappings);           // Set internal ga
 RLAPI void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration); // Set gamepad vibration for both motors (duration in seconds)
 
 // Input-related functions: mouse
-RLAPI bool IsMouseButtonPressed(int button);                  // Check if mouse button has been pressed once
-RLAPI bool IsMouseButtonDown(int button);                     // Check if mouse button is being pressed
-RLAPI bool IsMouseButtonReleased(int button);                 // Check if mouse button has been released once
-RLAPI bool IsMouseButtonUp(int button);                       // Check if mouse button is NOT being pressed
+RLAPI bool IsMouseButtonPressed(int button);                  // Check if a mouse button has been pressed once
+RLAPI bool IsMouseButtonDown(int button);                     // Check if a mouse button is being pressed
+RLAPI bool IsMouseButtonReleased(int button);                 // Check if a mouse button has been released once
+RLAPI bool IsMouseButtonUp(int button);                       // Check if a mouse button is NOT being pressed
 RLAPI int GetMouseX(void);                                    // Get mouse position X
 RLAPI int GetMouseY(void);                                    // Get mouse position Y
 RLAPI Vector2 GetMousePosition(void);                         // Get mouse position XY
@@ -1242,14 +1238,14 @@ RLAPI void SetMouseCursor(int cursor);                        // Set mouse curso
 RLAPI int GetTouchX(void);                                    // Get touch position X for touch point 0 (relative to screen size)
 RLAPI int GetTouchY(void);                                    // Get touch position Y for touch point 0 (relative to screen size)
 RLAPI Vector2 GetTouchPosition(int index);                    // Get touch position XY for a touch point index (relative to screen size)
-RLAPI int GetTouchPointId(int index);                         // Get touch point identifier for provided index
+RLAPI int GetTouchPointId(int index);                         // Get touch point identifier for given index
 RLAPI int GetTouchPointCount(void);                           // Get number of touch points
 
 //------------------------------------------------------------------------------------
 // Gestures and Touch Handling Functions (Module: rgestures)
 //------------------------------------------------------------------------------------
 RLAPI void SetGesturesEnabled(unsigned int flags);            // Enable a set of gestures using flags
-RLAPI bool IsGestureDetected(unsigned int gesture);           // Check if gesture has been detected
+RLAPI bool IsGestureDetected(unsigned int gesture);           // Check if a gesture have been detected
 RLAPI int GetGestureDetected(void);                           // Get latest detected gesture
 RLAPI float GetGestureHoldDuration(void);                     // Get gesture hold time in seconds
 RLAPI Vector2 GetGestureDragVector(void);                     // Get gesture drag vector
@@ -1269,7 +1265,7 @@ RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, f
 // Set texture and rectangle to be used on shapes drawing
 // NOTE: It can be useful when using basic shapes and one single font,
 // defining a font char white rectangle would allow drawing everything in a single draw call
-RLAPI void SetShapesTexture(Texture2D texture, Rectangle rec); // Set texture and rectangle to be used on shapes drawing
+RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing
 RLAPI Texture2D GetShapesTexture(void);                 // Get texture that is used for shapes drawing
 RLAPI Rectangle GetShapesTextureRectangle(void);        // Get texture source rectangle that is used for shapes drawing
 
@@ -1282,44 +1278,38 @@ RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color
 RLAPI void DrawLineStrip(const Vector2 *points, int pointCount, Color color);                            // Draw lines sequence (using gl lines)
 RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw line segment cubic-bezier in-out interpolation
 RLAPI void DrawLineDashed(Vector2 startPos, Vector2 endPos, int dashSize, int spaceSize, Color color);   // Draw a dashed line
-RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle, counter-clockwise vertex order
-RLAPI void DrawTriangleGradient(Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3);       // Draw triangle with interpolated colors, counter-clockwise vertex/color order
-RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline, counter-clockwise vertex order
-RLAPI void DrawTriangleLinesEx(Vector2 v1, Vector2 v2, Vector2 v3, float thick, Color color);            // Draw triangle outline with line thickness, counter-clockwise vertex order
-RLAPI void DrawTriangleFan(const Vector2 *points, int pointCount, Color color);                          // Draw a triangle fan defined by points (first vertex is the center)
-RLAPI void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color);                        // Draw a triangle strip defined by points
+RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
+RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
+RLAPI void DrawCircleGradient(Vector2 center, float radius, Color inner, Color outer);                   // Draw a gradient-filled circle
+RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle
+RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
+RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
+RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color);                                  // Draw circle outline (Vector version)
+RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);             // Draw ellipse
+RLAPI void DrawEllipseV(Vector2 center, float radiusH, float radiusV, Color color);                      // Draw ellipse (Vector version)
+RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);        // Draw ellipse outline
+RLAPI void DrawEllipseLinesV(Vector2 center, float radiusH, float radiusV, Color color);                 // Draw ellipse outline (Vector version)
+RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring
+RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline
 RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color);                        // Draw a color-filled rectangle
 RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
 RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
 RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
 RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color top, Color bottom);   // Draw a vertical-gradient-filled rectangle
 RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color left, Color right);   // Draw a horizontal-gradient-filled rectangle
-RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors, counter-clockwise color order
+RLAPI void DrawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color bottomRight, Color topRight); // Draw a gradient-filled rectangle with custom vertex colors
 RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
-RLAPI void DrawRectangleLinesEx(Rectangle rec, float thick, Color color);                                // Draw rectangle outline with line thickness
+RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color);                            // Draw rectangle outline with extended parameters
 RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);              // Draw rectangle with rounded edges
 RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, Color color);         // Draw rectangle lines with rounded edges
-RLAPI void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float thick, Color color); // Draw rectangle lines with rounded edges outline and line thickness
-RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a polygon of n sides
+RLAPI void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline
+RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline (vertex in counter-clockwise order!)
+RLAPI void DrawTriangleFan(const Vector2 *points, int pointCount, Color color);                          // Draw a triangle fan defined by points (first vertex is the center)
+RLAPI void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color);                        // Draw a triangle strip defined by points
+RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
 RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);          // Draw a polygon outline of n sides
-RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float thick, Color color); // Draw a polygon outline of n sides with line thickness
-RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
-RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
-RLAPI void DrawCircleGradient(Vector2 center, float radius, Color inner, Color outer);                   // Draw a gradient-filled circle
-RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle
-RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
-RLAPI void DrawCircleSectorLinesEx(Vector2 center, float radius, float startAngle, float endAngle, int segments, float thick, Color color); // Draw circle sector outline with thickness
-RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
-RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color);                                  // Draw circle outline (Vector version)
-RLAPI void DrawCircleLinesEx(Vector2 center, float radius, float thick, Color color);                    // Draw circle outline with line thickness
-RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);             // Draw ellipse
-RLAPI void DrawEllipseV(Vector2 center, float radiusH, float radiusV, Color color);                      // Draw ellipse (Vector version)
-RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);        // Draw ellipse outline
-RLAPI void DrawEllipseLinesV(Vector2 center, float radiusH, float radiusV, Color color);                 // Draw ellipse outline (Vector version)
-RLAPI void DrawEllipseLinesEx(Vector2 center, float radiusH, float radiusV, float thick, Color color);   // Draw ellipse outline with line thickness
-RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring
-RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline
-RLAPI void DrawRingLinesEx(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, float thick, Color color); // Draw ring outline with line thickness
+RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters
 
 // Splines drawing functions
 RLAPI void DrawSplineLinear(const Vector2 *points, int pointCount, float thick, Color color);            // Draw spline: Linear, minimum 2 points
@@ -1333,18 +1323,18 @@ RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vecto
 RLAPI void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point
 RLAPI void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points
 
-// Spline segment point evaluation functions, for a provided t [0.0f .. 1.0f]
+// Spline segment point evaluation functions, for a given t [0.0f .. 1.0f]
 RLAPI Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t);                           // Get (evaluate) spline point: Linear
 RLAPI Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t);              // Get (evaluate) spline point: B-Spline
 RLAPI Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t);         // Get (evaluate) spline point: Catmull-Rom
-RLAPI Vector2 GetSplinePointBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float t);                // Get (evaluate) spline point: Quadratic Bezier
+RLAPI Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t);                     // Get (evaluate) spline point: Quadratic Bezier
 RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t);        // Get (evaluate) spline point: Cubic Bezier
 
 // Basic shapes collision detection functions
 RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                           // Check collision between two rectangles
 RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);        // Check collision between two circles
 RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                         // Check collision between circle and rectangle
-RLAPI bool CheckCollisionCircleLine(Vector2 center, float radius, Vector2 p1, Vector2 p2);               // Check if circle collides with a line created between two points [p1] and [p2]
+RLAPI bool CheckCollisionCircleLine(Vector2 center, float radius, Vector2 p1, Vector2 p2);               // Check if circle collides with a line created betweeen two points [p1] and [p2]
 RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                         // Check if point is inside rectangle
 RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                       // Check if point is inside circle
 RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);               // Check if point is inside a triangle
@@ -1365,7 +1355,7 @@ RLAPI Image LoadImageAnim(const char *fileName, int *frames);
 RLAPI Image LoadImageAnimFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int *frames); // Load image sequence from memory buffer
 RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);      // Load image from memory buffer, fileType refers to extension: i.e. '.png'
 RLAPI Image LoadImageFromTexture(Texture2D texture);                                                     // Load image from GPU texture data
-RLAPI Image LoadImageFromScreen(void);                                                                   // Load image from screen buffer (screenshot)
+RLAPI Image LoadImageFromScreen(void);                                                                   // Load image from screen buffer and (screenshot)
 RLAPI bool IsImageValid(Image image);                                                                    // Check if an image is valid (data and parameters)
 RLAPI void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
 RLAPI bool ExportImage(Image image, const char *fileName);                                               // Export image data to file, returns true on success
@@ -1411,7 +1401,7 @@ RLAPI void ImageRotateCCW(Image *image);
 RLAPI void ImageColorTint(Image *image, Color color);                                                    // Modify image color: tint
 RLAPI void ImageColorInvert(Image *image);                                                               // Modify image color: invert
 RLAPI void ImageColorGrayscale(Image *image);                                                            // Modify image color: grayscale
-RLAPI void ImageColorContrast(Image *image, int contrast);                                               // Modify image color: contrast (-100 to 100)
+RLAPI void ImageColorContrast(Image *image, float contrast);                                             // Modify image color: contrast (-100 to 100)
 RLAPI void ImageColorBrightness(Image *image, int brightness);                                           // Modify image color: brightness (-255 to 255)
 RLAPI void ImageColorReplace(Image *image, Color color, Color replace);                                  // Modify image color: replace color
 RLAPI Color *LoadImageColors(Image image);                                                               // Load color data from image as a Color array (RGBA - 32bit)
@@ -1423,38 +1413,28 @@ RLAPI Color GetImageColor(Image image, int x, int y);
 
 // Image drawing functions
 // NOTE: Image software-rendering functions (CPU)
-RLAPI void ImageClearBackground(Image *dst, Color color);                                                // Clear image background with provided color
+RLAPI void ImageClearBackground(Image *dst, Color color);                                                // Clear image background with given color
 RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color);                                  // Draw pixel within an image
 RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color);                                   // Draw pixel within an image (Vector version)
 RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image
 RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color);                          // Draw line within an image (Vector version)
 RLAPI void ImageDrawLineEx(Image *dst, Vector2 start, Vector2 end, int thick, Color color);              // Draw a line defining thickness within an image
-RLAPI void ImageDrawLineStrip(Image *dst, const Vector2 *points, int pointCount, Color color);           // Draw a lines sequence within an image
-RLAPI void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color);               // Draw triangle within an image
-RLAPI void ImageDrawTriangleGradient(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3); // Draw triangle with interpolated colors within an image
-RLAPI void ImageDrawTriangleLines(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color);          // Draw triangle outline within an image
-RLAPI void ImageDrawTriangleFan(Image *dst, const Vector2 *points, int pointCount, Color color);         // Draw a triangle fan defined by points within an image (first vertex is the center)
-RLAPI void ImageDrawTriangleStrip(Image *dst, const Vector2 *points, int pointCount, Color color);       // Draw a triangle strip defined by points within an image
-RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color);       // Draw rectangle within an image
-RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color);                 // Draw rectangle within an image (Vector version)
-RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image
-RLAPI void ImageDrawRectanglePro(Image *dst, Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters within and image
-RLAPI void ImageDrawRectangleLines(Image *dst, int posX, int posY, int width, int height, Color color);  // Draw rectangle lines within an image
-RLAPI void ImageDrawRectangleLinesEx(Image *dst, Rectangle rec, int thick, Color color);                 // Draw rectangle lines within an image with line thickness
-RLAPI void ImageDrawRectangleGradientEx(Image *dst, Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw rectangle with gradient colors within an image, counter-clockwise color order
 RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color);               // Draw a filled circle within an image
 RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color);                        // Draw a filled circle within an image (Vector version)
 RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color);          // Draw circle outline within an image
 RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color);                   // Draw circle outline within an image (Vector version)
-RLAPI void ImageDrawCircleGradient(Image *dst, Vector2 center, float radius, Color inner, Color outer);  // Draw a gradient-filled circle within an image
-
-RLAPI void ImageDrawImage(Image *dst, Image src, int posX, int posY, Color tint);                      // Draw an image within an image
-RLAPI void ImageDrawImageEx(Image *dst, Image src, Vector2 position, float rotation, float scale, Color tint); // Draw an image with scaling and rotation within an image
-RLAPI void ImageDrawImageRec(Image *dst, Image src, Rectangle srcRec, Vector2 position, Color tint);     // Draw a part of an image defined by a rectangle within an image
-RLAPI void ImageDrawImagePro(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Vector2 origin, float rotation, Color tint); // Draw a part of an image defined by a rectangle into destination rectangle, with scaling and rotation, within an image
+RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color);       // Draw rectangle within an image
+RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color);                 // Draw rectangle within an image (Vector version)
+RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image
+RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color);                   // Draw rectangle lines within an image
+RLAPI void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color);               // Draw triangle within an image
+RLAPI void ImageDrawTriangleEx(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3); // Draw triangle with interpolated colors within an image
+RLAPI void ImageDrawTriangleLines(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color);          // Draw triangle outline within an image
+RLAPI void ImageDrawTriangleFan(Image *dst, const Vector2 *points, int pointCount, Color color);         // Draw a triangle fan defined by points within an image (first vertex is the center)
+RLAPI void ImageDrawTriangleStrip(Image *dst, const Vector2 *points, int pointCount, Color color);       // Draw a triangle strip defined by points within an image
+RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint);             // Draw a source image within a destination image (tint applied to source)
 RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color);   // Draw text (using default font) within an image (destination)
 RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination)
-RLAPI void ImageDrawTextPro(Image *dst, Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
 
 // Texture loading functions
 // NOTE: These functions require GPU access
@@ -1462,9 +1442,9 @@ RLAPI Texture2D LoadTexture(const char *fileName);
 RLAPI Texture2D LoadTextureFromImage(Image image);                                                       // Load texture from image data
 RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout);                                        // Load cubemap from image, multiple image cubemap layouts supported
 RLAPI RenderTexture2D LoadRenderTexture(int width, int height);                                          // Load texture for rendering (framebuffer)
-RLAPI bool IsTextureValid(Texture2D texture);                                                            // Check if texture is valid (loaded in GPU)
+RLAPI bool IsTextureValid(Texture2D texture);                                                            // Check if a texture is valid (loaded in GPU)
 RLAPI void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
-RLAPI bool IsRenderTextureValid(RenderTexture2D target);                                                 // Check if render texture is valid (loaded in GPU)
+RLAPI bool IsRenderTextureValid(RenderTexture2D target);                                                 // Check if a render texture is valid (loaded in GPU)
 RLAPI void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
 RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data (pixels should be able to fill texture)
 RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data (pixels and rec should fit in texture)
@@ -1477,10 +1457,10 @@ RLAPI void SetTextureWrap(Texture2D texture, int wrap);
 // Texture drawing functions
 RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint);                               // Draw a Texture2D
 RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);                                // Draw a Texture2D with position defined as Vector2
-RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with rotation and scale
-RLAPI void DrawTextureRec(Texture2D texture, Rectangle rec, Vector2 position, Color tint);               // Draw a part of a texture defined by a rectangle
-RLAPI void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a source rectangle to destination rectangle, with scaling and rotation
-RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dstrec, Vector2 origin, float rotation, Color tint); // Draw a texture (or part of it) that stretches or shrinks nicely
+RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
+RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint);            // Draw a part of a texture defined by a rectangle
+RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
+RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely
 
 // Color/pixel related functions
 RLAPI bool ColorIsEqual(Color col1, Color col2);                            // Check if two colors are equal
@@ -1497,7 +1477,7 @@ RLAPI Color ColorAlpha(Color color, float alpha);                           // G
 RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint);              // Get src alpha-blended into dst color with tint
 RLAPI Color ColorLerp(Color color1, Color color2, float factor);            // Get color lerp interpolation between two colors, factor [0.0f..1.0f]
 RLAPI Color GetColor(unsigned int hexValue);                                // Get Color structure from hexadecimal value
-RLAPI Color GetPixelColor(const void *srcPtr, int format);                  // Get Color from a source pixel pointer of certain format
+RLAPI Color GetPixelColor(void *srcPtr, int format);                        // Get Color from a source pixel pointer of certain format
 RLAPI void SetPixelColor(void *dstPtr, Color color, int format);            // Set color formatted into destination pixel pointer
 RLAPI int GetPixelDataSize(int width, int height, int format);              // Get pixel data size in bytes for certain format
 
@@ -1508,10 +1488,10 @@ RLAPI int GetPixelDataSize(int width, int height, int format);              // G
 // Font loading/unloading functions
 RLAPI Font GetFontDefault(void);                                                            // Get the default Font
 RLAPI Font LoadFont(const char *fileName);                                                  // Load font from file into GPU memory (VRAM)
-RLAPI Font LoadFontEx(const char *fileName, int fontSize, const int *codepoints, int codepointCount); // Load font from file with defined codepoints and generation size, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height
+RLAPI Font LoadFontEx(const char *fileName, int fontSize, const int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height
 RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar);                        // Load font from Image (XNA style)
 RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
-RLAPI bool IsFontValid(Font font);                                                          // Check if font is valid (font data loaded, WARNING: GPU texture not checked)
+RLAPI bool IsFontValid(Font font);                                                          // Check if a font is valid (font data loaded, WARNING: GPU texture not checked)
 RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount, int type, int *glyphCount); // Load font data for further use
 RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
 RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount);                               // Unload font chars info data (RAM)
@@ -1524,7 +1504,7 @@ RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color co
 RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
 RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
 RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
-RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple characters (codepoint)
+RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
 
 // Text font info functions
 RLAPI void SetTextLineSpacing(int spacing);                                                 // Set vertical line spacing when drawing with line-breaks
@@ -1552,7 +1532,7 @@ RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size);
 RLAPI char **LoadTextLines(const char *text, int *count);                                   // Load text as separate lines ('\n')
 RLAPI void UnloadTextLines(char **text, int lineCount);                                     // Unload text lines
 RLAPI int TextCopy(char *dst, const char *src);                                             // Copy one string to another, returns bytes copied
-RLAPI bool TextIsEqual(const char *text1, const char *text2);                               // Check if two text strings are equal
+RLAPI bool TextIsEqual(const char *text1, const char *text2);                               // Check if two text string are equal
 RLAPI unsigned int TextLength(const char *text);                                            // Get text length, checks for '\0' ending
 RLAPI const char *TextFormat(const char *text, ...);                                        // Text formatting with variables (sprintf() style)
 RLAPI const char *TextSubtext(const char *text, int position, int length);                  // Get a piece of a text string
@@ -1584,21 +1564,21 @@ RLAPI float TextToFloat(const char *text);
 RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
 RLAPI void DrawPoint3D(Vector3 position, Color color);                                                   // Draw a point in 3D space, actually a small line
 RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
-RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle, counter-clockwise vertex order
+RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle (vertex in counter-clockwise order!)
 RLAPI void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color);                      // Draw a triangle strip defined by points
 RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
 RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
 RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
 RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  // Draw cube wires (Vector version)
 RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
-RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with defined rings and slices
+RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
 RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
-RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color); // Draw a cylinder/cone
+RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
 RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos
-RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color); // Draw a cylinder/cone wires
+RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
 RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
-RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos
-RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos
+RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos
+RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos
 RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
 RLAPI void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
 RLAPI void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
@@ -1610,19 +1590,19 @@ RLAPI void DrawGrid(int slices, float spacing);
 // Model management functions
 RLAPI Model LoadModel(const char *fileName);                                                // Load model from files (meshes and materials)
 RLAPI Model LoadModelFromMesh(Mesh mesh);                                                   // Load model from generated mesh (default material)
-RLAPI bool IsModelValid(Model model);                                                       // Check if model is valid (loaded in GPU, VAO/VBOs)
+RLAPI bool IsModelValid(Model model);                                                       // Check if a model is valid (loaded in GPU, VAO/VBOs)
 RLAPI void UnloadModel(Model model);                                                        // Unload model (including meshes) from memory (RAM and/or VRAM)
 RLAPI BoundingBox GetModelBoundingBox(Model model);                                         // Compute model bounding box limits (considers all meshes)
 
 // Model drawing functions
 RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);               // Draw a model (with texture if set)
-RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with custom transform
+RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
 RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);          // Draw a model wires (with texture if set)
-RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires with custom transform
+RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
 RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                   // Draw bounding box (wires)
 RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint); // Draw a billboard texture
-RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by rectangle
-RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source rectangle with scaling and rotation
+RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
+RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation
 
 // Mesh management functions
 RLAPI void UploadMesh(Mesh *mesh, bool dynamic);                                            // Upload mesh vertex data in GPU and provide VAO/VBO ids
@@ -1651,7 +1631,7 @@ RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);
 // Material loading/unloading functions
 RLAPI Material *LoadMaterials(const char *fileName, int *materialCount);                    // Load materials from model file
 RLAPI Material LoadMaterialDefault(void);                                                   // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
-RLAPI bool IsMaterialValid(Material material);                                              // Check if material is valid (shader assigned, map textures loaded in GPU)
+RLAPI bool IsMaterialValid(Material material);                                              // Check if a material is valid (shader assigned, map textures loaded in GPU)
 RLAPI void UnloadMaterial(Material material);                                               // Unload material from GPU memory (VRAM)
 RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture);          // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
 RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId);                  // Set material for a mesh
@@ -1688,15 +1668,15 @@ RLAPI float GetMasterVolume(void);                                    // Get mas
 // Wave/Sound loading/unloading functions
 RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
 RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
-RLAPI bool IsWaveValid(Wave wave);                                    // Check if wave data is valid (data loaded and parameters)
+RLAPI bool IsWaveValid(Wave wave);                                    // Checks if wave data is valid (data loaded and parameters)
 RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
 RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
-RLAPI Sound LoadSoundAlias(Sound source);                             // Load sound alias, new sound that shares the same sample data as the source sound, does not own the sound data
-RLAPI bool IsSoundValid(Sound sound);                                 // Check if sound is valid (data loaded and buffers initialized)
-RLAPI void UpdateSound(Sound sound, const void *data, int frameCount); // Update sound buffer with new data (default data format: 32 bit float, stereo)
+RLAPI Sound LoadSoundAlias(Sound source);                             // Create a new sound that shares the same sample data as the source sound, does not own the sound data
+RLAPI bool IsSoundValid(Sound sound);                                 // Checks if a sound is valid (data loaded and buffers initialized)
+RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data (default data format: 32 bit float, stereo)
 RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
 RLAPI void UnloadSound(Sound sound);                                  // Unload sound
-RLAPI void UnloadSoundAlias(Sound alias);                             // Unload sound alias (does not deallocate sample data)
+RLAPI void UnloadSoundAlias(Sound alias);                             // Unload a sound alias (does not deallocate sample data)
 RLAPI bool ExportWave(Wave wave, const char *fileName);               // Export wave data to file, returns true on success
 RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h), returns true on success
 
@@ -1705,7 +1685,7 @@ RLAPI void PlaySound(Sound sound);                                    // Play a
 RLAPI void StopSound(Sound sound);                                    // Stop playing a sound
 RLAPI void PauseSound(Sound sound);                                   // Pause a sound
 RLAPI void ResumeSound(Sound sound);                                  // Resume a paused sound
-RLAPI bool IsSoundPlaying(Sound sound);                               // Check if sound is currently playing
+RLAPI bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
 RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
 RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
 RLAPI void SetSoundPan(Sound sound, float pan);                       // Set pan for a sound (-1.0 left, 0.0 center, 1.0 right)
@@ -1718,24 +1698,24 @@ RLAPI void UnloadWaveSamples(float *samples);                         // Unload
 // Music management functions
 RLAPI Music LoadMusicStream(const char *fileName);                    // Load music stream from file
 RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
-RLAPI bool IsMusicValid(Music music);                                 // Check if music stream is valid (context and buffers initialized)
+RLAPI bool IsMusicValid(Music music);                                 // Checks if a music stream is valid (context and buffers initialized)
 RLAPI void UnloadMusicStream(Music music);                            // Unload music stream
 RLAPI void PlayMusicStream(Music music);                              // Start music playing
 RLAPI bool IsMusicStreamPlaying(Music music);                         // Check if music is playing
-RLAPI void UpdateMusicStream(Music music);                            // Update buffers for music streaming
+RLAPI void UpdateMusicStream(Music music);                            // Updates buffers for music streaming
 RLAPI void StopMusicStream(Music music);                              // Stop music playing
 RLAPI void PauseMusicStream(Music music);                             // Pause music playing
 RLAPI void ResumeMusicStream(Music music);                            // Resume playing paused music
 RLAPI void SeekMusicStream(Music music, float position);              // Seek music to a position (in seconds)
 RLAPI void SetMusicVolume(Music music, float volume);                 // Set volume for music (1.0 is max level)
-RLAPI void SetMusicPitch(Music music, float pitch);                   // Set pitch for music (1.0 is base level)
-RLAPI void SetMusicPan(Music music, float pan);                       // Set pan for music (-1.0 left, 0.0 center, 1.0 right)
+RLAPI void SetMusicPitch(Music music, float pitch);                   // Set pitch for a music (1.0 is base level)
+RLAPI void SetMusicPan(Music music, float pan);                       // Set pan for a music (-1.0 left, 0.0 center, 1.0 right)
 RLAPI float GetMusicTimeLength(Music music);                          // Get music time length (in seconds)
 RLAPI float GetMusicTimePlayed(Music music);                          // Get current music time played (in seconds)
 
 // AudioStream management functions
 RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
-RLAPI bool IsAudioStreamValid(AudioStream stream);                    // Check if an audio stream is valid (buffers initialized)
+RLAPI bool IsAudioStreamValid(AudioStream stream);                    // Checks if an audio stream is valid (buffers initialized)
 RLAPI void UnloadAudioStream(AudioStream stream);                     // Unload audio stream and free memory
 RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data
 RLAPI bool IsAudioStreamProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
@@ -1746,7 +1726,7 @@ RLAPI bool IsAudioStreamPlaying(AudioStream stream);                  // Check i
 RLAPI void StopAudioStream(AudioStream stream);                       // Stop audio stream
 RLAPI void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
 RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
-RLAPI void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan for audio stream (-1.0 left, 0.0 center, 1.0 right)
+RLAPI void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan for audio stream (-1.0 to 1.0 range, 0.0 is centered)
 RLAPI void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
 RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
 
diff --git a/src/libraries/raylib/raylib/src/raymath.h b/src/libraries/raylib/raylib/src/raymath.h
index ff6bb8d..9398258 100644
--- a/src/libraries/raylib/raylib/src/raymath.h
+++ b/src/libraries/raylib/raylib/src/raymath.h
@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   raymath v2.0 - Math functions to work with Vector2, Vector3, Vector4, Matrix and Quaternions
+*   raymath v2.0 - Math functions to work with Vector2, Vector3, Matrix and Quaternions
 *
 *   CONVENTIONS:
 *     - Matrix structure is defined as row-major (memory layout) but parameters naming AND all
@@ -2714,13 +2714,13 @@ RMAPI void MatrixDecompose(Matrix mat, Vector3 *translation, Quaternion *rotatio
         stabilizer = fmaxf(stabilizer, fabsf(matColumns[i].y));
         stabilizer = fmaxf(stabilizer, fabsf(matColumns[i].z));
     }
-    matColumns[0] = Vector3Scale(matColumns[0], 1.0f/stabilizer);
-    matColumns[1] = Vector3Scale(matColumns[1], 1.0f/stabilizer);
-    matColumns[2] = Vector3Scale(matColumns[2], 1.0f/stabilizer);
+    matColumns[0] = Vector3Scale(matColumns[0], 1.0f / stabilizer);
+    matColumns[1] = Vector3Scale(matColumns[1], 1.0f / stabilizer);
+    matColumns[2] = Vector3Scale(matColumns[2], 1.0f / stabilizer);
 
     // X Scale
     scl.x = Vector3Length(matColumns[0]);
-    if (scl.x > eps) matColumns[0] = Vector3Scale(matColumns[0], 1.0f/scl.x);
+    if (scl.x > eps) matColumns[0] = Vector3Scale(matColumns[0], 1.0f / scl.x);
 
     // Compute XY shear and make col2 orthogonal
     shear[0] = Vector3DotProduct(matColumns[0], matColumns[1]);
@@ -2730,7 +2730,7 @@ RMAPI void MatrixDecompose(Matrix mat, Vector3 *translation, Quaternion *rotatio
     scl.y = Vector3Length(matColumns[1]);
     if (scl.y > eps)
     {
-        matColumns[1] = Vector3Scale(matColumns[1], 1.0f/scl.y);
+        matColumns[1] = Vector3Scale(matColumns[1], 1.0f / scl.y);
         shear[0] /= scl.y; // Correct XY shear
     }
 
@@ -2744,7 +2744,7 @@ RMAPI void MatrixDecompose(Matrix mat, Vector3 *translation, Quaternion *rotatio
     scl.z = Vector3Length(matColumns[2]);
     if (scl.z > eps)
     {
-        matColumns[2] = Vector3Scale(matColumns[2], 1.0f/scl.z);
+        matColumns[2] = Vector3Scale(matColumns[2], 1.0f / scl.z);
         shear[1] /= scl.z; // Correct XZ shear
         shear[2] /= scl.z; // Correct YZ shear
     }
@@ -2802,11 +2802,6 @@ inline const Vector2& operator -= (Vector2& lhs, const Vector2& rhs)
     return lhs;
 }
 
-inline Vector2 operator * (const float& lhs, const Vector2& rhs)
-{
-    return Vector2Scale(rhs, lhs);
-}
-
 inline Vector2 operator * (const Vector2& lhs, const float& rhs)
 {
     return Vector2Scale(lhs, rhs);
@@ -2901,11 +2896,6 @@ inline const Vector3& operator -= (Vector3& lhs, const Vector3& rhs)
     return lhs;
 }
 
-inline Vector3 operator * (const float& lhs, const Vector3& rhs)
-{
-    return Vector3Scale(rhs, lhs);
-}
-
 inline Vector3 operator * (const Vector3& lhs, const float& rhs)
 {
     return Vector3Scale(lhs, rhs);
@@ -3001,11 +2991,6 @@ inline const Vector4& operator -= (Vector4& lhs, const Vector4& rhs)
     return lhs;
 }
 
-inline Vector4 operator * (const float& lhs, const Vector4& rhs)
-{
-    return Vector4Scale(rhs, lhs);
-}
-
 inline Vector4 operator * (const Vector4& lhs, const float& rhs)
 {
     return Vector4Scale(lhs, rhs);
diff --git a/src/libraries/raylib/raylib/src/rcore.c b/src/libraries/raylib/raylib/src/rcore.c
index 9394f3f..d99919b 100644
--- a/src/libraries/raylib/raylib/src/rcore.c
+++ b/src/libraries/raylib/raylib/src/rcore.c
@@ -106,16 +106,11 @@
 
 #include "config.h"                 // Defines module configuration flags
 
-#include <stdlib.h>                 // Required for: srand(), rand(), exit()
+#include <stdlib.h>                 // Required for: srand(), rand(), atexit(), exit()
 #include <stdio.h>                  // Required for: FILE, fopen(), fseek(), ftell(), fread(), fwrite(), fprintf(), vprintf(), fclose(), sprintf() [Used in OpenURL()]
-#include <string.h>                 // Required for: strlen(), strcmp(), strrchr(), memset(), memcpy(), strcat()
+#include <string.h>                 // Required for: strlen(), strncpy(), strcmp(), strrchr(), memset(), strcat()
 #include <stdarg.h>                 // Required for: va_list, va_start(), va_end() [Used in TraceLog()]
-
-#ifndef PICO_RP2350
 #include <time.h>                   // Required for: time() [Used in InitTimer()]
-#else
-#include "pico/rand.h"              // Pico doesn't implement time, and will implement its own hardware timer elsewhere.  However, we need something to get a random seed from...
-#endif
 #include <math.h>                   // Required for: tan() [Used in BeginMode3D()], atan2f() [Used in LoadVrStereoConfig()]
 
 #if defined(PLATFORM_MEMORY) || defined(PLATFORM_WEB)
@@ -390,7 +385,7 @@ typedef struct CoreData {
         double draw;                        // Time measure for frame draw (seconds)
         double frame;                       // Time measure for one frame (seconds)
         double target;                      // Desired time for one frame, if 0 not applied (seconds)
-        unsigned long long base;            // Base time measure for hi-res timer (ticks or nanoseconds)
+        unsigned long long int base;        // Base time measure for hi-res timer (ticks or nanoseconds)
         unsigned int frameCounter;          // Frame counter (frames)
 
     } Time;
@@ -447,6 +442,18 @@ typedef enum AutomationEventType {
     ACTION_SETTARGETFPS             // param[0]: fps
 } AutomationEventType;
 
+// Event type to config events flags
+// WARNING: Not used at the moment
+typedef enum {
+    EVENT_INPUT_KEYBOARD    = 0,
+    EVENT_INPUT_MOUSE       = 1,
+    EVENT_INPUT_GAMEPAD     = 2,
+    EVENT_INPUT_TOUCH       = 4,
+    EVENT_INPUT_GESTURE     = 8,
+    EVENT_WINDOW            = 16,
+    EVENT_CUSTOM            = 32
+} EventType;
+
 // Event type name strings, required for export
 static const char *autoEventTypeName[] = {
     "EVENT_NONE",
@@ -475,6 +482,16 @@ static const char *autoEventTypeName[] = {
     "ACTION_SETTARGETFPS"
 };
 
+/*
+// Automation event (24 bytes)
+// NOTE: Opaque struct, internal to raylib
+struct AutomationEvent {
+    unsigned int frame;                 // Event frame
+    unsigned int type;                  // Event type (AutomationEventType)
+    int params[4];                      // Event parameters (if required)
+};
+*/
+
 static AutomationEventList *currentEventList = NULL;        // Current automation events list, set by user, keep internal pointer
 static bool automationEventRecording = false;               // Recording automation events flag
 //static short automationEventEnabled = 0b0000001111111111; // TODO: Automation events enabled for recording/playing
@@ -511,11 +528,11 @@ __declspec(dllimport) void __stdcall Sleep(unsigned long msTimeout); // Required
 const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed'
 #endif
 
-// NOTE: PLATFORM_DESKTOP defaults to GLFW backend
 #if defined(PLATFORM_DESKTOP)
     #define PLATFORM_DESKTOP_GLFW
 #endif
 
+
 // Include platform-specific submodules
 #if defined(PLATFORM_DESKTOP_GLFW)
     #include "platforms/rcore_desktop_glfw.c"
@@ -718,12 +735,8 @@ void InitWindow(int width, int height, const char *title)
     CORE.Time.frameCounter = 0;
     CORE.Window.shouldClose = false;
 
-    // Initialize random seed using available timer source instead of standard time() on embedded platforms
-    #ifndef PICO_RP2350
+    // Initialize random seed
     SetRandomSeed((unsigned int)time(NULL));
-    #else
-    SetRandomSeed(get_rand_32());
-    #endif
 
     TRACELOG(LOG_INFO, "SYSTEM: Working Directory: %s", GetWorkingDirectory());
 }
@@ -794,11 +807,6 @@ bool IsWindowState(unsigned int flag)
     return FLAG_IS_SET(CORE.Window.flags, flag);
 }
 
-bool IsWindowCloseFlagSet()
-{
-    return CORE.Window.shouldClose;
-}
-
 // Get current screen width
 int GetScreenWidth(void)
 {
@@ -861,14 +869,14 @@ bool IsCursorOnScreen(void)
 // Module Functions Definition: Screen Drawing
 //----------------------------------------------------------------------------------
 
-// Clear background (framebuffer) to color
+// Set background color (framebuffer clear color)
 void ClearBackground(Color color)
 {
     rlClearColor(color.r, color.g, color.b, color.a);   // Set clear color
     rlClearScreenBuffers();                             // Clear current framebuffers
 }
 
-// Begin canvas (framebuffer) drawing
+// Setup canvas (framebuffer) to start drawing
 void BeginDrawing(void)
 {
     // WARNING: Previously to BeginDrawing() other render textures drawing could happen,
@@ -885,7 +893,7 @@ void BeginDrawing(void)
                                         // NOTE: Not required with OpenGL 3.3+
 }
 
-// End canvas (framebuffer) drawing and swap buffers (double buffering)
+// End canvas drawing and swap buffers (double buffering)
 void EndDrawing(void)
 {
     rlDrawRenderBatchActive();      // Update and draw internal render batch
@@ -941,7 +949,7 @@ void BeginMode2D(Camera2D camera)
     rlMultMatrixf(MatrixToFloat(GetCameraMatrix2D(camera)));
 }
 
-// End 2D mode with custom camera
+// Ends 2D mode with custom camera
 void EndMode2D(void)
 {
     rlDrawRenderBatchActive();      // Update and draw internal render batch
@@ -990,7 +998,7 @@ void BeginMode3D(Camera camera)
     rlEnableDepthTest();            // Enable DEPTH_TEST for 3D
 }
 
-// End 3D mode and returns to default 2D orthographic mode
+// Ends 3D mode and returns to default 2D orthographic mode
 void EndMode3D(void)
 {
     rlDrawRenderBatchActive();      // Update and draw internal render batch
@@ -1037,7 +1045,7 @@ void BeginTextureMode(RenderTexture2D target)
     CORE.Window.usingFbo = true;
 }
 
-// End drawing to render texture
+// Ends drawing to render texture
 void EndTextureMode(void)
 {
     rlDrawRenderBatchActive();      // Update and draw internal render batch
@@ -1307,7 +1315,7 @@ Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode)
     return shader;
 }
 
-// Check if shader is valid (loaded on GPU)
+// Check if a shader is valid (loaded on GPU)
 bool IsShaderValid(Shader shader)
 {
     return ((shader.id > 0) &&          // Validate shader id (GPU loaded successfully)
@@ -1506,7 +1514,7 @@ Matrix GetCameraMatrix2D(Camera2D camera)
     return matTransform;
 }
 
-// Get screen space position from a 3d world space position
+// Get the screen space position from a 3d world space position
 Vector2 GetWorldToScreen(Vector3 position, Camera camera)
 {
     Vector2 screenPosition = GetWorldToScreenEx(position, camera, GetScreenWidth(), GetScreenHeight());
@@ -1514,7 +1522,7 @@ Vector2 GetWorldToScreen(Vector3 position, Camera camera)
     return screenPosition;
 }
 
-// Get sized screen space position for a 3d world space position (useful for texture drawing)
+// Get size position for a 3d world space position (useful for texture drawing)
 Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height)
 {
     // Calculate projection matrix (from perspective instead of frustum
@@ -1556,7 +1564,7 @@ Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int heigh
     return screenPosition;
 }
 
-// Get screen space position for a 2d camera world space position
+// Get the screen space position for a 2d camera world space position
 Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera)
 {
     Matrix matCamera = GetCameraMatrix2D(camera);
@@ -1565,7 +1573,7 @@ Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera)
     return (Vector2){ transform.x, transform.y };
 }
 
-// Get world space position for a 2d camera screen space position
+// Get the world space position for a 2d camera screen space position
 Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera)
 {
     Matrix invMatCamera = MatrixInvert(GetCameraMatrix2D(camera));
@@ -1749,9 +1757,9 @@ int GetRandomValue(int min, int max)
     else
     {
         // Rejection sampling to get a uniform integer in [min, max]
-        unsigned long c = (unsigned long)RAND_MAX + 1UL; // Number of possible results
-        unsigned long m = (unsigned long)range;          // Size of the target interval
-        unsigned long t = c - (c%m);                     // Largest multiple of m <= c
+        unsigned long c = (unsigned long)RAND_MAX + 1UL;  // number of possible rand() results
+        unsigned long m = (unsigned long)range;           // size of the target interval
+        unsigned long t = c - (c%m);                    // largest multiple of m <= c
         unsigned long r = 0;
 
         for (;;)
@@ -1818,6 +1826,7 @@ void UnloadRandomSequence(int *sequence)
 }
 
 // Takes a screenshot of current screen
+// NOTE: Provided fileName should not contain paths, saving to working directory
 void TakeScreenshot(const char *fileName)
 {
 #if SUPPORT_MODULE_RTEXTURES
@@ -1832,8 +1841,7 @@ void TakeScreenshot(const char *fileName)
     Image image = { imgData, (int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y), 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 };
 
     char path[MAX_FILEPATH_LENGTH] = { 0 };
-    if (!IsPathAbsolute(fileName)) snprintf(path, MAX_FILEPATH_LENGTH, "%s", TextFormat("%s/%s", CORE.Storage.basePath, fileName));
-    else snprintf(path, MAX_FILEPATH_LENGTH, "%s", fileName);
+    strncpy(path, TextFormat("%s/%s", CORE.Storage.basePath, fileName), MAX_FILEPATH_LENGTH - 1);
 
     ExportImage(image, path); // WARNING: Module required: rtextures
     RL_FREE(imgData);
@@ -1845,7 +1853,7 @@ void TakeScreenshot(const char *fileName)
 #endif
 }
 
-// Set up window configuration flags (view FLAGS)
+// Setup window configuration flags (view FLAGS)
 // NOTE: This function is expected to be called before window creation,
 // because it sets up some flags for the window creation process
 // To configure window states after creation, use SetWindowState()
@@ -1858,6 +1866,8 @@ void SetConfigFlags(unsigned int flags)
     FLAG_SET(CORE.Window.flags, flags);
 }
 
+// void OpenURL(const char *url);   // Defined per platform
+
 //----------------------------------------------------------------------------------
 // Module Functions Definition: Logging system
 //----------------------------------------------------------------------------------
@@ -1897,12 +1907,12 @@ void TraceLog(int logType, const char *text, ...)
 
     switch (logType)
     {
-        case LOG_TRACE: memcpy(buffer, "TRACE: ", 7); break;
-        case LOG_DEBUG: memcpy(buffer, "DEBUG: ", 7); break;
-        case LOG_INFO: memcpy(buffer, "INFO: ", 6); break;
-        case LOG_WARNING: memcpy(buffer, "WARNING: ", 9); break;
-        case LOG_ERROR: memcpy(buffer, "ERROR: ", 7); break;
-        case LOG_FATAL: memcpy(buffer, "FATAL: ", 7); break;
+        case LOG_TRACE: strncpy(buffer, "TRACE: ", 8); break;
+        case LOG_DEBUG: strncpy(buffer, "DEBUG: ", 8); break;
+        case LOG_INFO: strncpy(buffer, "INFO: ", 7); break;
+        case LOG_WARNING: strncpy(buffer, "WARNING: ", 10); break;
+        case LOG_ERROR: strncpy(buffer, "ERROR: ", 8); break;
+        case LOG_FATAL: strncpy(buffer, "FATAL: ", 8); break;
         default: break;
     }
 
@@ -1982,7 +1992,7 @@ unsigned char *LoadFileData(const char *fileName, int *dataSize)
                     size_t count = fread(data, sizeof(unsigned char), size, file);
 
                     // WARNING: fread() returns a size_t value, usually 'unsigned int' (32bit compilation) and 'unsigned long long' (64bit compilation)
-                    // dataSize is unified along raylib as a 'int' type, so, for file-sizes >INT_MAX (2147483647 bytes) there is a limitation
+                    // dataSize is unified along raylib as a 'int' type, so, for file-sizes > INT_MAX (2147483647 bytes) there is a limitation
                     if (count > 2147483647)
                     {
                         TRACELOG(LOG_WARNING, "FILEIO: [%s] File is bigger than 2147483647 bytes, avoid using LoadFileData()", fileName);
@@ -1994,7 +2004,7 @@ unsigned char *LoadFileData(const char *fileName, int *dataSize)
                     {
                         *dataSize = (int)count;
 
-                        if ((*dataSize) != size) TRACELOG(LOG_WARNING, "FILEIO: [%s] File partially loaded (%i bytes out of %i)", fileName, *dataSize, size);
+                        if ((*dataSize) != size) TRACELOG(LOG_WARNING, "FILEIO: [%s] File partially loaded (%i bytes out of %i)", fileName, dataSize, count);
                         else TRACELOG(LOG_INFO, "FILEIO: [%s] File loaded successfully", fileName);
                     }
                 }
@@ -2018,7 +2028,7 @@ void UnloadFileData(unsigned char *data)
 }
 
 // Save data to file from buffer
-bool SaveFileData(const char *fileName, const void *data, int dataSize)
+bool SaveFileData(const char *fileName, void *data, int dataSize)
 {
     bool result = false;
 
@@ -2075,7 +2085,7 @@ bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileN
 
     // Get file name from path
     char varFileName[256] = { 0 };
-    snprintf(varFileName, 256, "%s", GetFileNameWithoutExt(fileName));
+    strncpy(varFileName, GetFileNameWithoutExt(fileName), 256 - 1);
     for (int i = 0; varFileName[i] != '\0'; i++)
     {
         // Convert variable name to uppercase
@@ -2217,12 +2227,13 @@ void SetSaveFileTextCallback(SaveFileTextCallback callback)
 // NOTE: Only rename file name required, not full path
 int FileRename(const char *fileName, const char *fileRename)
 {
-    int result = -1;
+    int result = 0;
 
     if (FileExists(fileName))
     {
         result = rename(fileName, fileRename);
     }
+    else result = -1;
 
     return result;
 }
@@ -2230,12 +2241,13 @@ int FileRename(const char *fileName, const char *fileRename)
 // Remove file (if exists)
 int FileRemove(const char *fileName)
 {
-    int result = -1;
+    int result = 0;
 
     if (FileExists(fileName))
     {
         result = remove(fileName);
     }
+    else result = -1;
 
     return result;
 }
@@ -2244,21 +2256,18 @@ int FileRemove(const char *fileName)
 // NOTE: If destination path does not exist, it is created!
 int FileCopy(const char *srcPath, const char *dstPath)
 {
-    int result = -1;
+    int result = 0;
     int srcDataSize = 0;
     unsigned char *srcFileData = LoadFileData(srcPath, &srcDataSize);
 
     // Create required paths if they do not exist
-    if (DirectoryExists(GetDirectoryPath(dstPath))) result = 0; // Already exists
-    else result = MakeDirectory(GetDirectoryPath(dstPath));
+    if (!DirectoryExists(GetDirectoryPath(dstPath)))
+        result = MakeDirectory(GetDirectoryPath(dstPath));
 
-    if (result == 0) // Directory created successfully or already exists
+    if (result == 0) // Directory created successfully (or already exists)
     {
         if ((srcFileData != NULL) && (srcDataSize > 0))
-        {
-            bool saved = SaveFileData(dstPath, srcFileData, srcDataSize);
-            if (saved) result = 0;
-        }
+            result = SaveFileData(dstPath, srcFileData, srcDataSize);
     }
 
     UnloadFileData(srcFileData);
@@ -2274,18 +2283,8 @@ int FileMove(const char *srcPath, const char *dstPath)
 
     if (FileExists(srcPath))
     {
-        result = FileCopy(srcPath, dstPath);
-
-        if (result == 0)
-        {
-            // Make sure file has been correctly copied before removing
-            if (FileExists(dstPath) && (GetFileLength(srcPath) == GetFileLength(dstPath)))
-            {
-                result = FileRemove(srcPath);
-                if (result != 0) TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to remove source file after copy", srcPath);
-            }
-            else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to copy file to [%s]", srcPath, dstPath);
-        }
+		if (FileCopy(srcPath, dstPath) == 0) result = FileRemove(srcPath);
+        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to copy file to [%s]", srcPath, dstPath);
     }
 	else TRACELOG(LOG_WARNING, "FILEIO: [%s] Source file does not exist", srcPath);
 
@@ -2296,18 +2295,16 @@ int FileMove(const char *srcPath, const char *dstPath)
 // WARNING: DEPENDENCY: [rtext] module
 int FileTextReplace(const char *fileName, const char *search, const char *replacement)
 {
-    int result = -1;
-
-#if SUPPORT_MODULE_RTEXT
+    int result = 0;
     char *fileText = NULL;
     char *fileTextUpdated = { 0 };
 
+#if SUPPORT_MODULE_RTEXT
     if (FileExists(fileName))
     {
         fileText = LoadFileText(fileName);
         fileTextUpdated = TextReplaceAlloc(fileText, search, replacement);
-        bool saved = SaveFileText(fileName, fileTextUpdated);
-        if (saved) result = 0;
+        result = SaveFileText(fileName, fileTextUpdated);
         MemFree(fileTextUpdated);
         UnloadFileText(fileText);
     }
@@ -2340,7 +2337,7 @@ bool FileExists(const char *fileName)
 {
     bool result = false;
 
-    if ((fileName != NULL) && (ACCESS(fileName) != -1)) result = true;
+    if (ACCESS(fileName) != -1) result = true;
 
     // NOTE: Alternatively, stat() can be used instead of access()
     //#include <sys/stat.h>
@@ -2365,7 +2362,8 @@ bool IsFileExtension(const char *fileName, const char *ext)
     {
         int fileExtLength = (int)strlen(fileExt);
         char fileExtLower[16] = { 0 };
-        for (int i = 0; (i < fileExtLength) && (i < 15); i++)
+        char *fileExtLowerPtr = fileExtLower;
+        for (int i = 0; (i < fileExtLength) && (i < 16); i++)
         {
             // Copy and convert to lower-case
             if ((fileExt[i] >= 'A') && (fileExt[i] <= 'Z')) fileExtLower[i] =  fileExt[i] + 32;
@@ -2376,7 +2374,7 @@ bool IsFileExtension(const char *fileName, const char *ext)
         int extLength = (int)strlen(ext);
         char *extList = (char *)RL_CALLOC(extLength + 1, 1);
         char *extListPtrs[MAX_FILE_EXTENSIONS] = { 0 };
-        memcpy(extList, ext, extLength);
+        strncpy(extList, ext, extLength);
         extListPtrs[0] = extList;
 
         for (int i = 0; i < extLength; i++)
@@ -2385,15 +2383,11 @@ bool IsFileExtension(const char *fileName, const char *ext)
             if ((extList[i] >= 'A') && (extList[i] <= 'Z')) extList[i] += 32;
 
             // Get pointer to next extension and add null-terminator
-            if (extList[i] == ';')
+            if ((extList[i] == ';') && (extCount < (MAX_FILE_EXTENSIONS - 1)))
             {
                 extList[i] = '\0';
-
-                if (extCount < MAX_FILE_EXTENSIONS)
-                {
-                    extListPtrs[extCount] = extList + i + 1;
-                    extCount++;
-                }
+                extListPtrs[extCount] = extList + i + 1;
+                extCount++;
             }
         }
 
@@ -2401,7 +2395,7 @@ bool IsFileExtension(const char *fileName, const char *ext)
         {
             // Consider the case where extension provided
             // does not start with the '.'
-            char *fileExtLowerPtr = fileExtLower;
+            fileExtLowerPtr = fileExtLower;
             if (extListPtrs[i][0] != '.') fileExtLowerPtr++;
 
             if (strcmp(fileExtLowerPtr, extListPtrs[i]) == 0)
@@ -2417,7 +2411,7 @@ bool IsFileExtension(const char *fileName, const char *ext)
     return result;
 }
 
-// Check if directory path exists
+// Check if a directory path exists
 bool DirectoryExists(const char *dirPath)
 {
     bool result = false;
@@ -2519,7 +2513,7 @@ const char *GetFileNameWithoutExt(const char *filePath)
 
     if (filePath != NULL)
     {
-        snprintf(fileName, MAX_FILENAME_LENGTH, "%s", GetFileName(filePath)); // Get filename.ext without path
+        strncpy(fileName, GetFileName(filePath), MAX_FILENAME_LENGTH - 1); // Get filename.ext without path
         int fileNameLength = (int)strlen(fileName); // Get size in bytes
 
         for (int i = fileNameLength; i > 0; i--) // Reverse search '.'
@@ -2536,7 +2530,7 @@ const char *GetFileNameWithoutExt(const char *filePath)
     return fileName;
 }
 
-// Get directory for a provided filePath
+// Get directory for a given filePath
 const char *GetDirectoryPath(const char *filePath)
 {
     /*
@@ -2573,6 +2567,7 @@ const char *GetDirectoryPath(const char *filePath)
         }
         else
         {
+            // NOTE: Be careful, strncpy() is not safe, it does not care about '\0'
             char *dirPathPtr = dirPath;
             if ((filePath[1] != ':') && (filePath[0] != '\\') && (filePath[0] != '/')) dirPathPtr += 2;     // Skip drive letter, "C:"
             memcpy(dirPathPtr, filePath, strlen(filePath) - (strlen(lastSlash) - 1));
@@ -2583,32 +2578,24 @@ const char *GetDirectoryPath(const char *filePath)
     return dirPath;
 }
 
-// Get previous directory path for a provided path
+// Get previous directory path for a given path
 const char *GetPrevDirectoryPath(const char *dirPath)
 {
     static char prevDirPath[MAX_FILEPATH_LENGTH] = { 0 };
     memset(prevDirPath, 0, MAX_FILEPATH_LENGTH);
+    int dirPathLength = (int)strlen(dirPath);
 
-    const int lastIndex = (int)strlen(dirPath) - 1;
-    bool isFile = IsPathFile(dirPath);
-    for (int i = lastIndex; i >= 0; i--)
+    if (dirPathLength <= 3) strncpy(prevDirPath, dirPath, MAX_FILEPATH_LENGTH  - 1);
+
+    for (int i = (dirPathLength - 1); (i >= 0) && (dirPathLength > 3); i--)
     {
-        // If the character is a path separator.
         if ((dirPath[i] == '\\') || (dirPath[i] == '/'))
         {
-            // If this character is a leading '/' (e.g. the '/' in "/usr") or
-            // part of a drive root (e.g. "C:\"), include it with the result.
-            if ((i == 0) || ((i == 2) && (dirPath[1] == ':'))) i += 1;
-            // If this character is a trailing path separator (e.g. the last
-            // '/' in "/usr/bin/" or the last '\' in "C:\raylib\"), continue.
-            else if (i == lastIndex) continue;
+            // Check for root: "C:\" or "/"
+            if (((i == 2) && (dirPath[1] ==':')) || (i == 0)) i++;
 
-            if (!isFile)
-            {
-                memcpy(prevDirPath, dirPath, i);
-                break;
-            }
-            else isFile = false;
+            strncpy(prevDirPath, dirPath, i);
+            break;
         }
     }
 
@@ -2621,7 +2608,7 @@ const char *GetWorkingDirectory(void)
     static char currentDir[MAX_FILEPATH_LENGTH] = { 0 };
     memset(currentDir, 0, MAX_FILEPATH_LENGTH);
 
-    char *path = GETCWD(currentDir, MAX_FILEPATH_LENGTH);
+    char *path = GETCWD(currentDir, MAX_FILEPATH_LENGTH - 1);
 
     return path;
 }
@@ -2829,61 +2816,23 @@ int MakeDirectory(const char *dirPath)
 }
 
 // Change working directory, returns true on success
-int ChangeDirectory(const char *dirPath)
+bool ChangeDirectory(const char *dirPath)
 {
-    // NOTE: On success, CHDIR() return 0; on error, returns -1 and errno is set to indicate the error,
-    // depending on the filesystem, other errors can be returned
-    int result = CHDIR(dirPath);
+    bool result = CHDIR(dirPath);
 
     if (result != 0) TRACELOG(LOG_WARNING, "SYSTEM: Failed to change to directory: %s", dirPath);
     else TRACELOG(LOG_INFO, "SYSTEM: Working Directory: %s", dirPath);
 
-    return result;
+    return (result == 0);
 }
 
-// Check if provided path point to a file
+// Check if a given path point to a file
 bool IsPathFile(const char *path)
 {
-    bool result = false;
+    struct stat result = { 0 };
+    stat(path, &result);
 
-    struct stat info = { 0 };
-    stat(path, &info);
-
-    if (S_ISREG(info.st_mode)) result = true;
-
-    return result;
-}
-
-// Check if provided path point to a directory
-bool IsPathDirectory(const char *path)
-{
-    bool result = false;
-
-    if (!IsPathFile(path)) result = true;
-
-    return result;
-}
-
-// Check if provided path is an absolute path
-bool IsPathAbsolute(const char *path)
-{
-    int result = false;
-
-    if ((path != NULL) && (path[0] != '\0'))
-    {
-#if defined(_WIN32)
-        // Check UNC path (\\server\share)
-        if ((path[0] == '\\') && (path[1] == '\\')) result = true;
-        // Check path starts with a drive letter (e.g. C:\ or D:/)
-        else if ((((path[0] >= 'A') && (path[0] <= 'Z')) || ((path[0] >= 'a') && (path[0] <= 'z'))) &&
-                 (path[1] != '\0') && (path[1] == ':') && (path[2] != '\0') && ((path[2] == '\\') || (path[2] == '/'))) result = true;
-#else
-        // Check POSIX path, must start with /
-        if (path[0] == '/') result = true;
-#endif
-    }
-
-    return result;
+    return S_ISREG(result.st_mode);
 }
 
 // Check if fileName is valid for the platform/OS
@@ -2942,7 +2891,7 @@ bool IsFileNameValid(const char *fileName)
     return valid;
 }
 
-// Check if file has been dropped into window
+// Check if a file has been dropped into window
 bool IsFileDropped(void)
 {
     bool result = false;
@@ -3006,9 +2955,9 @@ unsigned int GetDirectoryFileCountEx(const char *basePath, const char *filter, b
             {
                 // Construct new path from our base path
                 #if defined(_WIN32)
-                    int pathLength = snprintf(path, MAX_FILEPATH_LENGTH, "%s\\%s", basePath, entity->d_name);
+                    int pathLength = snprintf(path, MAX_FILEPATH_LENGTH - 1, "%s\\%s", basePath, entity->d_name);
                 #else
-                    int pathLength = snprintf(path, MAX_FILEPATH_LENGTH, "%s/%s", basePath, entity->d_name);
+                    int pathLength = snprintf(path, MAX_FILEPATH_LENGTH - 1, "%s/%s", basePath, entity->d_name);
                 #endif
                 // Don't add to count if path too long
                 if ((pathLength < 0) || (pathLength >= MAX_FILEPATH_LENGTH))
@@ -3211,7 +3160,7 @@ unsigned char *DecodeDataBase64(const char *text, int *outputSize)
 }
 
 // Compute CRC32 hash code
-unsigned int ComputeCRC32(const unsigned char *data, int dataSize)
+unsigned int ComputeCRC32(unsigned char *data, int dataSize)
 {
     static unsigned int crcTable[256] = {
         0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
@@ -3257,7 +3206,7 @@ unsigned int ComputeCRC32(const unsigned char *data, int dataSize)
 
 // Compute MD5 hash code
 // NOTE: Returns a static int[4] array (16 bytes)
-unsigned int *ComputeMD5(const unsigned char *data, int dataSize)
+unsigned int *ComputeMD5(unsigned char *data, int dataSize)
 {
     #define ROTATE_LEFT(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
 
@@ -3317,7 +3266,7 @@ unsigned int *ComputeMD5(const unsigned char *data, int dataSize)
     memcpy(msg + newDataSize, &bitsLen, 4); // Append the len in bits at the end of the buffer
 
     // Process the message in successive 512-bit chunks for each 512-bit chunk of message
-    for (int offset = 0; offset < newDataSize; offset += 64)  // 512/8
+    for (int offset = 0; offset < newDataSize; offset += (512/8))
     {
         // Break chunk into sixteen 32-bit words w[j], 0 <= j <= 15
         unsigned int *w = (unsigned int *)(msg + offset);
@@ -3375,7 +3324,7 @@ unsigned int *ComputeMD5(const unsigned char *data, int dataSize)
 
 // Compute SHA-1 hash code
 // NOTE: Returns a static int[5] array (20 bytes)
-unsigned int *ComputeSHA1(const unsigned char *data, int dataSize)
+unsigned int *ComputeSHA1(unsigned char *data, int dataSize)
 {
     #define SHA1_ROTATE_LEFT(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
 
@@ -3403,27 +3352,27 @@ unsigned int *ComputeSHA1(const unsigned char *data, int dataSize)
     memcpy(msg, data, dataSize);
     msg[dataSize] = 128; // Write the '1' bit
 
-    unsigned long long bitsLen = 8ULL*dataSize;
-    msg[newDataSize - 1] = (unsigned char)(bitsLen);
-    msg[newDataSize - 2] = (unsigned char)(bitsLen >> 8);
-    msg[newDataSize - 3] = (unsigned char)(bitsLen >> 16);
-    msg[newDataSize - 4] = (unsigned char)(bitsLen >> 24);
-    msg[newDataSize - 5] = (unsigned char)(bitsLen >> 32);
-    msg[newDataSize - 6] = (unsigned char)(bitsLen >> 40);
-    msg[newDataSize - 7] = (unsigned char)(bitsLen >> 48);
-    msg[newDataSize - 8] = (unsigned char)(bitsLen >> 56);
+    unsigned long long bitsLen = 8ULL * dataSize;
+    msg[newDataSize-1] = (unsigned char)(bitsLen);
+    msg[newDataSize-2] = (unsigned char)(bitsLen >> 8);
+    msg[newDataSize-3] = (unsigned char)(bitsLen >> 16);
+    msg[newDataSize-4] = (unsigned char)(bitsLen >> 24);
+    msg[newDataSize-5] = (unsigned char)(bitsLen >> 32);
+    msg[newDataSize-6] = (unsigned char)(bitsLen >> 40);
+    msg[newDataSize-7] = (unsigned char)(bitsLen >> 48);
+    msg[newDataSize-8] = (unsigned char)(bitsLen >> 56);
 
     // Process the message in successive 512-bit chunks
-    for (int offset = 0; offset < newDataSize; offset += 64)  // 512/8
+    for (int offset = 0; offset < newDataSize; offset += (512/8))
     {
         // Break chunk into sixteen 32-bit words w[j], 0 <= j <= 15
         unsigned int w[80] = { 0 };
         for (int i = 0; i < 16; i++)
         {
-            w[i] = ((unsigned int)msg[offset + (i*4) + 0] << 24) |
-                   ((unsigned int)msg[offset + (i*4) + 1] << 16) |
-                   ((unsigned int)msg[offset + (i*4) + 2] << 8) |
-                   ((unsigned int)msg[offset + (i*4) + 3]);
+            w[i] = (msg[offset + (i*4) + 0] << 24) |
+                   (msg[offset + (i*4) + 1] << 16) |
+                   (msg[offset + (i*4) + 2] << 8) |
+                   (msg[offset + (i*4) + 3]);
         }
 
         // Message schedule: extend the sixteen 32-bit words into eighty 32-bit words:
@@ -3485,7 +3434,7 @@ unsigned int *ComputeSHA1(const unsigned char *data, int dataSize)
 
 // Compute SHA-256 hash code
 // NOTE: Returns a static int[8] array (32 bytes)
-unsigned int *ComputeSHA256(const unsigned char *data, int dataSize)
+unsigned int *ComputeSHA256(unsigned char *data, int dataSize)
 {
     #define SHA256_ROTATE_RIGHT(x, c) ((x >> c) | (x << ((sizeof(unsigned int)*8) - c)))
     #define SHA256_A0(x) (SHA256_ROTATE_RIGHT(x, 7) ^ SHA256_ROTATE_RIGHT(x, 18) ^ (x >> 3))
@@ -3520,8 +3469,8 @@ unsigned int *ComputeSHA256(const unsigned char *data, int dataSize)
     hash[6] = 0x1f83d9ab;
     hash[7] = 0x5be0cd19;
 
-    const unsigned long long bitLen = 8ULL*dataSize;
-    unsigned long long paddedSize = dataSize + sizeof(dataSize);
+    const unsigned long long int bitLen = ((unsigned long long int)dataSize)*8;
+    unsigned long long int paddedSize = dataSize + sizeof(dataSize);
     paddedSize += (64 - (paddedSize%64));
     unsigned char *buffer = (unsigned char *)RL_CALLOC(paddedSize, sizeof(unsigned char));
 
@@ -3532,7 +3481,7 @@ unsigned int *ComputeSHA256(const unsigned char *data, int dataSize)
         buffer[(paddedSize - sizeof(bitLen)) + (i - 1)] = (bitLen >> (8*(sizeof(bitLen) - i))) & 0xFF;
     }
 
-    for (unsigned long long blockN = 0; blockN < paddedSize/64; blockN++)
+    for (unsigned long long int blockN = 0; blockN < paddedSize/64; blockN++)
     {
         unsigned int a = hash[0];
         unsigned int b = hash[1];
@@ -3554,7 +3503,7 @@ unsigned int *ComputeSHA256(const unsigned char *data, int dataSize)
         }
         for (int t = 16; t < 64; t++) w[t] = SHA256_A1(w[t - 2]) + w[t - 7] + SHA256_A0(w[t - 15]) + w[t - 16];
 
-        for (int t = 0; t < 64; t++)
+        for (unsigned long long int t = 0; t < 64; t++)
         {
             unsigned int e1 = (SHA256_ROTATE_RIGHT(e, 6) ^ SHA256_ROTATE_RIGHT(e, 11) ^ SHA256_ROTATE_RIGHT(e, 25));
             unsigned int ch = ((e & f) ^ (~e & g));
@@ -3645,14 +3594,10 @@ AutomationEventList LoadAutomationEventList(const char *fileName)
                     case 'c': sscanf(buffer, "c %i", &list.count); break;
                     case 'e':
                     {
-                        if (counter < list.capacity)
-                        {
-                            sscanf(buffer, "e %d %d %d %d %d %d %63[^\n]s", &list.events[counter].frame, &list.events[counter].type,
-                                   &list.events[counter].params[0], &list.events[counter].params[1], &list.events[counter].params[2], &list.events[counter].params[3], eventDesc);
+                        sscanf(buffer, "e %d %d %d %d %d %d %[^\n]s", &list.events[counter].frame, &list.events[counter].type,
+                               &list.events[counter].params[0], &list.events[counter].params[1], &list.events[counter].params[2], &list.events[counter].params[3], eventDesc);
 
-                            counter++;
-                        }
-                        else TRACELOG(LOG_WARNING, "AUTOMATION: Event goes beyond automated list capacity (MAX: %u): %s", list.capacity, buffer);
+                        counter++;
                     } break;
                     default: break;
                 }
@@ -3857,7 +3802,7 @@ void PlayAutomationEvent(AutomationEvent event)
 // Module Functions Definition: Input Handling: Keyboard
 //----------------------------------------------------------------------------------
 
-// Check if key has been pressed once
+// Check if a key has been pressed once
 bool IsKeyPressed(int key)
 {
     bool pressed = false;
@@ -3870,7 +3815,7 @@ bool IsKeyPressed(int key)
     return pressed;
 }
 
-// Check if key has been pressed again
+// Check if a key has been pressed again
 bool IsKeyPressedRepeat(int key)
 {
     bool repeat = false;
@@ -3883,7 +3828,7 @@ bool IsKeyPressedRepeat(int key)
     return repeat;
 }
 
-// Check if key is being pressed (key held down)
+// Check if a key is being pressed (key held down)
 bool IsKeyDown(int key)
 {
     bool down = false;
@@ -3896,7 +3841,7 @@ bool IsKeyDown(int key)
     return down;
 }
 
-// Check if key has been released once
+// Check if a key has been released once
 bool IsKeyReleased(int key)
 {
     bool released = false;
@@ -3909,7 +3854,7 @@ bool IsKeyReleased(int key)
     return released;
 }
 
-// Check if key is NOT being pressed (key not held down)
+// Check if a key is NOT being pressed (key not held down)
 bool IsKeyUp(int key)
 {
     bool up = false;
@@ -3980,12 +3925,12 @@ void SetExitKey(int key)
 // NOTE: Functions with a platform-specific implementation on rcore_<platform>.c
 //int SetGamepadMappings(const char *mappings)
 
-// Check if gamepad is available
+// Check if a gamepad is available
 bool IsGamepadAvailable(int gamepad)
 {
     bool result = false;
 
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad]) result = true;
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad]) result = true;
 
     return result;
 }
@@ -3993,19 +3938,15 @@ bool IsGamepadAvailable(int gamepad)
 // Get gamepad internal name id
 const char *GetGamepadName(int gamepad)
 {
-    const char *name = NULL;
-
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS)) name = CORE.Input.Gamepad.name[gamepad];
-
-    return name;
+    return CORE.Input.Gamepad.name[gamepad];
 }
 
-// Check if gamepad button has been pressed once
+// Check if a gamepad button has been pressed once
 bool IsGamepadButtonPressed(int gamepad, int button)
 {
     bool pressed = false;
 
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
     {
         if ((CORE.Input.Gamepad.previousButtonState[gamepad][button] == 0) && (CORE.Input.Gamepad.currentButtonState[gamepad][button] == 1)) pressed = true;
     }
@@ -4013,12 +3954,12 @@ bool IsGamepadButtonPressed(int gamepad, int button)
     return pressed;
 }
 
-// Check if gamepad button is being pressed
+// Check if a gamepad button is being pressed
 bool IsGamepadButtonDown(int gamepad, int button)
 {
     bool down = false;
 
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
     {
         if (CORE.Input.Gamepad.currentButtonState[gamepad][button] == 1) down = true;
     }
@@ -4026,12 +3967,12 @@ bool IsGamepadButtonDown(int gamepad, int button)
     return down;
 }
 
-// Check if gamepad button has NOT been pressed once
+// Check if a gamepad button has NOT been pressed once
 bool IsGamepadButtonReleased(int gamepad, int button)
 {
     bool released = false;
 
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
     {
         if ((CORE.Input.Gamepad.previousButtonState[gamepad][button] == 1) && (CORE.Input.Gamepad.currentButtonState[gamepad][button] == 0)) released = true;
     }
@@ -4039,12 +3980,12 @@ bool IsGamepadButtonReleased(int gamepad, int button)
     return released;
 }
 
-// Check if gamepad button is NOT being pressed
+// Check if a gamepad button is NOT being pressed
 bool IsGamepadButtonUp(int gamepad, int button)
 {
     bool up = false;
 
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (button < MAX_GAMEPAD_BUTTONS))
     {
         if (CORE.Input.Gamepad.currentButtonState[gamepad][button] == 0) up = true;
     }
@@ -4062,11 +4003,7 @@ int GetGamepadButtonPressed(void)
 // Get gamepad axis count
 int GetGamepadAxisCount(int gamepad)
 {
-    int result = 0;
-
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS)) result = CORE.Input.Gamepad.axisCount[gamepad];
-
-    return result;
+    return CORE.Input.Gamepad.axisCount[gamepad];
 }
 
 // Get axis movement vector for a gamepad
@@ -4074,7 +4011,7 @@ float GetGamepadAxisMovement(int gamepad, int axis)
 {
     float value = ((axis == GAMEPAD_AXIS_LEFT_TRIGGER) || (axis == GAMEPAD_AXIS_RIGHT_TRIGGER))? -1.0f : 0.0f;
 
-    if ((gamepad >= 0) && (gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (axis < MAX_GAMEPAD_AXES))
+    if ((gamepad < MAX_GAMEPADS) && CORE.Input.Gamepad.ready[gamepad] && (axis < MAX_GAMEPAD_AXES))
     {
         float movement = (value < 0.0f)? CORE.Input.Gamepad.axisState[gamepad][axis] : fabsf(CORE.Input.Gamepad.axisState[gamepad][axis]);
 
@@ -4092,7 +4029,7 @@ float GetGamepadAxisMovement(int gamepad, int axis)
 //void SetMousePosition(int x, int y)
 //void SetMouseCursor(int cursor)
 
-// Check if mouse button has been pressed once
+// Check if a mouse button has been pressed once
 bool IsMouseButtonPressed(int button)
 {
     bool pressed = false;
@@ -4108,7 +4045,7 @@ bool IsMouseButtonPressed(int button)
     return pressed;
 }
 
-// Check if mouse button is being pressed
+// Check if a mouse button is being pressed
 bool IsMouseButtonDown(int button)
 {
     bool down = false;
@@ -4124,7 +4061,7 @@ bool IsMouseButtonDown(int button)
     return down;
 }
 
-// Check if mouse button has been released once
+// Check if a mouse button has been released once
 bool IsMouseButtonReleased(int button)
 {
     bool released = false;
@@ -4140,7 +4077,7 @@ bool IsMouseButtonReleased(int button)
     return released;
 }
 
-// Check if mouse button is NOT being pressed
+// Check if a mouse button is NOT being pressed
 bool IsMouseButtonUp(int button)
 {
     bool up = false;
@@ -4258,7 +4195,7 @@ Vector2 GetTouchPosition(int index)
     return position;
 }
 
-// Get touch point identifier for provided index
+// Get touch point identifier for given index
 int GetTouchPointId(int index)
 {
     int id = -1;
@@ -4298,7 +4235,7 @@ void InitTimer(void)
 
     if (clock_gettime(CLOCK_MONOTONIC, &now) == 0) // Success
     {
-        CORE.Time.base = (unsigned long long)now.tv_sec*1000000000LLU + (unsigned long long)now.tv_nsec;
+        CORE.Time.base = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec;
     }
     else TRACELOG(LOG_WARNING, "TIMER: Hi-resolution timer not available");
 #endif
@@ -4346,9 +4283,9 @@ static void ScanDirectoryFiles(const char *basePath, FilePathList *files, const
             {
                 // Construct new path from our base path
             #if defined(_WIN32)
-                int pathLength = snprintf(path, MAX_FILEPATH_LENGTH, "%s\\%s", basePath, dp->d_name);
+                int pathLength = snprintf(path, MAX_FILEPATH_LENGTH - 1, "%s\\%s", basePath, dp->d_name);
             #else
-                int pathLength = snprintf(path, MAX_FILEPATH_LENGTH, "%s/%s", basePath, dp->d_name);
+                int pathLength = snprintf(path, MAX_FILEPATH_LENGTH - 1, "%s/%s", basePath, dp->d_name);
             #endif
 
                 if ((pathLength < 0) || (pathLength >= MAX_FILEPATH_LENGTH))
@@ -4360,7 +4297,7 @@ static void ScanDirectoryFiles(const char *basePath, FilePathList *files, const
                     if ((filter == NULL) || (strstr(filter, FILE_FILTER_TAG_ALL) != NULL) ||
                         (strstr(filter, FILE_FILTER_TAG_FILE_ONLY) != NULL) || IsFileExtension(path, filter))
                     {
-                        memcpy(files->paths[files->count], path, pathLength);
+                        strncpy(files->paths[files->count], path, MAX_FILEPATH_LENGTH - 1);
                         files->count++;
                     }
                 }
@@ -4368,7 +4305,7 @@ static void ScanDirectoryFiles(const char *basePath, FilePathList *files, const
                 {
                     if ((filter != NULL) && ((strstr(filter, FILE_FILTER_TAG_DIR_ONLY) != NULL) || (strstr(filter, FILE_FILTER_TAG_ALL) != NULL)))
                     {
-                        memcpy(files->paths[files->count], path, pathLength);
+                        strncpy(files->paths[files->count], path, MAX_FILEPATH_LENGTH - 1);
                         files->count++;
                     }
 
diff --git a/src/libraries/raylib/raylib/src/rgestures.h b/src/libraries/raylib/raylib/src/rgestures.h
index e279581..bb51d72 100644
--- a/src/libraries/raylib/raylib/src/rgestures.h
+++ b/src/libraries/raylib/raylib/src/rgestures.h
@@ -59,13 +59,10 @@
 // NOTE: Below types are required for standalone usage
 //----------------------------------------------------------------------------------
 // Boolean type
-#if !defined(__cplusplus)
 #if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
     #include <stdbool.h>
-#elif !defined(bool)
+#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
     typedef enum bool { false = 0, true = !false } bool;
-    #define RL_BOOL_TYPE
-#endif
 #endif
 
 #if !defined(RL_VECTOR2_TYPE)
@@ -127,7 +124,7 @@ void UpdateGestures(void);                              // Update gestures detec
 
 #if defined(RGESTURES_STANDALONE)
 void SetGesturesEnabled(unsigned int flags);            // Enable a set of gestures using flags
-bool IsGestureDetected(int gesture);                    // Check if gesture has been detected
+bool IsGestureDetected(int gesture);                    // Check if a gesture has been detected
 int GetGestureDetected(void);                           // Get latest detected gesture
 
 float GetGestureHoldDuration(void);                     // Get gesture hold time in seconds
@@ -157,8 +154,8 @@ float GetGesturePinchAngle(void);                       // Get gesture pinch ang
     extern "C" {        // Prevents name mangling of functions
     #endif
     // Functions required to query time on Windows
-    int __stdcall QueryPerformanceCounter(unsigned long long *lpPerformanceCount);
-    int __stdcall QueryPerformanceFrequency(unsigned long long *lpFrequency);
+    int __stdcall QueryPerformanceCounter(unsigned long long int *lpPerformanceCount);
+    int __stdcall QueryPerformanceFrequency(unsigned long long int *lpFrequency);
     #if defined(__cplusplus)
     }
     #endif
@@ -257,7 +254,7 @@ void SetGesturesEnabled(unsigned int flags)
     GESTURES.enabledFlags = flags;
 }
 
-// Check if gesture have been detected
+// Check if a gesture have been detected
 bool IsGestureDetected(unsigned int gesture)
 {
     if ((GESTURES.enabledFlags & GESTURES.current) == gesture) return true;
@@ -353,7 +350,7 @@ void ProcessGestureEvent(GestureEvent event)
             GESTURES.Drag.vector.y = GESTURES.Touch.moveDownPositionA.y - GESTURES.Touch.downDragPosition.y;
         }
     }
-    else if (GESTURES.Touch.pointCount == 2)
+    else if (GESTURES.Touch.pointCount == 2)    // Two touch points
     {
         if (event.touchAction == TOUCH_ACTION_DOWN)
         {
@@ -518,36 +515,37 @@ static double rgGetCurrentTime(void)
     time = GetTime();
 #else
 #if defined(_WIN32)
-    unsigned long long clockFrequency = 0;
-    unsigned long long currentClockTicks = 0;
+    unsigned long long int clockFrequency, currentTime;
 
     QueryPerformanceFrequency(&clockFrequency); // BE CAREFUL: Costly operation!
-    QueryPerformanceCounter(&currentClockTicks);
+    QueryPerformanceCounter(&currentTime);
 
-    time = (double)currentClockTicks/clockFrequency; // Time in seconds
+    time = (double)currentTime/clockFrequency;  // Time in seconds
 #endif
+
 #if defined(__linux__)
     // NOTE: Only for Linux-based systems
-    struct timespec now = { 0 };
+    struct timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
-    unsigned long long nanoSeconds = (unsigned long long)now.tv_sec*1000000000LLU + (unsigned long long)now.tv_nsec;
+    unsigned long long int nowTime = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec;     // Time in nanoseconds
 
-    time = ((double)nanoSeconds*1e-9); // Time in seconds
+    time = ((double)nowTime*1e-9);     // Time in seconds
 #endif
+
 #if defined(__APPLE__)
     //#define CLOCK_REALTIME  CALENDAR_CLOCK    // returns UTC time since 1970-01-01
     //#define CLOCK_MONOTONIC SYSTEM_CLOCK      // returns the time since boot time
 
-    clock_serv_t cclock = { 0 };
-    mach_timespec_t now = { 0 };
+    clock_serv_t cclock;
+    mach_timespec_t now;
     host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
 
     // NOTE: OS X does not have clock_gettime(), using clock_get_time()
     clock_get_time(cclock, &now);
     mach_port_deallocate(mach_task_self(), cclock);
-    unsigned long long nanoSeconds = (unsigned long long)now.tv_sec*1000000000LLU + (unsigned long long)now.tv_nsec;
+    unsigned long long int nowTime = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec;     // Time in nanoseconds
 
-    time = ((double)nanoSeconds*1e-9); // Time in seconds
+    time = ((double)nowTime*1e-9);     // Time in seconds
 #endif
 #endif
 
diff --git a/src/libraries/raylib/raylib/src/rglfw.c b/src/libraries/raylib/raylib/src/rglfw.c
index 5cdb48d..53399aa 100644
--- a/src/libraries/raylib/raylib/src/rglfw.c
+++ b/src/libraries/raylib/raylib/src/rglfw.c
@@ -77,15 +77,6 @@
 #include "external/glfw/src/window.c"
 #include "external/glfw/src/input.c"
 #include "external/glfw/src/vulkan.c"
-#include "external/glfw/src/egl_context.c"
-#include "external/glfw/src/osmesa_context.c"
-
-//We need to define this function because GLFW calls it even though raylib does
-//not use GLFW's Null platform
-GLFWbool _glfwConnectNull(int platformID, _GLFWplatform* platform)
-{
-    return GLFW_FALSE;
-}
 
 #if defined(_WIN32) || defined(__CYGWIN__)
     #include "external/glfw/src/win32_init.c"
@@ -96,6 +87,9 @@ GLFWbool _glfwConnectNull(int platformID, _GLFWplatform* platform)
     #include "external/glfw/src/win32_time.c"
     #include "external/glfw/src/win32_thread.c"
     #include "external/glfw/src/wgl_context.c"
+
+    #include "external/glfw/src/egl_context.c"
+    #include "external/glfw/src/osmesa_context.c"
 #endif
 
 #if defined(__linux__)
@@ -106,42 +100,19 @@ GLFWbool _glfwConnectNull(int platformID, _GLFWplatform* platform)
     #include "external/glfw/src/linux_joystick.c"
     #include "external/glfw/src/xkb_unicode.c"
 
-    #if defined(_GLFW_WAYLAND)
-        //These functions need to be temporarily renamed because including
-        //source files for both Wayland and X11 results in pairs of functions
-        //with the same name and thus a build error
-        #define  createKeyTables createKeyTablesWayland
-        #define  translateKey    translateKeyWayland
-        #define  acquireMonitor  acquireMonitorWayland
-        #define  releaseMonitor  releaseMonitorWayland
+    #include "external/glfw/src/egl_context.c"
+    #include "external/glfw/src/osmesa_context.c"
 
+    #if defined(_GLFW_WAYLAND)
         #include "external/glfw/src/wl_init.c"
         #include "external/glfw/src/wl_monitor.c"
         #include "external/glfw/src/wl_window.c"
-
-        #undef   createKeyTables
-        #undef   translateKey
-        #undef   acquireMonitor
-        #undef   releaseMonitor
     #endif
     #if defined(_GLFW_X11)
-        //These functions need to be temporarily renamed because including
-        //source files for both Wayland and X11 results in pairs of functions
-        //with the same name and thus a build error
-        #define  createKeyTables createKeyTablesX11
-        #define  translateKey    translateKeyX11
-        #define  acquireMonitor  acquireMonitorX11
-        #define  releaseMonitor  releaseMonitorX11
-
         #include "external/glfw/src/x11_init.c"
         #include "external/glfw/src/x11_monitor.c"
         #include "external/glfw/src/x11_window.c"
         #include "external/glfw/src/glx_context.c"
-
-        #undef   createKeyTables
-        #undef   translateKey
-        #undef   acquireMonitor
-        #undef   releaseMonitor
     #endif
 #endif
 
@@ -157,6 +128,9 @@ GLFWbool _glfwConnectNull(int platformID, _GLFWplatform* platform)
     #include "external/glfw/src/x11_monitor.c"
     #include "external/glfw/src/x11_window.c"
     #include "external/glfw/src/glx_context.c"
+
+    #include "external/glfw/src/egl_context.c"
+    #include "external/glfw/src/osmesa_context.c"
 #endif
 
 #if defined(__APPLE__)
@@ -166,6 +140,9 @@ GLFWbool _glfwConnectNull(int platformID, _GLFWplatform* platform)
     #include "external/glfw/src/cocoa_joystick.m"
     #include "external/glfw/src/cocoa_monitor.m"
     #include "external/glfw/src/cocoa_window.m"
-    #include "external/glfw/src/macos_time.c"
+    #include "external/glfw/src/cocoa_time.c"
     #include "external/glfw/src/nsgl_context.m"
+
+    #include "external/glfw/src/egl_context.c"
+    #include "external/glfw/src/osmesa_context.c"
 #endif
diff --git a/src/libraries/raylib/raylib/src/rlgl.h b/src/libraries/raylib/raylib/src/rlgl.h
index cf087de..5c6e95a 100644
--- a/src/libraries/raylib/raylib/src/rlgl.h
+++ b/src/libraries/raylib/raylib/src/rlgl.h
@@ -56,8 +56,8 @@
 *       #define RL_CULL_DISTANCE_NEAR              0.05    // Default projection matrix near cull distance
 *       #define RL_CULL_DISTANCE_FAR             4000.0    // Default projection matrix far cull distance
 *
-*       When loading a shader, the following vertex attributes and uniform location names are tried to be set automatically:
-*       WARNING: Pre-defined names can not be changed, they are used by default shaders and all raylib examples shaders, they are just listed here for reference
+*       When loading a shader, the following vertex attributes and uniform
+*       location names are tried to be set automatically:
 *
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
@@ -67,8 +67,6 @@
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES  "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS  "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
-*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
-*
 *       #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
 *       #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
 *       #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
@@ -76,7 +74,6 @@
 *       #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView)))
 *       #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
 *       #define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES "boneMatrices"     // bone matrices
-*
 *       #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
 *       #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
 *       #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
@@ -327,7 +324,6 @@
 #define RL_DRAW_FRAMEBUFFER                     0x8CA9      // GL_DRAW_FRAMEBUFFER
 
 // Default shader vertex attribute locations
-// NOTE: Locations can be redefined by user if required
 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
     #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION    0
 #endif
@@ -362,13 +358,11 @@
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
-#if !defined(__cplusplus)
 #if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
     #include <stdbool.h>
-#elif !defined(bool)
-    typedef enum bool { false = 0, true = !false } bool;
-    #define RL_BOOL_TYPE
-#endif
+#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
+    // Boolean type
+typedef enum bool { false = 0, true = !false } bool;
 #endif
 
 #if !defined(RL_MATRIX_TYPE)
@@ -847,11 +841,11 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
         #define SW_CALLOC(n,sz) RL_CALLOC(n, sz)
         #define SW_REALLOC(ptr, newSz) RL_REALLOC(ptr, newSz)
         #define SW_FREE(ptr) RL_FREE(ptr)
-        #include "external/rlsw.h"      // OpenGL 1.1 software implementation
+        #include "external/rlsw.h"          // OpenGL 1.1 software implementation
     #else
         #if defined(__APPLE__)
-            #include <OpenGL/gl.h>      // OpenGL 1.1 library for OSX
-            #include <OpenGL/glext.h>   // OpenGL extensions library
+            #include <OpenGL/gl.h>          // OpenGL 1.1 library for OSX
+            #include <OpenGL/glext.h>       // OpenGL extensions library
         #else
             // APIENTRY for OpenGL function pointer declarations is required
             #if !defined(APIENTRY)
@@ -866,7 +860,7 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
                 #define WINGDIAPI __declspec(dllimport)
             #endif
 
-            #include <GL/gl.h>          // OpenGL 1.1 library
+            #include <GL/gl.h>              // OpenGL 1.1 library
         #endif
     #endif
 #endif
@@ -900,17 +894,16 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
     // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi
     // provided headers (despite being defined in official Khronos GLES2 headers)
     // TODO: Avoid raylib platform-dependent code on rlgl, it should be a completely portable library
-    #if defined(PLATFORM_DRM)           // Use CONFIG_DRM?
+    #if defined(PLATFORM_DRM)
     typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
     typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
     typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor);
     #endif
 #endif
 
-#include <stdlib.h>             // Required for: calloc(), free()
-#include <string.h>             // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
-#include <math.h>               // Required for: sqrtf(), sinf(), cosf(), floor(), log()
-#include <limits.h>             // Required for: INT_MAX
+#include <stdlib.h>                     // Required for: calloc(), free()
+#include <string.h>                     // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
+#include <math.h>                       // Required for: sqrtf(), sinf(), cosf(), floor(), log()
 
 //----------------------------------------------------------------------------------
 // Defines and Macros
@@ -998,28 +991,65 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
 #endif
 
 // Default shader vertex attribute names to set location points
-// WARNING: Pre-defined names can not be changed, they are used by default shaders and all raylib examples shaders, they are just listed here for reference
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION          "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD          "vertexTexCoord"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL            "vertexNormal"      // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR             "vertexColor"       // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT           "vertexTangent"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2         "vertexTexCoord2"   // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES       "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS       "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES  "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS  "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
+#endif
 
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP              "mvp"               // model-view-projection matrix
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW             "matView"           // view matrix
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION       "matProjection"     // projection matrix
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL            "matModel"          // model matrix
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL           "matNormal"         // normal matrix (transpose(inverse(matModelView))
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR            "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES     "boneMatrices"      // bone matrices (required for GPU skinning)
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM
+    #define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
+#endif
 
-#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0       "texture0"          // texture0 (texture slot active 0)
-#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1       "texture1"          // texture1 (texture slot active 1)
-#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2       "texture2"          // texture2 (texture slot active 2)
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+#endif
+#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0
+    #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+#endif
+#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1
+    #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+#endif
+#ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2
+    #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+#endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES
+    #define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES "boneMatrices"     // bone matrices (required for GPU skinning)
+#endif
 
 //----------------------------------------------------------------------------------
 // Module Types and Structures Definition
@@ -1205,11 +1235,7 @@ void rlMatrixMode(int mode)
 // Push the current matrix into RLGL.State.stack
 void rlPushMatrix(void)
 {
-    if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE)
-    {
-        TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)");
-        return;
-    }
+    if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)");
 
     if (RLGL.State.currentMatrixMode == RL_MODELVIEW)
     {
@@ -2377,7 +2403,7 @@ void rlglClose(void)
 // NOTE: External loader function must be provided
 void rlLoadExtensions(void *loader)
 {
-#if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21
+#if defined(GRAPHICS_API_OPENGL_33)     // Also defined for GRAPHICS_API_OPENGL_21
     // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions)
     if (gladLoadGL((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions");
     else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully");
@@ -2470,7 +2496,7 @@ void rlLoadExtensions(void *loader)
     // NOTE: String duplication rquired because glGetString() returns a const string
     int extensionsLength = (int)strlen(extensions); // Get extensions string size in bytes
     char *extensionsDup = (char *)RL_CALLOC(extensionsLength + 1, sizeof(char)); // Allocate space for copy with additional EOL byte
-    snprintf(extensionsDup, extensionsLength, "%s", extensions);
+    strncpy(extensionsDup, extensions, extensionsLength);
     extList[numExt] = extensionsDup;
 
     for (int i = 0; i < extensionsLength; i++)
@@ -2508,7 +2534,7 @@ void rlLoadExtensions(void *loader)
         }
 
         // Check instanced rendering support
-        if (strstr(extList[i], (const char *)"instanced_arrays") != NULL) // Broad check for instanced_arrays
+        if (strstr(extList[i], (const char *)"instanced_arrays") != NULL)   // Broad check for instanced_arrays
         {
             // Specific check
             if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0)      // ANGLE
@@ -2990,7 +3016,7 @@ void rlDrawRenderBatch(rlRenderBatch *batch)
 
         // NOTE: glMapBuffer() causes sync issue
         // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job
-        // To avoid waiting (idle), glBufferData() can be called first with NULL pointer before glMapBuffer()
+        // To avoid waiting (idle), glBufferData() can bee called first with NULL pointer before glMapBuffer()
         // Doing that, the previous data in PBO will be discarded and glMapBuffer() returns a new
         // allocated pointer immediately even if GPU is still working with the previous data
 
@@ -3340,15 +3366,8 @@ unsigned int rlLoadTexture(const void *data, int width, int height, int format,
     // Texture parameters configuration
     // NOTE: glTexParameteri does NOT affect texture uploading
 #if defined(GRAPHICS_API_OPENGL_ES2)
-
-    // Check if texture is power-of-two (POT)
-    bool texIsPOT = false;
-
-    if (((width > 0) && ((width & (width - 1)) == 0)) &&
-        ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true;
-
     // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used
-    if ((texIsPOT) || (RLGL.ExtSupported.texNPOT))
+    if (RLGL.ExtSupported.texNPOT)
     {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);       // Set texture to repeat on x-axis
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);       // Set texture to repeat on y-axis
@@ -3619,7 +3638,7 @@ void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned
         case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_ARB; break;
         case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_ARB; break;
         case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_ARB; break;
-        #else // GRAPHICS_API_OPENGL_ES2
+        #else // defined(GRAPHICS_API_OPENGL_ES2)
         case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_OES; break;   // NOTE: Requires extension OES_texture_half_float
         case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_OES; break;         // NOTE: Requires extension OES_texture_half_float
         case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_OES; break;    // NOTE: Requires extension OES_texture_half_float
@@ -3749,17 +3768,9 @@ void *rlReadTexturePixels(unsigned int id, int width, int height, int format)
     // Attach our texture to FBO
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0);
 
-#if defined(FBO_READ_TEXTURE_AS_RGBA)
     // Reading data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
     pixels = RL_CALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8), 1);
     glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
-#else
-    // Reading data as original texture format, in some platforms (RPI, Wasm) it works
-    pixels = (unsigned char *)RL_MALLOC(rlGetPixelDataSize(width, height, format));
-    unsigned int glInternalFormat = 0, glFormat = 0, glType = 0;
-    rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
-    glReadPixels(0, 0, width, height, glFormat, glType, pixels);
-#endif
 
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 
@@ -3793,10 +3804,6 @@ unsigned char *rlReadScreenPixels(int width, int height)
 {
     unsigned char *imgData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char));
 
-    // NOTE: Buffer retrieved is GL_FRONT in single-buffered configurations
-    // and GL_BACK in double-buffered configurations, make sure to call it at the end of frame
-    //glReadBuffer(GL_BACK);
-
     // NOTE: glReadPixels() returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
     // WARNING: Getting alpha channel! Be careful, it can be transparent if not cleared properly!
     glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
@@ -5241,9 +5248,7 @@ static int rlGetPixelDataSize(int width, int height, int format)
         {
             int blockWidth = (width + 3)/4;
             int blockHeight = (height + 3)/4;
-            unsigned long long dataSizeBytes = (unsigned long long)blockWidth*blockHeight*8;
-            if (dataSizeBytes < INT_MAX) dataSize = (int)dataSizeBytes;
-
+            dataSize = blockWidth*blockHeight*8;
         } break;
         case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA:
         case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA:
@@ -5252,17 +5257,13 @@ static int rlGetPixelDataSize(int width, int height, int format)
         {
             int blockWidth = (width + 3)/4;
             int blockHeight = (height + 3)/4;
-            unsigned long long dataSizeBytes = (unsigned long long)blockWidth*blockHeight*16;
-            if (dataSizeBytes < INT_MAX) dataSize = (int)dataSizeBytes;
-
+            dataSize = blockWidth*blockHeight*16;
         } break;
         case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: // 4 bytes per each 4x4 block
         {
             int blockWidth = (width + 3)/4;
             int blockHeight = (height + 3)/4;
-            unsigned long long dataSizeBytes = (unsigned long long)blockWidth*blockHeight*4;
-            if (dataSizeBytes < INT_MAX) dataSize = (int)dataSizeBytes;
-
+            dataSize = blockWidth*blockHeight*4;
         } break;
         default: break;
     }
@@ -5271,12 +5272,10 @@ static int rlGetPixelDataSize(int width, int height, int format)
     if ((format >= RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) &&
         (format <= RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16))
     {
-        unsigned long long dataSizeBytes = ((unsigned long long)width*height*bpp) >> 3;  // Get size in bytes (dividing by 8)
-        if (dataSizeBytes < INT_MAX) dataSize = (int)dataSizeBytes;
+        double bytesPerPixel = (double)bpp/8.0;
+        dataSize = (int)(bytesPerPixel*width*height); // Total data size in bytes
     }
 
-    if (dataSize == 0) TRACELOG(LOG_WARNING, "Requested image size is larger than 2GB, it can not be allocated");
-
     return dataSize;
 }
 
diff --git a/src/libraries/raylib/raylib/src/rmodels.c b/src/libraries/raylib/raylib/src/rmodels.c
index 4dbfb4b..6d3169e 100644
--- a/src/libraries/raylib/raylib/src/rmodels.c
+++ b/src/libraries/raylib/raylib/src/rmodels.c
@@ -50,9 +50,9 @@
 #include "rlgl.h"           // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2
 #include "raymath.h"        // Required for: Vector3, Quaternion and Matrix functionality
 
-#include <stdio.h>          // Required for: sprintf(), snprintf()
+#include <stdio.h>          // Required for: sprintf()
 #include <stdlib.h>         // Required for: malloc(), calloc(), free()
-#include <string.h>         // Required for: strlen(), memcmp()
+#include <string.h>         // Required for: memcmp(), strlen(), strncpy()
 #include <math.h>           // Required for: sinf(), cosf(), sqrtf(), fabsf()
 
 #if SUPPORT_FILEFORMAT_OBJ || SUPPORT_FILEFORMAT_MTL
@@ -85,7 +85,7 @@
     #define VOX_FREE RL_FREE
 
     #define VOX_LOADER_IMPLEMENTATION
-    #include "external/vox_loader.h"    // VOX file format loading (MagicaVoxel)
+    #include "external/vox_loader.h"    // VOX file format loading (MagikaVoxel)
 #endif
 
 #if SUPPORT_FILEFORMAT_M3D
@@ -435,7 +435,7 @@ void DrawSphere(Vector3 centerPos, float radius, Color color)
     DrawSphereEx(centerPos, radius, 16, 16, color);
 }
 
-// Draw sphere with defined rings and slices
+// Draw sphere with extended parameters
 void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color)
 {
 #if 0
@@ -488,7 +488,7 @@ void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color
         rlBegin(RL_TRIANGLES);
             rlColor4ub(color.r, color.g, color.b, color.a);
 
-            float ringangle = DEG2RAD*(180.0f/rings); // Angle between latitudinal parallels
+            float ringangle = DEG2RAD*(180.0f/(rings + 1)); // Angle between latitudinal parallels
             float sliceangle = DEG2RAD*(360.0f/slices); // Angle between longitudinal meridians
 
             float cosring = cosf(ringangle);
@@ -500,7 +500,7 @@ void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color
             vertices[2] = (Vector3){ 0, 1, 0 };
             vertices[3] = (Vector3){ sinring, cosring, 0 };
 
-            for (int i = 0; i < rings; i++)
+            for (int i = 0; i < rings + 1; i++)
             {
                 for (int j = 0; j < slices; j++)
                 {
@@ -542,42 +542,31 @@ void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Col
         rlBegin(RL_LINES);
             rlColor4ub(color.r, color.g, color.b, color.a);
 
-            float ringangle = DEG2RAD*(180.0f/rings); // Angle between latitudinal parallels
-            float sliceangle = DEG2RAD*(360.0f/slices); // Angle between longitudinal meridians
-
-            float cosring = cosf(ringangle);
-            float sinring = sinf(ringangle);
-            float cosslice = cosf(sliceangle);
-            float sinslice = sinf(sliceangle);
-
-            Vector3 vertices[4] = { 0 }; // Required to store face vertices
-            vertices[2] = (Vector3){ 0, 1, 0 };
-            vertices[3] = (Vector3){ sinring, cosring, 0 };
-
-            for (int i = 0; i < rings; i++)
+            for (int i = 0; i < (rings + 2); i++)
             {
                 for (int j = 0; j < slices; j++)
                 {
-                    vertices[0] = vertices[2]; // Rotate around y axis to set up vertices for next face
-                    vertices[1] = vertices[3];
-                    vertices[2] = (Vector3){ cosslice*vertices[2].x - sinslice*vertices[2].z, vertices[2].y, sinslice*vertices[2].x + cosslice*vertices[2].z }; // Rotation matrix around y axis
-                    vertices[3] = (Vector3){ cosslice*vertices[3].x - sinslice*vertices[3].z, vertices[3].y, sinslice*vertices[3].x + cosslice*vertices[3].z };
+                    rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)),
+                               sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)),
+                               cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices)));
+                    rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),
+                               sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),
+                               cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));
 
-                    // Longitude Lines
-                    rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z);
-                    rlVertex3f(vertices[1].x, vertices[1].y, vertices[1].z);
+                    rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*(j + 1)/slices)),
+                               sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),
+                               cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*(j + 1)/slices)));
+                    rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)),
+                               sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),
+                               cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices)));
 
-                    // Latitude Lines
-                    rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z);
-                    rlVertex3f(vertices[2].x, vertices[2].y, vertices[2].z);
-
-                    // Diagonal Lines
-                    rlVertex3f(vertices[0].x, vertices[0].y, vertices[0].z);
-                    rlVertex3f(vertices[3].x, vertices[3].y, vertices[3].z);
+                    rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*sinf(DEG2RAD*(360.0f*j/slices)),
+                               sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1))),
+                               cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*(i + 1)))*cosf(DEG2RAD*(360.0f*j/slices)));
+                    rlVertex3f(cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*sinf(DEG2RAD*(360.0f*j/slices)),
+                               sinf(DEG2RAD*(270 + (180.0f/(rings + 1))*i)),
+                               cosf(DEG2RAD*(270 + (180.0f/(rings + 1))*i))*cosf(DEG2RAD*(360.0f*j/slices)));
                 }
-
-                vertices[2] = vertices[3]; // Rotate around z axis to set up  starting vertices for next ring
-                vertices[3] = (Vector3){ cosring*vertices[3].x + sinring*vertices[3].y, -sinring*vertices[3].x + cosring*vertices[3].y, vertices[3].z }; // Rotation matrix around z axis
             }
         rlEnd();
     rlPopMatrix();
@@ -735,9 +724,9 @@ void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, fl
 
 // Draw a wired cylinder with base at startPos and top at endPos
 // NOTE: It could be also used for pyramid and cone
-void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int slices, Color color)
+void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)
 {
-    if (slices < 3) slices = 3;
+    if (sides < 3) sides = 3;
 
     Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z };
     if ((direction.x == 0) && (direction.y == 0) && (direction.z == 0)) return; // Security check
@@ -746,12 +735,12 @@ void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, fl
     Vector3 b1 = Vector3Normalize(Vector3Perpendicular(direction));
     Vector3 b2 = Vector3Normalize(Vector3CrossProduct(b1, direction));
 
-    float baseAngle = (2.0f*PI)/slices;
+    float baseAngle = (2.0f*PI)/sides;
 
     rlBegin(RL_LINES);
         rlColor4ub(color.r, color.g, color.b, color.a);
 
-        for (int i = 0; i < slices; i++)
+        for (int i = 0; i < sides; i++)
         {
             // Compute the four vertices
             float s1 = sinf(baseAngle*(i + 0))*startRadius;
@@ -780,10 +769,10 @@ void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, fl
 }
 
 // Draw a capsule with the center of its sphere caps at startPos and endPos
-void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color)
+void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color)
 {
     if (slices < 3) slices = 3;
-    if (rings  < 1) rings  = 1;
+
     Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z };
 
     // draw a sphere if start and end points are the same
@@ -919,10 +908,10 @@ void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int rings, int
 }
 
 // Draw capsule wires with the center of its sphere caps at startPos and endPos
-void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color)
+void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color)
 {
     if (slices < 3) slices = 3;
-    if (rings  < 1) rings = 1;
+
     Vector3 direction = { endPos.x - startPos.x, endPos.y - startPos.y, endPos.z - startPos.z };
 
     // draw a sphere if start and end points are the same
@@ -1178,7 +1167,7 @@ Model LoadModelFromMesh(Mesh mesh)
     return model;
 }
 
-// Check if model is valid (loaded in GPU, VAO/VBOs)
+// Check if a model is valid (loaded in GPU, VAO/VBOs)
 bool IsModelValid(Model model)
 {
     bool result = false;
@@ -1193,17 +1182,16 @@ bool IsModelValid(Model model)
     // but some VBOs could not be used, it depends on Mesh vertex data
     for (int i = 0; i < model.meshCount; i++)
     {
-        if ((model.meshes[i].vertices != NULL) && (model.meshes[i].vboId[0] == 0)) { result = false; break; }   // Vertex position buffer not uploaded to GPU
+        if ((model.meshes[i].vertices != NULL) && (model.meshes[i].vboId[0] == 0)) { result = false; break; }  // Vertex position buffer not uploaded to GPU
         if ((model.meshes[i].texcoords != NULL) && (model.meshes[i].vboId[1] == 0)) { result = false; break; }  // Vertex textcoords buffer not uploaded to GPU
-        if ((model.meshes[i].normals != NULL) && (model.meshes[i].vboId[2] == 0)) { result = false; break; }    // Vertex normals buffer not uploaded to GPU
-        if ((model.meshes[i].colors != NULL) && (model.meshes[i].vboId[3] == 0)) { result = false; break; }     // Vertex colors buffer not uploaded to GPU
-        if ((model.meshes[i].tangents != NULL) && (model.meshes[i].vboId[4] == 0)) { result = false; break; }   // Vertex tangents buffer not uploaded to GPU
-        if ((model.meshes[i].texcoords2 != NULL) && (model.meshes[i].vboId[5] == 0)) { result = false; break; } // Vertex texcoords2 buffer not uploaded to GPU
-        if ((model.meshes[i].indices != NULL) && (model.meshes[i].vboId[6] == 0)) { result = false; break; }    // Vertex indices buffer not uploaded to GPU
-#if SUPPORT_GPU_SKINNING
-        if ((model.meshes[i].boneIndices != NULL) && (model.meshes[i].vboId[7] == 0)) { result = false; break; } // Vertex boneIndices buffer not uploaded to GPU
-        if ((model.meshes[i].boneWeights != NULL) && (model.meshes[i].vboId[8] == 0)) { result = false; break; } // Vertex boneWeights buffer not uploaded to GPU
-#endif
+        if ((model.meshes[i].normals != NULL) && (model.meshes[i].vboId[2] == 0)) { result = false; break; }  // Vertex normals buffer not uploaded to GPU
+        if ((model.meshes[i].colors != NULL) && (model.meshes[i].vboId[3] == 0)) { result = false; break; }  // Vertex colors buffer not uploaded to GPU
+        if ((model.meshes[i].tangents != NULL) && (model.meshes[i].vboId[4] == 0)) { result = false; break; }  // Vertex tangents buffer not uploaded to GPU
+        if ((model.meshes[i].texcoords2 != NULL) && (model.meshes[i].vboId[5] == 0)) { result = false; break; }  // Vertex texcoords2 buffer not uploaded to GPU
+        if ((model.meshes[i].indices != NULL) && (model.meshes[i].vboId[6] == 0)) { result = false; break; }  // Vertex indices buffer not uploaded to GPU
+        if ((model.meshes[i].boneIndices != NULL) && (model.meshes[i].vboId[7] == 0)) { result = false; break; }  // Vertex boneIndices buffer not uploaded to GPU
+        if ((model.meshes[i].boneWeights != NULL) && (model.meshes[i].vboId[8] == 0)) { result = false; break; }  // Vertex boneWeights buffer not uploaded to GPU
+
         // NOTE: Some OpenGL versions do not support VAO, so avoid below check
         //if (model.meshes[i].vaoId == 0) { result = false; break }
     }
@@ -1233,8 +1221,6 @@ void UnloadModel(Model model)
     // Unload animation data
     RL_FREE(model.skeleton.bones);
     RL_FREE(model.skeleton.bindPose);
-    RL_FREE(model.currentPose);
-    RL_FREE(model.boneMatrices);
 
     TRACELOG(LOG_INFO, "MODEL: Unloaded model (and meshes) from RAM and VRAM");
 }
@@ -2084,7 +2070,7 @@ bool ExportMeshAsCode(Mesh mesh, const char *fileName)
 
     // Get file name from path and convert variable name to uppercase
     char varFileName[256] = { 0 };
-    snprintf(varFileName, 256, "%s", GetFileNameWithoutExt(fileName)); // NOTE: Using function provided by [rcore] module
+    strncpy(varFileName, GetFileNameWithoutExt(fileName), 256 - 1); // NOTE: Using function provided by [rcore] module
     for (int i = 0; varFileName[i] != '\0'; i++) if ((varFileName[i] >= 'a') && (varFileName[i] <= 'z')) { varFileName[i] = varFileName[i] - 32; }
 
     // Add image information
@@ -2241,7 +2227,7 @@ Material LoadMaterialDefault(void)
     return material;
 }
 
-// Check if material is valid (map textures loaded in GPU)
+// Check if a material is valid (map textures loaded in GPU)
 bool IsMaterialValid(Material material)
 {
     bool result = false;
@@ -2331,7 +2317,7 @@ void UpdateModelAnimation(Model model, ModelAnimation anim, float frame)
         Matrix currentPoseMatrix = { 0 };
 
         // Update all bones and bone matrices of model
-        for (unsigned int boneIndex = 0; boneIndex < model.skeleton.boneCount; boneIndex++)
+        for (int boneIndex = 0; boneIndex < model.skeleton.boneCount; boneIndex++)
         {
             // Compute interpolated pose between current and next frame
             // NOTE: Storing animation frame data in model.currentPose
@@ -2401,7 +2387,7 @@ void UpdateModelAnimationEx(Model model, ModelAnimation animA, float frameA, Mod
         Matrix bindPoseMatrix = { 0 };
         Matrix currentPoseMatrix = { 0 };
 
-        for (unsigned int boneIndex = 0; boneIndex < model.skeleton.boneCount; boneIndex++)
+        for (int boneIndex = 0; boneIndex < model.skeleton.boneCount; boneIndex++)
         {
             // Get frame-interpolation for first animation
             Vector3 frameATranslation = Vector3Lerp(
@@ -3153,8 +3139,6 @@ Mesh GenMeshCone(float radius, float height, int slices)
 }
 
 // Generate torus mesh
-// NOTE: The distance between the center of the hole and the center of the
-// tube is half size of the radius of the tube (radius*size/2)
 Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
 {
     Mesh mesh = { 0 };
@@ -3931,7 +3915,7 @@ void DrawModel(Model model, Vector3 position, float scale, Color tint)
     DrawModelEx(model, position, rotationAxis, 0.0f, vScale, tint);
 }
 
-// Draw a model with custom transform
+// Draw a model with extended parameters
 void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)
 {
     // Calculate transformation matrix from function parameters
@@ -3951,7 +3935,7 @@ void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rota
         Color colDiffuse = mat.maps[MATERIAL_MAP_DIFFUSE].color;
 
         // Applying color tint directly to material diffuse map,
-        // because it comes as an input parameter to the function
+        // because is comes as an input paramter to the function
         Color colTinted = { 0 };
         colTinted.r = (unsigned char)(((int)colDiffuse.r*(int)tint.r)/255);
         colTinted.g = (unsigned char)(((int)colDiffuse.g*(int)tint.g)/255);
@@ -3985,7 +3969,7 @@ void DrawModelWires(Model model, Vector3 position, float scale, Color tint)
     rlDisableWireMode();
 }
 
-// Draw a model wires with custom transform
+// Draw a model wires (with texture if set) with extended parameters
 void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)
 {
     rlEnableWireMode();
@@ -3998,22 +3982,22 @@ void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float
 // Draw a billboard
 void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint)
 {
-    Rectangle rec = { 0.0f, 0.0f, (float)texture.width, (float)texture.height };
+    Rectangle source = { 0.0f, 0.0f, (float)texture.width, (float)texture.height };
 
-    DrawBillboardRec(camera, texture, rec, position, (Vector2){ scale*fabsf((float)rec.width/rec.height), scale }, tint);
+    DrawBillboardRec(camera, texture, source, position, (Vector2){ scale*fabsf((float)source.width/source.height), scale }, tint);
 }
 
 // Draw a billboard (part of a texture defined by a rectangle)
-void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector2 size, Color tint)
+void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint)
 {
     // NOTE: Billboard locked on axis-Y
     Vector3 up = { 0.0f, 1.0f, 0.0f };
 
-    DrawBillboardPro(camera, texture, rec, position, up, size, Vector2Scale(size, 0.5), 0.0f, tint);
+    DrawBillboardPro(camera, texture, source, position, up, size, Vector2Scale(size, 0.5), 0.0f, tint);
 }
 
-// Draw a billboard texture defined by source rectangle with scaling and rotation
-void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint)
+// Draw a billboard with additional parameters
+void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint)
 {
     // Compute the up vector and the right vector
     Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
@@ -4024,20 +4008,20 @@ void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 p
     // Flip the content of the billboard while maintaining the counterclockwise edge rendering order
     if (size.x < 0.0f)
     {
-        rec.x -= size.x;
-        rec.width *= -1.0;
+        source.x -= size.x;
+        source.width *= -1.0;
         right = Vector3Negate(right);
         origin.x *= -1.0f;
     }
     if (size.y < 0.0f)
     {
-        rec.y -= size.y;
-        rec.height *= -1.0;
+        source.y -= size.y;
+        source.height *= -1.0;
         up = Vector3Negate(up);
         origin.y *= -1.0f;
     }
 
-    // Draw the texture region described by rec on the following rectangle in 3D space:
+    // Draw the texture region described by source on the following rectangle in 3D space:
     //
     //                size.x          <--.
     //  3 ^---------------------------+ 2 \ rotation
@@ -4069,10 +4053,10 @@ void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 p
     }
 
     Vector2 texcoords[4];
-    texcoords[0] = (Vector2){ (float)rec.x/texture.width, (float)(rec.y + rec.height)/texture.height };
-    texcoords[1] = (Vector2){ (float)(rec.x + rec.width)/texture.width, (float)(rec.y + rec.height)/texture.height };
-    texcoords[2] = (Vector2){ (float)(rec.x + rec.width)/texture.width, (float)rec.y/texture.height };
-    texcoords[3] = (Vector2){ (float)rec.x/texture.width, (float)rec.y/texture.height };
+    texcoords[0] = (Vector2){ (float)source.x/texture.width, (float)(source.y + source.height)/texture.height };
+    texcoords[1] = (Vector2){ (float)(source.x + source.width)/texture.width, (float)(source.y + source.height)/texture.height };
+    texcoords[2] = (Vector2){ (float)(source.x + source.width)/texture.width, (float)source.y/texture.height };
+    texcoords[3] = (Vector2){ (float)source.x/texture.width, (float)source.y/texture.height };
 
     rlSetTexture(texture.id);
     rlBegin(RL_QUADS);
@@ -4432,7 +4416,7 @@ static Model LoadOBJ(const char *fileName)
     }
 
     char currentDir[MAX_FILEPATH_LENGTH] = { 0 };
-    snprintf(currentDir, MAX_FILEPATH_LENGTH, "%s", GetWorkingDirectory()); // Save current working directory
+    strncpy(currentDir, GetWorkingDirectory(), MAX_FILEPATH_LENGTH - 1); // Save current working directory
     const char *workingDir = GetDirectoryPath(fileName); // Switch to OBJ directory for material path correctness
     if (CHDIR(workingDir) != 0) TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to change working directory", workingDir);
 
@@ -5024,7 +5008,7 @@ static Model LoadIQM(const char *fileName)
     // Initialize runtime animation data: current pose and bone matrices
     model.currentPose = (Transform *)RL_CALLOC(model.skeleton.boneCount, sizeof(Transform));
     model.boneMatrices = (Matrix *)RL_CALLOC(model.skeleton.boneCount, sizeof(Matrix));
-    for (unsigned int j = 0; j < model.skeleton.boneCount; j++) model.boneMatrices[j] = MatrixIdentity();
+    for (int j = 0; j < model.skeleton.boneCount; j++) model.boneMatrices[j] = MatrixIdentity();
 
     UnloadFileData(fileData);
 
@@ -5252,7 +5236,7 @@ static ModelAnimation *LoadModelAnimationsIQM(const char *fileName, int *animCou
         // Build frameposes
         for (unsigned int frame = 0; frame < anim[a].num_frames; frame++)
         {
-            for (unsigned int i = 0; i < animations[a].boneCount; i++)
+            for (int i = 0; i < animations[a].boneCount; i++)
             {
                 if (bones[i].parent >= 0)
                 {
@@ -5327,8 +5311,8 @@ static Image LoadImageFromCgltfImage(cgltf_image *cgltfImage, const char *texPat
             {
                 int base64Size = (int)strlen(cgltfImage->uri + i + 1);
                 while (cgltfImage->uri[i + base64Size] == '=') base64Size--;    // Ignore optional paddings
-                int numberOfEncodedBits = base64Size*6 - (base64Size*6)%8;      // Encoded bits minus extra bits, so it becomes a multiple of 8 bits
-                int outSize = numberOfEncodedBits >> 3;                         // Actual encoded bytes
+                int numberOfEncodedBits = base64Size*6 - (base64Size*6) % 8 ;   // Encoded bits minus extra bits, so it becomes a multiple of 8 bits
+                int outSize = numberOfEncodedBits/8 ;                           // Actual encoded bytes
                 void *data = NULL;
 
                 cgltf_options options = { 0 };
@@ -5348,7 +5332,7 @@ static Image LoadImageFromCgltfImage(cgltf_image *cgltfImage, const char *texPat
             image = LoadImage(TextFormat("%s/%s", texPath, cgltfImage->uri));
         }
     }
-    else if ((cgltfImage->buffer_view != NULL) && (cgltfImage->buffer_view->buffer->data != NULL)) // Check if image is provided as data buffer
+    else if ((cgltfImage->buffer_view != NULL) && (cgltfImage->buffer_view->buffer->data != NULL))    // Check if image is provided as data buffer
     {
         unsigned char *data = (unsigned char *)RL_MALLOC(cgltfImage->buffer_view->size);
         int offset = (int)cgltfImage->buffer_view->offset;
@@ -5380,28 +5364,26 @@ static Image LoadImageFromCgltfImage(cgltf_image *cgltfImage, const char *texPat
 }
 
 // Load bone info from GLTF skin data
-static BoneInfo *LoadBoneInfoGLTF(cgltf_skin skin, unsigned int *boneCount)
+static BoneInfo *LoadBoneInfoGLTF(cgltf_skin skin, int *boneCount)
 {
-    *boneCount = (unsigned int)skin.joints_count;
+    *boneCount = (int)skin.joints_count;
     BoneInfo *bones = (BoneInfo *)RL_CALLOC(skin.joints_count, sizeof(BoneInfo));
 
     for (unsigned int i = 0; i < skin.joints_count; i++)
     {
         cgltf_node node = *skin.joints[i];
-        if (node.name != NULL) snprintf(bones[i].name, sizeof(bones[i].name), "%s", node.name);
+        if (node.name != NULL) strncpy(bones[i].name, node.name, sizeof(bones[i].name) - 1);
 
-        // Find parent bone index by walking up the node tree past any
-        // non-joint ancestors (intermediate transform nodes used by some
-        // DCC exporters), until we hit a node that is also in skin.joints.
+        // Find parent bone index
         int parentIndex = -1;
-        cgltf_node *ancestor = node.parent;
-        while (ancestor != NULL && parentIndex == -1)
+
+        for (unsigned int j = 0; j < skin.joints_count; j++)
         {
-            for (unsigned int j = 0; j < skin.joints_count; j++)
+            if (skin.joints[j] == node.parent)
             {
-                if (skin.joints[j] == ancestor) { parentIndex = (int)j; break; }
+                parentIndex = (int)j;
+                break;
             }
-            if (parentIndex == -1) ancestor = ancestor->parent;
         }
 
         bones[i].parent = parentIndex;
@@ -5776,7 +5758,7 @@ static Model LoadGLTF(const char *fileName)
                             else TRACELOG(LOG_WARNING, "MODEL: [%s] Vertices attribute data format not supported, use vec3 float", fileName);
                         }
                     }
-                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_normal) // NORMAL, vec3, float
+                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_normal)   // NORMAL, vec3, float
                     {
                         cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data;
 
@@ -5876,7 +5858,7 @@ static Model LoadGLTF(const char *fileName)
                             else TRACELOG(LOG_WARNING, "MODEL: [%s] Normals attribute data format not supported, use vec3 float", fileName);
                         }
                     }
-                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_tangent) // TANGENT, vec4, float, w is tangent basis sign
+                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_tangent)   // TANGENT, vec4, float, w is tangent basis sign
                     {
                         cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data;
 
@@ -5913,7 +5895,7 @@ static Model LoadGLTF(const char *fileName)
 
                         if (attribute->type == cgltf_type_vec2)
                         {
-                            if (attribute->component_type == cgltf_component_type_r_32f) // vec2, float
+                            if (attribute->component_type == cgltf_component_type_r_32f)  // vec2, float
                             {
                                 // Init raylib mesh texcoords to copy glTF attribute data
                                 texcoordPtr = (float *)RL_MALLOC(attribute->count*2*sizeof(float));
@@ -5962,7 +5944,7 @@ static Model LoadGLTF(const char *fileName)
                             if (texcoordPtr != NULL) RL_FREE(texcoordPtr);
                         }
                     }
-                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_color) // COLOR_n, vec3/vec4, float/u8n/u16n
+                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_color)    // COLOR_n, vec3/vec4, float/u8n/u16n
                     {
                         cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data;
 
@@ -5971,7 +5953,7 @@ static Model LoadGLTF(const char *fileName)
                         if (model.meshes[meshIndex].colors != NULL) TRACELOG(LOG_WARNING, "MODEL: [%s] Colors attribute data already loaded", fileName);
                         else
                         {
-                            if (attribute->type == cgltf_type_vec3) // RGB
+                            if (attribute->type == cgltf_type_vec3)  // RGB
                             {
                                 if (attribute->component_type == cgltf_component_type_r_8u)
                                 {
@@ -6155,38 +6137,19 @@ static Model LoadGLTF(const char *fileName)
             model.skeleton.bones = LoadBoneInfoGLTF(skin, &model.skeleton.boneCount);
             model.skeleton.bindPose = (Transform *)RL_CALLOC(model.skeleton.boneCount, sizeof(Transform));
 
-            for (unsigned int i = 0; i < model.skeleton.boneCount; i++)
+            for (int i = 0; i < model.skeleton.boneCount; i++)
             {
-                Matrix bindMatrix = { 0 };
-                cgltf_float inverseBindTransform[16] = { 0 };
+                cgltf_node *node = skin.joints[i];
+                cgltf_float worldTransform[16];
+                cgltf_node_transform_world(node, worldTransform);
+                Matrix worldMatrix = {
+                    worldTransform[0], worldTransform[4], worldTransform[8], worldTransform[12],
+                    worldTransform[1], worldTransform[5], worldTransform[9], worldTransform[13],
+                    worldTransform[2], worldTransform[6], worldTransform[10], worldTransform[14],
+                    worldTransform[3], worldTransform[7], worldTransform[11], worldTransform[15]
+                };
 
-                if ((skin.inverse_bind_matrices != NULL) &&
-                    (skin.inverse_bind_matrices->count >= skin.joints_count) &&
-                    cgltf_accessor_read_float(skin.inverse_bind_matrices, i, inverseBindTransform, 16))
-                {
-                    Matrix inverseBindMatrix = {
-                        inverseBindTransform[0], inverseBindTransform[4], inverseBindTransform[8], inverseBindTransform[12],
-                        inverseBindTransform[1], inverseBindTransform[5], inverseBindTransform[9], inverseBindTransform[13],
-                        inverseBindTransform[2], inverseBindTransform[6], inverseBindTransform[10], inverseBindTransform[14],
-                        inverseBindTransform[3], inverseBindTransform[7], inverseBindTransform[11], inverseBindTransform[15]
-                    };
-                    bindMatrix = MatrixInvert(inverseBindMatrix);
-                }
-                else
-                {
-                    cgltf_float worldTransform[16] = { 0 };
-                    cgltf_node_transform_world(skin.joints[i], worldTransform);
-
-                    Matrix worldMatrix = {
-                        worldTransform[0], worldTransform[4], worldTransform[8], worldTransform[12],
-                        worldTransform[1], worldTransform[5], worldTransform[9], worldTransform[13],
-                        worldTransform[2], worldTransform[6], worldTransform[10], worldTransform[14],
-                        worldTransform[3], worldTransform[7], worldTransform[11], worldTransform[15]
-                    };
-                    bindMatrix = worldMatrix;
-                }
-
-                MatrixDecompose(bindMatrix,
+                MatrixDecompose(worldMatrix,
                     &(model.skeleton.bindPose[i].translation),
                     &(model.skeleton.bindPose[i].rotation),
                     &(model.skeleton.bindPose[i].scale));
@@ -6264,7 +6227,7 @@ static Model LoadGLTF(const char *fileName)
                         }
                         else TRACELOG(LOG_WARNING, "MODEL: [%s] Joint attribute data format not supported", fileName);
                     }
-                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_weights) // WEIGHTS_n (vec4, u8n/u16n/f32)
+                    else if (mesh->primitives[p].attributes[j].type == cgltf_attribute_type_weights)  // WEIGHTS_n (vec4, u8n/u16n/f32)
                     {
                         cgltf_accessor *attribute = mesh->primitives[p].attributes[j].data;
 
@@ -6320,7 +6283,7 @@ static Model LoadGLTF(const char *fileName)
                 if ((data->skins_count > 0) && !hasJoints && (node->parent != NULL) && (node->parent->mesh == NULL))
                 {
                     int parentBoneId = -1;
-                    for (unsigned int joint = 0; joint < model.skeleton.boneCount; joint++)
+                    for (int joint = 0; joint < model.skeleton.boneCount; joint++)
                     {
                         if (data->skins[0].joints[joint] == node->parent)
                         {
@@ -6358,7 +6321,7 @@ static Model LoadGLTF(const char *fileName)
         // Initialize runtime animation data: current pose and bone matrices
         model.currentPose = (Transform *)RL_CALLOC(model.skeleton.boneCount, sizeof(Transform));
         model.boneMatrices = (Matrix *)RL_CALLOC(model.skeleton.boneCount, sizeof(Matrix));
-        for (unsigned int j = 0; j < model.skeleton.boneCount; j++) model.boneMatrices[j] = MatrixIdentity();
+        for (int j = 0; j < model.skeleton.boneCount; j++) model.boneMatrices[j] = MatrixIdentity();
         //----------------------------------------------------------------------------------------------------
 
         // Free unused allocated memory in case of no bones defined
@@ -6390,7 +6353,6 @@ static bool GetPoseAtTimeGLTF(cgltf_interpolation_type interpolationType, cgltf_
     float tstart = 0.0f;
     float tend = 0.0f;
     int keyframe = 0;       // Defaults to first pose
-    bool found = false;
 
     for (int i = 0; i < (int)input->count - 1; i++)
     {
@@ -6403,26 +6365,10 @@ static bool GetPoseAtTimeGLTF(cgltf_interpolation_type interpolationType, cgltf_
         if ((tstart <= time) && (time < tend))
         {
             keyframe = i;
-            found = true;
             break;
         }
     }
 
-    // No interval contains a time at (or past) the last keyframe, because the
-    // search above requires time < tend: clamp to the edge interval instead of
-    // falling back to keyframe 0, which returns a pose from the start
-    if (!found && ((int)input->count >= 2))
-    {
-        keyframe = (int)input->count - 2;
-
-        float tfirst = 0.0f;
-        if (!cgltf_accessor_read_float(input, 0, &tfirst, 1)) return false;
-        if (time < tfirst) keyframe = 0;
-
-        if (!cgltf_accessor_read_float(input, keyframe, &tstart, 1)) return false;
-        if (!cgltf_accessor_read_float(input, keyframe + 1, &tend, 1)) return false;
-    }
-
     // Constant animation, no need to interpolate
     if (FloatEquals(tend, tstart))
     {
@@ -6568,58 +6514,20 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
         if (data->skins_count > 0)
         {
             cgltf_skin skin = data->skins[0];
-
-            // Precompute, per joint, the static transform contributed by any
-            // intermediate non-joint nodes between the joint and its nearest
-            // joint ancestor. This handles exporters (e.g. wow.export) that
-            // store bone offsets on dummy parent nodes rather than on the
-            // joints themselves. Depends only on the skin, not the animation.
-            int jointCount = (int)skin.joints_count;
-            Matrix *extOffset = (Matrix *)RL_MALLOC(jointCount*sizeof(Matrix));
-
-            if (extOffset == NULL)
-            {
-                // Allocation failed: abort animation loading at the source rather than
-                // propagating a NULL pointer into the per-frame transform loop below
-                TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to allocate joint offset buffer", fileName);
-                cgltf_free(data);
-                UnloadFileData(fileData);
-                *animCount = 0;
-                return NULL;
-            }
-
             *animCount = (int)data->animations_count;
             animations = (ModelAnimation *)RL_CALLOC(data->animations_count, sizeof(ModelAnimation));
 
-            for (int k = 0; k < jointCount; k++)
-            {
-                extOffset[k] = MatrixIdentity();
-                cgltf_node *n = skin.joints[k]->parent;
-
-                while (n != NULL)
-                {
-                    bool isJoint = false;
-                    for (int jj = 0; jj < jointCount; jj++)
-                    {
-                        if (skin.joints[jj] == n)
-                        {
-                            isJoint = true;
-                            break;
-                        }
-                    }
-
-                    if (isJoint) break;
-
-                    // Compose the intermediate node's local TRS (scale, then rotation, then translation)
-                    Matrix nodeScale = MatrixScale(n->scale[0], n->scale[1], n->scale[2]);
-                    Matrix nodeRotation = QuaternionToMatrix((Quaternion){ n->rotation[0], n->rotation[1], n->rotation[2], n->rotation[3] });
-                    Matrix nodeTranslation = MatrixTranslate(n->translation[0], n->translation[1], n->translation[2]);
-                    Matrix nodeTransform = MatrixMultiply(MatrixMultiply(nodeScale, nodeRotation), nodeTranslation);
-
-                    extOffset[k] = MatrixMultiply(extOffset[k], nodeTransform);
-                    n = n->parent;
-                }
-            }
+            Transform worldTransform = { 0 };
+            cgltf_float cgltf_worldTransform[16] = { 0 };
+            cgltf_node *node = skin.joints[0];
+            cgltf_node_transform_world(node->parent, cgltf_worldTransform);
+            Matrix worldMatrix = {
+                cgltf_worldTransform[0], cgltf_worldTransform[4], cgltf_worldTransform[8], cgltf_worldTransform[12],
+                cgltf_worldTransform[1], cgltf_worldTransform[5], cgltf_worldTransform[9], cgltf_worldTransform[13],
+                cgltf_worldTransform[2], cgltf_worldTransform[6], cgltf_worldTransform[10], cgltf_worldTransform[14],
+                cgltf_worldTransform[3], cgltf_worldTransform[7], cgltf_worldTransform[11], cgltf_worldTransform[15]
+            };
+            MatrixDecompose(worldMatrix, &worldTransform.translation, &worldTransform.rotation, &worldTransform.scale);
 
             for (unsigned int a = 0; a < data->animations_count; a++)
             {
@@ -6631,6 +6539,7 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
                     cgltf_animation_channel *translate;
                     cgltf_animation_channel *rotate;
                     cgltf_animation_channel *scale;
+                    cgltf_interpolation_type interpolationType;
                 };
 
                 struct Channels *boneChannels = (struct Channels *)RL_CALLOC(animations[a].boneCount, sizeof(struct Channels));
@@ -6652,6 +6561,8 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
 
                     if (boneIndex == -1) continue; // Animation channel for a node not in the skeleton
 
+                    boneChannels[boneIndex].interpolationType = animData.channels[j].sampler->interpolation;
+
                     if (animData.channels[j].sampler->interpolation != cgltf_interpolation_type_max_enum)
                     {
                         if (channel.target_path == cgltf_animation_path_type_translation)
@@ -6685,7 +6596,7 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
                     animDuration = (time > animDuration)? time : animDuration;
                 }
 
-                if (animData.name != NULL) snprintf(animations[a].name, sizeof(animations[a].name), "%s", animData.name);
+                if (animData.name != NULL) strncpy(animations[a].name, animData.name, sizeof(animations[a].name) - 1);
 
                 animations[a].keyframeCount = (int)(animDuration*GLTF_FRAMERATE) + 1;
                 animations[a].keyframePoses = (Transform **)RL_CALLOC(animations[a].keyframeCount, sizeof(Transform *));
@@ -6695,7 +6606,7 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
                     animations[a].keyframePoses[j] = (Transform *)RL_CALLOC(animations[a].boneCount, sizeof(Transform));
                     float time = (float)j / GLTF_FRAMERATE;
 
-                    for (unsigned int k = 0; k < animations[a].boneCount; k++)
+                    for (int k = 0; k < animations[a].boneCount; k++)
                     {
                         Vector3 translation = {skin.joints[k]->translation[0], skin.joints[k]->translation[1], skin.joints[k]->translation[2]};
                         Quaternion rotation = {skin.joints[k]->rotation[0], skin.joints[k]->rotation[1], skin.joints[k]->rotation[2], skin.joints[k]->rotation[3]};
@@ -6703,7 +6614,7 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
 
                         if (boneChannels[k].translate)
                         {
-                            if (!GetPoseAtTimeGLTF(boneChannels[k].translate->sampler->interpolation, boneChannels[k].translate->sampler->input, boneChannels[k].translate->sampler->output, time, &translation))
+                            if (!GetPoseAtTimeGLTF(boneChannels[k].interpolationType, boneChannels[k].translate->sampler->input, boneChannels[k].translate->sampler->output, time, &translation))
                             {
                                 TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load translate pose data for bone %s", fileName, bones[k].name);
                             }
@@ -6711,7 +6622,7 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
 
                         if (boneChannels[k].rotate)
                         {
-                            if (!GetPoseAtTimeGLTF(boneChannels[k].rotate->sampler->interpolation, boneChannels[k].rotate->sampler->input, boneChannels[k].rotate->sampler->output, time, &rotation))
+                            if (!GetPoseAtTimeGLTF(boneChannels[k].interpolationType, boneChannels[k].rotate->sampler->input, boneChannels[k].rotate->sampler->output, time, &rotation))
                             {
                                 TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load rotate pose data for bone %s", fileName, bones[k].name);
                             }
@@ -6719,26 +6630,26 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
 
                         if (boneChannels[k].scale)
                         {
-                            if (!GetPoseAtTimeGLTF(boneChannels[k].scale->sampler->interpolation, boneChannels[k].scale->sampler->input, boneChannels[k].scale->sampler->output, time, &scale))
+                            if (!GetPoseAtTimeGLTF(boneChannels[k].interpolationType, boneChannels[k].scale->sampler->input, boneChannels[k].scale->sampler->output, time, &scale))
                             {
                                 TRACELOG(LOG_INFO, "MODEL: [%s] Failed to load scale pose data for bone %s", fileName, bones[k].name);
                             }
                         }
 
-                        // Compose joint local TRS, then prepend the static
-                        // intermediate non-joint offsets so the final TRS is
-                        // expressed relative to the joint's skeleton parent.
-                        Matrix S = MatrixScale(scale.x, scale.y, scale.z);
-                        Matrix R = QuaternionToMatrix(rotation);
-                        Matrix T = MatrixTranslate(translation.x, translation.y, translation.z);
-                        Matrix jointLocal = MatrixMultiply(MatrixMultiply(S, R), T);
-                        Matrix combined = MatrixMultiply(jointLocal, extOffset[k]);
-
-                        Transform tr;
-                        MatrixDecompose(combined, &tr.translation, &tr.rotation, &tr.scale);
-                        animations[a].keyframePoses[j][k] = tr;
+                        animations[a].keyframePoses[j][k] = (Transform){
+                            .translation = translation,
+                            .rotation = rotation,
+                            .scale = scale
+                        };
                     }
 
+                    Transform *root = &animations[a].keyframePoses[j][0];
+                    root->rotation = QuaternionMultiply(worldTransform.rotation, root->rotation);
+                    root->scale = Vector3Multiply(root->scale, worldTransform.scale);
+                    root->translation = Vector3Multiply(root->translation, worldTransform.scale);
+                    root->translation = Vector3RotateByQuaternion(root->translation, worldTransform.rotation);
+                    root->translation = Vector3Add(root->translation, worldTransform.translation);
+
                     BuildPoseFromParentJoints(bones, animations[a].boneCount, animations[a].keyframePoses[j]);
                 }
 
@@ -6746,8 +6657,6 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
                 RL_FREE(boneChannels);
                 RL_FREE(bones);
             }
-
-            RL_FREE(extOffset);
         }
 
         if (data->skins_count > 1)
@@ -7175,7 +7084,7 @@ static Model LoadM3D(const char *fileName)
             for (i = 0; i < (int)m3d->numbone; i++)
             {
                 model.skeleton.bones[i].parent = m3d->bone[i].parent;
-                snprintf(model.skeleton.bones[i].name, sizeof(model.skeleton.bones[i].name), "%s", m3d->bone[i].name);
+                strncpy(model.skeleton.bones[i].name, m3d->bone[i].name, sizeof(model.skeleton.bones[i].name) - 1);
                 model.skeleton.bindPose[i].translation.x = m3d->vertex[m3d->bone[i].pos].x*m3d->scale;
                 model.skeleton.bindPose[i].translation.y = m3d->vertex[m3d->bone[i].pos].y*m3d->scale;
                 model.skeleton.bindPose[i].translation.z = m3d->vertex[m3d->bone[i].pos].z*m3d->scale;
@@ -7229,7 +7138,7 @@ static Model LoadM3D(const char *fileName)
             // Initialize runtime animation data: current pose and bone matrices
             model.currentPose = (Transform *)RL_CALLOC(model.skeleton.boneCount, sizeof(Transform));
             model.boneMatrices = (Matrix *)RL_CALLOC(model.skeleton.boneCount, sizeof(Matrix));
-            for (unsigned int j = 0; j < model.skeleton.boneCount; j++) model.boneMatrices[j] = MatrixIdentity();
+            for (int j = 0; j < model.skeleton.boneCount; j++) model.boneMatrices[j] = MatrixIdentity();
         }
 
         m3d_free(m3d);
@@ -7239,7 +7148,7 @@ static Model LoadM3D(const char *fileName)
     return model;
 }
 
-#define M3D_ANIMDELAY 17    // Animation frames delay, (~1000 ms/60 FPS = 16.666666 ms)
+#define M3D_ANIMDELAY 17    // Animation frames delay, (~1000 ms/60 FPS = 16.666666* ms)
 
 // Load M3D animation data
 static ModelAnimation *LoadModelAnimationsM3D(const char *fileName, int *animCount)
@@ -7283,14 +7192,14 @@ static ModelAnimation *LoadModelAnimationsM3D(const char *fileName, int *animCou
 
             animations[a].keyframeCount = m3d->action[a].durationmsec/M3D_ANIMDELAY;
             animations[a].keyframePoses = (Transform **)RL_CALLOC(animations[a].keyframeCount, sizeof(Transform *));
-            snprintf(animations[a].name, sizeof(animations[a].name), "%s", m3d->action[a].name);
+            strncpy(animations[a].name, m3d->action[a].name, sizeof(animations[a].name) - 1);
 
             TRACELOG(LOG_INFO, "MODEL: [%s] Loaded animation: %s | Frames: %d | Duration: %fs", fileName, animations[a].name, animations[a].keyframeCount, m3d->action[a].durationmsec);
 
             for (i = 0; i < (int)m3d->numbone; i++)
             {
                 bones[i].parent = m3d->bone[i].parent;
-                snprintf(bones[i].name, sizeof(bones[i].name), "%s", m3d->bone[i].name);
+                strncpy(bones[i].name, m3d->bone[i].name, sizeof(bones[i].name) - 1);
             }
 
             // A special, never transformed "no bone" bone, used for boneless vertices
diff --git a/src/libraries/raylib/raylib/src/rshapes.c b/src/libraries/raylib/raylib/src/rshapes.c
index 466cff7..cdd440c 100644
--- a/src/libraries/raylib/raylib/src/rshapes.c
+++ b/src/libraries/raylib/raylib/src/rshapes.c
@@ -90,12 +90,12 @@ static float EaseCubicInOut(float t, float b, float c, float d);    // Cubic eas
 // Set texture and rectangle to be used on shapes drawing
 // NOTE: It can be useful when using basic shapes and one single font,
 // defining a font char white rectangle would allow drawing everything in a single draw call
-void SetShapesTexture(Texture2D texture, Rectangle rec)
+void SetShapesTexture(Texture2D texture, Rectangle source)
 {
     // Reset texture to default pixel if required
     // WARNING: Shapes texture should be probably better validated,
     // it can break the rendering of all shapes if misused
-    if ((texture.id == 0) || (rec.width == 0) || (rec.height == 0))
+    if ((texture.id == 0) || (source.width == 0) || (source.height == 0))
     {
         texShapes = (Texture2D){ 1, 1, 1, 1, 7 };
         texShapesRec = (Rectangle){ 0.0f, 0.0f, 1.0f, 1.0f };
@@ -103,7 +103,7 @@ void SetShapesTexture(Texture2D texture, Rectangle rec)
     else
     {
         texShapes = texture;
-        texShapesRec = rec;
+        texShapesRec = source;
     }
 }
 
@@ -311,288 +311,408 @@ void DrawLineDashed(Vector2 startPos, Vector2 endPos, int dashSize, int spaceSiz
     rlEnd();
 }
 
-// Draw a triangle
-// NOTE: Vertex must be provided in counter-clockwise order
-void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
+// Draw a color-filled circle
+void DrawCircle(int centerX, int centerY, float radius, Color color)
 {
-    DrawTriangleGradient(v1, v2, v3, color, color, color);
+    DrawCircleV((Vector2){ (float)centerX, (float)centerY }, radius, color);
 }
 
-// Draw triangle with interpolated colors (vertex in counter-clockwise order!)
-void DrawTriangleGradient(Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3)
+// Draw a color-filled circle (Vector version)
+// NOTE: On OpenGL 3.3 and ES2 using QUADS to avoid drawing order issues
+void DrawCircleV(Vector2 center, float radius, Color color)
 {
+    DrawCircleSector(center, radius, 0, 360, 36, color);
+}
+
+// Draw a gradient-filled circle
+void DrawCircleGradient(Vector2 center, float radius, Color inner, Color outer)
+{
+    rlBegin(RL_TRIANGLES);
+        for (int i = 0; i < 360; i += 10)
+        {
+            rlColor4ub(inner.r, inner.g, inner.b, inner.a);
+            rlVertex2f(center.x, center.y);
+            rlColor4ub(outer.r, outer.g, outer.b, outer.a);
+            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radius, center.y + sinf(DEG2RAD*(i + 10))*radius);
+            rlColor4ub(outer.r, outer.g, outer.b, outer.a);
+            rlVertex2f(center.x + cosf(DEG2RAD*i)*radius, center.y + sinf(DEG2RAD*i)*radius);
+        }
+    rlEnd();
+}
+
+// Draw a piece of a circle
+void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color)
+{
+    if (startAngle == endAngle) return;
+    if (radius <= 0.0f) radius = 0.1f;  // Avoid div by zero
+
+    // Function expects (endAngle > startAngle)
+    if (endAngle < startAngle)
+    {
+        // Swap values
+        float tmp = startAngle;
+        startAngle = endAngle;
+        endAngle = tmp;
+    }
+
+    int minSegments = (int)ceilf((endAngle - startAngle)/90);
+
+    if (segments < minSegments)
+    {
+        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
+        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
+        segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360);
+
+        if (segments <= 0) segments = minSegments;
+    }
+
+    float stepLength = (endAngle - startAngle)/(float)segments;
+    float angle = startAngle;
+
 #if SUPPORT_QUADS_DRAW_MODE
     rlSetTexture(GetShapesTexture().id);
     Rectangle shapeRect = GetShapesTextureRectangle();
 
     rlBegin(RL_QUADS);
-        rlNormal3f(0.0f, 0.0f, 1.0f);
 
-        rlColor4ub(c1.r, c1.g, c1.b, c1.a);
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v1.x, v1.y);
+        // NOTE: Every QUAD actually represents two segments
+        for (int i = 0; i < segments/2; i++)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
 
-        rlColor4ub(c2.r, c2.g, c2.b, c2.a);
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v2.x, v2.y);
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(center.x, center.y);
 
-        rlColor4ub(c3.r, c3.g, c3.b, c3.a);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v3.x, v3.y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength*2.0f))*radius, center.y + sinf(DEG2RAD*(angle + stepLength*2.0f))*radius);
+
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
+
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
+
+            angle += (stepLength*2.0f);
+        }
+
+        // NOTE: In case number of segments is odd, adding one last piece to the cake
+        if ((((unsigned int)segments)%2) == 1)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(center.x, center.y);
+
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
+
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
+
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(center.x, center.y);
+        }
 
-        rlColor4ub(c3.r, c3.g, c3.b, c3.a);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v3.x, v3.y);
     rlEnd();
 
     rlSetTexture(0);
 #else
     rlBegin(RL_TRIANGLES);
-        rlColor4ub(c1.r, c1.g, c1.b, c1.a);
-        rlVertex2f(v1.x, v1.y);
-        rlColor4ub(c2.r, c2.g, c2.b, c2.a);
-        rlVertex2f(v2.x, v2.y);
-        rlColor4ub(c3.r, c3.g, c3.b, c3.a);
-        rlVertex2f(v3.x, v3.y);
+        for (int i = 0; i < segments; i++)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+
+            rlVertex2f(center.x, center.y);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
+
+            angle += stepLength;
+        }
     rlEnd();
 #endif
 }
 
-// Draw a triangle using lines
-// NOTE: Vertex must be provided in counter-clockwise order
-void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
+// Draw a piece of a circle outlines
+void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color)
+{
+    if (startAngle == endAngle) return;
+    if (radius <= 0.0f) radius = 0.1f;  // Avoid div by zero issue
+
+    // Function expects (endAngle > startAngle)
+    if (endAngle < startAngle)
+    {
+        // Swap values
+        float tmp = startAngle;
+        startAngle = endAngle;
+        endAngle = tmp;
+    }
+
+    int minSegments = (int)ceilf((endAngle - startAngle)/90);
+
+    if (segments < minSegments)
+    {
+        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
+        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
+        segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360);
+
+        if (segments <= 0) segments = minSegments;
+    }
+
+    float stepLength = (endAngle - startAngle)/(float)segments;
+    float angle = startAngle;
+    bool showCapLines = true;
+
+    rlBegin(RL_LINES);
+        if (showCapLines)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(center.x, center.y);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
+        }
+
+        for (int i = 0; i < segments; i++)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
+
+            angle += stepLength;
+        }
+
+        if (showCapLines)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(center.x, center.y);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
+        }
+    rlEnd();
+}
+
+// Draw circle outline
+void DrawCircleLines(int centerX, int centerY, float radius, Color color)
+{
+    DrawCircleLinesV((Vector2){ (float)centerX, (float)centerY }, radius, color);
+}
+
+// Draw circle outline (Vector version)
+void DrawCircleLinesV(Vector2 center, float radius, Color color)
 {
     rlBegin(RL_LINES);
         rlColor4ub(color.r, color.g, color.b, color.a);
-        rlVertex2f(v1.x, v1.y);
-        rlVertex2f(v2.x, v2.y);
 
-        rlVertex2f(v2.x, v2.y);
-        rlVertex2f(v3.x, v3.y);
-
-        rlVertex2f(v3.x, v3.y);
-        rlVertex2f(v1.x, v1.y);
+        // NOTE: Circle outline is drawn pixel by pixel every degree (0 to 360)
+        for (int i = 0; i < 360; i += 10)
+        {
+            rlVertex2f(center.x + cosf(DEG2RAD*i)*radius, center.y + sinf(DEG2RAD*i)*radius);
+            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radius, center.y + sinf(DEG2RAD*(i + 10))*radius);
+        }
     rlEnd();
 }
 
-// Draw a triangle using lines with thickness
-// NOTE: Vertex must be provided in counter-clockwise order
-void DrawTriangleLinesEx(Vector2 v1, Vector2 v2, Vector2 v3, float thick, Color color)
+// Draw ellipse
+void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color)
 {
-    /*
-    A sketch to make things simpler
+    DrawEllipseV((Vector2){ (float)centerX, (float)centerY }, radiusH, radiusV, color);
+}
 
-    The exterior points are v1-3, the interior points are v4-6, and the exterior edges are e1-3
+// Draw ellipse (Vector version)
+void DrawEllipseV(Vector2 center, float radiusH, float radiusV, Color color)
+{
+    rlBegin(RL_TRIANGLES);
+        for (int i = 0; i < 360; i += 10)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(center.x,  center.y);
+            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radiusH, center.y + sinf(DEG2RAD*(i + 10))*radiusV);
+            rlVertex2f(center.x + cosf(DEG2RAD*i)*radiusH, center.y + sinf(DEG2RAD*i)*radiusV);
+        }
+    rlEnd();
+}
 
-             v1
-             /\
-            /v4\
-           //  \\
-          //    \\
-      e3 //      \\ e2
-        //        \\
-       //          \\
-      //v5        v6\\
-     v2==============v3
-             e1
-    */
+// Draw ellipse outline
+void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color)
+{
+    DrawEllipseLinesV((Vector2){ (float)centerX, (float)centerY }, radiusH, radiusV, color);
+}
 
-    Vector2 e1 = {v2.x - v3.x, v2.y - v3.y};
-    Vector2 e2 = {v3.x - v1.x, v3.y - v1.y};
-    Vector2 e3 = {v1.x - v2.x, v1.y - v2.y};
+// Draw ellipse outline
+void DrawEllipseLinesV(Vector2 center, float radiusH, float radiusV, Color color)
+{
+    rlBegin(RL_LINES);
+        for (int i = 0; i < 360; i += 10)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radiusH, center.y + sinf(DEG2RAD*(i + 10))*radiusV);
+            rlVertex2f(center.x + cosf(DEG2RAD*i)*radiusH, center.y + sinf(DEG2RAD*i)*radiusV);
+        }
+    rlEnd();
+}
 
-    float e1Length = sqrtf(e1.x*e1.x + e1.y*e1.y);
-    float e2Length = sqrtf(e2.x*e2.x + e2.y*e2.y);
-    float e3Length = sqrtf(e3.x*e3.x + e3.y*e3.y);
+// Draw ring
+void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color)
+{
+    if (startAngle == endAngle) return;
 
-    float perimeter = e1Length + e2Length + e3Length;
-    float semiperimeter = perimeter/2.0f;
-
-    // The incenter of a triangle is equidistant from each edge, which is useful for drawing a nice looking outline
-    Vector2 incenter = {
-        (e1Length*v1.x + e2Length*v2.x + e3Length*v3.x)/perimeter,
-        (e1Length*v1.y + e2Length*v2.y + e3Length*v3.y)/perimeter
-    };
-
-    // The inradius of a triangle is the radius of the biggest circle that can fit inside of said triangle
-    // That circle is also centered on the incenter
-    float inradius = sqrtf(((semiperimeter - e1Length)*(semiperimeter - e2Length)*(semiperimeter - e3Length))/semiperimeter);
-
-    // The triangle (v1, v2, v3) will be scaled by this to get (v4, v5, v6)
-    float scale = 1.0f - thick/inradius;
-
-    // Just a filled-in triangle
-    if (scale <= 0.0f)
+    // Function expects (outerRadius > innerRadius)
+    if (outerRadius < innerRadius)
     {
-        DrawTriangle(v1, v2, v3, color);
+        float tmp = outerRadius;
+        outerRadius = innerRadius;
+        innerRadius = tmp;
+
+        if (outerRadius <= 0.0f) outerRadius = 0.1f;
+    }
+
+    // Function expects (endAngle > startAngle)
+    if (endAngle < startAngle)
+    {
+        // Swap values
+        float tmp = startAngle;
+        startAngle = endAngle;
+        endAngle = tmp;
+    }
+
+    int minSegments = (int)ceilf((endAngle - startAngle)/90);
+
+    if (segments < minSegments)
+    {
+        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
+        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
+        segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360);
+
+        if (segments <= 0) segments = minSegments;
+    }
+
+    // Not a ring
+    if (innerRadius <= 0.0f)
+    {
+        DrawCircleSector(center, outerRadius, startAngle, endAngle, segments, color);
         return;
     }
 
-    // In order for the scaling to be correct, the incenter has to be at the origin (0, 0) when scaling
-    Vector2 v4 = {incenter.x + (v1.x - incenter.x)*scale, incenter.y + (v1.y - incenter.y)*scale};
-    Vector2 v5 = {incenter.x + (v2.x - incenter.x)*scale, incenter.y + (v2.y - incenter.y)*scale};
-    Vector2 v6 = {incenter.x + (v3.x - incenter.x)*scale, incenter.y + (v3.y - incenter.y)*scale};
-
-    // Swap the vertices so the winding order is correct
-    if (thick < 0.0f)
-    {
-        Vector2 temp = v1;
-        v1 = v4;
-        v4 = temp;
-
-        temp = v2;
-        v2 = v5;
-        v5 = temp;
-
-        temp = v3;
-        v3 = v6;
-        v6 = temp;
-    }
+    float stepLength = (endAngle - startAngle)/(float)segments;
+    float angle = startAngle;
 
 #if SUPPORT_QUADS_DRAW_MODE
     rlSetTexture(GetShapesTexture().id);
     Rectangle shapeRect = GetShapesTextureRectangle();
 
     rlBegin(RL_QUADS);
+        for (int i = 0; i < segments; i++)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
 
-        rlColor4ub(color.r, color.g, color.b, color.a);
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
 
-        // Edge 3
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v1.x, v1.y);
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
 
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v2.x, v2.y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
 
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v5.x, v5.y);
-
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v4.x, v4.y);
-
-        // Edge 1
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v2.x, v2.y);
-
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v3.x, v3.y);
-
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v6.x, v6.y);
-
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v5.x, v5.y);
-
-        // Edge 2
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v3.x, v3.y);
-
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v1.x, v1.y);
-
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(v4.x, v4.y);
-
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(v6.x, v6.y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
 
+            angle += stepLength;
+        }
     rlEnd();
 
     rlSetTexture(0);
 #else
     rlBegin(RL_TRIANGLES);
+        for (int i = 0; i < segments; i++)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
 
-        rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
 
-        // Edge 3
-        rlVertex2f(v1.x, v1.y);
-        rlVertex2f(v2.x, v2.y);
-        rlVertex2f(v4.x, v4.y);
-
-        rlVertex2f(v2.x, v2.y);
-        rlVertex2f(v5.x, v5.y);
-        rlVertex2f(v4.x, v4.y);
-
-        // Edge 1
-        rlVertex2f(v2.x, v2.y);
-        rlVertex2f(v3.x, v3.y);
-        rlVertex2f(v5.x, v5.y);
-
-        rlVertex2f(v3.x, v3.y);
-        rlVertex2f(v6.x, v6.y);
-        rlVertex2f(v5.x, v5.y);
-
-        // Edge 2
-        rlVertex2f(v3.x, v3.y);
-        rlVertex2f(v1.x, v1.y);
-        rlVertex2f(v4.x, v4.y);
-
-        rlVertex2f(v3.x, v3.y);
-        rlVertex2f(v4.x, v4.y);
-        rlVertex2f(v6.x, v6.y);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
 
+            angle += stepLength;
+        }
     rlEnd();
 #endif
 }
 
-// Draw a triangle fan defined by points
-// NOTE: First vertex provided is the center, shared by all triangles
-// By default, following vertex should be provided in counter-clockwise order
-void DrawTriangleFan(const Vector2 *points, int pointCount, Color color)
+// Draw ring outline
+void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color)
 {
-    if (pointCount >= 3)
-    {
-        rlSetTexture(GetShapesTexture().id);
-        Rectangle shapeRect = GetShapesTextureRectangle();
+    if (startAngle == endAngle) return;
 
-        rlBegin(RL_QUADS);
+    // Function expects (outerRadius > innerRadius)
+    if (outerRadius < innerRadius)
+    {
+        float tmp = outerRadius;
+        outerRadius = innerRadius;
+        innerRadius = tmp;
+
+        if (outerRadius <= 0.0f) outerRadius = 0.1f;
+    }
+
+    // Function expects (endAngle > startAngle)
+    if (endAngle < startAngle)
+    {
+        // Swap values
+        float tmp = startAngle;
+        startAngle = endAngle;
+        endAngle = tmp;
+    }
+
+    int minSegments = (int)ceilf((endAngle - startAngle)/90);
+
+    if (segments < minSegments)
+    {
+        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
+        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
+        segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360);
+
+        if (segments <= 0) segments = minSegments;
+    }
+
+    if (innerRadius <= 0.0f)
+    {
+        DrawCircleSectorLines(center, outerRadius, startAngle, endAngle, segments, color);
+        return;
+    }
+
+    float stepLength = (endAngle - startAngle)/(float)segments;
+    float angle = startAngle;
+    bool showCapLines = true;
+
+    rlBegin(RL_LINES);
+        if (showCapLines)
+        {
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
+        }
+
+        for (int i = 0; i < segments; i++)
+        {
             rlColor4ub(color.r, color.g, color.b, color.a);
 
-            for (int i = 1; i < pointCount - 1; i++)
-            {
-                rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(points[0].x, points[0].y);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
 
-                rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(points[i].x, points[i].y);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
 
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(points[i + 1].x, points[i + 1].y);
+            angle += stepLength;
+        }
 
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(points[i + 1].x, points[i + 1].y);
-            }
-        rlEnd();
-        rlSetTexture(0);
-    }
-}
-
-// Draw a triangle strip defined by points
-// NOTE: Every new vertex connects with previous two
-void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color)
-{
-    if (pointCount >= 3)
-    {
-        rlBegin(RL_TRIANGLES);
+        if (showCapLines)
+        {
             rlColor4ub(color.r, color.g, color.b, color.a);
-
-            for (int i = 2; i < pointCount; i++)
-            {
-                if ((i%2) == 0)
-                {
-                    rlVertex2f(points[i].x, points[i].y);
-                    rlVertex2f(points[i - 2].x, points[i - 2].y);
-                    rlVertex2f(points[i - 1].x, points[i - 1].y);
-                }
-                else
-                {
-                    rlVertex2f(points[i].x, points[i].y);
-                    rlVertex2f(points[i - 1].x, points[i - 1].y);
-                    rlVertex2f(points[i - 2].x, points[i - 2].y);
-                }
-            }
-        rlEnd();
-    }
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
+        }
+    rlEnd();
 }
 
 // Draw a color-filled rectangle
@@ -707,8 +827,8 @@ void DrawRectangleGradientH(int posX, int posY, int width, int height, Color lef
     DrawRectangleGradientEx((Rectangle){ (float)posX, (float)posY, (float)width, (float)height }, left, left, right, right);
 }
 
-// Draw a gradient-filled rectangle with custom vertex colors, counter-clockwise color order
-void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4)
+// Draw a gradient-filled rectangle
+void DrawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color bottomRight, Color topRight)
 {
     rlSetTexture(GetShapesTexture().id);
     Rectangle shapeRect = GetShapesTextureRectangle();
@@ -717,19 +837,19 @@ void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3,
         rlNormal3f(0.0f, 0.0f, 1.0f);
 
         // NOTE: Default raylib font character 95 is a white square
-        rlColor4ub(col1.r, col1.g, col1.b, col1.a);
+        rlColor4ub(topLeft.r, topLeft.g, topLeft.b, topLeft.a);
         rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
         rlVertex2f(rec.x, rec.y);
 
-        rlColor4ub(col2.r, col2.g, col2.b, col2.a);
+        rlColor4ub(bottomLeft.r, bottomLeft.g, bottomLeft.b, bottomLeft.a);
         rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
         rlVertex2f(rec.x, rec.y + rec.height);
 
-        rlColor4ub(col3.r, col3.g, col3.b, col3.a);
+        rlColor4ub(bottomRight.r, bottomRight.g, bottomRight.b, bottomRight.a);
         rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
         rlVertex2f(rec.x + rec.width, rec.y + rec.height);
 
-        rlColor4ub(col4.r, col4.g, col4.b, col4.a);
+        rlColor4ub(topRight.r, topRight.g, topRight.b, topRight.a);
         rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
         rlVertex2f(rec.x + rec.width, rec.y);
     rlEnd();
@@ -788,67 +908,35 @@ void DrawRectangleLines(int posX, int posY, int width, int height, Color color)
 */
 }
 
-// Draw rectangle outline with line thickness
-void DrawRectangleLinesEx(Rectangle rec, float thick, Color color)
+// Draw rectangle outline with extended parameters
+void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color)
 {
-    if ((thick > rec.width/2) || (thick > rec.height/2))
+    if ((lineThick > rec.width) || (lineThick > rec.height))
     {
-        if (rec.width >= rec.height) thick = rec.height/2;
-        else if (rec.width <= rec.height) thick = rec.width/2;
+        if (rec.width >= rec.height) lineThick = rec.height/2;
+        else if (rec.width <= rec.height) lineThick = rec.width/2;
     }
 
-    if (thick > 0.0f)
-    {
-        // When rec = { x, y, 8.0f, 6.0f } and thick = 2, the following
-        // four rectangles are drawn ([T]op, [B]ottom, [L]eft, [R]ight):
-        //
-        //   TTTTTTTT
-        //   TTTTTTTT
-        //   LL    RR
-        //   LL    RR
-        //   BBBBBBBB
-        //   BBBBBBBB
-        //
+    // When rec = { x, y, 8.0f, 6.0f } and lineThick = 2, the following
+    // four rectangles are drawn ([T]op, [B]ottom, [L]eft, [R]ight):
+    //
+    //   TTTTTTTT
+    //   TTTTTTTT
+    //   LL    RR
+    //   LL    RR
+    //   BBBBBBBB
+    //   BBBBBBBB
+    //
 
-        Rectangle top = { rec.x, rec.y, rec.width, thick };
-        Rectangle bottom = { rec.x, rec.y - thick + rec.height, rec.width, thick };
-        Rectangle left = { rec.x, rec.y + thick, thick, rec.height - thick*2.0f };
-        Rectangle right = { rec.x - thick + rec.width, rec.y + thick, thick, rec.height - thick*2.0f };
+    Rectangle top = { rec.x, rec.y, rec.width, lineThick };
+    Rectangle bottom = { rec.x, rec.y - lineThick + rec.height, rec.width, lineThick };
+    Rectangle left = { rec.x, rec.y + lineThick, lineThick, rec.height - lineThick*2.0f };
+    Rectangle right = { rec.x - lineThick + rec.width, rec.y + lineThick, lineThick, rec.height - lineThick*2.0f };
 
-        DrawRectangleRec(top, color);
-        DrawRectangleRec(bottom, color);
-        DrawRectangleRec(left, color);
-        DrawRectangleRec(right, color);
-    }
-    else
-    {
-        // When rec = { x, y, 8.0f, 6.0f } and thick = -2, the following
-        // four rectangles are drawn ([T]op, [B]ottom, [L]eft, [R]ight):
-        //
-        //   TTTTTTTTTTTT
-        //   TTTTTTTTTTTT
-        //   LL        RR
-        //   LL        RR
-        //   LL        RR
-        //   LL        RR
-        //   LL        RR
-        //   LL        RR
-        //   BBBBBBBBBBBB
-        //   BBBBBBBBBBBB
-        //
-
-        thick *= -1.0f;
-
-        Rectangle top = { rec.x - thick, rec.y - thick, rec.width + thick*2.0f, thick };
-        Rectangle bottom = { rec.x - thick, rec.y + rec.height, rec.width + thick*2.0f, thick};
-        Rectangle left = { rec.x - thick, rec.y, thick, rec.height };
-        Rectangle right = { rec.x + rec.width, rec.y, thick, rec.height };
-
-        DrawRectangleRec(top, color);
-        DrawRectangleRec(bottom, color);
-        DrawRectangleRec(left, color);
-        DrawRectangleRec(right, color);
-    }
+    DrawRectangleRec(top, color);
+    DrawRectangleRec(bottom, color);
+    DrawRectangleRec(left, color);
+    DrawRectangleRec(right, color);
 }
 
 // Draw rectangle with rounded edges
@@ -872,7 +960,7 @@ void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color co
     {
         // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
         float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
-        segments = (int)ceilf((2*PI/th)/4.0f);
+        segments = (int)(ceilf(2*PI/th)/4.0f);
         if (segments <= 0) segments = 4;
     }
 
@@ -1080,10 +1168,19 @@ void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color co
 // Draw rectangle with rounded edges
 void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, Color color)
 {
+    // NOTE: For line thicknes <=1.0f using RL_LINES, otherwise using RL_QUADS/RL_TRIANGLES
+    DrawRectangleRoundedLinesEx(rec, roundness, segments, 1.0f, color);
+}
+
+// Draw rectangle with rounded edges outline
+void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float lineThick, Color color)
+{
+    if (lineThick < 0) lineThick = 0;
+
     // Not a rounded rectangle
     if (roundness <= 0.0f)
     {
-        DrawRectangleLines((int)rec.x, (int)rec.y, (int)rec.width, (int)rec.height, color);
+        DrawRectangleLinesEx((Rectangle){rec.x-lineThick, rec.y-lineThick, rec.width+2*lineThick, rec.height+2*lineThick}, lineThick, color);
         return;
     }
 
@@ -1098,165 +1195,12 @@ void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, Col
     {
         // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
         float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
-        segments = (int)ceilf((2*PI/th)/4.0f);
+        segments = (int)(ceilf(2*PI/th)/2.0f);
         if (segments <= 0) segments = 4;
     }
 
     float stepLength = 90.0f/(float)segments;
-
-    /*
-    Quick sketch to make sense of all of this,
-    marks the 8 + 4 (corner centers P8-11) points used
-
-           P0 ------------------ P1
-          /                        \
-         /                          \
-     P7 /                            \ P2
-       |    *P8               P9*     |
-       |                              |
-       |                              |
-     P6 \   *P11             P10*    / P3
-         \                          /
-          \                        /
-           P5 ------------------ P4
-    */
-
-    // The x-coordinates used for the outline
-    const float x0 = rec.x + radius + 0.5f;
-    const float x1 = (rec.x + rec.width) - radius - 0.5f;
-    const float x2 = rec.x + rec.width - 0.5f;
-    const float x3 = rec.x + 0.5f;
-
-    // The y-coordinates used for the outline
-    const float y0 = rec.y + 0.5f;
-    const float y1 = rec.y + radius + 0.5f;
-    const float y2 = (rec.y + rec.height) - radius - 0.5f;
-    const float y3 = rec.y + rec.height - 0.5f;
-
-    const Vector2 point[8] = {
-        {x0, y0}, // P0
-        {x1, y0}, // P1
-        {x2, y1}, // P2
-        {x2, y2}, // P3
-        {x1, y3}, // P4
-        {x0, y3}, // P5
-        {x3, y2}, // P6
-        {x3, y1}, // P7
-    };
-
-    const Vector2 centers[4] = {
-        {x0, y1}, // P16
-        {x1, y1}, // P17
-        {x1, y2}, // P18
-        {x0, y2}  // P19
-    };
-
-    const float angles[4] = { 180.0f, 270.0f, 0.0f, 90.0f };
-
-    rlBegin(RL_LINES);
-        // Draw all the 4 corners first: Upper Left Corner, Upper Right Corner, Lower Right Corner, Lower Left Corner
-        for (int k = 0; k < 4; ++k) // Hope the compiler is smart enough to unroll this loop
-        {
-            float angle = angles[k];
-            const Vector2 center = centers[k];
-
-            for (int i = 0; i < segments; i++)
-            {
-                rlColor4ub(color.r, color.g, color.b, color.a);
-                rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-                rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
-                angle += stepLength;
-            }
-        }
-
-        // And now the remaining 4 lines
-        for (int i = 0; i < 8; i += 2)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(point[i].x, point[i].y);
-            rlVertex2f(point[i + 1].x, point[i + 1].y);
-        }
-    rlEnd();
-}
-
-// Draw rectangle with rounded edges outline with line thickness
-void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float thick, Color color)
-{
-    // Not a rounded rectangle
-    if (roundness <= 0.0f)
-    {
-        DrawRectangleLinesEx(rec, thick, color);
-        return;
-    }
-
-    if (roundness >= 1.0f) roundness = 1.0f;
-
-    float radius = 0.0f;
-    float roundedOutlineThick = 0.0f;
-    float outerRadius = 0.0f;
-    float innerRadius = 0.0f;
-    if (thick >= 0.0f)
-    {
-        // Calculate corner radius
-        radius = (rec.width > rec.height)? (rec.height*roundness)/2 : (rec.width*roundness)/2;
-        if (radius <= 0.0f) return;
-
-        outerRadius = radius;
-        innerRadius = outerRadius - thick;
-
-        // The maximum thickness the outline can have and still be rounded on the interior edge is equal to the corner radius
-        // Put another way, when `innerRadius <= 0`, the interior of the outline is just a normal rectangle with no rounding
-        if (innerRadius <= 0.0f)
-        {
-            innerRadius = 0.0f;
-            roundedOutlineThick = outerRadius;
-
-            // Draw the not-rounded portion of the outline
-            DrawRectangleLinesEx((Rectangle){ rec.x + outerRadius, rec.y + outerRadius, rec.width - outerRadius*2.0f, rec.height - outerRadius*2.0f }, thick - outerRadius, color);
-        }
-        else
-        {
-            roundedOutlineThick = thick;
-        }
-
-        // Calculate number of segments to use for the corners
-        if (segments < 4)
-        {
-            // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-            float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
-            segments = (int)ceilf((2*PI/th)/4.0f);
-            if (segments <= 0) segments = 4;
-        }
-    }
-    else
-    {
-        thick *= -1.0f;
-
-        // Calculate corner radius
-        radius = (rec.width > rec.height)? (rec.height*roundness)/2 : (rec.width*roundness)/2;
-        if (radius <= 0.0f) return; // Only possible if the rectangle has 0 width or height
-
-        // Expand the rectangle
-        rec.x -= thick;
-        rec.y -= thick;
-        rec.width += thick*2.0f;
-        rec.height += thick*2.0f;
-
-        innerRadius = radius;
-        outerRadius = innerRadius + thick;
-        roundedOutlineThick = thick;
-
-        // Calculate number of segments to use for the corners
-        if (segments < 4)
-        {
-            // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-            float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/innerRadius, 2) - 1);
-            segments = (int)ceilf((2*PI/th)/4.0f);
-            if (segments <= 0) segments = 4;
-        }
-    }
-
-    float stepLength = 90.0f/(float)segments;
+    const float outerRadius = radius + lineThick, innerRadius = radius;
 
     /*
     Quick sketch to make sense of all of this,
@@ -1274,193 +1218,320 @@ void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, f
           \\ P13              P12 //
            P5 ================== P4
     */
-
-    // The x-coordinates used for the outline
-    const float x0 = rec.x + outerRadius;
-    const float x1 = (rec.x + rec.width) - outerRadius;
-    const float x2 = rec.x + rec.width;
-    const float x3 = rec.x;
-    const float x4 = rec.x + rec.width - roundedOutlineThick;
-    const float x5 = rec.x + roundedOutlineThick;
-
-    // The y-coordinates used for the outline
-    const float y0 = rec.y;
-    const float y1 = rec.y + outerRadius;
-    const float y2 = (rec.y + rec.height) - outerRadius;
-    const float y3 = rec.y + rec.height;
-    const float y4 = rec.y + roundedOutlineThick;
-    const float y5 = rec.y + rec.height - roundedOutlineThick;
-
     const Vector2 point[16] = {
-        {x0, y0}, // P0
-        {x1, y0}, // P1
-        {x2, y1}, // P2
-        {x2, y2}, // P3
-        {x1, y3}, // P4
-        {x0, y3}, // P5
-        {x3, y2}, // P6
-        {x3, y1}, // P7
-        {x0, y4}, // P8
-        {x1, y4}, // P9
-        {x4, y1}, // P10
-        {x4, y2}, // P11
-        {x1, y5}, // P12
-        {x0, y5}, // P13
-        {x5, y2}, // P14
-        {x5, y1}  // P15
+        {(float)rec.x + innerRadius + 0.5f, rec.y - lineThick + 0.5f},
+        {(float)(rec.x + rec.width) - innerRadius - 0.5f, rec.y - lineThick + 0.5f},
+        {rec.x + rec.width + lineThick - 0.5f, (float)rec.y + innerRadius + 0.5f}, // PO, P1, P2
+        {rec.x + rec.width + lineThick - 0.5f, (float)(rec.y + rec.height) - innerRadius - 0.5f},
+        {(float)(rec.x + rec.width) - innerRadius - 0.5f, rec.y + rec.height + lineThick - 0.5f}, // P3, P4
+        {(float)rec.x + innerRadius + 0.5f, rec.y + rec.height + lineThick - 0.5f},
+        {rec.x - lineThick + 0.5f, (float)(rec.y + rec.height) - innerRadius - 0.5f},
+        {rec.x - lineThick + 0.5f, (float)rec.y + innerRadius + 0.5f}, // P5, P6, P7
+        {(float)rec.x + innerRadius + 0.5f, rec.y + 0.5f},
+        {(float)(rec.x + rec.width) - innerRadius - 0.5f, rec.y + 0.5f}, // P8, P9
+        {rec.x + rec.width - 0.5f, (float)rec.y + innerRadius + 0.5f},
+        {rec.x + rec.width - 0.5f, (float)(rec.y + rec.height) - innerRadius - 0.5f}, // P10, P11
+        {(float)(rec.x + rec.width) - innerRadius - 0.5f, rec.y + rec.height - 0.5f},
+        {(float)rec.x + innerRadius + 0.5f, rec.y + rec.height - 0.5f}, // P12, P13
+        {rec.x + 0.5f, (float)(rec.y + rec.height) - innerRadius - 0.5f},
+        {rec.x + 0.5f, (float)rec.y + innerRadius + 0.5f} // P14, P15
     };
 
     const Vector2 centers[4] = {
-        {x0, y1}, // P16
-        {x1, y1}, // P17
-        {x1, y2}, // P18
-        {x0, y2}  // P19
+        {(float)rec.x + innerRadius + 0.5f, (float)rec.y + innerRadius + 0.5f},
+        {(float)(rec.x + rec.width) - innerRadius - 0.5f, (float)rec.y + innerRadius + 0.5f}, // P16, P17
+        {(float)(rec.x + rec.width) - innerRadius - 0.5f, (float)(rec.y + rec.height) - innerRadius - 0.5f},
+        {(float)rec.x + innerRadius + 0.5f, (float)(rec.y + rec.height) - innerRadius - 0.5f} // P18, P19
     };
 
     const float angles[4] = { 180.0f, 270.0f, 0.0f, 90.0f };
 
+    if (lineThick > 1)
+    {
+#if SUPPORT_QUADS_DRAW_MODE
+        rlSetTexture(GetShapesTexture().id);
+        Rectangle shapeRect = GetShapesTextureRectangle();
+
+        rlBegin(RL_QUADS);
+
+            // Draw all the 4 corners first: Upper Left Corner, Upper Right Corner, Lower Right Corner, Lower Left Corner
+            for (int k = 0; k < 4; ++k) // Hope the compiler is smart enough to unroll this loop
+            {
+                float angle = angles[k];
+                const Vector2 center = centers[k];
+                for (int i = 0; i < segments; i++)
+                {
+                    rlColor4ub(color.r, color.g, color.b, color.a);
+
+                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+                    rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
+
+                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+                    rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
+
+                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+                    rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
+
+                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+                    rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+
+                    angle += stepLength;
+                }
+            }
+
+            // Upper rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[0].x, point[0].y);
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[8].x, point[8].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[9].x, point[9].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[1].x, point[1].y);
+
+            // Right rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[2].x, point[2].y);
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[10].x, point[10].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[11].x, point[11].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[3].x, point[3].y);
+
+            // Lower rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[13].x, point[13].y);
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[5].x, point[5].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[4].x, point[4].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[12].x, point[12].y);
+
+            // Left rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[15].x, point[15].y);
+            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[7].x, point[7].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+            rlVertex2f(point[6].x, point[6].y);
+            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+            rlVertex2f(point[14].x, point[14].y);
+
+        rlEnd();
+        rlSetTexture(0);
+#else
+        rlBegin(RL_TRIANGLES);
+
+            // Draw all of the 4 corners first: Upper Left Corner, Upper Right Corner, Lower Right Corner, Lower Left Corner
+            for (int k = 0; k < 4; ++k) // Hope the compiler is smart enough to unroll this loop
+            {
+                float angle = angles[k];
+                const Vector2 center = centers[k];
+
+                for (int i = 0; i < segments; i++)
+                {
+                    rlColor4ub(color.r, color.g, color.b, color.a);
+
+                    rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
+                    rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
+                    rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+
+                    rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
+                    rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
+                    rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+
+                    angle += stepLength;
+                }
+            }
+
+            // Upper rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(point[0].x, point[0].y);
+            rlVertex2f(point[8].x, point[8].y);
+            rlVertex2f(point[9].x, point[9].y);
+            rlVertex2f(point[1].x, point[1].y);
+            rlVertex2f(point[0].x, point[0].y);
+            rlVertex2f(point[9].x, point[9].y);
+
+            // Right rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(point[10].x, point[10].y);
+            rlVertex2f(point[11].x, point[11].y);
+            rlVertex2f(point[3].x, point[3].y);
+            rlVertex2f(point[2].x, point[2].y);
+            rlVertex2f(point[10].x, point[10].y);
+            rlVertex2f(point[3].x, point[3].y);
+
+            // Lower rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(point[13].x, point[13].y);
+            rlVertex2f(point[5].x, point[5].y);
+            rlVertex2f(point[4].x, point[4].y);
+            rlVertex2f(point[12].x, point[12].y);
+            rlVertex2f(point[13].x, point[13].y);
+            rlVertex2f(point[4].x, point[4].y);
+
+            // Left rectangle
+            rlColor4ub(color.r, color.g, color.b, color.a);
+            rlVertex2f(point[7].x, point[7].y);
+            rlVertex2f(point[6].x, point[6].y);
+            rlVertex2f(point[14].x, point[14].y);
+            rlVertex2f(point[15].x, point[15].y);
+            rlVertex2f(point[7].x, point[7].y);
+            rlVertex2f(point[14].x, point[14].y);
+        rlEnd();
+#endif
+    }
+    else
+    {
+        // Use LINES to draw the outline
+        rlBegin(RL_LINES);
+            // Draw all the 4 corners first: Upper Left Corner, Upper Right Corner, Lower Right Corner, Lower Left Corner
+            for (int k = 0; k < 4; ++k) // Hope the compiler is smart enough to unroll this loop
+            {
+                float angle = angles[k];
+                const Vector2 center = centers[k];
+
+                for (int i = 0; i < segments; i++)
+                {
+                    rlColor4ub(color.r, color.g, color.b, color.a);
+                    rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
+                    rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
+                    angle += stepLength;
+                }
+            }
+
+            // And now the remaining 4 lines
+            for (int i = 0; i < 8; i += 2)
+            {
+                rlColor4ub(color.r, color.g, color.b, color.a);
+                rlVertex2f(point[i].x, point[i].y);
+                rlVertex2f(point[i + 1].x, point[i + 1].y);
+            }
+        rlEnd();
+    }
+}
+
+// Draw a triangle
+// NOTE: Vertex must be provided in counter-clockwise order
+void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
+{
 #if SUPPORT_QUADS_DRAW_MODE
     rlSetTexture(GetShapesTexture().id);
     Rectangle shapeRect = GetShapesTextureRectangle();
 
     rlBegin(RL_QUADS);
-
-        // Draw all the 4 corners first: Upper Left Corner, Upper Right Corner, Lower Right Corner, Lower Left Corner
-        for (int k = 0; k < 4; ++k) // Hope the compiler is smart enough to unroll this loop
-        {
-            float angle = angles[k];
-            const Vector2 center = centers[k];
-            for (int i = 0; i < segments; i++)
-            {
-                rlColor4ub(color.r, color.g, color.b, color.a);
-
-                rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-
-                rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-                angle += stepLength;
-            }
-        }
-
-        // Upper rectangle
+        rlNormal3f(0.0f, 0.0f, 1.0f);
         rlColor4ub(color.r, color.g, color.b, color.a);
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[0].x, point[0].y);
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[8].x, point[8].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[9].x, point[9].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[1].x, point[1].y);
 
-        // Right rectangle
-        rlColor4ub(color.r, color.g, color.b, color.a);
         rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[2].x, point[2].y);
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[10].x, point[10].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[11].x, point[11].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[3].x, point[3].y);
+        rlVertex2f(v1.x, v1.y);
 
-        // Lower rectangle
-        rlColor4ub(color.r, color.g, color.b, color.a);
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[13].x, point[13].y);
         rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[5].x, point[5].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[4].x, point[4].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[12].x, point[12].y);
+        rlVertex2f(v2.x, v2.y);
 
-        // Left rectangle
-        rlColor4ub(color.r, color.g, color.b, color.a);
-        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[15].x, point[15].y);
-        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[7].x, point[7].y);
         rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-        rlVertex2f(point[6].x, point[6].y);
-        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-        rlVertex2f(point[14].x, point[14].y);
+        rlVertex2f(v3.x, v3.y);
 
+        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+        rlVertex2f(v3.x, v3.y);
     rlEnd();
+
     rlSetTexture(0);
 #else
     rlBegin(RL_TRIANGLES);
-
-        // Draw all of the 4 corners first: Upper Left Corner, Upper Right Corner, Lower Right Corner, Lower Left Corner
-        for (int k = 0; k < 4; ++k) // Hope the compiler is smart enough to unroll this loop
-        {
-            float angle = angles[k];
-            const Vector2 center = centers[k];
-
-            for (int i = 0; i < segments; i++)
-            {
-                rlColor4ub(color.r, color.g, color.b, color.a);
-
-                rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-                rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-                rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-                rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-                rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-                rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-                angle += stepLength;
-            }
-        }
-
-        // Upper rectangle
         rlColor4ub(color.r, color.g, color.b, color.a);
-        rlVertex2f(point[0].x, point[0].y);
-        rlVertex2f(point[8].x, point[8].y);
-        rlVertex2f(point[9].x, point[9].y);
-        rlVertex2f(point[1].x, point[1].y);
-        rlVertex2f(point[0].x, point[0].y);
-        rlVertex2f(point[9].x, point[9].y);
-
-        // Right rectangle
-        rlColor4ub(color.r, color.g, color.b, color.a);
-        rlVertex2f(point[10].x, point[10].y);
-        rlVertex2f(point[11].x, point[11].y);
-        rlVertex2f(point[3].x, point[3].y);
-        rlVertex2f(point[2].x, point[2].y);
-        rlVertex2f(point[10].x, point[10].y);
-        rlVertex2f(point[3].x, point[3].y);
-
-        // Lower rectangle
-        rlColor4ub(color.r, color.g, color.b, color.a);
-        rlVertex2f(point[13].x, point[13].y);
-        rlVertex2f(point[5].x, point[5].y);
-        rlVertex2f(point[4].x, point[4].y);
-        rlVertex2f(point[12].x, point[12].y);
-        rlVertex2f(point[13].x, point[13].y);
-        rlVertex2f(point[4].x, point[4].y);
-
-        // Left rectangle
-        rlColor4ub(color.r, color.g, color.b, color.a);
-        rlVertex2f(point[7].x, point[7].y);
-        rlVertex2f(point[6].x, point[6].y);
-        rlVertex2f(point[14].x, point[14].y);
-        rlVertex2f(point[15].x, point[15].y);
-        rlVertex2f(point[7].x, point[7].y);
-        rlVertex2f(point[14].x, point[14].y);
+        rlVertex2f(v1.x, v1.y);
+        rlVertex2f(v2.x, v2.y);
+        rlVertex2f(v3.x, v3.y);
     rlEnd();
 #endif
 }
 
-// Draw a polygon of n sides
+// Draw a triangle using lines
+// NOTE: Vertex must be provided in counter-clockwise order
+void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
+{
+    rlBegin(RL_LINES);
+        rlColor4ub(color.r, color.g, color.b, color.a);
+        rlVertex2f(v1.x, v1.y);
+        rlVertex2f(v2.x, v2.y);
+
+        rlVertex2f(v2.x, v2.y);
+        rlVertex2f(v3.x, v3.y);
+
+        rlVertex2f(v3.x, v3.y);
+        rlVertex2f(v1.x, v1.y);
+    rlEnd();
+}
+
+// Draw a triangle fan defined by points
+// NOTE: First vertex provided is the center, shared by all triangles
+// By default, following vertex should be provided in counter-clockwise order
+void DrawTriangleFan(const Vector2 *points, int pointCount, Color color)
+{
+    if (pointCount >= 3)
+    {
+        rlSetTexture(GetShapesTexture().id);
+        Rectangle shapeRect = GetShapesTextureRectangle();
+
+        rlBegin(RL_QUADS);
+            rlColor4ub(color.r, color.g, color.b, color.a);
+
+            for (int i = 1; i < pointCount - 1; i++)
+            {
+                rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
+                rlVertex2f(points[0].x, points[0].y);
+
+                rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+                rlVertex2f(points[i].x, points[i].y);
+
+                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
+                rlVertex2f(points[i + 1].x, points[i + 1].y);
+
+                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
+                rlVertex2f(points[i + 1].x, points[i + 1].y);
+            }
+        rlEnd();
+        rlSetTexture(0);
+    }
+}
+
+// Draw a triangle strip defined by points
+// NOTE: Every new vertex connects with previous two
+void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color)
+{
+    if (pointCount >= 3)
+    {
+        rlBegin(RL_TRIANGLES);
+            rlColor4ub(color.r, color.g, color.b, color.a);
+
+            for (int i = 2; i < pointCount; i++)
+            {
+                if ((i%2) == 0)
+                {
+                    rlVertex2f(points[i].x, points[i].y);
+                    rlVertex2f(points[i - 2].x, points[i - 2].y);
+                    rlVertex2f(points[i - 1].x, points[i - 1].y);
+                }
+                else
+                {
+                    rlVertex2f(points[i].x, points[i].y);
+                    rlVertex2f(points[i - 1].x, points[i - 1].y);
+                    rlVertex2f(points[i - 2].x, points[i - 2].y);
+                }
+            }
+        rlEnd();
+    }
+}
+
+// Draw a regular polygon of n sides (Vector version)
 void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color)
 {
     if (sides < 3) sides = 3;
@@ -1529,26 +1600,12 @@ void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Colo
     rlEnd();
 }
 
-void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float thick, Color color)
+void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color)
 {
     if (sides < 3) sides = 3;
     float centralAngle = rotation*DEG2RAD;
     float exteriorAngle = 360.0f/(float)sides*DEG2RAD;
-    float apothem = radius*cosf(DEG2RAD*180.0f/(float)sides);
-
-    float outerRadius = 0.0f;
-    float innerRadius = 0.0f;
-    if (thick >= 0.0f)
-    {
-        outerRadius = radius;
-        innerRadius = fmaxf(0.0f, radius - thick*(radius/apothem));
-    }
-    else
-    {
-        thick *= -1.0f;
-        outerRadius = radius + thick*(radius/apothem);
-        innerRadius = radius;
-    }
+    float innerRadius = radius - (lineThick*cosf(DEG2RAD*exteriorAngle/2.0f));
 
 #if SUPPORT_QUADS_DRAW_MODE
     rlSetTexture(GetShapesTexture().id);
@@ -1561,7 +1618,7 @@ void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, fl
             float nextAngle = centralAngle + exteriorAngle;
 
             rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(centralAngle)*outerRadius, center.y + sinf(centralAngle)*outerRadius);
+            rlVertex2f(center.x + cosf(centralAngle)*radius, center.y + sinf(centralAngle)*radius);
 
             rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
             rlVertex2f(center.x + cosf(centralAngle)*innerRadius, center.y + sinf(centralAngle)*innerRadius);
@@ -1570,7 +1627,7 @@ void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, fl
             rlVertex2f(center.x + cosf(nextAngle)*innerRadius, center.y + sinf(nextAngle)*innerRadius);
 
             rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(nextAngle)*outerRadius, center.y + sinf(nextAngle)*outerRadius);
+            rlVertex2f(center.x + cosf(nextAngle)*radius, center.y + sinf(nextAngle)*radius);
 
             centralAngle = nextAngle;
         }
@@ -1583,13 +1640,13 @@ void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, fl
             rlColor4ub(color.r, color.g, color.b, color.a);
             float nextAngle = centralAngle + exteriorAngle;
 
-            rlVertex2f(center.x + cosf(nextAngle)*outerRadius, center.y + sinf(nextAngle)*outerRadius);
-            rlVertex2f(center.x + cosf(centralAngle)*outerRadius, center.y + sinf(centralAngle)*outerRadius);
+            rlVertex2f(center.x + cosf(nextAngle)*radius, center.y + sinf(nextAngle)*radius);
+            rlVertex2f(center.x + cosf(centralAngle)*radius, center.y + sinf(centralAngle)*radius);
             rlVertex2f(center.x + cosf(centralAngle)*innerRadius, center.y + sinf(centralAngle)*innerRadius);
 
             rlVertex2f(center.x + cosf(centralAngle)*innerRadius, center.y + sinf(centralAngle)*innerRadius);
             rlVertex2f(center.x + cosf(nextAngle)*innerRadius, center.y + sinf(nextAngle)*innerRadius);
-            rlVertex2f(center.x + cosf(nextAngle)*outerRadius, center.y + sinf(nextAngle)*outerRadius);
+            rlVertex2f(center.x + cosf(nextAngle)*radius, center.y + sinf(nextAngle)*radius);
 
             centralAngle = nextAngle;
         }
@@ -1597,2117 +1654,6 @@ void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, fl
 #endif
 }
 
-// Draw a color-filled circle
-void DrawCircle(int centerX, int centerY, float radius, Color color)
-{
-    DrawCircleV((Vector2){ (float)centerX, (float)centerY }, radius, color);
-}
-
-// Draw a color-filled circle (Vector version)
-// NOTE: On OpenGL 3.3 and ES2 using QUADS to avoid drawing order issues
-void DrawCircleV(Vector2 center, float radius, Color color)
-{
-    DrawCircleSector(center, radius, 0, 360, 36, color);
-}
-
-// Draw a gradient-filled circle
-void DrawCircleGradient(Vector2 center, float radius, Color inner, Color outer)
-{
-    rlBegin(RL_TRIANGLES);
-        for (int i = 0; i < 360; i += 10)
-        {
-            rlColor4ub(inner.r, inner.g, inner.b, inner.a);
-            rlVertex2f(center.x, center.y);
-            rlColor4ub(outer.r, outer.g, outer.b, outer.a);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radius, center.y + sinf(DEG2RAD*(i + 10))*radius);
-            rlColor4ub(outer.r, outer.g, outer.b, outer.a);
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*radius, center.y + sinf(DEG2RAD*i)*radius);
-        }
-    rlEnd();
-}
-
-// Draw a piece of a circle
-void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color)
-{
-    if (startAngle == endAngle) return;
-    if (radius <= 0.0f) radius = 0.1f;  // Avoid div by zero
-
-    // Function expects (endAngle > startAngle)
-    if (endAngle < startAngle)
-    {
-        // Swap values
-        float tmp = startAngle;
-        startAngle = endAngle;
-        endAngle = tmp;
-    }
-
-    // Drawing a whole circle, things get weird without limiting the circle to 360 degrees
-    if (endAngle - startAngle >= 360.0f) endAngle = startAngle + 360.0f;
-
-    int minSegments = (int)ceilf((endAngle - startAngle)/90);
-
-    if (segments < minSegments)
-    {
-        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
-        segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
-
-        if (segments <= 0) segments = minSegments;
-    }
-
-    float stepLength = (endAngle - startAngle)/(float)segments;
-    float angle = startAngle;
-
-#if SUPPORT_QUADS_DRAW_MODE
-    rlSetTexture(GetShapesTexture().id);
-    Rectangle shapeRect = GetShapesTextureRectangle();
-
-    rlBegin(RL_QUADS);
-
-        // NOTE: Every QUAD actually represents two segments
-        for (int i = 0; i < segments/2; i++)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x, center.y);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength*2.0f))*radius, center.y + sinf(DEG2RAD*(angle + stepLength*2.0f))*radius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-
-            angle += (stepLength*2.0f);
-        }
-
-        // NOTE: In case number of segments is odd, adding one last piece to the cake
-        if ((((unsigned int)segments)%2) == 1)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x, center.y);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x, center.y);
-        }
-
-    rlEnd();
-
-    rlSetTexture(0);
-#else
-    rlBegin(RL_TRIANGLES);
-        for (int i = 0; i < segments; i++)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-
-            angle += stepLength;
-        }
-    rlEnd();
-#endif
-}
-
-// Draw a piece of a circle outlines
-void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color)
-{
-    if (startAngle == endAngle) return;
-    if (radius <= 0.0f) radius = 0.1f;  // Avoid div by zero issue
-
-    // Function expects (endAngle > startAngle)
-    if (endAngle < startAngle)
-    {
-        // Swap values
-        float tmp = startAngle;
-        startAngle = endAngle;
-        endAngle = tmp;
-    }
-
-    bool showCapLines = true;
-    // Drawing a whole circle, things get weird without limiting the circle to 360 degrees
-    if (endAngle - startAngle >= 360.0f)
-    {
-        showCapLines = false;
-        endAngle = startAngle + 360.0f;
-    }
-
-    int minSegments = (int)ceilf((endAngle - startAngle)/90);
-
-    if (segments < minSegments)
-    {
-        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
-        segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
-
-        if (segments <= 0) segments = minSegments;
-    }
-
-    float stepLength = (endAngle - startAngle)/(float)segments;
-    float angle = startAngle;
-
-    rlBegin(RL_LINES);
-        if (showCapLines)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-        }
-
-        for (int i = 0; i < segments; i++)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*radius, center.y + sinf(DEG2RAD*(angle + stepLength))*radius);
-
-            angle += stepLength;
-        }
-
-        if (showCapLines)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*radius, center.y + sinf(DEG2RAD*angle)*radius);
-        }
-    rlEnd();
-}
-
-// Draw a piece of a circle outlines with thickness
-void DrawCircleSectorLinesEx(Vector2 center, float radius, float startAngle, float endAngle, int segments, float thick, Color color)
-{
-    if (startAngle == endAngle) return;
-    if (radius <= 0.0f) radius = 0.1f;  // Avoid div by zero issue
-
-    // Function expects (endAngle > startAngle)
-    if (endAngle < startAngle)
-    {
-        // Swap values
-        float tmp = startAngle;
-        startAngle = endAngle;
-        endAngle = tmp;
-    }
-
-    bool showCapLines = true;
-    // Drawing a whole circle, things get weird without limiting the circle to 360 degrees
-    if (endAngle - startAngle >= 360.0f)
-    {
-        showCapLines = thick >= 0.0f;
-        endAngle = startAngle + 360.0f;
-    }
-
-    int minSegments = (int)ceilf((endAngle - startAngle)/90);
-
-    if (segments < minSegments)
-    {
-        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
-        segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
-
-        if (segments <= 0) segments = minSegments;
-    }
-
-    float stepLength = (endAngle - startAngle)/(float)segments;
-    float angle = startAngle;
-
-    /*
-    A sketch to help make things clearer
-
-    NOTE: Some considerations are different when `thick` is negative
-          The vertices used here are still relevant, but would instead be outside of the circle
-          S0 is always the center
-
-    The circle sector outline is drawn in 3 main pieces, the circle outline, cap 1, and cap 2
-    The circle outline is self explanatory
-    Cap 1 covers the `startAngle` edge and cap 2 covers the `endAngle` edge
-    S0 is the first shared point between the caps, and also the circle's center
-    S1 is the second shared point (sometimes not shared) between the caps
-      S1 is also C0 and C3 in this sketch. In certain cases, S1 goes outside of
-      the circle and C0 and C3 become different points
-    C1 is one of cap 1's vertices that is on the inside edge of the circle outline
-    C2 is like C1, but is also on the `startAngle` edge
-    C4 is cap 2's vertex that corresponds with C1
-    C5 is cap 2's vertex that corresponds with C2, except on the `endAngle` edge
-
-                   [][][][][]
-               [][]        []
-             []      []C4[]C5
-           []    [][]  {}  {}
-         []    []      {}  {}
-       []    []        {}C {} <- endAngle
-       []  []          {}a {}
-     []    []          {}p {}
-     []  []            {}2 {}
-     []  []            {}  {}
-     []  []            {}  {}     startAngle
-     []  []            {}  S0{}{}{}{}{}{}{}{}C2[][]
-     []  []            {}{}       Cap1       []  []
-     []  []            S1{}{}{}{}{}{}{}{}{}{}C1  []
-     []  []                                  []  []
-     []    []                              []    []
-       []  []       Not filled in          []  []
-       []    []                          []    []
-         []    []                      []    []
-           []    [][]              [][]    []
-             []      [][][][][][][]      []
-               [][]  Circle outline  [][]
-                   [][][][][][][][][]
-
-    [] = Circle outline edge pixel
-    {} = Cap outline edge pixel
-    */
-
-    // We are not drawing a circle, we are drawing an n-sided polygon
-    // So, we need to adjust the outline thickness of the "circle" for it to look correct with fewer segments
-    float apothem = radius*cosf(DEG2RAD*((endAngle - startAngle)/2.0f)/(float)segments);
-    float radiusThick = thick*(radius/apothem);
-
-    float outerRadius = radius;
-    float innerRadius = radius - radiusThick;
-
-    if (thick >= 0.0f)
-    {
-        if (thick >= innerRadius)
-        {
-            DrawCircleSector(center, radius, startAngle, endAngle, segments, color);
-            return;
-        }
-    }
-    else
-    {
-        float tmp = outerRadius;
-        outerRadius = innerRadius;
-        innerRadius = tmp;
-    }
-
-    // Cap 1 vertices
-    Vector2 c0 = { 0 };
-    Vector2 c1 = { 0 };
-    Vector2 c2 = { 0 };
-
-    // Cap 2 vertices
-    Vector2 c3 = { 0 };
-    Vector2 c4 = { 0 };
-    Vector2 c5 = { 0 };
-
-    // The number of angle steps that come before C1 (from `startAngle`, counter clockwise)
-    int stepsBeforeC1 = 0;
-    bool s1OutsideOfCircle = false;
-    // The number of angle steps that come before C0 (from `startAngle`, counter clockwise)
-    // Only used if S1 is outside of the circle
-    int stepsBeforeC0 = 0;
-
-    if (showCapLines)
-    {
-        if (thick >= 0.0f)
-        {
-            c2 = (Vector2){ center.x + cosf(DEG2RAD*startAngle)*innerRadius, center.y + sinf(DEG2RAD*startAngle)*innerRadius };
-            c5 = (Vector2){ center.x + cosf(DEG2RAD*endAngle)*innerRadius, center.y + sinf(DEG2RAD*endAngle)*innerRadius };
-
-            // For C1 and C4, we need to find the point that lies on the circle (n-sided polygon, actually)
-            // We want C1 and C4 to be `thick` pixels perpendicularly from the `startAngle` and `endAngle` edges
-            // and to be on the `innerRadius` edge
-
-            float c1Angle = RAD2DEG*asinf(thick/innerRadius);
-
-            // There are more segments before C1 than there are segments being drawn,
-            // so the whole circle sector must be covered
-            if (c1Angle/stepLength >= (float)segments)
-            {
-                DrawCircleSector(center, radius, startAngle, endAngle, segments, color);
-                return;
-            }
-
-            // Do this after the previous check just in case `stepLength` is really small and
-            // dividing by it produces a very large number
-            stepsBeforeC1 = (int)(c1Angle/stepLength);
-
-            // The angles of the vertices on the circle outline before and after C1
-            float vertexAngleBeforeC1 = stepLength*(float)stepsBeforeC1;
-            float vertexAngleAfterC1 = stepLength*((float)(stepsBeforeC1 + 1));
-
-            /*
-            Here is another sketch
-
-            We know which outline line segment C1 is on (`vertexAngleBeforeC1` and `vertexAngleAfterC1`)
-            Now we just need to know where on that line segment C1 is
-
-            We can change our frame of reference so that `startAngle` is 0 degrees and `center` is at the origin (0, 0)
-            This makes the math much simpler because now we can just go straight down by `thick` pixels and
-            use the horizontal line that passes through that point to determine where C1 is on our line segment
-
-            The line segment is defined by p1 and p2, we need C1, which is on that edge
-            The 'y' axis of C1 is equal to `thick` (within this modified frame of reference)
-
-                         p1
-                         /|
-                        / |
-                       /  |
-                      /   |
-                     /    |
-                    /     |
-                   /      |
-                  /       |
-                C1---------  <-- y axis = `thick`
-                /
-               /
-             p2
-            */
-
-            Vector2 p1 = { cosf(DEG2RAD*vertexAngleBeforeC1)*innerRadius, sinf(DEG2RAD*vertexAngleBeforeC1)*innerRadius };
-            Vector2 p2 = { cosf(DEG2RAD*vertexAngleAfterC1)*innerRadius, sinf(DEG2RAD*vertexAngleAfterC1)*innerRadius };
-
-            // Find the `t` of C1 between p1 and p2 ('t' as in `Lerp(start, end, t)`)
-            // This is used to lerp between the actual vertices (outside of our modified frame of reference)
-            // before and after C1
-            float t = (p1.y - thick)/(p1.y - p2.y);
-
-            Vector2 vertexBeforeCap1Vertex = { center.x + cosf(DEG2RAD*(startAngle + vertexAngleBeforeC1))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + vertexAngleBeforeC1))*innerRadius };
-            Vector2 vertexAfterCap1Vertex = { center.x + cosf(DEG2RAD*(startAngle + vertexAngleAfterC1))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + vertexAngleAfterC1))*innerRadius };
-
-            c1.x = vertexBeforeCap1Vertex.x + (vertexAfterCap1Vertex.x - vertexBeforeCap1Vertex.x)*t;
-            c1.y = vertexBeforeCap1Vertex.y + (vertexAfterCap1Vertex.y - vertexBeforeCap1Vertex.y)*t;
-
-            Vector2 vertexBeforeCap2Vertex = { center.x + cosf(DEG2RAD*(endAngle - vertexAngleBeforeC1))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - vertexAngleBeforeC1))*innerRadius };
-            Vector2 vertexAfterCap2Vertex = { center.x + cosf(DEG2RAD*(endAngle - vertexAngleAfterC1))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - vertexAngleAfterC1))*innerRadius };
-
-            c4.x = vertexBeforeCap2Vertex.x + (vertexAfterCap2Vertex.x - vertexBeforeCap2Vertex.x)*t;
-            c4.y = vertexBeforeCap2Vertex.y + (vertexAfterCap2Vertex.y - vertexBeforeCap2Vertex.y)*t;
-
-            /*
-            Another sketch couldn't hurt
-
-            This is a "zoomed in" view of the center of the circle sector
-            You can see where S0 is, and where we want S1 to be
-            `innerAngleBetweenCapEnds` is the angle of the diagonal line ('//') between the cap ends
-            `S1Length` is the length of that line
-
-            Since the caps are always parallel to `startAngle` and `endAngle`,
-            we always have a right triangle we can use to determine where S1 is
-
-             []      []
-             []      []
-             []  C   [] <- endAngle
-             []  a   []
-             []  p   []
-             []  2   []  startAngle
-             [][][][]S0[][][][][][]
-                   //[]
-                 //  [] Cap 1
-               //    []
-             S1      [][][][][][][]
-            */
-
-            float innerAngleBetweenCapEnds = ((endAngle - 90.0f) - (startAngle + 90.0f))/2.0f;
-            float s1Length = thick/cosf(DEG2RAD*innerAngleBetweenCapEnds);
-
-            // As `startAngle` and `endAngle` draw more of a circle, S1 goes further out from the center
-            // It can go so far that it is outside of the circle, by a lot
-            // This case needs to be detected and handled
-            // If S1 is within the circle, nothing special needs to happen
-            // But, if S1 is outside of the circle, we need to find the two points (C0 and C3) where
-            // the line segments C0->C1 and C0->C3 intersect the circle outline,
-            // using the same method we used to find C1 and C4
-            if ((innerAngleBetweenCapEnds < 90.0f) && (s1Length <= innerRadius))
-            {
-                // S1 is inside of the circle
-
-                float betweenStartAndEndAngle = (endAngle + startAngle)/2.0f;
-                c0 = (Vector2){ center.x + cosf(DEG2RAD*betweenStartAndEndAngle)*s1Length, center.y + sinf(DEG2RAD*betweenStartAndEndAngle)*s1Length };
-                c3 = c0;
-
-                p1 = (Vector2){ c1.x - center.x, c1.y - center.y };
-                p2 = (Vector2){ c0.x - center.x, c0.y - center.y };
-
-                // Copied from "raymath.h" Vector2Angle()
-                float dot = p1.x*p2.x + p1.y*p2.y;
-                float det = p1.x*p2.y - p1.y*p2.x;
-                float c1ToS1Angle = atan2f(det, dot);
-
-                // If C1 and C4 are on the wrong side of S1, the whole circle sector is covered
-                if (c1ToS1Angle < 0.0f)
-                {
-                    DrawCircleSector(center, radius, startAngle, endAngle, segments, color);
-                    return;
-                }
-            }
-            else
-            {
-                // S1 is outside of the circle
-
-                if (endAngle - startAngle <= 180.0f)
-                {
-                    DrawCircleSector(center, radius, startAngle, endAngle, segments, color);
-                    return;
-                }
-
-                s1OutsideOfCircle = true;
-
-                stepsBeforeC0 = (int)((180.0f + RAD2DEG*asinf(thick/-innerRadius))/stepLength);
-
-                // Reuse the code for finding C1 and C4 to find C0 and C3
-
-                float vertexAngleBeforeC0 = stepLength*(float)stepsBeforeC0;
-                float vertexAngleAfterC0 = stepLength*((float)(stepsBeforeC0 + 1));
-
-                p1 = (Vector2){ cosf(DEG2RAD*vertexAngleBeforeC0)*innerRadius, sinf(DEG2RAD*vertexAngleBeforeC0)*innerRadius };
-                p2 = (Vector2){ cosf(DEG2RAD*vertexAngleAfterC0)*innerRadius, sinf(DEG2RAD*vertexAngleAfterC0)*innerRadius };
-
-                t = (p1.y - thick)/(p1.y - p2.y);
-
-                vertexBeforeCap1Vertex = (Vector2){ center.x + cosf(DEG2RAD*(startAngle + vertexAngleBeforeC0))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + vertexAngleBeforeC0))*innerRadius };
-                vertexAfterCap1Vertex = (Vector2){ center.x + cosf(DEG2RAD*(startAngle + vertexAngleAfterC0))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + vertexAngleAfterC0))*innerRadius };
-
-                c0.x = vertexBeforeCap1Vertex.x + (vertexAfterCap1Vertex.x - vertexBeforeCap1Vertex.x)*t;
-                c0.y = vertexBeforeCap1Vertex.y + (vertexAfterCap1Vertex.y - vertexBeforeCap1Vertex.y)*t;
-
-                vertexBeforeCap2Vertex = (Vector2){ center.x + cosf(DEG2RAD*(endAngle - vertexAngleBeforeC0))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - vertexAngleBeforeC0))*innerRadius };
-                vertexAfterCap2Vertex = (Vector2){ center.x + cosf(DEG2RAD*(endAngle - vertexAngleAfterC0))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - vertexAngleAfterC0))*innerRadius };
-
-                c3.x = vertexBeforeCap2Vertex.x + (vertexAfterCap2Vertex.x - vertexBeforeCap2Vertex.x)*t;
-                c3.y = vertexBeforeCap2Vertex.y + (vertexAfterCap2Vertex.y - vertexBeforeCap2Vertex.y)*t;
-            }
-        }
-        else
-        {
-            float outerAngleBetweenCapEnds = ((endAngle + 90.0f) - (startAngle - 90.0f))/2.0f;
-            float s1Length = thick/cosf(DEG2RAD*outerAngleBetweenCapEnds);
-            float betweenStartAndEndAngle = 180.0f + (endAngle + startAngle)/2.0f;
-            c0 = (Vector2){ center.x + cosf(DEG2RAD*betweenStartAndEndAngle)*s1Length, center.y + sinf(DEG2RAD*betweenStartAndEndAngle)*s1Length };
-            c3 = c0;
-
-            c2 = (Vector2){ center.x + cosf(DEG2RAD*startAngle)*outerRadius, center.y + sinf(DEG2RAD*startAngle)*outerRadius };
-            c5 = (Vector2){ center.x + cosf(DEG2RAD*endAngle)*outerRadius, center.y + sinf(DEG2RAD*endAngle)*outerRadius };
-
-            // Change the frame of reference so that `center` is the origin and `startAngle` is 0 degrees
-
-            Vector2 c0Translated = { c0.x - center.x, c0.y - center.y };
-            Vector2 circleVertex1 = { c2.x - center.x, c2.y - center.y };
-            Vector2 circleVertex2 = { cosf(DEG2RAD*(startAngle + stepLength))*outerRadius, sinf(DEG2RAD*(startAngle + stepLength))*outerRadius };
-
-            // Copied from "raymath.h" Vector2Rotate()
-            float tempX = c0Translated.x;
-            c0Translated.x = cosf(-DEG2RAD*startAngle)*tempX - sinf(-DEG2RAD*startAngle)*c0Translated.y;
-            c0Translated.y = sinf(-DEG2RAD*startAngle)*tempX + cosf(-DEG2RAD*startAngle)*c0Translated.y;
-
-            tempX = circleVertex1.x;
-            circleVertex1.x = cosf(-DEG2RAD*startAngle)*tempX - sinf(-DEG2RAD*startAngle)*circleVertex1.y;
-            circleVertex1.y = sinf(-DEG2RAD*startAngle)*tempX + cosf(-DEG2RAD*startAngle)*circleVertex1.y;
-
-            tempX = circleVertex2.x;
-            circleVertex2.x = cosf(-DEG2RAD*startAngle)*tempX - sinf(-DEG2RAD*startAngle)*circleVertex2.y;
-            circleVertex2.y = sinf(-DEG2RAD*startAngle)*tempX + cosf(-DEG2RAD*startAngle)*circleVertex2.y;
-
-            // Figure out the line that `circleVertex1` and `circleVertex2` are on
-            float rise = circleVertex1.y - circleVertex2.y;
-            float run = circleVertex1.x - circleVertex2.x;
-            // Get where that line intersects the horizontal line that `c0Translated` is on
-            float c1Rise = c0Translated.y - circleVertex1.y;
-            float c1Run = (c1Rise/rise)*run;
-            float c1DistanceFromC0 = (circleVertex1.x + c1Run) - c0Translated.x;
-
-            c1 = (Vector2){ c0.x + cosf(DEG2RAD*startAngle)*c1DistanceFromC0, c0.y + sinf(DEG2RAD*startAngle)*c1DistanceFromC0 };
-            c4 = (Vector2){ c0.x + cosf(DEG2RAD*endAngle)*c1DistanceFromC0, c0.y + sinf(DEG2RAD*endAngle)*c1DistanceFromC0 };
-
-            if (c1DistanceFromC0 < 0.0f)
-            {
-                // The caps are intersecting each other
-
-                Vector2 circleVertex3 = { c5.x - center.x, c5.y - center.y };
-                Vector2 circleVertex4 = { cosf(DEG2RAD*(endAngle - stepLength))*outerRadius, sinf(DEG2RAD*(endAngle - stepLength))*outerRadius };
-
-                tempX = circleVertex3.x;
-                circleVertex3.x = cosf(-DEG2RAD*startAngle)*tempX - sinf(-DEG2RAD*startAngle)*circleVertex3.y;
-                circleVertex3.y = sinf(-DEG2RAD*startAngle)*tempX + cosf(-DEG2RAD*startAngle)*circleVertex3.y;
-
-                tempX = circleVertex4.x;
-                circleVertex4.x = cosf(-DEG2RAD*startAngle)*tempX - sinf(-DEG2RAD*startAngle)*circleVertex4.y;
-                circleVertex4.y = sinf(-DEG2RAD*startAngle)*tempX + cosf(-DEG2RAD*startAngle)*circleVertex4.y;
-
-                // `startAngle` is 0 degrees within this frame of reference,
-                // so C1 just goes horizontally out from C0
-                Vector2 c1Translated = { c0Translated.x + c1DistanceFromC0, c0Translated.y };
-
-                // Make `circleVertex2` the origin
-                circleVertex1.x -= circleVertex2.x;
-                circleVertex1.y -= circleVertex2.y;
-                circleVertex3.x -= circleVertex2.x;
-                circleVertex3.y -= circleVertex2.y;
-                circleVertex4.x -= circleVertex2.x;
-                circleVertex4.y -= circleVertex2.y;
-                c1Translated.x -= circleVertex2.x;
-                c1Translated.y -= circleVertex2.y;
-
-                // Make the line between `circleVertex1` and `circleVertex2` a horizontal line
-                float theta = atan2f(circleVertex1.y, circleVertex1.x);
-
-                // Copied from "raymath.h" Vector2Rotate()
-                tempX = circleVertex1.x;
-                circleVertex1.x = cosf(-theta)*tempX - sinf(-theta)*circleVertex1.y;
-                circleVertex1.y = sinf(-theta)*tempX + cosf(-theta)*circleVertex1.y;
-
-                tempX = circleVertex3.x;
-                circleVertex3.x = cosf(-theta)*tempX - sinf(-theta)*circleVertex3.y;
-                circleVertex3.y = sinf(-theta)*tempX + cosf(-theta)*circleVertex3.y;
-
-                tempX = circleVertex4.x;
-                circleVertex4.x = cosf(-theta)*tempX - sinf(-theta)*circleVertex4.y;
-                circleVertex4.y = sinf(-theta)*tempX + cosf(-theta)*circleVertex4.y;
-
-                tempX = c1Translated.x;
-                c1Translated.x = cosf(-theta)*tempX - sinf(-theta)*c1Translated.y;
-                c1Translated.y = sinf(-theta)*tempX + cosf(-theta)*c1Translated.y;
-
-                // Find where the line that `circleVertex3` and `circleVertex4` are on would intersect the
-                // line segment defined by `circleVertex1` and `c1Translated`
-                rise = circleVertex3.y - circleVertex4.y;
-                run = circleVertex3.x - circleVertex4.x;
-                float targetRise = -circleVertex3.y;
-                float targetX = circleVertex3.x + (targetRise/rise)*run;
-
-                float t = (c1Translated.x - targetX)/(c1Translated.x - circleVertex1.x);
-
-                c1 = (Vector2){ c1.x + (c2.x - c1.x)*t, c1.y + (c2.y - c1.y)*t };
-                c4 = c1;
-                c0 = c1;
-                c3 = c1;
-            }
-
-            // Swap vertices to correct the winding order
-            Vector2 temp = c0;
-            c0 = c2;
-            c2 = temp;
-
-            temp = c3;
-            c3 = c5;
-            c5 = temp;
-        }
-    }
-
-#if SUPPORT_QUADS_DRAW_MODE
-    rlSetTexture(GetShapesTexture().id);
-    Rectangle shapeRect = GetShapesTextureRectangle();
-
-    rlBegin(RL_QUADS);
-
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        // Draw the circle outline
-        for (int i = 0; i < segments; i++)
-        {
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-
-            angle += stepLength;
-        }
-
-        // Draw the caps
-        if (showCapLines)
-        {
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x, center.y);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(c0.x, c0.y);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(c1.x, c1.y);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(c2.x, c2.y);
-
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x, center.y);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(c5.x, c5.y);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(c4.x, c4.y);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(c3.x, c3.y);
-
-            // Some extra work may be needed when `thick` is positive
-            if (thick >= 0.0f)
-            {
-                // Fill in the gaps between cap 1 and the circle outline and cap 2 and the circle outline
-                if (stepsBeforeC1 > 0)
-                {
-                    // Draw quads using pairs of vertices on the circle outline
-                    angle = 0;
-                    for (int i = 0; i < stepsBeforeC1/2; i++)
-                    {
-                        // Cap1
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(c1.x, c1.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + (angle + stepLength*2.0f)))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + (angle + stepLength*2.0f)))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + (angle + stepLength)))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + (angle + stepLength)))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerRadius);
-
-                        // Cap2
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(c4.x, c4.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - (angle + stepLength)))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - (angle + stepLength)))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - (angle + stepLength*2.0f)))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - (angle + stepLength*2.0f)))*innerRadius);
-
-                        angle += stepLength*2.0f;
-                    }
-
-                    if (stepsBeforeC1%2 == 1)
-                    {
-                        // Cap1
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(c1.x, c1.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(c1.x, c1.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + (angle + stepLength)))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + (angle + stepLength)))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerRadius);
-
-                        // Cap2
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(c4.x, c4.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(c4.x, c4.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - (angle + stepLength)))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - (angle + stepLength)))*innerRadius);
-                    }
-                }
-
-                // Fill in the gap between C0, C3 and the circle outline
-                if (s1OutsideOfCircle)
-                {
-                    int verticesBetweenC0andC3 = (segments - stepsBeforeC0*2) - 1;
-
-                    // No gap to fill
-                    if (verticesBetweenC0andC3 == 0)
-                    {
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x, center.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x, center.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(c3.x, c3.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(c0.x, c0.y);
-                    }
-                    // There's a gap to fill
-                    else
-                    {
-                        // Triangle touching C0
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x, center.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x, center.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(c0.x, c0.y);
-
-                        // Triangle touching C3
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x, center.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(center.x, center.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(c3.x, c3.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius);
-
-                        // Triangles between the previous two
-                        verticesBetweenC0andC3 -= 1;
-                        angle = startAngle + stepLength*(stepsBeforeC0 + 1);
-                        for (int i = 0; i < verticesBetweenC0andC3/2; i++)
-                        {
-                            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                            rlVertex2f(center.x, center.y);
-
-                            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength*2.0f))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength*2.0f))*innerRadius);
-
-                            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-                            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-
-                            angle += stepLength*2.0f;
-                        }
-
-                        if (verticesBetweenC0andC3%2 == 1)
-                        {
-                            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                            rlVertex2f(center.x, center.y);
-
-                            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                            rlVertex2f(center.x, center.y);
-
-                            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-                            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-                        }
-                    }
-                }
-            }
-        }
-    rlEnd();
-
-    rlSetTexture(0);
-#else
-    rlBegin(RL_TRIANGLES);
-
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        // Draw the circle outline
-        for (int i = 0; i < segments; i++)
-        {
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-
-            angle += stepLength;
-        }
-
-        // Draw the caps
-        if (showCapLines)
-        {
-            // Cap 1
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(c0.x, c0.y);
-            rlVertex2f(c1.x, c1.y);
-
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(c1.x, c1.y);
-            rlVertex2f(c2.x, c2.y);
-
-            // Cap 2
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(c5.x, c5.y);
-            rlVertex2f(c4.x, c4.y);
-
-            rlVertex2f(center.x, center.y);
-            rlVertex2f(c4.x, c4.y);
-            rlVertex2f(c3.x, c3.y);
-
-            // Some extra work may be needed when `thick` is positive
-            if (thick >= 0.0f)
-            {
-                // Fill in the gaps between cap 1 and the circle outline and cap 2 and the circle outline
-                if (stepsBeforeC1 > 0)
-                {
-                    angle = 0;
-                    for (int i = 0; i < stepsBeforeC1; i++)
-                    {
-                        // Cap 1
-                        rlVertex2f(c1.x, c1.y);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + (angle + stepLength)))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + (angle + stepLength)))*innerRadius);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerRadius);
-
-                        // Cap 2
-                        rlVertex2f(c4.x, c4.y);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerRadius);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - (angle + stepLength)))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - (angle + stepLength)))*innerRadius);
-
-                        angle += stepLength;
-                    }
-                }
-
-                // Fill in the gap between C0, C3 and the circle outline
-                if (s1OutsideOfCircle)
-                {
-                    int verticesBetweenC0andC3 = (segments - stepsBeforeC0*2) - 1;
-
-                    // No gap to fill
-                    if (verticesBetweenC0andC3 == 0)
-                    {
-                        rlVertex2f(center.x, center.y);
-                        rlVertex2f(c3.x, c3.y);
-                        rlVertex2f(c0.x, c0.y);
-                    }
-                    // There's a gap to fill
-                    else
-                    {
-                        // Triangle touching C0
-                        rlVertex2f(center.x, center.y);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius, center.y + sinf(DEG2RAD*(startAngle + stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius);
-                        rlVertex2f(c0.x, c0.y);
-
-                        // Triangle touching C3
-                        rlVertex2f(center.x, center.y);
-                        rlVertex2f(c3.x, c3.y);
-                        rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius, center.y + sinf(DEG2RAD*(endAngle - stepLength*(float)(stepsBeforeC0 + 1)))*innerRadius);
-
-                        // Triangles between the previous two
-                        verticesBetweenC0andC3 -= 1;
-                        angle = startAngle + stepLength*(stepsBeforeC0 + 1);
-                        for (int i = 0; i < verticesBetweenC0andC3; i++)
-                        {
-                            rlVertex2f(center.x, center.y);
-                            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-                            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-
-                            angle += stepLength;
-                        }
-                    }
-                }
-            }
-        }
-
-    rlEnd();
-#endif
-}
-
-// Draw circle outline
-void DrawCircleLines(int centerX, int centerY, float radius, Color color)
-{
-    DrawCircleLinesV((Vector2){ (float)centerX, (float)centerY }, radius, color);
-}
-
-// Draw circle outline (Vector version)
-void DrawCircleLinesV(Vector2 center, float radius, Color color)
-{
-    rlBegin(RL_LINES);
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        // NOTE: Circle outline is drawn pixel by pixel every degree (0 to 360)
-        for (int i = 0; i < 360; i += 10)
-        {
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*radius, center.y + sinf(DEG2RAD*i)*radius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radius, center.y + sinf(DEG2RAD*(i + 10))*radius);
-        }
-    rlEnd();
-}
-
-void DrawCircleLinesEx(Vector2 center, float radius, float thick, Color color)
-{
-    DrawRing(center, radius - thick, radius, 0.0f, 360.0f, 36, color);
-}
-
-// Draw ellipse
-void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color)
-{
-    DrawEllipseV((Vector2){ (float)centerX, (float)centerY }, radiusH, radiusV, color);
-}
-
-// Draw ellipse (Vector version)
-void DrawEllipseV(Vector2 center, float radiusH, float radiusV, Color color)
-{
-    rlBegin(RL_TRIANGLES);
-        for (int i = 0; i < 360; i += 10)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(center.x,  center.y);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radiusH, center.y + sinf(DEG2RAD*(i + 10))*radiusV);
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*radiusH, center.y + sinf(DEG2RAD*i)*radiusV);
-        }
-    rlEnd();
-}
-
-// Draw ellipse outline
-void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color)
-{
-    DrawEllipseLinesV((Vector2){ (float)centerX, (float)centerY }, radiusH, radiusV, color);
-}
-
-// Draw ellipse outline
-void DrawEllipseLinesV(Vector2 center, float radiusH, float radiusV, Color color)
-{
-    rlBegin(RL_LINES);
-        for (int i = 0; i < 360; i += 10)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*radiusH, center.y + sinf(DEG2RAD*(i + 10))*radiusV);
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*radiusH, center.y + sinf(DEG2RAD*i)*radiusV);
-        }
-    rlEnd();
-}
-
-// Draw ellipse outline with thickness
-void DrawEllipseLinesEx(Vector2 center, float radiusH, float radiusV, float thick, Color color)
-{
-    float outerRadiusH = radiusH, innerRadiusH = radiusH - thick;
-    float outerRadiusV = radiusV, innerRadiusV = radiusV - thick;
-
-    if (thick >= 0.0f) {
-        // Just a filled-in ellipse
-        if (innerRadiusH <= 0.0f || innerRadiusV <= 0.0f)
-        {
-            DrawEllipseV(center, radiusH, radiusV, color);
-            return;
-        }
-    }
-    else
-    {
-        // The outline is growing outside of the ellipse, so swap the inner and outer radius
-        float tmp = outerRadiusH;
-        outerRadiusH = innerRadiusH;
-        innerRadiusH = tmp;
-
-        tmp = outerRadiusV;
-        outerRadiusV = innerRadiusV;
-        innerRadiusV = tmp;
-    }
-
-#if SUPPORT_QUADS_DRAW_MODE
-    rlSetTexture(GetShapesTexture().id);
-    Rectangle shapeRect = GetShapesTextureRectangle();
-
-    rlBegin(RL_QUADS);
-
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        for (int i = 0; i < 360; i += 10)
-        {
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*innerRadiusH, center.y + sinf(DEG2RAD*i)*innerRadiusV);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*innerRadiusH, center.y + sinf(DEG2RAD*(i + 10))*innerRadiusV);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*outerRadiusH, center.y + sinf(DEG2RAD*(i + 10))*outerRadiusV);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*outerRadiusH, center.y + sinf(DEG2RAD*i)*outerRadiusV);
-        }
-    rlEnd();
-
-    rlSetTexture(0);
-#else
-    rlBegin(RL_TRIANGLES);
-
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        for (int i = 0; i < 360; i += 10)
-        {
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*innerRadiusH, center.y + sinf(DEG2RAD*i)*innerRadiusV);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*innerRadiusH, center.y + sinf(DEG2RAD*(i + 10))*innerRadiusV);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*outerRadiusH, center.y + sinf(DEG2RAD*(i + 10))*outerRadiusV);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*innerRadiusH, center.y + sinf(DEG2RAD*i)*innerRadiusV);
-            rlVertex2f(center.x + cosf(DEG2RAD*(i + 10))*outerRadiusH, center.y + sinf(DEG2RAD*(i + 10))*outerRadiusV);
-            rlVertex2f(center.x + cosf(DEG2RAD*i)*outerRadiusH, center.y + sinf(DEG2RAD*i)*outerRadiusV);
-        }
-    rlEnd();
-#endif
-}
-
-// Draw ring
-void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color)
-{
-    if (startAngle == endAngle) return;
-
-    // Function expects (outerRadius > innerRadius)
-    if (outerRadius < innerRadius)
-    {
-        float tmp = outerRadius;
-        outerRadius = innerRadius;
-        innerRadius = tmp;
-
-        if (outerRadius <= 0.0f) outerRadius = 0.1f;
-    }
-
-    // Function expects (endAngle > startAngle)
-    if (endAngle < startAngle)
-    {
-        // Swap values
-        float tmp = startAngle;
-        startAngle = endAngle;
-        endAngle = tmp;
-    }
-
-    // Drawing a whole circle, things get weird without limiting the circle to 360 degrees
-    if (endAngle - startAngle >= 360.0f) endAngle = startAngle + 360.0f;
-
-    int minSegments = (int)ceilf((endAngle - startAngle)/90);
-
-    if (segments < minSegments)
-    {
-        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
-        segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
-
-        if (segments <= 0) segments = minSegments;
-    }
-
-    // Not a ring
-    if (innerRadius <= 0.0f)
-    {
-        DrawCircleSector(center, outerRadius, startAngle, endAngle, segments, color);
-        return;
-    }
-
-    float stepLength = (endAngle - startAngle)/(float)segments;
-    float angle = startAngle;
-
-#if SUPPORT_QUADS_DRAW_MODE
-    rlSetTexture(GetShapesTexture().id);
-    Rectangle shapeRect = GetShapesTextureRectangle();
-
-    rlBegin(RL_QUADS);
-        for (int i = 0; i < segments; i++)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-
-            angle += stepLength;
-        }
-    rlEnd();
-
-    rlSetTexture(0);
-#else
-    rlBegin(RL_TRIANGLES);
-        for (int i = 0; i < segments; i++)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-
-            angle += stepLength;
-        }
-    rlEnd();
-#endif
-}
-
-// Draw ring outline
-void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color)
-{
-    if (startAngle == endAngle) return;
-
-    // Function expects (outerRadius > innerRadius)
-    if (outerRadius < innerRadius)
-    {
-        float tmp = outerRadius;
-        outerRadius = innerRadius;
-        innerRadius = tmp;
-
-        if (outerRadius <= 0.0f) outerRadius = 0.1f;
-    }
-
-    // Function expects (endAngle > startAngle)
-    if (endAngle < startAngle)
-    {
-        // Swap values
-        float tmp = startAngle;
-        startAngle = endAngle;
-        endAngle = tmp;
-    }
-
-    bool showCapLines = true;
-    // Drawing a whole circle, things get weird without limiting the circle to 360 degrees
-    if (endAngle - startAngle >= 360.0f)
-    {
-        showCapLines = false;
-        endAngle = startAngle + 360.0f;
-    }
-
-    int minSegments = (int)ceilf((endAngle - startAngle)/90);
-
-    if (segments < minSegments)
-    {
-        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
-        segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
-
-        if (segments <= 0) segments = minSegments;
-    }
-
-    if (innerRadius <= 0.0f)
-    {
-        DrawCircleSectorLines(center, outerRadius, startAngle, endAngle, segments, color);
-        return;
-    }
-
-    float stepLength = (endAngle - startAngle)/(float)segments;
-    float angle = startAngle;
-
-    rlBegin(RL_LINES);
-        if (showCapLines)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-        }
-
-        for (int i = 0; i < segments; i++)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerRadius);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerRadius);
-
-            angle += stepLength;
-        }
-
-        if (showCapLines)
-        {
-            rlColor4ub(color.r, color.g, color.b, color.a);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerRadius, center.y + sinf(DEG2RAD*angle)*outerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerRadius, center.y + sinf(DEG2RAD*angle)*innerRadius);
-        }
-    rlEnd();
-}
-
-// Draw ring outline with line thickness
-void DrawRingLinesEx(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, float thick, Color color)
-{
-    if (startAngle == endAngle) return;
-
-    // Function expects (outerRadius > innerRadius)
-    if (outerRadius < innerRadius)
-    {
-        float tmp = outerRadius;
-        outerRadius = innerRadius;
-        innerRadius = tmp;
-
-        if (outerRadius <= 0.0f) outerRadius = 0.1f;
-    }
-
-    // Function expects (endAngle > startAngle)
-    if (endAngle < startAngle)
-    {
-        // Swap values
-        float tmp = startAngle;
-        startAngle = endAngle;
-        endAngle = tmp;
-    }
-
-    bool showCapLines = true;
-    // Drawing a whole circle, things get weird without limiting the circle to 360 degrees
-    if (endAngle - startAngle >= 360.0f)
-    {
-        showCapLines = thick >= 0.0f;
-        endAngle = startAngle + 360.0f;
-    }
-
-    int minSegments = (int)ceilf((endAngle - startAngle)/90);
-
-    if (segments < minSegments)
-    {
-        // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
-        float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
-        segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
-
-        if (segments <= 0) segments = minSegments;
-    }
-
-    float stepLength = (endAngle - startAngle)/(float)segments;
-
-    // We are not drawing a circle, we are drawing an n-sided polygon
-    // So, we need to adjust the outline thickness of the "circle" for it to look correct with fewer segments
-    float apothem = outerRadius*cosf(DEG2RAD*((endAngle - startAngle)/2.0f)/(float)segments);
-    float radiusThick = thick*(outerRadius/apothem);
-
-    // These names can be confusing, but they are useful
-    // Since 2 rings are being drawn, there are 4 radiuses (or radii)
-    // "Inner" means closer to the center, "outer" means farther from the center
-    // Sorted from farthest to closest you get:
-    //   1. outerOuterRadius (farthest)
-    //   2. innerOuterRadius
-    //   3. outerInnerRadius
-    //   4. innerInnerRadius (closest)
-    float innerOuterRadius = 0.0f;
-    float outerOuterRadius = 0.0f;
-    float innerInnerRadius = 0.0f;
-    float outerInnerRadius = 0.0f;
-
-    if (thick >= 0.0f)
-    {
-        innerRadius = fmaxf(0.0f, innerRadius);
-
-        // Just a filled-in ring
-        if (radiusThick > (outerRadius - innerRadius)/2.0f)
-        {
-            DrawRing(center, innerRadius, outerRadius, startAngle, endAngle, segments, color);
-            return;
-        }
-
-        innerInnerRadius = innerRadius;
-        outerInnerRadius = innerInnerRadius + radiusThick;
-
-        outerOuterRadius = outerRadius;
-        innerOuterRadius = outerOuterRadius - radiusThick;
-    }
-    else
-    {
-        // Just a circle sector outline
-        if (innerRadius <= 0.0f)
-        {
-            DrawCircleSectorLinesEx(center, outerRadius, startAngle, endAngle, segments, thick, color);
-            return;
-        }
-
-        outerInnerRadius = innerRadius;
-        innerInnerRadius = fmaxf(0.0f, outerInnerRadius + radiusThick);
-
-        innerOuterRadius = outerRadius;
-        outerOuterRadius = innerOuterRadius - radiusThick;
-    }
-
-    // For positive `thick` values
-    int stepsBeforeInner = 0;
-    int stepsBeforeOuter = 0;
-    float tInner = 0.0f;
-    float tOuter = 0.0f;
-    bool innerAnglesCrossEachOther = false;
-
-    // For negative `thick` values
-    Vector2 cap1SecondInnerVertex = { 0 };
-    Vector2 cap1SecondOuterVertex = { 0 };
-    Vector2 cap2SecondInnerVertex = { 0 };
-    Vector2 cap2SecondOuterVertex = { 0 };
-    bool capsIntersect = false;
-    Vector2 capIntersectionVertex = { 0 };
-
-    if (showCapLines)
-    {
-        if (thick >= 0.0f)
-        {
-            // Get the angle of the arc that has `thick` length along the inner and outer radii
-            float cap1InnerAngleEnd = RAD2DEG*(thick/outerInnerRadius);
-            float cap1OuterAngleEnd = RAD2DEG*(thick/innerOuterRadius);
-
-            // Just a filled-in ring
-            if (endAngle - startAngle < cap1OuterAngleEnd*2.0f)
-            {
-                DrawRing(center, innerRadius, outerRadius, startAngle, endAngle, segments, color);
-                return;
-            }
-
-            if (endAngle - startAngle < cap1InnerAngleEnd*2.0f) innerAnglesCrossEachOther = true;
-
-            stepsBeforeInner = (int)(cap1InnerAngleEnd/stepLength);
-            stepsBeforeOuter = (int)(cap1OuterAngleEnd/stepLength);
-
-            // We need to find where `cap1InnerAngleEnd` intersects the edge defined
-            // by `beforeInnerVertex` and `afterInnerVertex`
-            //
-            // We can make this easy by making `center` the origin (0, 0) and
-            // making `cap1InnerAngleEnd` 0 degrees (a horizontal line)
-            //
-            // With that, we know these lines intersect when 'y' equals 0,
-            // so we just need to solve for 't' (as in `Lerp(start, end, t)`)
-            Vector2 beforeInnerVertex = { cosf(DEG2RAD*((float)stepsBeforeInner*stepLength - cap1InnerAngleEnd))*outerInnerRadius, sinf(DEG2RAD*((float)stepsBeforeInner*stepLength - cap1InnerAngleEnd))*outerInnerRadius };
-            Vector2 afterInnerVertex = { cosf(DEG2RAD*((float)(stepsBeforeInner + 1)*stepLength - cap1InnerAngleEnd))*outerInnerRadius, sinf(DEG2RAD*((float)(stepsBeforeInner + 1)*stepLength - cap1InnerAngleEnd))*outerInnerRadius };
-            tInner = beforeInnerVertex.y/(beforeInnerVertex.y - afterInnerVertex.y);
-
-            // The same as above, but for the outer edge
-            Vector2 beforeOuterVertex = { cosf(DEG2RAD*((float)stepsBeforeOuter*stepLength - cap1OuterAngleEnd))*innerOuterRadius, sinf(DEG2RAD*((float)stepsBeforeOuter*stepLength - cap1OuterAngleEnd))*innerOuterRadius };
-            Vector2 afterOuterVertex = { cosf(DEG2RAD*((float)(stepsBeforeOuter + 1)*stepLength - cap1OuterAngleEnd))*innerOuterRadius, sinf(DEG2RAD*((float)(stepsBeforeOuter + 1)*stepLength - cap1OuterAngleEnd))*innerOuterRadius };
-            tOuter = beforeOuterVertex.y/(beforeOuterVertex.y - afterOuterVertex.y);
-        }
-        else
-        {
-            // "Cap 1" is the outline on `startAngle` and "Cap 2" is the outline on `endAngle`
-
-            /*
-            A sketch to help make all this a little more understandable
-            (This is an overly simplified representation of cap 1)
-
-             I2[][][][][]O2  <- y = thick
-             []          []
-             []          []
-             I0----------O0  <- angle = 0 degrees, y = 0
-             []          []
-             I1          O1  <- angle = stepLength
-
-            Cap 2 is a mirror copy of cap 1, the inside and outside vertices switch sides
-
-            We're using a frame of reference where `center` is (0, 0) and `startAngle` is 0 degrees
-
-            I0 is `innerInnerRadius` distance from `center` at `starAngle`
-            I1 is `innerInnerRadius` distance from `center` at `starAngle + stepLength`
-            I2 goes out from I0 perpendicular to `startAngle`
-            O0 is the same as I0, except using `outerOuterRadius` instead of `innerInnerRadius`
-            O1 is the same as I1, except using `outerOuterRadius` instead of `innerInnerRadius`
-            O2 is the same as I2, except goes out from O0
-
-            The intersection cases between the caps edges are:
-              1. No intersections, easy
-              2. The I0->I2 and I2->O2 edges intersect between the caps
-              3. The I0->I2 and O0->O2 edges intersect between the caps
-
-            Notice that cap 1 and 2's I2->O2 and O0->O2 edges can't intersect at the same time,
-            and, if there's any intersection, I0->I2 is one of the edges
-            */
-
-            Vector2 cap1O0 = { outerOuterRadius, 0.0f };
-            Vector2 cap1O1 = { cosf(DEG2RAD*stepLength)*outerOuterRadius, sinf(DEG2RAD*stepLength)*outerOuterRadius };
-
-            // Assuming a linear interpolation such as `value = Lerp(start, end, t)`
-            // We can find O2 by getting its 't' between O1.y and O0.y (which is always greater than 1)
-            // We can solve for `t` using `t = (start - value)/(start - end)`
-            // Since we know `end = 0` we can simplify it to `t = (start - value)/start`
-            float tOuter = (cap1O1.y - thick)/cap1O1.y;
-            Vector2 cap1O2 = { cap1O1.x + (cap1O0.x - cap1O1.x)*tOuter, thick };
-
-            Vector2 cap1I0 = { innerInnerRadius, 0.0f };
-
-            float capLongEdgeLength = outerOuterRadius - innerInnerRadius;
-            Vector2 cap1I2 = { cap1O2.x - capLongEdgeLength, thick };
-
-            Vector2 cap2O0 = { cosf(DEG2RAD*(endAngle - startAngle))*outerOuterRadius, sinf(DEG2RAD*(endAngle - startAngle))*outerOuterRadius };
-            Vector2 cap2O1 = { cosf(DEG2RAD*(endAngle - startAngle - stepLength))*outerOuterRadius, sinf(DEG2RAD*(endAngle - startAngle - stepLength))*outerOuterRadius };
-            Vector2 cap2O2 = { cap2O1.x + (cap2O0.x - cap2O1.x)*tOuter, cap2O1.y + (cap2O0.y - cap2O1.y)*tOuter };
-
-            Vector2 cap2I0 = { cosf(DEG2RAD*(endAngle - startAngle))*innerInnerRadius, sinf(DEG2RAD*(endAngle - startAngle))*innerInnerRadius };
-            Vector2 cap2I2 = { cap2O2.x - cosf(DEG2RAD*(endAngle - startAngle))*capLongEdgeLength, cap2O2.y - sinf(DEG2RAD*(endAngle - startAngle))*capLongEdgeLength};
-
-            // The 't' of the intersection between I2 and O2 (`Lerp(I2, O2, t)`)
-            float tCapLongEdgeCross = -1.0f;
-            // Avoid division by zero
-            if (cap2I2.y - cap2O2.y != 0.0f)
-            {
-                // Find where the long edge of cap 2 intersects the long edge of cap 1
-                tCapLongEdgeCross = (cap2I2.y - thick)/(cap2I2.y - cap2O2.y);
-                if ((tCapLongEdgeCross >= 0.0f) && (tCapLongEdgeCross <= 1.0f)) capsIntersect = true;
-            }
-
-            // Rotate the frame of reference so that cap 1's I0->I2 edge is a vertical line
-            float rotateBy = -DEG2RAD*stepLength/2.0f;
-
-            // Copied from "raymath.h" Vector2Rotate()
-            // Though we only use the x axis, so we ignore the y axis
-            float cosres = cosf(rotateBy);
-            float sinres = sinf(rotateBy);
-
-            cap1I2.x = cap1I2.x*cosres - cap1I2.y*sinres;
-            cap1O2.x = cap1O2.x*cosres - cap1O2.y*sinres;
-            cap2I0.x = cap2I0.x*cosres - cap2I0.y*sinres;
-            cap2I2.x = cap2I2.x*cosres - cap2I2.y*sinres;
-            cap2O0.x = cap2O0.x*cosres - cap2O0.y*sinres;
-            cap2O2.x = cap2O2.x*cosres - cap2O2.y*sinres;
-
-            // The 't' of the intersection between I0 and I2 (`Lerp(I0, I2, t)`)
-            float tCrossInner = -1.0f;
-            // Avoid division by zero
-            if (cap2I0.x - cap2I2.x != 0.0f) tCrossInner = (cap2I0.x - cap1I2.x)/(cap2I0.x - cap2I2.x);
-            // Make sure `tCrossInner` is 0 when it should be (mitigate floating-point rounding woes)
-            if (innerInnerRadius <= 0.0f) tCrossInner = 0.0f;
-
-            // The 't' of the intersection between O0 and O2 (`Lerp(O0, O2, t)`)
-            float tCrossOuter = -1.0f;
-            // Avoid division by zero
-            if (cap2O0.x - cap2O2.x != 0.0f) tCrossOuter = (cap2O0.x - cap1O2.x)/(cap2O0.x - cap2O2.x);
-
-            // With our additional information, calculate the vertices we need
-            // outside of our modified frame of reference
-
-            cap1O0 = (Vector2){ center.x + cosf(DEG2RAD*startAngle)*outerOuterRadius, center.y + sinf(DEG2RAD*startAngle)*outerOuterRadius };
-            cap1O1 = (Vector2){ center.x + cosf(DEG2RAD*(startAngle + stepLength))*outerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + stepLength))*outerOuterRadius };
-            cap1O2 = (Vector2){ cap1O1.x + (cap1O0.x - cap1O1.x)*tOuter, cap1O1.y + (cap1O0.y - cap1O1.y)*tOuter };
-
-            cap2O0 = (Vector2){ center.x + cosf(DEG2RAD*endAngle)*outerOuterRadius, center.y + sinf(DEG2RAD*endAngle)*outerOuterRadius };
-            cap2O1 = (Vector2){ center.x + cosf(DEG2RAD*(endAngle - stepLength))*outerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - stepLength))*outerOuterRadius };
-            cap2O2 = (Vector2){ cap2O1.x + (cap2O0.x - cap2O1.x)*tOuter, cap2O1.y + (cap2O0.y - cap2O1.y)*tOuter };
-
-            cap1I0 = (Vector2){ center.x + cosf(DEG2RAD*startAngle)*innerInnerRadius, center.y + sinf(DEG2RAD*startAngle)*innerInnerRadius };
-            cap1I2 = (Vector2){ cap1O2.x - cosf(DEG2RAD*startAngle)*capLongEdgeLength, cap1O2.y - sinf(DEG2RAD*startAngle)*capLongEdgeLength };
-
-            cap2I0 = (Vector2){ center.x + cosf(DEG2RAD*endAngle)*innerInnerRadius, center.y + sinf(DEG2RAD*endAngle)*innerInnerRadius };
-            cap2I2 = (Vector2){ cap2O2.x - cosf(DEG2RAD*endAngle)*capLongEdgeLength, cap2O2.y - sinf(DEG2RAD*endAngle)*capLongEdgeLength };
-
-            if (capsIntersect)
-            {
-                capIntersectionVertex = (Vector2){ cap2I2.x + (cap2O2.x - cap2I2.x)*tCapLongEdgeCross, cap2I2.y + (cap2O2.y - cap2I2.y)*tCapLongEdgeCross };
-
-                cap2I2 = (Vector2){ cap2I0.x + (cap2I2.x - cap2I0.x)*tCrossInner, cap2I0.y + (cap2I2.y - cap2I0.y)*tCrossInner };
-                cap1I2 = cap2I2;
-            }
-            else if ((tCrossOuter >= 0.0f) && (tCrossOuter <= 1.0f))
-            {
-                cap2O2 = (Vector2){ cap2O0.x + (cap2O2.x - cap2O0.x)*tCrossOuter, cap2O0.y + (cap2O2.y - cap2O0.y)*tCrossOuter };
-                cap1O2 = cap2O2;
-
-                cap2I2 = (Vector2){ cap2I0.x + (cap2I2.x - cap2I0.x)*tCrossInner, cap2I0.y + (cap2I2.y - cap2I0.y)*tCrossInner };
-                cap1I2 = cap2I2;
-            }
-
-            cap1SecondInnerVertex = cap1I2;
-            cap1SecondOuterVertex = cap1O2;
-            cap2SecondInnerVertex = cap2I2;
-            cap2SecondOuterVertex = cap2O2;
-        }
-    }
-
-    float angle = startAngle;
-
-#if SUPPORT_QUADS_DRAW_MODE
-    rlSetTexture(GetShapesTexture().id);
-    Rectangle shapeRect = GetShapesTextureRectangle();
-
-    rlBegin(RL_QUADS);
-
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        for (int i = 0; i < segments; i++)
-        {
-            // `innerRadius` outline
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerInnerRadius, center.y + sinf(DEG2RAD*angle)*outerInnerRadius);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerInnerRadius, center.y + sinf(DEG2RAD*angle)*innerInnerRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerInnerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerInnerRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerInnerRadius);
-
-            // `outerRadius` outline
-            rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerOuterRadius, center.y + sinf(DEG2RAD*angle)*outerOuterRadius);
-
-            rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerOuterRadius, center.y + sinf(DEG2RAD*angle)*innerOuterRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerOuterRadius);
-
-            rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerOuterRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerOuterRadius);
-
-            angle += stepLength;
-        }
-
-        if (showCapLines)
-        {
-            if (thick >= 0.0f)
-            {
-                angle = 0.0f;
-
-                for (int i = 0; i < stepsBeforeOuter; i++)
-                {
-                    // Cap 1
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerOuterRadius);
-
-                    // Cap 2
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerOuterRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius);
-
-                    angle += stepLength;
-                }
-
-                // We've already moved `stepsBeforeOuter` steps from each end
-                int totalStepsLeft = segments - stepsBeforeOuter*2;
-                int innerStepsLeft = stepsBeforeInner - stepsBeforeOuter;
-
-                // Cap 1
-                Vector2 cap1OuterVertexBeforeEnd = { center.x + cosf(DEG2RAD*(startAngle + angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerOuterRadius };
-                Vector2 cap1OuterVertexAfterEnd = { center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius };
-                Vector2 cap1InnerVertexBeforeEnd = { center.x + cosf(DEG2RAD*(startAngle + angle + (float)innerStepsLeft*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + (float)innerStepsLeft*stepLength))*outerInnerRadius };
-                Vector2 cap1InnerVertexAfterEnd = { center.x + cosf(DEG2RAD*(startAngle + angle + (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius };
-                Vector2 cap1InnerVertexEnd = { cap1InnerVertexBeforeEnd.x + (cap1InnerVertexAfterEnd.x - cap1InnerVertexBeforeEnd.x)*tInner, cap1InnerVertexBeforeEnd.y + (cap1InnerVertexAfterEnd.y - cap1InnerVertexBeforeEnd.y)*tInner };
-                Vector2 cap1OuterVertexEnd = { cap1OuterVertexBeforeEnd.x + (cap1OuterVertexAfterEnd.x - cap1OuterVertexBeforeEnd.x)*tOuter, cap1OuterVertexBeforeEnd.y + (cap1OuterVertexAfterEnd.y - cap1OuterVertexBeforeEnd.y)*tOuter };
-
-                // Cap 2
-                Vector2 cap2OuterVertexBeforeEnd = { center.x + cosf(DEG2RAD*(endAngle - angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerOuterRadius };
-                Vector2 cap2OuterVertexAfterEnd = { center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius };
-                Vector2 cap2InnerVertexBeforeEnd = { center.x + cosf(DEG2RAD*(endAngle - angle - (float)innerStepsLeft*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - (float)innerStepsLeft*stepLength))*outerInnerRadius };
-                Vector2 cap2InnerVertexAfterEnd = { center.x + cosf(DEG2RAD*(endAngle - angle - (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius };
-                Vector2 cap2InnerVertexEnd = { cap2InnerVertexBeforeEnd.x + (cap2InnerVertexAfterEnd.x - cap2InnerVertexBeforeEnd.x)*tInner, cap2InnerVertexBeforeEnd.y + (cap2InnerVertexAfterEnd.y - cap2InnerVertexBeforeEnd.y)*tInner };
-                Vector2 cap2OuterVertexEnd = { cap2OuterVertexBeforeEnd.x + (cap2OuterVertexAfterEnd.x - cap2OuterVertexBeforeEnd.x)*tOuter, cap2OuterVertexBeforeEnd.y + (cap2OuterVertexAfterEnd.y - cap2OuterVertexBeforeEnd.y)*tOuter };
-
-                int stepsCount = (innerAnglesCrossEachOther)? totalStepsLeft/2 : innerStepsLeft;
-
-                // Iterate over pairs of steps
-                for (int i = 0; i < stepsCount/2; i++)
-                {
-                    // Cap 1
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength*2.0f))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength*2.0f))*outerInnerRadius);
-
-                    // Cap 2
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength*2.0f))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength*2.0f))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius);
-
-                    angle += stepLength*2.0f;
-                }
-
-                // Handle the last step if there's an odd amount
-                if (stepsCount%2 == 1)
-                {
-                    // Cap 1
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius);
-
-                    // Cap 2
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius);
-
-                    angle += stepLength;
-                }
-
-                // When the inner angles coming from `startAngle` and `endAngle` cross each other,
-                // the `*innerVertexEnd` vertices go past each other and cause the geometry to intersect itself
-                if (innerAnglesCrossEachOther)
-                {
-                    // We need to find where the line defined by `cap1InnerVertexEnd` and `cap1OuterVertexEnd` intersects
-                    // the line defined by `cap2InnerVertexEnd` and `cap2OuterVertexEnd`
-                    // That point is then used instead to prevent the outline from intersecting itself
-
-                    // Make `cap1InnerVertexEnd` the origin and the angle to `cap1OuterVertexEnd` 0 degrees
-                    Vector2 tempCap1OuterVertexEnd = { cap1OuterVertexEnd.x - cap1InnerVertexEnd.x, cap1OuterVertexEnd.y - cap1InnerVertexEnd.y };
-                    Vector2 tempCap2InnerVertexEnd = { cap2InnerVertexEnd.x - cap1InnerVertexEnd.x, cap2InnerVertexEnd.y - cap1InnerVertexEnd.y };
-                    Vector2 tempCap2OuterVertexEnd = { cap2OuterVertexEnd.x - cap1InnerVertexEnd.x, cap2OuterVertexEnd.y - cap1InnerVertexEnd.y };
-
-                    float rotateBy = -atan2f(tempCap1OuterVertexEnd.y, tempCap1OuterVertexEnd.x);
-                    // We only need the y coordinates, so only rotate the y coordinates
-                    float start = sinf(rotateBy)*tempCap2InnerVertexEnd.x + cosf(rotateBy)*tempCap2InnerVertexEnd.y;
-                    float end = sinf(rotateBy)*tempCap2OuterVertexEnd.x + cosf(rotateBy)*tempCap2OuterVertexEnd.y;
-                    float tCross = start/(start - end);
-
-                    Vector2 intersection = { cap2InnerVertexEnd.x + (cap2OuterVertexEnd.x - cap2InnerVertexEnd.x)*tCross, cap2InnerVertexEnd.y + (cap2OuterVertexEnd.y - cap2InnerVertexEnd.y)*tCross };
-
-                    if (segments%2 == 0)
-                    {
-                        // There are an even number of segments, so there's 1 vertex exactly in the middle
-
-                        Vector2 middleInnerVertex = { center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius };
-
-                        // Cap 1
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(intersection.x, intersection.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(cap1OuterVertexEnd.x, cap1OuterVertexEnd.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(middleInnerVertex.x, middleInnerVertex.y);
-
-                        // Cap 2
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(intersection.x, intersection.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(middleInnerVertex.x, middleInnerVertex.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(cap2OuterVertexEnd.x, cap2OuterVertexEnd.y);
-                    }
-                    else
-                    {
-                        // There are an odd number of segments, so there are 2 vertices in the middle
-
-                        Vector2 middleInnerVertex1 = { center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius };
-                        Vector2 middleInnerVertex2 = { center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius };
-
-                        // Cap 1
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(intersection.x, intersection.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(cap1OuterVertexEnd.x, cap1OuterVertexEnd.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(middleInnerVertex1.x, middleInnerVertex1.y);
-
-                        // Cap 2
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(intersection.x, intersection.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(middleInnerVertex2.x, middleInnerVertex2.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(cap2OuterVertexEnd.x, cap2OuterVertexEnd.y);
-
-                        // Triangle between the caps
-                        rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(intersection.x, intersection.y);
-
-                        rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(intersection.x, intersection.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                        rlVertex2f(middleInnerVertex1.x, middleInnerVertex1.y);
-
-                        rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                        rlVertex2f(middleInnerVertex2.x, middleInnerVertex2.y);
-                    }
-                }
-                else
-                {
-                    // Cap 1
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap1InnerVertexBeforeEnd.x, cap1InnerVertexBeforeEnd.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap1InnerVertexEnd.x, cap1InnerVertexEnd.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap1OuterVertexEnd.x, cap1OuterVertexEnd.y);
-
-                    // Cap 2
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap2OuterVertexEnd.x, cap2OuterVertexEnd.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap2InnerVertexEnd.x, cap2InnerVertexEnd.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap2InnerVertexBeforeEnd.x, cap2InnerVertexBeforeEnd.y);
-                }
-            }
-            else
-            {
-                // Cap 1
-                Vector2 cap1FirstInnerVertex = { center.x + cosf(DEG2RAD*startAngle)*innerInnerRadius, center.y + sinf(DEG2RAD*startAngle)*innerInnerRadius };
-                Vector2 cap1FirstOuterVertex = { center.x + cosf(DEG2RAD*startAngle)*outerOuterRadius, center.y + sinf(DEG2RAD*startAngle)*outerOuterRadius };
-
-                rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(cap1FirstInnerVertex.x, cap1FirstInnerVertex.y);
-
-                rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(cap1FirstOuterVertex.x, cap1FirstOuterVertex.y);
-
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(cap1SecondOuterVertex.x, cap1SecondOuterVertex.y);
-
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(cap1SecondInnerVertex.x, cap1SecondInnerVertex.y);
-
-                // Cap 2
-                Vector2 cap2FirstInnerVertex = { center.x + cosf(DEG2RAD*endAngle)*innerInnerRadius, center.y + sinf(DEG2RAD*endAngle)*innerInnerRadius };
-                Vector2 cap2FirstOuterVertex = { center.x + cosf(DEG2RAD*endAngle)*outerOuterRadius, center.y + sinf(DEG2RAD*endAngle)*outerOuterRadius };
-
-                rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(cap2FirstInnerVertex.x, cap2FirstInnerVertex.y);
-
-                rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(cap2SecondInnerVertex.x, cap2SecondInnerVertex.y);
-
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                rlVertex2f(cap2SecondOuterVertex.x, cap2SecondOuterVertex.y);
-
-                rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                rlVertex2f(cap2FirstOuterVertex.x, cap2FirstOuterVertex.y);
-
-                if (capsIntersect)
-                {
-                    // Cap 1
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap1SecondInnerVertex.x, cap1SecondInnerVertex.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap1SecondInnerVertex.x, cap1SecondInnerVertex.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap1SecondOuterVertex.x, cap1SecondOuterVertex.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(capIntersectionVertex.x, capIntersectionVertex.y);
-
-                    // Cap 2
-                    rlTexCoord2f(shapeRect.x/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap2SecondInnerVertex.x, cap2SecondInnerVertex.y);
-
-                    rlTexCoord2f(shapeRect.x/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(capIntersectionVertex.x, capIntersectionVertex.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, shapeRect.y/texShapes.height);
-                    rlVertex2f(cap2SecondOuterVertex.x, cap2SecondOuterVertex.y);
-
-                    rlTexCoord2f((shapeRect.x + shapeRect.width)/texShapes.width, (shapeRect.y + shapeRect.height)/texShapes.height);
-                    rlVertex2f(cap2SecondInnerVertex.x, cap2SecondInnerVertex.y);
-                }
-            }
-        }
-    rlEnd();
-#else
-    rlBegin(RL_TRIANGLES);
-
-        rlColor4ub(color.r, color.g, color.b, color.a);
-
-        for (int i = 0; i < segments; i++)
-        {
-            // `innerRadius` outline
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerInnerRadius, center.y + sinf(DEG2RAD*angle)*outerInnerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerInnerRadius, center.y + sinf(DEG2RAD*angle)*innerInnerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerInnerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerInnerRadius);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerInnerRadius, center.y + sinf(DEG2RAD*angle)*outerInnerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerInnerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerInnerRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerInnerRadius);
-
-            // `outerRadius` outline
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerOuterRadius, center.y + sinf(DEG2RAD*angle)*outerOuterRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*innerOuterRadius, center.y + sinf(DEG2RAD*angle)*innerOuterRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerOuterRadius);
-
-            rlVertex2f(center.x + cosf(DEG2RAD*angle)*outerOuterRadius, center.y + sinf(DEG2RAD*angle)*outerOuterRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*innerOuterRadius);
-            rlVertex2f(center.x + cosf(DEG2RAD*(angle + stepLength))*outerOuterRadius, center.y + sinf(DEG2RAD*(angle + stepLength))*outerOuterRadius);
-
-            angle += stepLength;
-        }
-
-        if (showCapLines)
-        {
-            if (thick >= 0.0f)
-            {
-                angle = 0.0f;
-
-                for (int i = 0; i < stepsBeforeOuter; i++)
-                {
-                    // Cap 1
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius);
-
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerOuterRadius);
-
-                    // Cap 2
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerOuterRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius);
-
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius);
-
-                    angle += stepLength;
-                }
-
-                // We've already moved `stepsBeforeOuter` steps from each end
-                int totalStepsLeft = segments - stepsBeforeOuter*2;
-                int innerStepsLeft = stepsBeforeInner - stepsBeforeOuter;
-
-                // Cap 1
-                Vector2 cap1OuterVertexBeforeEnd = { center.x + cosf(DEG2RAD*(startAngle + angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*innerOuterRadius };
-                Vector2 cap1OuterVertexAfterEnd = { center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*innerOuterRadius };
-                Vector2 cap1InnerVertexBeforeEnd = { center.x + cosf(DEG2RAD*(startAngle + angle + (float)innerStepsLeft*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + (float)innerStepsLeft*stepLength))*outerInnerRadius };
-                Vector2 cap1InnerVertexAfterEnd = { center.x + cosf(DEG2RAD*(startAngle + angle + (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius };
-                Vector2 cap1InnerVertexEnd = { cap1InnerVertexBeforeEnd.x + (cap1InnerVertexAfterEnd.x - cap1InnerVertexBeforeEnd.x)*tInner, cap1InnerVertexBeforeEnd.y + (cap1InnerVertexAfterEnd.y - cap1InnerVertexBeforeEnd.y)*tInner };
-                Vector2 cap1OuterVertexEnd = { cap1OuterVertexBeforeEnd.x + (cap1OuterVertexAfterEnd.x - cap1OuterVertexBeforeEnd.x)*tOuter, cap1OuterVertexBeforeEnd.y + (cap1OuterVertexAfterEnd.y - cap1OuterVertexBeforeEnd.y)*tOuter };
-
-                // Cap 2
-                Vector2 cap2OuterVertexBeforeEnd = { center.x + cosf(DEG2RAD*(endAngle - angle))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*innerOuterRadius };
-                Vector2 cap2OuterVertexAfterEnd = { center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*innerOuterRadius };
-                Vector2 cap2InnerVertexBeforeEnd = { center.x + cosf(DEG2RAD*(endAngle - angle - (float)innerStepsLeft*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - (float)innerStepsLeft*stepLength))*outerInnerRadius };
-                Vector2 cap2InnerVertexAfterEnd = { center.x + cosf(DEG2RAD*(endAngle - angle - (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - (float)(innerStepsLeft + 1)*stepLength))*outerInnerRadius };
-                Vector2 cap2InnerVertexEnd = { cap2InnerVertexBeforeEnd.x + (cap2InnerVertexAfterEnd.x - cap2InnerVertexBeforeEnd.x)*tInner, cap2InnerVertexBeforeEnd.y + (cap2InnerVertexAfterEnd.y - cap2InnerVertexBeforeEnd.y)*tInner };
-                Vector2 cap2OuterVertexEnd = { cap2OuterVertexBeforeEnd.x + (cap2OuterVertexAfterEnd.x - cap2OuterVertexBeforeEnd.x)*tOuter, cap2OuterVertexBeforeEnd.y + (cap2OuterVertexAfterEnd.y - cap2OuterVertexBeforeEnd.y)*tOuter };
-
-                int stepsCount = (innerAnglesCrossEachOther)? totalStepsLeft/2 : innerStepsLeft;
-
-                for (int i = 0; i < stepsCount; i++)
-                {
-                    // Cap 1
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle + stepLength))*outerInnerRadius);
-
-                    // Cap 2
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle - stepLength))*outerInnerRadius);
-                    rlVertex2f(center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius);
-
-                    angle += stepLength;
-                }
-
-                // When the inner angles coming from `startAngle` and `endAngle` cross each other,
-                // the `*innerVertexEnd` vertices go past each other and cause the geometry to intersect itself
-                if (innerAnglesCrossEachOther)
-                {
-                    // We need to find where the line defined by `cap1InnerVertexEnd` and `cap1OuterVertexEnd` intersects
-                    // the line defined by `cap2InnerVertexEnd` and `cap2OuterVertexEnd`
-                    // That point is then used instead to prevent the outline from intersecting itself
-
-                    // Make `cap1InnerVertexEnd` the origin and the angle to `cap1OuterVertexEnd` 0 degrees
-                    Vector2 tempCap1OuterVertexEnd = { cap1OuterVertexEnd.x - cap1InnerVertexEnd.x, cap1OuterVertexEnd.y - cap1InnerVertexEnd.y };
-                    Vector2 tempCap2InnerVertexEnd = { cap2InnerVertexEnd.x - cap1InnerVertexEnd.x, cap2InnerVertexEnd.y - cap1InnerVertexEnd.y };
-                    Vector2 tempCap2OuterVertexEnd = { cap2OuterVertexEnd.x - cap1InnerVertexEnd.x, cap2OuterVertexEnd.y - cap1InnerVertexEnd.y };
-
-                    float rotateBy = -atan2f(tempCap1OuterVertexEnd.y, tempCap1OuterVertexEnd.x);
-                    // We only need the y coordinates, so only rotate the y coordinates
-                    float start = sinf(rotateBy)*tempCap2InnerVertexEnd.x + cosf(rotateBy)*tempCap2InnerVertexEnd.y;
-                    float end = sinf(rotateBy)*tempCap2OuterVertexEnd.x + cosf(rotateBy)*tempCap2OuterVertexEnd.y;
-                    float tCross = start/(start - end);
-
-                    Vector2 intersection = { cap2InnerVertexEnd.x + (cap2OuterVertexEnd.x - cap2InnerVertexEnd.x)*tCross, cap2InnerVertexEnd.y + (cap2OuterVertexEnd.y - cap2InnerVertexEnd.y)*tCross };
-
-                    if (segments%2 == 0)
-                    {
-                        // There are an even number of segments, so there's 1 vertex exactly in the middle
-
-                        Vector2 middleInnerVertex = { center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius };
-
-                        // Cap 1
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(cap1OuterVertexEnd.x, cap1OuterVertexEnd.y);
-                        rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-                        rlVertex2f(middleInnerVertex.x, middleInnerVertex.y);
-
-                        // Cap 2
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(middleInnerVertex.x, middleInnerVertex.y);
-                        rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-                        rlVertex2f(cap2OuterVertexEnd.x, cap2OuterVertexEnd.y);
-                    }
-                    else
-                    {
-                        // There are an odd number of segments, so there are 2 vertices in the middle
-
-                        Vector2 middleInnerVertex1 = { center.x + cosf(DEG2RAD*(startAngle + angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(startAngle + angle))*outerInnerRadius };
-                        Vector2 middleInnerVertex2 = { center.x + cosf(DEG2RAD*(endAngle - angle))*outerInnerRadius, center.y + sinf(DEG2RAD*(endAngle - angle))*outerInnerRadius };
-
-                        // Cap 1
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(cap1OuterVertexEnd.x, cap1OuterVertexEnd.y);
-                        rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-                        rlVertex2f(middleInnerVertex1.x, middleInnerVertex1.y);
-
-                        // Cap 2
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(middleInnerVertex2.x, middleInnerVertex2.y);
-                        rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-                        rlVertex2f(cap2OuterVertexEnd.x, cap2OuterVertexEnd.y);
-
-                        // Triangle between the caps
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(middleInnerVertex1.x, middleInnerVertex1.y);
-
-                        rlVertex2f(intersection.x, intersection.y);
-                        rlVertex2f(middleInnerVertex1.x, middleInnerVertex1.y);
-                        rlVertex2f(middleInnerVertex2.x, middleInnerVertex2.y);
-                    }
-                }
-                else
-                {
-                    // Cap 1
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-                    rlVertex2f(cap1InnerVertexBeforeEnd.x, cap1InnerVertexBeforeEnd.y);
-                    rlVertex2f(cap1InnerVertexEnd.x, cap1InnerVertexEnd.y);
-
-                    rlVertex2f(cap1OuterVertexBeforeEnd.x, cap1OuterVertexBeforeEnd.y);
-                    rlVertex2f(cap1InnerVertexEnd.x, cap1InnerVertexEnd.y);
-                    rlVertex2f(cap1OuterVertexEnd.x, cap1OuterVertexEnd.y);
-
-                    // Cap 2
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-                    rlVertex2f(cap2OuterVertexEnd.x, cap2OuterVertexEnd.y);
-                    rlVertex2f(cap2InnerVertexEnd.x, cap2InnerVertexEnd.y);
-
-                    rlVertex2f(cap2OuterVertexBeforeEnd.x, cap2OuterVertexBeforeEnd.y);
-                    rlVertex2f(cap2InnerVertexEnd.x, cap2InnerVertexEnd.y);
-                    rlVertex2f(cap2InnerVertexBeforeEnd.x, cap2InnerVertexBeforeEnd.y);
-                }
-            }
-            else
-            {
-                // Cap 1
-                Vector2 cap1FirstInnerVertex = { center.x + cosf(DEG2RAD*startAngle)*innerInnerRadius, center.y + sinf(DEG2RAD*startAngle)*innerInnerRadius };
-                Vector2 cap1FirstOuterVertex = { center.x + cosf(DEG2RAD*startAngle)*outerOuterRadius, center.y + sinf(DEG2RAD*startAngle)*outerOuterRadius };
-
-                rlVertex2f(cap1FirstInnerVertex.x, cap1FirstInnerVertex.y);
-                rlVertex2f(cap1FirstOuterVertex.x, cap1FirstOuterVertex.y);
-                rlVertex2f(cap1SecondOuterVertex.x, cap1SecondOuterVertex.y);
-
-                rlVertex2f(cap1FirstInnerVertex.x, cap1FirstInnerVertex.y);
-                rlVertex2f(cap1SecondOuterVertex.x, cap1SecondOuterVertex.y);
-                rlVertex2f(cap1SecondInnerVertex.x, cap1SecondInnerVertex.y);
-
-                // Cap 2
-                Vector2 cap2FirstInnerVertex = { center.x + cosf(DEG2RAD*endAngle)*innerInnerRadius, center.y + sinf(DEG2RAD*endAngle)*innerInnerRadius };
-                Vector2 cap2FirstOuterVertex = { center.x + cosf(DEG2RAD*endAngle)*outerOuterRadius, center.y + sinf(DEG2RAD*endAngle)*outerOuterRadius };
-
-                rlVertex2f(cap2FirstInnerVertex.x, cap2FirstInnerVertex.y);
-                rlVertex2f(cap2SecondInnerVertex.x, cap2SecondInnerVertex.y);
-                rlVertex2f(cap2SecondOuterVertex.x, cap2SecondOuterVertex.y);
-
-                rlVertex2f(cap2FirstInnerVertex.x, cap2FirstInnerVertex.y);
-                rlVertex2f(cap2SecondOuterVertex.x, cap2SecondOuterVertex.y);
-                rlVertex2f(cap2FirstOuterVertex.x, cap2FirstOuterVertex.y);
-
-                if (capsIntersect)
-                {
-                    // Cap 1
-                    rlVertex2f(cap1SecondInnerVertex.x, cap1SecondInnerVertex.y);
-                    rlVertex2f(cap1SecondOuterVertex.x, cap1SecondOuterVertex.y);
-                    rlVertex2f(capIntersectionVertex.x, capIntersectionVertex.y);
-
-                    // Cap 2
-                    rlVertex2f(cap2SecondInnerVertex.x, cap2SecondInnerVertex.y);
-                    rlVertex2f(capIntersectionVertex.x, capIntersectionVertex.y);
-                    rlVertex2f(cap2SecondOuterVertex.x, cap2SecondOuterVertex.y);
-                }
-            }
-        }
-
-    rlEnd();
-#endif
-}
-
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Splines functions
 //----------------------------------------------------------------------------------
@@ -4268,7 +2214,7 @@ Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4,
 }
 
 // Get spline point for a given t [0.0f .. 1.0f], Quadratic Bezier
-Vector2 GetSplinePointBezierQuadratic(Vector2 startPos, Vector2 controlPos, Vector2 endPos, float t)
+Vector2 GetSplinePointBezierQuad(Vector2 startPos, Vector2 controlPos, Vector2 endPos, float t)
 {
     Vector2 point = { 0 };
 
@@ -4441,11 +2387,8 @@ bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2,
 
         if ((0.0f <= t) && (t <= 1.0f) && (0.0f <= u) && (u <= 1.0f))
         {
-            if (collisionPoint)
-            {
-                collisionPoint->x = startPos1.x + t*rx;
-                collisionPoint->y = startPos1.y + t*ry;
-            }
+            collisionPoint->x = startPos1.x + t*rx;
+            collisionPoint->y = startPos1.y + t*ry;
 
             collision = true;
         }
diff --git a/src/libraries/raylib/raylib/src/rtext.c b/src/libraries/raylib/raylib/src/rtext.c
index 08fde1a..7b9d5f2 100644
--- a/src/libraries/raylib/raylib/src/rtext.c
+++ b/src/libraries/raylib/raylib/src/rtext.c
@@ -58,8 +58,8 @@
 #include "rlgl.h"           // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2 -> Only DrawTextPro()
 
 #include <stdlib.h>         // Required for: malloc(), free()
-#include <stdio.h>          // Required for: vsprintf(), snprintf()
-#include <string.h>         // Required for: strcmp(), strstr(), strncpy(), sscanf() [Used in LoadBMFont()]
+#include <stdio.h>          // Required for: vsprintf()
+#include <string.h>         // Required for: strcmp(), strstr(), strncpy() [Used in TextReplace()], sscanf() [Used in LoadBMFont()]
 #include <stdarg.h>         // Required for: va_list, va_start(), vsprintf(), va_end() [Used in TextFormat()]
 #include <ctype.h>          // Required for: toupper(), tolower() [Used in TextToUpper(), TextToLower()]
 
@@ -156,7 +156,7 @@ extern void LoadFontDefault(void)
 {
     #define BIT_CHECK(a,b) ((a) & (1u << (b)))
 
-    // Check to see if the font for an image has already been allocated,
+    // Check to see if the font for an image has alreeady been allocated,
     // and if no need to upload, then return
     if (defaultFont.glyphs != NULL) return;
 
@@ -327,7 +327,7 @@ extern void UnloadFontDefault(void)
     defaultFont.recs = NULL;
 }
 
-// Get the default font
+// Get the default font, useful to be used with extended parameters
 Font GetFontDefault()
 {
     return defaultFont;
@@ -381,9 +381,9 @@ Font LoadFont(const char *fileName)
     return font;
 }
 
-// Load font from file with defined codepoints and generation size
-// NOTE: NULL for codepoints and 0 for codepointCount to load the default character set (32..126),
-// font size is provided in pixels height
+// Load Font from TTF or BDF font file with generation parameters
+// NOTE: You can pass an array with desired characters, those characters should be available in the font
+// if array is NULL, default char set is selected 32..126
 Font LoadFontEx(const char *fileName, int fontSize, const int *codepoints, int codepointCount)
 {
     Font font = { 0 };
@@ -417,6 +417,9 @@ Font LoadFontFromImage(Image image, Color key, int firstChar)
     int charSpacing = 0;
     int lineSpacing = 0;
 
+    int x = 0;
+    int y = 0;
+
     // Allocate a temporal arrays for glyphs data measures,
     // once the actual number of glyphs is obtained, copy data to a sized array
     int tempCharValues[MAX_GLYPHS_FROM_IMAGE] = { 0 };
@@ -425,8 +428,6 @@ Font LoadFontFromImage(Image image, Color key, int firstChar)
     Color *pixels = LoadImageColors(image);
 
     // Parse image data to get charSpacing and lineSpacing
-    int x = 0;
-    int y = 0;
     for (y = 0; y < image.height; y++)
     {
         for (x = 0; x < image.width; x++)
@@ -437,12 +438,7 @@ Font LoadFontFromImage(Image image, Color key, int firstChar)
         if (!COLOR_EQUAL(pixels[y*image.width + x], key)) break;
     }
 
-    // Security check
-    if ((x == 0) || (y == 0))
-    {
-        UnloadImageColors(pixels);
-        return font;
-    }
+    if ((x == 0) || (y == 0)) return font; // Security check
 
     charSpacing = x;
     lineSpacing = y;
@@ -540,7 +536,7 @@ Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int
     Font font = { 0 };
 
     char fileExtLower[16] = { 0 };
-    snprintf(fileExtLower, 16, "%s", TextToLower(fileType));
+    strncpy(fileExtLower, TextToLower(fileType), 16 - 1);
 
     font.baseSize = fontSize;
     font.glyphPadding = 0;
@@ -584,20 +580,15 @@ Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int
 
         TRACELOG(LOG_INFO, "FONT: Data loaded successfully (%i pixel size | %i glyphs)", font.baseSize, font.glyphCount);
     }
-    else
-    {
-        TRACELOG(LOG_WARNING, "FONT: Font is not supported by LoadFontEx/LoadFontFromMemory or no glyphs found, reverted to default font");
-        font = GetFontDefault();
-    }
+    else font = GetFontDefault();
 #else
-    TRACELOG(LOG_WARNING, "FONT: Font is not supported by LoadFontEx/LoadFontFromMemory or no glyphs found, reverted to default font");
     font = GetFontDefault();
 #endif
 
     return font;
 }
 
-// Check if font is valid (font data loaded)
+// Check if a font is valid (font data loaded)
 // WARNING: GPU texture not checked
 bool IsFontValid(Font font)
 {
@@ -687,7 +678,7 @@ GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSiz
                 //      stbtt_GetCodepointBitmapBox()        -- how big the bitmap must be
                 //      stbtt_MakeCodepointBitmap()          -- renders into a provided bitmap
 
-                // Check if glyph is available in the font
+                // Check if a glyph is available in the font
                 // WARNING: if (index == 0), glyph not found, it could fallback to default .notdef glyph (if defined in font)
                 int index = stbtt_FindGlyphIndex(&fontInfo, cp);
 
@@ -717,7 +708,7 @@ GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSiz
                         default: break;
                     }
 
-                    if (glyphs[k].image.data != NULL) // Glyph data has been found in the font
+                    if (glyphs[k].image.data != NULL)    // Glyph data has been found in the font
                     {
                         stbtt_GetCodepointHMetrics(&fontInfo, cp, &glyphs[k].advanceX, NULL);
                         glyphs[k].advanceX = (int)((float)glyphs[k].advanceX*scaleFactor);
@@ -849,7 +840,7 @@ Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyp
     // DEBUG: View padding in the generated image setting a gray background...
     //for (int i = 0; i < atlas.width*atlas.height; i++) ((unsigned char *)atlas.data)[i] = 100;
 
-    if (packMethod == 0) // Use basic packing algorithm
+    if (packMethod == 0)   // Use basic packing algorithm
     {
         int offsetX = padding;
         int offsetY = padding;
@@ -911,7 +902,7 @@ Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyp
             offsetX += (glyphs[i].image.width + 2*padding);
         }
     }
-    else if (packMethod == 1) // Use Skyline rect packing algorithm (stb_pack_rect)
+    else if (packMethod == 1)  // Use Skyline rect packing algorithm (stb_pack_rect)
     {
         stbrp_context *context = (stbrp_context *)RL_MALLOC(sizeof(*context));
         stbrp_node *nodes = (stbrp_node *)RL_MALLOC(glyphCount*sizeof(*nodes));
@@ -951,8 +942,8 @@ Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyp
                         // Security fix: check both lower and upper bounds
                         if (destX >= 0 && destX < atlas.width && destY >= 0 && destY < atlas.height)
                         {
-                            ((unsigned char *)atlas.data)[destY*atlas.width + destX] =
-                                ((unsigned char *)glyphs[i].image.data)[y*glyphs[i].image.width + x];
+                            ((unsigned char *)atlas.data)[destY * atlas.width + destX] =
+                                ((unsigned char *)glyphs[i].image.data)[y * glyphs[i].image.width + x];
                         }
                     }
                 }
@@ -1034,7 +1025,7 @@ bool ExportFontAsCode(Font font, const char *fileName)
 
     // Get file name from path
     char fileNamePascal[256] = { 0 };
-    snprintf(fileNamePascal, 256, "%s", TextToPascal(GetFileNameWithoutExt(fileName)));
+    strncpy(fileNamePascal, TextToPascal(GetFileNameWithoutExt(fileName)), 256 - 1);
 
     // Get font atlas image and size, required to estimate code file size
     // NOTE: This mechanism is highly coupled to raylib
@@ -1288,7 +1279,7 @@ void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSiz
     DrawTexturePro(font.texture, srcRec, dstRec, (Vector2){ 0, 0 }, 0.0f, tint);
 }
 
-// Draw multiple characters (codepoints)
+// Draw multiple character (codepoints)
 void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint)
 {
     float textOffsetY = 0;          // Offset between lines (on linebreak '\n')
@@ -1536,7 +1527,7 @@ char **LoadTextLines(const char *text, int *count)
             if ((text[i] == '\n') || (text[i] == '\0'))
             {
                 lines[l] = (char *)RL_CALLOC(lineLen + 1, 1);
-                memcpy(lines[l], &text[i - lineLen], lineLen);
+                strncpy(lines[l], &text[i - lineLen], lineLen);
                 lineLen = 0;
                 l++;
             }
@@ -1683,7 +1674,7 @@ int TextCopy(char *dst, const char *src)
     return bytes;
 }
 
-// Check if two text strings are equal
+// Check if two text string are equal
 // REQUIRES: strcmp()
 bool TextIsEqual(const char *text1, const char *text2)
 {
@@ -1703,7 +1694,7 @@ const char *TextSubtext(const char *text, int position, int length)
     static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
     memset(buffer, 0, MAX_TEXT_BUFFER_LENGTH);
 
-    if ((text != NULL) && (position >= 0) && (length > 0))
+    if (text != NULL)
     {
         int textLength = TextLength(text);
 
@@ -1733,7 +1724,7 @@ const char *TextRemoveSpaces(const char *text)
     if (text != NULL)
     {
         // Avoid copying the ' ' characters
-        for (int i = 0, j = 0; (i < MAX_TEXT_BUFFER_LENGTH - 1) && (text[i] != '\0'); i++)
+        for (int i = 0, j = 0; (i < MAX_TEXT_BUFFER_LENGTH - 1) && (text[j] != '\0'); i++)
         {
             if (text[i] != ' ') { buffer[j] = text[i]; j++; }
         }
@@ -1759,8 +1750,8 @@ char *GetTextBetween(const char *text, const char *begin, const char *end)
         {
             endIndex += (beginIndex + beginLen);
             int len = (endIndex - beginIndex - beginLen);
-            if (len < (MAX_TEXT_BUFFER_LENGTH - 1)) memcpy(buffer, text + beginIndex + beginLen, len);
-            else snprintf(buffer, MAX_TEXT_BUFFER_LENGTH, "%s", text + beginIndex + beginLen);
+            if (len < (MAX_TEXT_BUFFER_LENGTH - 1)) strncpy(buffer, text + beginIndex + beginLen, len);
+            else strncpy(buffer, text + beginIndex + beginLen, MAX_TEXT_BUFFER_LENGTH - 1);
         }
     }
 
@@ -1768,7 +1759,7 @@ char *GetTextBetween(const char *text, const char *begin, const char *end)
 }
 
 // Replace text string
-// REQUIRES: strstr(), memcpy()
+// REQUIRES: strstr(), strncpy()
 // NOTE: Limited text replace functionality, using static string
 char *TextReplace(const char *text, const char *search, const char *replacement)
 {
@@ -1825,7 +1816,7 @@ char *TextReplace(const char *text, const char *search, const char *replacement)
 
             // Copy remaind text part after replacement to result (pointed by moving temp)
             // NOTE: Text pointer internal copy has been updated along the process
-            memcpy(tempPtr, text, TextLength(text));
+            strncpy(tempPtr, text, TextLength(text));
         }
         else TRACELOG(LOG_WARNING, "Text with replacement is longer than internal buffer, use TextReplaceAlloc()");
     }
@@ -1834,7 +1825,7 @@ char *TextReplace(const char *text, const char *search, const char *replacement)
 }
 
 // Replace text string
-// REQUIRES: strstr(), memcpy()
+// REQUIRES: strstr(), strncpy()
 // WARNING: Allocated memory must be manually freed
 char *TextReplaceAlloc(const char *text, const char *search, const char *replacement)
 {
@@ -1864,7 +1855,7 @@ char *TextReplaceAlloc(const char *text, const char *search, const char *replace
         int tempLen = textLen + (replaceLen - searchLen)*count + 1;
         temp = result = (char *)RL_CALLOC(tempLen, sizeof(char));
 
-        if (result != NULL) // Memory was allocated
+        if (result != NULL)   // Memory was allocated
         {
             // First time through the loop, all the variable are set correctly from here on,
             //  - 'temp' points to the end of the result string
@@ -1891,7 +1882,7 @@ char *TextReplaceAlloc(const char *text, const char *search, const char *replace
 
             // Copy remaind text part after replacement to result (pointed by moving temp)
             // NOTE: Text pointer internal copy has been updated along the process
-            memcpy(temp, text, TextLength(text));
+            strncpy(temp, text, TextLength(text));
         }
     }
 
@@ -1923,13 +1914,9 @@ char *TextReplaceBetween(const char *text, const char *begin, const char *end, c
                 int replaceLen = (replacement == NULL)? 0 : TextLength(replacement);
                 //int toreplaceLen = endIndex - beginIndex - beginLen;
 
-                if ((beginIndex + beginLen + replaceLen + (textLen - endIndex)) < (MAX_TEXT_BUFFER_LENGTH - 1))
-                {
-                    strncpy(buffer, text, beginIndex + beginLen); // Copy first text part
-                    if (replacement != NULL) strncpy(buffer + beginIndex + beginLen, replacement, replaceLen); // Copy replacement (if provided)
-                    strncpy(buffer + beginIndex + beginLen + replaceLen, text + endIndex, textLen - endIndex); // Copy end text part
-                }
-                else TRACELOG(LOG_WARNING, "TEXT: Text with replaced string is longer than internal buffer (MAX_TEXT_BUFFER_LENGTH)");
+                strncpy(buffer, text, beginIndex + beginLen); // Copy first text part
+                if (replacement != NULL) strncpy(buffer + beginIndex + beginLen, replacement, replaceLen); // Copy replacement (if provided)
+                strncpy(buffer + beginIndex + beginLen + replaceLen, text + endIndex, textLen - endIndex); // Copy end text part
             }
         }
     }
@@ -1979,11 +1966,10 @@ char *TextInsert(const char *text, const char *insert, int position)
 {
     static char buffer[MAX_TEXT_BUFFER_LENGTH] = { 0 };
     memset(buffer, 0, MAX_TEXT_BUFFER_LENGTH);
-    int textLen = TextLength(text);
 
-    if ((text != NULL) && (insert != NULL) && (position >= 0))
+    if ((text != NULL) && (insert != NULL))
     {
-        if (position > textLen) position = textLen; // End of text string
+        int textLen = TextLength(text);
         int insertLen = TextLength(insert);
 
         if ((textLen + insertLen) < (MAX_TEXT_BUFFER_LENGTH - 1))
@@ -1991,8 +1977,8 @@ char *TextInsert(const char *text, const char *insert, int position)
             // TODO: Allow copying data inserted up to maximum buffer size and stop
 
             for (int i = 0; i < position; i++) buffer[i] = text[i];
-            for (int i = 0; i < insertLen; i++) buffer[i+position] = insert[i];
-            for (int i = position; i < textLen; i++) buffer[i+insertLen] = text[i];
+            for (int i = position; i < insertLen + position; i++) buffer[i] = insert[i - position];
+            for (int i = (insertLen + position); i < (textLen + insertLen); i++) buffer[i] = text[i];
 
             buffer[textLen + insertLen] = '\0'; // Add EOL
         }
@@ -2007,18 +1993,17 @@ char *TextInsert(const char *text, const char *insert, int position)
 char *TextInsertAlloc(const char *text, const char *insert, int position)
 {
     char *result = NULL;
-    int textLen = TextLength(text);
 
-    if ((text != NULL) && (insert != NULL) && (position >= 0))
+    if ((text != NULL) && (insert != NULL))
     {
-        if (position > textLen) position = textLen; // End of text string
+        int textLen = TextLength(text);
         int insertLen = TextLength(insert);
 
         result = (char *)RL_MALLOC(textLen + insertLen + 1);
 
         for (int i = 0; i < position; i++) result[i] = text[i];
-        for (int i = 0; i < insertLen; i++) result[i+position] = insert[i];
-        for (int i = position; i < textLen; i++) result[i+insertLen] = text[i];
+        for (int i = position; i < insertLen + position; i++) result[i] = insert[i - position];
+        for (int i = (insertLen + position); i < (textLen + insertLen); i++) result[i] = text[i];
 
         result[textLen + insertLen] = '\0'; // Add EOL
     }
@@ -2042,7 +2027,7 @@ char *TextJoin(char **textList, int count, const char *delimiter)
         int textLength = TextLength(textList[i]);
 
         // Make sure joined text could fit inside MAX_TEXT_BUFFER_LENGTH
-        if ((totalLength + textLength + delimiterLen) < MAX_TEXT_BUFFER_LENGTH)
+        if ((totalLength + textLength) < MAX_TEXT_BUFFER_LENGTH)
         {
             memcpy(textPtr, textList[i], textLength);
             totalLength += textLength;
@@ -2206,43 +2191,18 @@ char *TextToSnake(const char *text)
     if (text != NULL)
     {
         // Check for next separator to upper case another character
-        for (int i = 0, j = 0; (i < MAX_TEXT_BUFFER_LENGTH - 1) && (text[j] != '\0'); j++)
+        for (int i = 0, j = 0; (i < MAX_TEXT_BUFFER_LENGTH - 1) && (text[j] != '\0'); i++, j++)
         {
-            if (text[j] == ' ')
+            if ((text[j] >= 'A') && (text[j] <= 'Z'))
             {
-                if ((i > 0) && (buffer[i - 1] != '_'))
+                if (i >= 1)
                 {
                     buffer[i] = '_';
                     i++;
                 }
-            }
-            else if ((text[j] >= 'A') && (text[j] <= 'Z'))
-            {
-                if ((i > 0) && (buffer[i - 1] != '_'))
-                {
-                    char prev = text[j - 1];
-                    char next = text[j + 1];
-
-                    // Considering multiple cap leters to be on single word (HTTPRequest --> http_request)
-                    if (((prev >= 'a') && (prev <= 'z')) ||
-                        (((prev >= 'A') && (prev <= 'Z')) && ((next >= 'a') && (next <= 'z'))))
-                    {
-                        if (i < MAX_TEXT_BUFFER_LENGTH - 2)
-                        {
-                            buffer[i] = '_';
-                            i++;
-                        }
-                    }
-                }
-
                 buffer[i] = text[j] + 32;
-                i++;
-            }
-            else
-            {
-                buffer[i] = text[j];
-                i++;
             }
+            else buffer[i] = text[j];
         }
     }
 
@@ -2707,8 +2667,8 @@ static Font LoadBMFont(const char *fileName)
         for (int i = 1; i < pageCount; i++)
         {
             Rectangle srcRec = { 0.0f, 0.0f, (float)imWidth, (float)imHeight };
-            Rectangle dstRec = { 0.0f, (float)imHeight*(float)i, (float)imWidth, (float)imHeight };
-            ImageDrawImagePro(&fullFont, imFonts[i], srcRec, dstRec, (Vector2){ 0 }, 0.0f, WHITE);
+            Rectangle destRec = { 0.0f, (float)imHeight*(float)i, (float)imWidth, (float)imHeight };
+            ImageDraw(&fullFont, imFonts[i], srcRec, destRec, WHITE);
         }
     }
 
@@ -2740,7 +2700,7 @@ static Font LoadBMFont(const char *fileName)
                        &charId, &charX, &charY, &charWidth, &charHeight, &charOffsetX, &charOffsetY, &charAdvanceX, &pageID);
         fileTextPtr += (readBytes + 1);
 
-        if (readVars == 9) // Make sure all char data has been properly read
+        if (readVars == 9)  // Make sure all char data has been properly read
         {
             // Get character rectangle in the font atlas texture
             font.recs[i] = (Rectangle){ (float)charX, (float)charY + (float)imHeight*pageID, (float)charWidth, (float)charHeight };
diff --git a/src/libraries/raylib/raylib/src/rtextures.c b/src/libraries/raylib/raylib/src/rtextures.c
index e630771..bfe9efe 100644
--- a/src/libraries/raylib/raylib/src/rtextures.c
+++ b/src/libraries/raylib/raylib/src/rtextures.c
@@ -12,7 +12,6 @@
 *       #define SUPPORT_FILEFORMAT_JPG      0
 *       #define SUPPORT_FILEFORMAT_GIF      1
 *       #define SUPPORT_FILEFORMAT_QOI      1
-*       #define SUPPORT_FILEFORMAT_PEP      1
 *       #define SUPPORT_FILEFORMAT_PSD      0
 *       #define SUPPORT_FILEFORMAT_HDR      0
 *       #define SUPPORT_FILEFORMAT_PIC      0
@@ -70,7 +69,6 @@
 #include <string.h>             // Required for: strlen() [Used in ImageTextEx()], strcmp() [Used in LoadImageFromMemory()/LoadImageAnimFromMemory()/ExportImageToMemory()]
 #include <math.h>               // Required for: fabsf() [Used in DrawTextureRec()]
 #include <stdio.h>              // Required for: sprintf() [Used in ExportImageAsCode()]
-#include <limits.h>             // Required for: INT_MAX
 
 // Support only desired texture formats on stb_image
 #if !SUPPORT_FILEFORMAT_BMP
@@ -190,15 +188,7 @@
     #if defined(_MSC_VER)
         #pragma warning(pop)            // Disable MSVC warning suppression
     #endif
-#endif
 
-#if SUPPORT_FILEFORMAT_PEP
-	#define PEP_MALLOC RL_MALLOC
-	#define PEP_REALLOC RL_REALLOC
-	#define PEP_FREE RL_FREE
-
-    #define PEP_IMPLEMENTATION
-    #include "external/pep.h"
 #endif
 
 #if SUPPORT_IMAGE_EXPORT
@@ -315,7 +305,7 @@ Image LoadImageRaw(const char *fileName, int width, int height, int format, int
         unsigned char *dataPtr = fileData;
         int size = GetPixelDataSize(width, height, format);
 
-        if (size <= dataSize) // Security check
+        if (size <= dataSize)   // Security check
         {
             // Offset file data to expected raw image by header size
             if ((headerSize > 0) && ((headerSize + size) <= dataSize)) dataPtr += headerSize;
@@ -520,31 +510,6 @@ Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, i
         }
     }
 #endif
-#if SUPPORT_FILEFORMAT_PEP
-    else if ((strcmp(fileType, ".pep") == 0) || (strcmp(fileType, ".PEP") == 0))
-    {
-        if (fileData != NULL)
-        {
-            // Deserialize file data into pep structure
-            pep p = pep_deserialize(fileData, dataSize);
-
-            // Decompress pep data for image struct
-            // Decompression options:
-            //  - First color transparent, 3rd parameter: 1
-            //  - Premultiply alpha on loading, 4th parameter: 1
-            unsigned int *pepData = pep_decompress(&p, pep_rgba, 1, 1);
-
-            image.data = pepData;
-            image.width = p.width;
-            image.height = p.height;
-            image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
-            image.mipmaps = 1;
-
-            PEP_FREE(pepData);
-            pep_free(&p);
-        }
-    }
-#endif
 #if SUPPORT_FILEFORMAT_DDS
     else if ((strcmp(fileType, ".dds") == 0) || (strcmp(fileType, ".DDS") == 0))
     {
@@ -597,18 +562,15 @@ Image LoadImageFromTexture(Texture2D texture)
         {
             image.width = texture.width;
             image.height = texture.height;
-#if defined(FBO_READ_TEXTURE_AS_RGBA)
-            // WARNING: On OpenGL ES 2.0/WebGL 1.0, there is no glGetTexImage() so,
-            // texture data is retrieved by creating an RGBA fbo, binding the texture
-            // to the fbo color attachment, and reading it as RGBA data with glReadPixels()
-            // Returned data *should* be RGBA but it seems on some platforms (RPI, WASM)
-            // original texture format is retrieved, so adding a define for this patch
-            image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
-#else
             image.format = texture.format;
-#endif
             image.mipmaps = 1;
 
+#if defined(GRAPHICS_API_OPENGL_ES2)
+            // NOTE: Data retrieved on OpenGL ES 2.0 should be RGBA,
+            // coming from FBO color buffer attachment, but it seems
+            // original texture format is retrieved on RPI...
+            image.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
+#endif
             TRACELOG(LOG_INFO, "TEXTURE: [ID %i] Pixel data retrieved successfully", texture.id);
         }
         else TRACELOG(LOG_WARNING, "TEXTURE: [ID %i] Failed to retrieve pixel data", texture.id);
@@ -618,7 +580,7 @@ Image LoadImageFromTexture(Texture2D texture)
     return image;
 }
 
-// Load image from screen buffer (screenshot)
+// Load image from screen buffer and (screenshot)
 Image LoadImageFromScreen(void)
 {
     Image image = { 0 };
@@ -716,25 +678,6 @@ bool ExportImage(Image image, const char *fileName)
         }
     }
 #endif
-#if SUPPORT_FILEFORMAT_PEP
-    else if (IsFileExtension(fileName, ".pep"))
-    {
-        if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
-        {
-            // NOTE: Only RGBA 32bit (8bit per channel) image format supported
-            pep p = pep_compress(image.data, image.width, image.height, pep_rgba, pep_8bit);
-
-            unsigned int pepDataSize = 0;
-            unsigned char *pepData = pep_serialize(&p, &pepDataSize);
-
-            result = SaveFileData(fileName, pepData, pepDataSize);
-
-            PEP_FREE(pepData);
-            pep_free(&p);
-        }
-        else TRACELOG(LOG_WARNING, "IMAGE: Image can not be exported, .pep requires RGBA 32bit input");
-    }
-#endif
 #if SUPPORT_FILEFORMAT_KTX
     else if (IsFileExtension(fileName, ".ktx"))
     {
@@ -814,7 +757,7 @@ bool ExportImageAsCode(Image image, const char *fileName)
 
     // Get file name from path and convert variable name to uppercase
     char varFileName[256] = { 0 };
-    snprintf(varFileName, 256, "%s", GetFileNameWithoutExt(fileName)); // NOTE: Using function provided by [rcore] module
+    strncpy(varFileName, GetFileNameWithoutExt(fileName), 256 - 1); // NOTE: Using function provided by [rcore] module
     for (int i = 0; varFileName[i] != '\0'; i++) if ((varFileName[i] >= 'a') && (varFileName[i] <= 'z')) { varFileName[i] = varFileName[i] - 32; }
 
     // Add image information
@@ -844,10 +787,9 @@ bool ExportImageAsCode(Image image, const char *fileName)
 // Generate image: plain color
 Image GenImageColor(int width, int height, Color color)
 {
-    int dataSize = GetPixelDataSize(width, height, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8);
-    Color *pixels = (Color *)RL_CALLOC(dataSize, 1);
+    Color *pixels = (Color *)RL_CALLOC(width*height, sizeof(Color));
 
-    for (int i = 0; (pixels != NULL) && (i < width*height); i++) pixels[i] = color;
+    for (int i = 0; i < width*height; i++) pixels[i] = color;
 
     Image image = {
         .data = pixels,
@@ -1230,34 +1172,18 @@ Image ImageFromImage(Image image, Rectangle rec)
 {
     Image result = { 0 };
 
-    // Security check to avoid program crash
-    if ((image.data == NULL) || (image.width == 0) || (image.height == 0)) return result;
+    int bytesPerPixel = GetPixelDataSize(1, 1, image.format);
 
-    if (image.format < PIXELFORMAT_COMPRESSED_DXT1_RGB)
-	{
-        // Basic rectangle validation: size smaller than image size
-        if ((rec.x >= 0) && (rec.y >= 0) && (rec.width > 0) && (rec.height > 0) &&
-            (((int)rec.x + (int)rec.width) <= image.width) &&
-            (((int)rec.y + (int)rec.height) <= image.height))
-        {
-            int bytesPerPixel = GetPixelDataSize(1, 1, image.format);
+    result.width = (int)rec.width;
+    result.height = (int)rec.height;
+    result.data = RL_CALLOC((int)rec.width*(int)rec.height*bytesPerPixel, 1);
+    result.format = image.format;
+    result.mipmaps = 1;
 
-            result.width = (int)rec.width;
-            result.height = (int)rec.height;
-            result.data = RL_CALLOC((int)rec.width*(int)rec.height*bytesPerPixel, 1);
-            result.format = image.format;
-            result.mipmaps = 1;
-
-            for (int y = 0; y < (int)rec.height; y++)
-            {
-                memcpy(((unsigned char *)result.data) + y*(int)rec.width*bytesPerPixel,
-                    ((unsigned char *)image.data) + ((y + (int)rec.y)*image.width + (int)rec.x)*bytesPerPixel,
-                    (int)rec.width*bytesPerPixel);
-            }
-        }
-        else TRACELOG(LOG_WARNING, "IMAGE: ImageToImage(), rectangle provided not valid");
-	}
-    else TRACELOG(LOG_WARNING, "IMAGE: Image manipulation not supported for compressed formats");
+    for (int y = 0; y < (int)rec.height; y++)
+    {
+        memcpy(((unsigned char *)result.data) + y*(int)rec.width*bytesPerPixel, ((unsigned char *)image.data) + ((y + (int)rec.y)*image.width + (int)rec.x)*bytesPerPixel, (int)rec.width*bytesPerPixel);
+    }
 
     return result;
 }
@@ -1574,8 +1500,7 @@ Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Co
             if ((codepoint != ' ') && (codepoint != '\t'))
             {
                 Rectangle rec = { (float)(textOffsetX + font.glyphs[index].offsetX), (float)(textOffsetY + font.glyphs[index].offsetY), (float)font.recs[index].width, (float)font.recs[index].height };
-                ImageDrawImagePro(&imText, font.glyphs[index].image, (Rectangle){ 0, 0, (float)font.glyphs[index].image.width, (float)font.glyphs[index].image.height },
-                    rec, (Vector2){ 0 }, 0.0f, tint);
+                ImageDraw(&imText, font.glyphs[index].image, (Rectangle){ 0, 0, (float)font.glyphs[index].image.width, (float)font.glyphs[index].image.height }, rec, tint);
             }
 
             if (font.glyphs[index].advanceX == 0) textOffsetX += (int)(font.recs[index].width + spacing);
@@ -1819,7 +1744,7 @@ void ImageResize(Image *image, int newWidth, int newHeight)
     // Security check to avoid program crash
     if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
 
-    // Check if fast path can be used on image scaling
+    // Check if a fast path can be used on image scaling
     // It can be for 8 bit per channel images with 1 to 4 channels per pixel
     if ((image->format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) ||
         (image->format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) ||
@@ -2702,49 +2627,45 @@ void ImageRotate(Image *image, int degrees)
         int width = (int)(fabsf(image->width*cosRadius) + fabsf(image->height*sinRadius));
         int height = (int)(fabsf(image->height*cosRadius) + fabsf(image->width*sinRadius));
 
-        int dataSize = GetPixelDataSize(width, height, image->format);
         int bytesPerPixel = GetPixelDataSize(1, 1, image->format);
-        unsigned char *rotatedData = (unsigned char *)RL_CALLOC(dataSize, 1);
+        unsigned char *rotatedData = (unsigned char *)RL_CALLOC(width*height, bytesPerPixel);
 
-        if (rotatedData != NULL)
+        for (int y = 0; y < height; y++)
         {
-            for (int y = 0; y < height; y++)
+            for (int x = 0; x < width; x++)
             {
-                for (int x = 0; x < width; x++)
+                float oldX = ((x - width/2.0f)*cosRadius + (y - height/2.0f)*sinRadius) + image->width/2.0f;
+                float oldY = ((y - height/2.0f)*cosRadius - (x - width/2.0f)*sinRadius) + image->height/2.0f;
+
+                if ((oldX >= 0) && (oldX < image->width) && (oldY >= 0) && (oldY < image->height))
                 {
-                    float oldX = ((x - width/2.0f)*cosRadius + (y - height/2.0f)*sinRadius) + image->width/2.0f;
-                    float oldY = ((y - height/2.0f)*cosRadius - (x - width/2.0f)*sinRadius) + image->height/2.0f;
+                    int x1 = (int)floorf(oldX);
+                    int y1 = (int)floorf(oldY);
+                    int x2 = MIN(x1 + 1, image->width - 1);
+                    int y2 = MIN(y1 + 1, image->height - 1);
 
-                    if ((oldX >= 0) && (oldX < image->width) && (oldY >= 0) && (oldY < image->height))
+                    float px = oldX - x1;
+                    float py = oldY - y1;
+
+                    for (int i = 0; i < bytesPerPixel; i++)
                     {
-                        int x1 = (int)floorf(oldX);
-                        int y1 = (int)floorf(oldY);
-                        int x2 = MIN(x1 + 1, image->width - 1);
-                        int y2 = MIN(y1 + 1, image->height - 1);
+                        float f1 = ((unsigned char *)image->data)[(y1*image->width + x1)*bytesPerPixel + i];
+                        float f2 = ((unsigned char *)image->data)[(y1*image->width + x2)*bytesPerPixel + i];
+                        float f3 = ((unsigned char *)image->data)[(y2*image->width + x1)*bytesPerPixel + i];
+                        float f4 = ((unsigned char *)image->data)[(y2*image->width + x2)*bytesPerPixel + i];
 
-                        float px = oldX - x1;
-                        float py = oldY - y1;
+                        float val = f1*(1 - px)*(1 - py) + f2*px*(1 - py) + f3*(1 - px)*py + f4*px*py;
 
-                        for (int i = 0; i < bytesPerPixel; i++)
-                        {
-                            float f1 = ((unsigned char *)image->data)[(y1*image->width + x1)*bytesPerPixel + i];
-                            float f2 = ((unsigned char *)image->data)[(y1*image->width + x2)*bytesPerPixel + i];
-                            float f3 = ((unsigned char *)image->data)[(y2*image->width + x1)*bytesPerPixel + i];
-                            float f4 = ((unsigned char *)image->data)[(y2*image->width + x2)*bytesPerPixel + i];
-
-                            float val = f1*(1 - px)*(1 - py) + f2*px*(1 - py) + f3*(1 - px)*py + f4*px*py;
-
-                            rotatedData[(y*width + x)*bytesPerPixel + i] = (unsigned char)val;
-                        }
+                        rotatedData[(y*width + x)*bytesPerPixel + i] = (unsigned char)val;
                     }
                 }
             }
-
-            RL_FREE(image->data);
-            image->data = rotatedData;
-            image->width = width;
-            image->height = height;
         }
+
+        RL_FREE(image->data);
+        image->data = rotatedData;
+        image->width = width;
+        image->height = height;
     }
 }
 
@@ -2874,7 +2795,7 @@ void ImageColorGrayscale(Image *image)
 
 // Modify image color: contrast
 // NOTE: Contrast values between -100 and 100
-void ImageColorContrast(Image *image, int contrast)
+void ImageColorContrast(Image *image, float contrast)
 {
     // Security check to avoid program crash
     if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
@@ -2882,8 +2803,8 @@ void ImageColorContrast(Image *image, int contrast)
     if (contrast < -100) contrast = -100;
     if (contrast > 100) contrast = 100;
 
-    float factor = (float)(100.0f + contrast)/100.0f;
-    factor *= factor;
+    contrast = (100.0f + contrast)/100.0f;
+    contrast *= contrast;
 
     Color *pixels = LoadImageColors(*image);
 
@@ -2891,7 +2812,7 @@ void ImageColorContrast(Image *image, int contrast)
     {
         float pR = (float)pixels[i].r/255.0f;
         pR -= 0.5f;
-        pR *= factor;
+        pR *= contrast;
         pR += 0.5f;
         pR *= 255;
         if (pR < 0) pR = 0;
@@ -2899,7 +2820,7 @@ void ImageColorContrast(Image *image, int contrast)
 
         float pG = (float)pixels[i].g/255.0f;
         pG -= 0.5f;
-        pG *= factor;
+        pG *= contrast;
         pG += 0.5f;
         pG *= 255;
         if (pG < 0) pG = 0;
@@ -2907,7 +2828,7 @@ void ImageColorContrast(Image *image, int contrast)
 
         float pB = (float)pixels[i].b/255.0f;
         pB -= 0.5f;
-        pB *= factor;
+        pB *= contrast;
         pB += 0.5f;
         pB *= 255;
         if (pB < 0) pB = 0;
@@ -3585,7 +3506,7 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
     }
 
     // Initialize variables for drawing loop
-    int endVal = longLen + 1;
+    int endVal = longLen;
     int sgnInc = 1;
 
     // Adjust direction increment based on longLen sign
@@ -3593,7 +3514,6 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
     {
         longLen = -longLen;
         sgnInc = -1;
-        endVal -= 2;
     }
 
     // Calculate fixed-point increment for shorter length
@@ -3603,8 +3523,7 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
     if (yLonger)
     {
         // If line is more vertical, iterate over y-axis
-		// Init j with 0.5 in 16-bit fixed point (1 << 15) for better rounding.
-        for (int i = 0, j = (1 << 15); i != endVal; i += sgnInc, j += decInc)
+        for (int i = 0, j = 0; i != endVal; i += sgnInc, j += decInc)
         {
             // Calculate pixel position and draw it
             ImageDrawPixel(dst, startPosX + (j >> 16), startPosY + i, color);
@@ -3613,7 +3532,7 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
     else
     {
         // If line is more horizontal, iterate over x-axis
-        for (int i = 0, j = (1 << 15); i != endVal; i += sgnInc, j += decInc)
+        for (int i = 0, j = 0; i != endVal; i += sgnInc, j += decInc)
         {
             // Calculate pixel position and draw it
             ImageDrawPixel(dst, startPosX + i, startPosY + (j >> 16), color);
@@ -3688,15 +3607,137 @@ void ImageDrawLineEx(Image *dst, Vector2 start, Vector2 end, int thick, Color co
     }
 }
 
-// Draw a lines sequence within an image
-void ImageDrawLineStrip(Image *dst, const Vector2 *points, int pointCount, Color color)
+// Draw circle within an image
+void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color)
 {
-    for (int i = 0; i < pointCount - 1; i++)
+    int x = 0;
+    int y = radius;
+    int decesionParameter = 3 - 2*radius;
+
+    while (y >= x)
     {
-        ImageDrawLineV(dst, points[i], points[i + 1], color);
+        ImageDrawRectangle(dst, centerX - x, centerY + y, x*2, 1, color);
+        ImageDrawRectangle(dst, centerX - x, centerY - y, x*2, 1, color);
+        ImageDrawRectangle(dst, centerX - y, centerY + x, y*2, 1, color);
+        ImageDrawRectangle(dst, centerX - y, centerY - x, y*2, 1, color);
+        x++;
+
+        if (decesionParameter > 0)
+        {
+            y--;
+            decesionParameter = decesionParameter + 4*(x - y) + 10;
+        }
+        else decesionParameter = decesionParameter + 4*x + 6;
     }
 }
 
+// Draw circle within an image (Vector version)
+void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color)
+{
+    ImageDrawCircle(dst, (int)center.x, (int)center.y, radius, color);
+}
+
+// Draw circle outline within an image
+void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color)
+{
+    int x = 0;
+    int y = radius;
+    int decesionParameter = 3 - 2*radius;
+
+    while (y >= x)
+    {
+        ImageDrawPixel(dst, centerX + x, centerY + y, color);
+        ImageDrawPixel(dst, centerX - x, centerY + y, color);
+        ImageDrawPixel(dst, centerX + x, centerY - y, color);
+        ImageDrawPixel(dst, centerX - x, centerY - y, color);
+        ImageDrawPixel(dst, centerX + y, centerY + x, color);
+        ImageDrawPixel(dst, centerX - y, centerY + x, color);
+        ImageDrawPixel(dst, centerX + y, centerY - x, color);
+        ImageDrawPixel(dst, centerX - y, centerY - x, color);
+        x++;
+
+        if (decesionParameter > 0)
+        {
+            y--;
+            decesionParameter = decesionParameter + 4*(x - y) + 10;
+        }
+        else decesionParameter = decesionParameter + 4*x + 6;
+    }
+}
+
+// Draw circle outline within an image (Vector version)
+void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color)
+{
+    ImageDrawCircleLines(dst, (int)center.x, (int)center.y, radius, color);
+}
+
+// Draw rectangle within an image
+void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color)
+{
+    ImageDrawRectangleRec(dst, (Rectangle){ (float)posX, (float)posY, (float)width, (float)height }, color);
+}
+
+// Draw rectangle within an image (Vector version)
+void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color)
+{
+    ImageDrawRectangle(dst, (int)position.x, (int)position.y, (int)size.x, (int)size.y, color);
+}
+
+// Draw rectangle within an image
+void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color)
+{
+    // Security check to avoid program crash
+    if ((dst->data == NULL) || (dst->width == 0) || (dst->height == 0)) return;
+
+    // Security check to avoid drawing out of bounds in case of bad user data
+    if (rec.x < 0) { rec.width += rec.x; rec.x = 0; }
+    if (rec.y < 0) { rec.height += rec.y; rec.y = 0; }
+    if (rec.width < 0) rec.width = 0;
+    if (rec.height < 0) rec.height = 0;
+
+    // Clamp the size the the image bounds
+    if ((rec.x + rec.width) >= dst->width) rec.width = dst->width - rec.x;
+    if ((rec.y + rec.height) >= dst->height) rec.height = dst->height - rec.y;
+
+    // Check if the rect is even inside the image
+    if ((rec.x >= dst->width) || (rec.y >= dst->height)) return;
+    if (((rec.x + rec.width) <= 0) || (rec.y + rec.height <= 0)) return;
+
+    int sy = (int)rec.y;
+    int sx = (int)rec.x;
+
+    int bytesPerPixel = GetPixelDataSize(1, 1, dst->format);
+
+    // Fill in the first pixel of the first row based on image format
+    ImageDrawPixel(dst, sx, sy, color);
+
+    int bytesOffset = ((sy*dst->width) + sx)*bytesPerPixel;
+    unsigned char *pSrcPixel = (unsigned char *)dst->data + bytesOffset;
+
+    // Repeat the first pixel data throughout the row
+    for (int x = 1; x < (int)rec.width; x *= 2)
+    {
+        int pixelsToCopy = MIN(x, (int)rec.width - x);
+        memcpy(pSrcPixel + x*bytesPerPixel, pSrcPixel, pixelsToCopy*bytesPerPixel);
+    }
+
+    // Repeat the first row data for all other rows
+    int bytesPerRow = bytesPerPixel*(int)rec.width;
+    for (int y = 1; y < (int)rec.height; y++)
+    {
+        memcpy(pSrcPixel + (y*dst->width)*bytesPerPixel, pSrcPixel, bytesPerRow);
+    }
+}
+
+// Draw rectangle lines within an image
+void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color)
+{
+    ImageDrawRectangle(dst, (int)rec.x, (int)rec.y, (int)rec.width, thick, color);
+    ImageDrawRectangle(dst, (int)rec.x, (int)(rec.y + thick), thick, (int)(rec.height - thick*2), color);
+    ImageDrawRectangle(dst, (int)(rec.x + rec.width - thick), (int)(rec.y + thick), thick, (int)(rec.height - thick*2), color);
+    ImageDrawRectangle(dst, (int)rec.x, (int)(rec.y + rec.height - thick), (int)rec.width, thick, color);
+}
+
 // Draw triangle within an image
 void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color)
 {
@@ -3765,7 +3806,7 @@ void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color col
 }
 
 // Draw triangle with interpolated colors within an image
-void ImageDrawTriangleGradient(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3)
+void ImageDrawTriangleEx(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3)
 {
     // Calculate the 2D bounding box of the triangle
     // Determine the minimum and maximum x and y coordinates of the triangle vertices
@@ -3882,186 +3923,9 @@ void ImageDrawTriangleStrip(Image *dst, const Vector2 *points, int pointCount, C
     }
 }
 
-// Draw rectangle within an image
-void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color)
-{
-    ImageDrawRectangleRec(dst, (Rectangle){ (float)posX, (float)posY, (float)width, (float)height }, color);
-}
-
-// Draw rectangle within an image (Vector version)
-void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color)
-{
-    ImageDrawRectangle(dst, (int)position.x, (int)position.y, (int)size.x, (int)size.y, color);
-}
-
-// Draw rectangle within an image
-void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color)
-{
-    // Security check to avoid program crash
-    if ((dst->data == NULL) || (dst->width == 0) || (dst->height == 0)) return;
-
-    // Security check to avoid drawing out of bounds in case of bad user data
-    if (rec.x < 0) { rec.width += rec.x; rec.x = 0; }
-    if (rec.y < 0) { rec.height += rec.y; rec.y = 0; }
-    if (rec.width < 0) rec.width = 0;
-    if (rec.height < 0) rec.height = 0;
-
-    // Clamp the size the the image bounds
-    if ((rec.x + rec.width) >= dst->width) rec.width = dst->width - rec.x;
-    if ((rec.y + rec.height) >= dst->height) rec.height = dst->height - rec.y;
-
-    // Check if the rect is even inside the image
-    if ((rec.x >= dst->width) || (rec.y >= dst->height)) return;
-    if (((rec.x + rec.width) <= 0) || (rec.y + rec.height <= 0)) return;
-
-    int sy = (int)rec.y;
-    int sx = (int)rec.x;
-
-    int bytesPerPixel = GetPixelDataSize(1, 1, dst->format);
-
-    // Fill in the first pixel of the first row based on image format
-    ImageDrawPixel(dst, sx, sy, color);
-
-    int bytesOffset = ((sy*dst->width) + sx)*bytesPerPixel;
-    unsigned char *pSrcPixel = (unsigned char *)dst->data + bytesOffset;
-
-    // Repeat the first pixel data throughout the row
-    for (int x = 1; x < (int)rec.width; x *= 2)
-    {
-        int pixelsToCopy = MIN(x, (int)rec.width - x);
-        memcpy(pSrcPixel + x*bytesPerPixel, pSrcPixel, pixelsToCopy*bytesPerPixel);
-    }
-
-    // Repeat the first row data for all other rows
-    int bytesPerRow = bytesPerPixel*(int)rec.width;
-    for (int y = 1; y < (int)rec.height; y++)
-    {
-        memcpy(pSrcPixel + (y*dst->width)*bytesPerPixel, pSrcPixel, bytesPerRow);
-    }
-}
-
-// Draw a color-filled rectangle with pro parameters within and image
-void ImageDrawRectanglePro(Image *dst, Rectangle rec, Vector2 origin, float rotation, Color color)
-{
-    // TODO: NEW: Implement ImageDrawRectanglePro()
-}
-
-// Draw rectangle lines within an image
-void ImageDrawRectangleLines(Image *dst, int posX, int posY, int width, int height, Color color)
-{
-    Rectangle rec = { (float)posX, (float)posY, (float)width, (float)height };
-    ImageDrawRectangleLinesEx(dst, rec, 1, color);
-}
-
-// Draw rectangle lines within an image with line thickness
-void ImageDrawRectangleLinesEx(Image *dst, Rectangle rec, int thick, Color color)
-{
-    ImageDrawRectangle(dst, (int)rec.x, (int)rec.y, (int)rec.width, thick, color);
-    ImageDrawRectangle(dst, (int)rec.x, (int)(rec.y + thick), thick, (int)(rec.height - thick*2), color);
-    ImageDrawRectangle(dst, (int)(rec.x + rec.width - thick), (int)(rec.y + thick), thick, (int)(rec.height - thick*2), color);
-    ImageDrawRectangle(dst, (int)rec.x, (int)(rec.y + rec.height - thick), (int)rec.width, thick, color);
-}
-
-// Draw rectangle with gradient colors within an image, counter-clockwise color order
-void ImageDrawRectangleGradientEx(Image *dst, Rectangle rec, Color col1, Color col2, Color col3, Color col4)
-{
-    // TODO: NEW: Implement ImageDrawRectangleGradientEx()
-}
-
-// Draw circle within an image
-void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color)
-{
-    int x = 0;
-    int y = radius;
-    int decesionParameter = 3 - 2*radius;
-
-    while (y >= x)
-    {
-        ImageDrawRectangle(dst, centerX - x, centerY + y, x*2, 1, color);
-        ImageDrawRectangle(dst, centerX - x, centerY - y, x*2, 1, color);
-        ImageDrawRectangle(dst, centerX - y, centerY + x, y*2, 1, color);
-        ImageDrawRectangle(dst, centerX - y, centerY - x, y*2, 1, color);
-        x++;
-
-        if (decesionParameter > 0)
-        {
-            y--;
-            decesionParameter = decesionParameter + 4*(x - y) + 10;
-        }
-        else decesionParameter = decesionParameter + 4*x + 6;
-    }
-}
-
-// Draw circle within an image (Vector version)
-void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color)
-{
-    ImageDrawCircle(dst, (int)center.x, (int)center.y, radius, color);
-}
-
-// Draw circle outline within an image
-void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color)
-{
-    int x = 0;
-    int y = radius;
-    int decesionParameter = 3 - 2*radius;
-
-    while (y >= x)
-    {
-        ImageDrawPixel(dst, centerX + x, centerY + y, color);
-        ImageDrawPixel(dst, centerX - x, centerY + y, color);
-        ImageDrawPixel(dst, centerX + x, centerY - y, color);
-        ImageDrawPixel(dst, centerX - x, centerY - y, color);
-        ImageDrawPixel(dst, centerX + y, centerY + x, color);
-        ImageDrawPixel(dst, centerX - y, centerY + x, color);
-        ImageDrawPixel(dst, centerX + y, centerY - x, color);
-        ImageDrawPixel(dst, centerX - y, centerY - x, color);
-        x++;
-
-        if (decesionParameter > 0)
-        {
-            y--;
-            decesionParameter = decesionParameter + 4*(x - y) + 10;
-        }
-        else decesionParameter = decesionParameter + 4*x + 6;
-    }
-}
-
-// Draw circle outline within an image (Vector version)
-void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color)
-{
-    ImageDrawCircleLines(dst, (int)center.x, (int)center.y, radius, color);
-}
-
-// Draw a gradient-filled circle within an image
-void ImageDrawCircleGradient(Image *dst, Vector2 center, float radius, Color inner, Color outer)
-{
-    // TODO: NEW: Implement ImageDrawCircleGradient()
-}
-
-// Draw an image within an image
-void ImageDrawImage(Image *dst, Image src, int posX, int posY, Color tint)
-{
-    Rectangle srcRec = { 0.0f, 0.0f, (float)src.width, (float)src.height };
-    Rectangle dstRec = { (float)posX, (float)posY, srcRec.width, srcRec.height };
-    ImageDrawImagePro(dst, src, srcRec, dstRec, (Vector2){ 0 }, 0.0f, tint);
-}
-
-// Draw an image with scaling and rotation within an image
-void ImageDrawImageEx(Image *dst, Image src, Vector2 position, float rotation, float scale, Color tint)
-{
-    // TODO: NEW: Implement ImageDrawImageEx()
-}
-
-// Draw a part of an image defined by a rectangle within an image
-void ImageDrawImageRec(Image *dst, Image src, Rectangle srcRec, Vector2 position, Color tint)
-{
-    Rectangle dstRec = { position.x, position.y, srcRec.width, srcRec.height };
-    ImageDrawImagePro(dst, src, srcRec, dstRec, (Vector2){ 0 }, 0.0f, tint);
-}
-
-// Draw a part of an image defined by a rectangle into destination rectangle, with scaling and rotation, within an image
-// TODO: REVIEW: ImageDrawImagePro(), implement origin and rotation for image drawing
-void ImageDrawImagePro(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Vector2 origin, float rotation, Color tint)
+// Draw an image (source) within an image (destination)
+// NOTE: Color tint is applied to source image
+void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint)
 {
     // Security check to avoid program crash
     if ((dst->data == NULL) || (dst->width == 0) || (dst->height == 0) ||
@@ -4122,7 +3986,7 @@ void ImageDrawImagePro(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec
         //    [x] Consider fast path: no alpha blending required cases (src has no alpha)
         //    [x] Consider fast path: same src/dst format with no alpha -> direct line copy
         //    [-] GetPixelColor(): Get Vector4 instead of Color, easier for ColorAlphaBlend()
-        //    [-] Support 16bit and 32bit (float) channels drawing
+        //    [ ] TODO: Support 16bit and 32bit (float) channels drawing
 
         Color colSrc = { 0 };
         Color colDst = { 0 };
@@ -4206,7 +4070,7 @@ void ImageDrawImagePro(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec
             mipmapDstRec.x /= 2;
             mipmapDstRec.y /= 2;
 
-            ImageDrawImagePro(&mipmapDst, mipmapSrc, mipmapSrcRec, mipmapDstRec, (Vector2){ 0 }, 0.0f, tint);
+            ImageDraw(&mipmapDst, mipmapSrc, mipmapSrcRec, mipmapDstRec, tint);
         }
     }
 }
@@ -4233,17 +4097,11 @@ void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position,
     Rectangle srcRec = { 0.0f, 0.0f, (float)imText.width, (float)imText.height };
     Rectangle dstRec = { position.x, position.y, (float)imText.width, (float)imText.height };
 
-    ImageDrawImagePro(dst, imText, srcRec, dstRec, (Vector2){ 0 }, 0.0f, WHITE);
+    ImageDraw(dst, imText, srcRec, dstRec, WHITE);
 
     UnloadImage(imText);
 }
 
-// Draw text using Font and pro parameters (rotation)
-void ImageDrawTextPro(Image *dst, Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint)
-{
-    // TODO: NEW: Implement ImageDrawTextPro()
-}
-
 //------------------------------------------------------------------------------------
 // Texture loading functions
 //------------------------------------------------------------------------------------
@@ -4288,7 +4146,7 @@ TextureCubemap LoadTextureCubemap(Image image, int layout)
 {
     TextureCubemap cubemap = { 0 };
 
-    if (layout == CUBEMAP_LAYOUT_AUTO_DETECT) // Try to automatically guess layout type
+    if (layout == CUBEMAP_LAYOUT_AUTO_DETECT)      // Try to automatically guess layout type
     {
         // Check image width/height to determine the type of cubemap provided
         if (image.width > image.height)
@@ -4365,7 +4223,7 @@ TextureCubemap LoadTextureCubemap(Image image, int layout)
                 ImageMipmaps(&faces);
             }
 
-            for (int i = 0; i < 6; i++) ImageDrawImagePro(&faces, mipmapped, faceRecs[i], (Rectangle){ 0, (float)size*i, (float)size, (float)size }, (Vector2){ 0 }, 0.0f, WHITE);
+            for (int i = 0; i < 6; i++) ImageDraw(&faces, mipmapped, faceRecs[i], (Rectangle){ 0, (float)size*i, (float)size, (float)size }, WHITE);
 
             UnloadImage(mipmapped);
         }
@@ -4428,7 +4286,7 @@ RenderTexture2D LoadRenderTexture(int width, int height)
     return target;
 }
 
-// Check if texture is valid (loaded in GPU)
+// Check if a texture is valid (loaded in GPU)
 bool IsTextureValid(Texture2D texture)
 {
     bool result = false;
@@ -4453,7 +4311,7 @@ void UnloadTexture(Texture2D texture)
     }
 }
 
-// Check if render texture is valid (loaded in GPU)
+// Check if a render texture is valid (loaded in GPU)
 bool IsRenderTextureValid(RenderTexture2D target)
 {
     bool result = false;
@@ -4621,28 +4479,28 @@ void DrawTextureV(Texture2D texture, Vector2 position, Color tint)
     DrawTextureEx(texture, position, 0, 1.0f, tint);
 }
 
-// Draw a texture with rotation and scale
+// Draw a texture with extended parameters
 void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)
 {
-    Rectangle srcrec = { 0.0f, 0.0f, (float)texture.width, (float)texture.height };
-    Rectangle dstrec = { position.x, position.y, (float)texture.width*scale, (float)texture.height*scale };
+    Rectangle source = { 0.0f, 0.0f, (float)texture.width, (float)texture.height };
+    Rectangle dest = { position.x, position.y, (float)texture.width*scale, (float)texture.height*scale };
     Vector2 origin = { 0.0f, 0.0f };
 
-    DrawTexturePro(texture, srcrec, dstrec, origin, rotation, tint);
+    DrawTexturePro(texture, source, dest, origin, rotation, tint);
 }
 
 // Draw a part of a texture (defined by a rectangle)
-void DrawTextureRec(Texture2D texture, Rectangle rec, Vector2 position, Color tint)
+void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint)
 {
-    Rectangle dstrec = { position.x, position.y, fabsf(rec.width), fabsf(rec.height) };
+    Rectangle dest = { position.x, position.y, fabsf(source.width), fabsf(source.height) };
     Vector2 origin = { 0.0f, 0.0f };
 
-    DrawTexturePro(texture, rec, dstrec, origin, 0.0f, tint);
+    DrawTexturePro(texture, source, dest, origin, 0.0f, tint);
 }
 
 // Draw a part of a texture (defined by a rectangle) with 'pro' parameters
 // NOTE: origin is relative to destination rectangle size
-void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vector2 origin, float rotation, Color tint)
+void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint)
 {
     // Check if texture is valid
     if (texture.id > 0)
@@ -4652,11 +4510,11 @@ void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vecto
 
         bool flipX = false;
 
-        if (srcrec.width < 0) { flipX = true; srcrec.width *= -1; }
-        if (srcrec.height < 0) srcrec.y -= srcrec.height;
+        if (source.width < 0) { flipX = true; source.width *= -1; }
+        if (source.height < 0) source.y -= source.height;
 
-        if (dstrec.width < 0) dstrec.width *= -1;
-        if (dstrec.height < 0) dstrec.height *= -1;
+        if (dest.width < 0) dest.width *= -1;
+        if (dest.height < 0) dest.height *= -1;
 
         Vector2 topLeft = { 0 };
         Vector2 topRight = { 0 };
@@ -4666,33 +4524,33 @@ void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vecto
         // Only calculate rotation if needed
         if (rotation == 0.0f)
         {
-            float x = dstrec.x - origin.x;
-            float y = dstrec.y - origin.y;
+            float x = dest.x - origin.x;
+            float y = dest.y - origin.y;
             topLeft = (Vector2){ x, y };
-            topRight = (Vector2){ x + dstrec.width, y };
-            bottomLeft = (Vector2){ x, y + dstrec.height };
-            bottomRight = (Vector2){ x + dstrec.width, y + dstrec.height };
+            topRight = (Vector2){ x + dest.width, y };
+            bottomLeft = (Vector2){ x, y + dest.height };
+            bottomRight = (Vector2){ x + dest.width, y + dest.height };
         }
         else
         {
             float sinRotation = sinf(rotation*DEG2RAD);
             float cosRotation = cosf(rotation*DEG2RAD);
-            float x = dstrec.x;
-            float y = dstrec.y;
+            float x = dest.x;
+            float y = dest.y;
             float dx = -origin.x;
             float dy = -origin.y;
 
             topLeft.x = x + dx*cosRotation - dy*sinRotation;
             topLeft.y = y + dx*sinRotation + dy*cosRotation;
 
-            topRight.x = x + (dx + dstrec.width)*cosRotation - dy*sinRotation;
-            topRight.y = y + (dx + dstrec.width)*sinRotation + dy*cosRotation;
+            topRight.x = x + (dx + dest.width)*cosRotation - dy*sinRotation;
+            topRight.y = y + (dx + dest.width)*sinRotation + dy*cosRotation;
 
-            bottomLeft.x = x + dx*cosRotation - (dy + dstrec.height)*sinRotation;
-            bottomLeft.y = y + dx*sinRotation + (dy + dstrec.height)*cosRotation;
+            bottomLeft.x = x + dx*cosRotation - (dy + dest.height)*sinRotation;
+            bottomLeft.y = y + dx*sinRotation + (dy + dest.height)*cosRotation;
 
-            bottomRight.x = x + (dx + dstrec.width)*cosRotation - (dy + dstrec.height)*sinRotation;
-            bottomRight.y = y + (dx + dstrec.width)*sinRotation + (dy + dstrec.height)*cosRotation;
+            bottomRight.x = x + (dx + dest.width)*cosRotation - (dy + dest.height)*sinRotation;
+            bottomRight.y = y + (dx + dest.width)*sinRotation + (dy + dest.height)*cosRotation;
         }
 
         rlSetTexture(texture.id);
@@ -4702,23 +4560,23 @@ void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vecto
             rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
 
             // Top-left corner for texture and quad
-            if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
-            else rlTexCoord2f(srcrec.x/width, srcrec.y/height);
+            if (flipX) rlTexCoord2f((source.x + source.width)/width, source.y/height);
+            else rlTexCoord2f(source.x/width, source.y/height);
             rlVertex2f(topLeft.x, topLeft.y);
 
             // Bottom-left corner for texture and quad
-            if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
-            else rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
+            if (flipX) rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height);
+            else rlTexCoord2f(source.x/width, (source.y + source.height)/height);
             rlVertex2f(bottomLeft.x, bottomLeft.y);
 
             // Bottom-right corner for texture and quad
-            if (flipX) rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
-            else rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
+            if (flipX) rlTexCoord2f(source.x/width, (source.y + source.height)/height);
+            else rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height);
             rlVertex2f(bottomRight.x, bottomRight.y);
 
             // Top-right corner for texture and quad
-            if (flipX) rlTexCoord2f(srcrec.x/width, srcrec.y/height);
-            else rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
+            if (flipX) rlTexCoord2f(source.x/width, source.y/height);
+            else rlTexCoord2f((source.x + source.width)/width, source.y/height);
             rlVertex2f(topRight.x, topRight.y);
 
         rlEnd();
@@ -4732,7 +4590,7 @@ void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vecto
         /*
         rlSetTexture(texture.id);
         rlPushMatrix();
-            rlTranslatef(dstrec.x, dstrec.y, 0.0f);
+            rlTranslatef(dest.x, dest.y, 0.0f);
             if (rotation != 0.0f) rlRotatef(rotation, 0.0f, 0.0f, 1.0f);
             rlTranslatef(-origin.x, -origin.y, 0.0f);
 
@@ -4741,24 +4599,24 @@ void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vecto
                 rlNormal3f(0.0f, 0.0f, 1.0f);                          // Normal vector pointing towards viewer
 
                 // Bottom-left corner for texture and quad
-                if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
-                else rlTexCoord2f(srcrec.x/width, srcrec.y/height);
+                if (flipX) rlTexCoord2f((source.x + source.width)/width, source.y/height);
+                else rlTexCoord2f(source.x/width, source.y/height);
                 rlVertex2f(0.0f, 0.0f);
 
                 // Bottom-right corner for texture and quad
-                if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
-                else rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
-                rlVertex2f(0.0f, dstrec.height);
+                if (flipX) rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height);
+                else rlTexCoord2f(source.x/width, (source.y + source.height)/height);
+                rlVertex2f(0.0f, dest.height);
 
                 // Top-right corner for texture and quad
-                if (flipX) rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
-                else rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
-                rlVertex2f(dstrec.width, dstrec.height);
+                if (flipX) rlTexCoord2f(source.x/width, (source.y + source.height)/height);
+                else rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height);
+                rlVertex2f(dest.width, dest.height);
 
                 // Top-left corner for texture and quad
-                if (flipX) rlTexCoord2f(srcrec.x/width, srcrec.y/height);
-                else rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
-                rlVertex2f(dstrec.width, 0.0f);
+                if (flipX) rlTexCoord2f(source.x/width, source.y/height);
+                else rlTexCoord2f((source.x + source.width)/width, source.y/height);
+                rlVertex2f(dest.width, 0.0f);
             rlEnd();
         rlPopMatrix();
         rlSetTexture(0);
@@ -4766,16 +4624,16 @@ void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vecto
     }
 }
 
-// Draw a texture (or part of it) that stretches or shrinks nicely using n-patch info
-void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dstrec, Vector2 origin, float rotation, Color tint)
+// Draws a texture (or part of it) that stretches or shrinks nicely using n-patch info
+void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint)
 {
     if (texture.id > 0)
     {
         float width = (float)texture.width;
         float height = (float)texture.height;
 
-        float patchWidth = ((int)dstrec.width <= 0)? 0.0f : dstrec.width;
-        float patchHeight = ((int)dstrec.height <= 0)? 0.0f : dstrec.height;
+        float patchWidth = ((int)dest.width <= 0)? 0.0f : dest.width;
+        float patchHeight = ((int)dest.height <= 0)? 0.0f : dest.height;
 
         if (nPatchInfo.source.width < 0) nPatchInfo.source.x -= nPatchInfo.source.width;
         if (nPatchInfo.source.height < 0) nPatchInfo.source.y -= nPatchInfo.source.height;
@@ -4834,7 +4692,7 @@ void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dstre
         rlSetTexture(texture.id);
 
         rlPushMatrix();
-            rlTranslatef(dstrec.x, dstrec.y, 0.0f);
+            rlTranslatef(dest.x, dest.y, 0.0f);
             rlRotatef(rotation, 0.0f, 0.0f, 1.0f);
             rlTranslatef(-origin.x, -origin.y, 0.0f);
 
@@ -5313,7 +5171,7 @@ Color GetColor(unsigned int hexValue)
 }
 
 // Get color from a pixel from certain format
-Color GetPixelColor(const void *srcPtr, int format)
+Color GetPixelColor(void *srcPtr, int format)
 {
     Color color = { 0 };
 
@@ -5524,24 +5382,17 @@ int GetPixelDataSize(int width, int height, int format)
         default: break;
     }
 
-    unsigned long long dataSizeBytes = ((unsigned long long)width*height*bpp) >> 3;  // Get size in bytes (dividing by 8)
+    double bytesPerPixel = (double)bpp/8.0;
+    dataSize = (int)(bytesPerPixel*width*height); // Total data size in bytes
 
-    if (dataSizeBytes < INT_MAX)
+    // Most compressed formats works on 4x4 blocks,
+    // if texture is smaller, minimum dataSize is 8 or 16
+    if ((width < 4) && (height < 4))
     {
-        dataSize = (int)dataSizeBytes;
-
-        // Most compressed formats works on 4x4 blocks,
-        // if texture is smaller, minimum dataSize is 8 or 16
-        if ((width < 4) && (height < 4))
-        {
-            if ((format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8;
-            else if ((format >= PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
-        }
+        if ((format >= PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8;
+        else if ((format >= PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
     }
 
-    // NOTE: In case required image data larger than 2GB, no memory allocated at all (NULL)
-    if (dataSize == 0) TRACELOG(LOG_WARNING, "Requested image size is larger than 2GB, it can not be allocated");
-
     return dataSize;
 }
 
diff --git a/src/libraries/snths_ui/ui.odin b/src/libraries/snths_ui/ui.odin
index cf4e4bf..d09343b 100644
--- a/src/libraries/snths_ui/ui.odin
+++ b/src/libraries/snths_ui/ui.odin
@@ -66,7 +66,6 @@ ElementType :: enum {
 	ToggleGroup,
 	Label,
 	Divider,
-	Toggle,
 	Custom0, Custom1, Custom2, Custom3, Custom4, Custom5, Custom6, Custom7, Custom8, Custom9,
 }
 
diff --git a/src/main.odin b/src/main.odin
index bfac4fe..28237a7 100644
--- a/src/main.odin
+++ b/src/main.odin
@@ -1,6 +1,7 @@
-package game
+package main
 
 import rl "libraries/raylib"
+import "base:runtime"
 
 WINDOW_WIDTH :: 1280
 WINDOW_HEIGHT :: 720
@@ -9,10 +10,9 @@ WINDOW_CAPTION :: "Transformation Visualizer"
 
 init :: proc() {
 	rl.SetTraceLogLevel(.WARNING)
-	rl.SetConfigFlags({.VSYNC_HINT, .WINDOW_RESIZABLE})
+	rl.SetConfigFlags({.VSYNC_HINT})
 	rl.InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_CAPTION)
 	rl.SetTargetFPS(WINDOW_FRAMERATE)
-	rl.SetExitKey(.KEY_NULL)
 	program_init()
 }
 
@@ -34,7 +34,7 @@ shutdown :: proc() {
 
 should_run :: proc() -> bool {
 	when ODIN_OS != .JS {
-		if program.window_should_close || rl.WindowShouldClose() {
+		if program.window_should_close {
 			return false
 		}
 	}
diff --git a/src/main_desktop.odin b/src/main_desktop.odin
new file mode 100644
index 0000000..f469777
--- /dev/null
+++ b/src/main_desktop.odin
@@ -0,0 +1,24 @@
+package main
+
+import rl "libraries/raylib"
+import "core:log"
+import "libraries/back"
+
+main :: proc() {
+	// exe_path := os.args[0]
+	// exe_dir := filepath.dir(string(exe_path))
+	// os.set_working_directory(exe_dir)
+	rl.ChangeDirectory(rl.GetApplicationDirectory())
+	back.register_segfault_handler()
+	context.assertion_failure_proc = back.assertion_failure_proc
+	register_illegal_instruction_handler()
+
+
+	context.logger = log.create_console_logger()
+
+	init()
+	for should_run() {
+		update()
+	}
+	shutdown()
+}
diff --git a/src/web/main.odin b/src/main_web.odin
similarity index 97%
rename from src/web/main.odin
rename to src/main_web.odin
index 58fa6a8..b6b34ea 100644
--- a/src/web/main.odin
+++ b/src/main_web.odin
@@ -1,6 +1,7 @@
+#+build wasm32, wasm64p32
+
 package main
 
-import game ".."
 import "core:log"
 import "core:mem"
 import "core:c"
@@ -20,7 +21,6 @@ import "core:fmt"
 	context.allocator = emscripten_allocator()
 	runtime.init_global_temporary_allocator(1*mem.Megabyte)
 
-	// TODO (synthas): Do this if it works nicely
 	// Since we now use js_wasm32 we should be able to remove this and use
 	// context.logger = log.create_console_logger(). However, that one produces
 	// extra newlines on web. So it's a bug in that core lib.
@@ -28,23 +28,23 @@ import "core:fmt"
 
 	web_context = context
 
-	game.init()
+	init()
 }
 
 @export main_update :: proc "c" () -> bool {
 	context = web_context
-	game.update()
-	return game.should_run()
+	update()
+	return should_run()
 }
 
 @export main_end :: proc "c" () {
 	context = web_context
-	game.shutdown()
+	shutdown()
 }
 
 @export web_window_size_changed :: proc "c" (w: c.int, h: c.int) {
 	context = web_context
-	game.parent_window_size_changed(int(w), int(h))
+	parent_window_size_changed(int(w), int(h))
 }
 
 ///////////////////////////////////////////////////////
diff --git a/src/program.odin b/src/program.odin
index 6709ba9..27b677f 100644
--- a/src/program.odin
+++ b/src/program.odin
@@ -1,4 +1,4 @@
-package game
+package main
 
 /*
 	Rules of matrices:
@@ -31,6 +31,7 @@ import rl "libraries/raylib"
 import ui "libraries/snths_ui"
 import "core:mem"
 import "core:fmt"
+import "core:math"
 import "core:math/linalg"
 import "core:strings"
 import "core:slice"
@@ -50,7 +51,6 @@ RAYGUI_ICON_RESET :: "#211#"
 RAYGUI_ICON_TRASH :: "#143#"
 RAYGUI_ICON_DOWN :: "#120#"
 RAYGUI_ICON_UP :: "#121#"
-RAYGUI_ICON_SNAP :: "#136#"
 
 TRANSFORMATION_RECTANGLE_COLOR_ORIGIN :: rl.RED
 TRANSFORMATION_RECTANGLE_COLOR_MIDDLE :: rl.MAGENTA
@@ -81,16 +81,13 @@ UiElementData_Slider :: struct {
 UiElementData_FloatInput :: struct {
 	value: ^f32,
 	value_string: cstring,
+	tag: bit_set[enum{UpdateMatrix}],
 }
 
 UiElementData_TextInput :: struct {
 	str: cstring,
 }
 
-UiElementData_Toggle :: struct {
-	value: ^bool,
-}
-
 UiElementData_ToggleGroup :: struct {
 	value: ^i32,
 }
@@ -123,7 +120,6 @@ UiButtonType :: enum {
 	MatrixMoveUp,
 	MatrixMoveDown,
 	CenterView,
-	CloseProgram,
 }
 
 UiButtonRecalculateFinishGroup :: bit_set[UiButtonType]{
@@ -196,7 +192,6 @@ ProgramDialogType :: enum {
 	CreateSkewMatrix,
 	SaveProject,
 	LoadProject,
-	CloseUnsavedProjectPrompt,
 	Error,
 }
 
@@ -207,10 +202,17 @@ ProgramDialogType :: enum {
 	.CreateSkewMatrix = "Create skew matrix",
 	.SaveProject = "Save project",
 	.LoadProject = "Load project",
-	.CloseUnsavedProjectPrompt = "Unsaved project",
 	.Error = "Error",
 }
 
+ProgramMessageType :: enum {
+	ChangeMatrixTypeClearData,
+}
+
+@rodata program_messages := [ProgramMessageType]cstring {
+	.ChangeMatrixTypeClearData = "Changing the matrix type will delete all current matrices.\nAre you sure you want to do this?",
+}
+
 program: Program
 
 InputFloatField :: [32]byte
@@ -281,22 +283,19 @@ Program :: struct {
 	mouse_draggable_radius: f32,
 	project_save_string: [DIALOG_STATE_TEXT_INPUT_FIELD_COUNT]byte,
 	rotation_mode: RotationMode,
-	saved_project_data: ProjectData,
 	grid: Grid,
 	grid_zoom_x_only: bool,
 	grid_zoom_y_only: bool,
 	grid_zoom_speed: f32,
-	grid_snap: bool,
 	font_style: FontStyle,
 	state: ProgramState,
+	message_type: ProgramMessageType,
 	dialog_type: ProgramDialogType,
 	dialog_data: ProgramData_DialogState,
 	dialog_message: cstring,
 	animation: Animation,
 	animation_state: ProgramAnimationState,
 	animation_speed: f32,
-	animation_mode: AnimationMode,
-	animation_progress_string: [DIALOG_STATE_TEXT_INPUT_FIELD_COUNT]byte,
 	window_should_close: bool,
 }
 
@@ -323,6 +322,8 @@ matrix_pool_get_mat3 :: proc() -> (value_strings: []InputFloatField, values: []f
 
 matrix_move_to :: proc(floats: []f32, inputs: []InputFloatField, from, to: int) {
 	if from == to do return
+	floats := program.matrix_float_pool
+	inputs := program.matrix_value_string_pool
 	floats_values_size := size_of(f32) * 9
 	inputs_buffer_size := size_of(InputFloatField) * 9
 	floats_moving_matrix := &floats[from * 9]
@@ -340,20 +341,14 @@ matrix_move_to :: proc(floats: []f32, inputs: []InputFloatField, from, to: int)
 }
 
 program_save_project :: proc(program: ^Program, path: string) -> ProjectWriteError {
-	project := program_create_project_data(program^)
-	project_write(&project, path) or_return
-	program.saved_project_data = project
-	program.saved_project_data.matrices = slice.clone(program.saved_project_data.matrices)
-	return nil
-}
-
-program_create_project_data :: proc(program: Program) -> ProjectData {
-	return {
+	project := ProjectData {
 		matrix_count = u32(program.matrix_count),
 		matrices = program.matrix_float_pool,
 		grid = program.grid,
 		shapes = program.animation.shapes,
 	}
+	project_write(&project, path) or_return
+	return nil
 }
 
 program_save_project_from_project_string_or_open_dialog :: proc(program: ^Program) {
@@ -384,8 +379,6 @@ program_load_project :: proc(program: ^Program, path: string) -> ProjectReadErro
 		write_matrix_to_values_and_value_strings(program.matrix_float_pool[start:end], program.matrix_value_string_pool[start:end], mat)
 	}
 	program.animation.matrix_count = program.matrix_count
-	program.saved_project_data = project
-	program.saved_project_data.matrices = slice.clone(program.saved_project_data.matrices)
 	return nil
 }
 
@@ -433,6 +426,8 @@ program_init :: proc(allocator := context.allocator) {
 	animation_init(&program.animation, program.matrix_float_pool)
 
 	if err := program_load_project(&program, default_project_load_location); err != nil {
+		program_show_dialog(&program, .Error, fmt.caprint(typeid_of(type_of(err)), ".", err))
+	} else {
 		mem.copy(&program.project_save_string[0], raw_data(default_project_load_location), len(default_project_load_location))
 	}
 }
@@ -448,6 +443,7 @@ program_get_master_matrix :: proc() -> mat3 {
 
 program_set_animation_state :: proc(state: ProgramAnimationState) {
 	if program.animation_state == state do return
+	previous_state := program.animation_state
 	program.animation_state = state
 	switch program.animation_state {
 	case .Ready:
@@ -465,7 +461,6 @@ program_update :: proc() {
 
 	ui_elements, top_bar_container, matrix_container := program_build_workspace_ui(&program.ui_context)
 	ui_overlay_elements: []ui.Element
-	program.animation.matrix_count = program.matrix_count
 
 	switch program.state {
 	case .Normal:
@@ -516,6 +511,9 @@ program_update :: proc() {
 				}
 			}
 		}
+		if rl.WindowShouldClose() {
+			program.window_should_close = true
+		}
 	case .Dialog:
 		ui_overlay_elements = program_build_dialog_ui(&program.ui_overlay_context, program.dialog_type)
 		if program.ui_overlay_queue_focus_first {
@@ -549,42 +547,13 @@ program_update :: proc() {
 				} else {
 					program.state = .Normal
 				}
-			case .CloseUnsavedProjectPrompt:
-				program.window_should_close = true
 			case .Error:
 				program.state = .Normal
 			}
 			program.animation.matrix_count = program.matrix_count
 			program.state = .Normal
 		}
-	}
-
-	if rl.IsKeyPressed(.ESCAPE) {
-		switch program.state {
-		case .Normal:
-			when ODIN_OS != .JS {
-				current_project_data := program_create_project_data(program)
-
-				current_matrices_ptr := cast([^]byte)raw_data(current_project_data.matrices)
-				current_matrices := current_matrices_ptr[:current_project_data.matrix_count * 9 * 4]
-				last_saved_matrices_ptr := cast([^]byte)raw_data(program.saved_project_data.matrices)
-				last_saved_matrices := last_saved_matrices_ptr[:program.saved_project_data.matrix_count * 9 * 4]
-
-				current_project_grid_ptr := cast([^]byte)&current_project_data.grid
-				last_saved_grid_ptr := cast([^]byte)&program.saved_project_data.grid
-
-				current_project_shapes_ptr := cast([^]byte)&current_project_data.shapes
-				last_saved_shapes_ptr := cast([^]byte)&program.saved_project_data.shapes
-
-				if mem.compare(current_matrices, last_saved_matrices) == 0 &&
-			 		mem.compare(current_project_grid_ptr[:size_of(Grid)], last_saved_grid_ptr[:size_of(Grid)]) == 0 &&
-					mem.compare(current_project_shapes_ptr[:size_of(AnimationShapes)], last_saved_shapes_ptr[:size_of(AnimationShapes)]) == 0 {
-					program.window_should_close = true
-				}
-
-				program_show_dialog(&program, .CloseUnsavedProjectPrompt, "Are you sure you want to quit?");
-			}
-		case .Dialog:
+		if rl.WindowShouldClose() {
 			program.state = .Normal
 		}
 	}
@@ -599,17 +568,14 @@ program_update :: proc() {
 	grid_origin_color := rl.Color{255, 255, 255, 128}
 	draw_grid(program.grid, grid_area, rect_grow(grid_text_clip, -4.0), rect_grow(grid_text_clip, -32.0), grid_color, grid_origin_color)
 
-	shape_coord_string: cstring
 	{
 		animation := &program.animation
 
 		if program.animation_state == .Playing {
-			write_float_to_buffer(program.animation_progress_string[:], animation.matrix_index)
 			animation.matrix_index += 0.01
 		}
 
-		grid_to_world_matrix := linalg.inverse(grid_world_to_grid_matrix(program.grid.zoom, program.grid.offset))
-		animation_draw(animation, grid_to_world_matrix, program.animation_mode)
+		animation_draw(animation^, linalg.inverse(grid_world_to_grid_matrix(program.grid.zoom, program.grid.offset)))
 
 		switch animation.type {
 		case .Rectangle:
@@ -630,17 +596,6 @@ program_update :: proc() {
 				corners_ref = &animation.shapes.rectangle,
 				corner_ref = &animation.shapes.rectangle.br})
 			append(&program.mouse_draggables, MouseDraggable_RectangleData{&animation.shapes.rectangle})
-
-			rectangle_corners := animation.shapes_animated_last.rectangle
-			rectangle := rect_from_corners(rectangle_corners.tl, rectangle_corners.tr, rectangle_corners.br, rectangle_corners.bl)
-			rectangle_corners = rectangle_corners_from_rect(rectangle)
-			shape_coord_string = fmt.ctprintf(
-				"tl: {{%.2f, %.2f}}\ntr: {{%.2f, %.2f}}\nbr: {{%.2f, %.2f}}\nbl: {{%.2f, %.2f}}",
-				rectangle_corners.tl.x, rectangle_corners.tl.y,
-				rectangle_corners.tr.x, rectangle_corners.tr.y,
-				rectangle_corners.br.x, rectangle_corners.br.y,
-				rectangle_corners.bl.x, rectangle_corners.bl.y,
-			)
 		}
 	}
 
@@ -668,9 +623,6 @@ program_update :: proc() {
 			program.font_style,
 			ui_overlay_elements)
 	}
-
-	shape_coords_string_position := program_screen_size() - 4.0
-	draw_text_aligned(shape_coord_string, shape_coords_string_position, program.font_style, .Right, .Bottom, rl.WHITE)
 }
 
 program_add_identity_matrix :: proc() {
@@ -722,11 +674,15 @@ write_matrix_to_values_and_value_strings :: proc(values: []f32, value_strings: [
 }
 
 write_float_to_buffer :: proc(buffer: []byte, value: f32) {
-	switch {
-	case fract(value) == 0.0:         fmt.bprintf(buffer, "%.0f", value)
-	case fract(value * 10.0) == 0.0:  fmt.bprintf(buffer, "%.1f", value)
-	case fract(value * 100.0) == 0.0: fmt.bprintf(buffer, "%.2f", value)
-	case:                             fmt.bprintf(buffer, "%.3f", value)
+	fraction := fract(value)
+	if fraction == 0.0 {
+		fmt.bprintf(buffer, "%.0f", value)
+	} else if fract(fraction * 10.0) == 0.0 {
+		fmt.bprintf(buffer, "%.1f", value)
+	} else if fract(fraction * 100.0) == 0.0 {
+		fmt.bprintf(buffer, "%.2f", value)
+	} else {
+		fmt.bprintf(buffer, "%.3f", value)
 	}
 }
 
@@ -761,7 +717,7 @@ program_build_dialog_ui :: proc(ctx: ^ui.Context, dialog_type: ProgramDialogType
 			} else {
 				button_type = .AddScaleMatrixConfirm
 			}
-			ui_confirm_and_cancel_buttons("Add", button_type, element_margin)
+			ui_confirm_and_cancel_buttons(button_type, element_margin)
 		case .CreateRotationMatrix:
 			ui_labeled_input_float_element("Angle", 4.0, &dialog_data.input_float_values[0], &dialog_data.input_float_value_strings[0])
 			toggle_group_dimensions := ui.dimensions_pixels(128.0, 32.0)
@@ -770,19 +726,17 @@ program_build_dialog_ui :: proc(ctx: ^ui.Context, dialog_type: ProgramDialogType
 			toggle_group_data := new(UiElementData_ToggleGroup)
 			toggle_group_data^ = {value = cast(^i32)&program.rotation_mode}
 			ui.element(.ToggleGroup, toggle_group_dimensions, toggle_group_config, toggle_group_data)
-			ui_confirm_and_cancel_buttons("Add", .AddRotationMatrixConfirm, element_margin)
+			ui_confirm_and_cancel_buttons(.AddRotationMatrixConfirm, element_margin)
 		case .CreateSkewMatrix:
 			ui_labeled_input_float_element("X", 4.0, &dialog_data.input_float_values[0], &dialog_data.input_float_value_strings[0])
 			ui_labeled_input_float_element("Y", 4.0, &dialog_data.input_float_values[1], &dialog_data.input_float_value_strings[1])
-			ui_confirm_and_cancel_buttons("Add", .AddSkewMatrixConfirm, element_margin)
+			ui_confirm_and_cancel_buttons(.AddSkewMatrixConfirm, element_margin)
 		case .SaveProject:
 			ui_labeled_input_text_element("Path", 4.0, dialog_data.input_text_buffers[0][:])
-			ui_confirm_and_cancel_buttons("Add", .ProjectSaveConfirm, element_margin)
+			ui_confirm_and_cancel_buttons(.ProjectSaveConfirm, element_margin)
 		case .LoadProject:
 			ui_labeled_input_text_element("Path", 4.0, dialog_data.input_text_buffers[0][:])
-			ui_confirm_and_cancel_buttons("Add", .ProjectLoadConfirm, element_margin)
-		case .CloseUnsavedProjectPrompt:
-			ui_confirm_and_cancel_buttons("Confirm", .CloseProgram, element_margin)
+			ui_confirm_and_cancel_buttons(.ProjectLoadConfirm, element_margin)
 		case .Error:
 			button_data: ^UiElementData_Button
 			button_data = new(UiElementData_Button, context.temp_allocator)
@@ -805,7 +759,9 @@ program_build_workspace_ui :: proc(ctx: ^ui.Context) -> (elements: []ui.Element,
 	top_bar_inner_height := ui.get_element_inner_area(top_bar_container^).height
 	top_bar_button_width := ui.Size_Pixels(top_bar_inner_height)
 	top_bar_button_dimensions := ui.Dimensions {top_bar_button_width, ui.Size_Percentage(1.0)}
-
+	top_bar_button_config := ui.ElementConfiguration {margin = top_bar_element_margin}
+	top_bar_dropdown_dimensions := ui.Dimensions {ui.Size_Pixels(160.0), ui.Size_Percentage(1.0)}
+	top_bar_dropdown_config := ui.ElementConfiguration {margin = top_bar_element_margin}
 	{
 		button_margin := top_bar_element_margin
 		button_config: ui.ElementConfiguration
@@ -873,7 +829,7 @@ program_build_workspace_ui :: proc(ctx: ^ui.Context) -> (elements: []ui.Element,
 		ui.element(.Button, button_dimensions, button_config, button_data)
 
 		button_data = new(UiElementData_Button, context.temp_allocator)
-		button_tooltip = fmt.ctprint("Add skew\nmatrix", sep = "")
+		button_tooltip = fmt.ctprint("Add rotation\nmatrix", sep = "")
 		button_config = {margin = button_margin, label = RAYGUI_ICON_SKEW_MATRIX, tooltip = button_tooltip}
 		button_data^ = {type = .AddSkewMatrix}
 		ui.same_line()
@@ -884,6 +840,7 @@ program_build_workspace_ui :: proc(ctx: ^ui.Context) -> (elements: []ui.Element,
 		ui.same_line()
 		ui.element(.Divider, divider_dimensions, divider_config)
 
+		play_button_label: cstring
 		button_data = new(UiElementData_Button, context.temp_allocator)
 		switch program.animation_state {
 		case .Ready:
@@ -926,44 +883,6 @@ program_build_workspace_ui :: proc(ctx: ^ui.Context) -> (elements: []ui.Element,
 		}
 		ui.same_line()
 		ui.element(.Slider, slider_dimensions, slider_config, slider_data)
-
-		float_config: ui.ElementConfiguration
-		float_data: ^UiElementData_FloatInput
-		float_dimensions := ui.Dimensions{top_bar_button_width * 2.0, ui.Size_Percentage(1.0)}
-		float_config = {margin = top_bar_element_margin * 2}
-		float_data = new(UiElementData_FloatInput, context.temp_allocator)
-		float_data^ = {
-			value = &program.animation.matrix_index,
-			value_string = transmute(cstring)&program.animation_progress_string,
-		}
-		ui.same_line()
-		ui.element(.InputFloat, float_dimensions, float_config, float_data)
-
-		toggle_group_config: ui.ElementConfiguration
-		toggle_group_dimensions := ui.Dimensions{top_bar_button_width * 3.0, ui.Size_Percentage(1.0)}
-		toggle_group_data: ^UiElementData_ToggleGroup
-
-		toggle_group_config = {
-			margin = top_bar_element_margin * 2,
-			label = enum_to_raygui_options_string(AnimationMode, context.temp_allocator),
-			tooltip = "Play animation\nstep by step;Play animation using the\nfull transformation matrix"}
-		toggle_group_data = new(UiElementData_ToggleGroup, context.temp_allocator)
-		toggle_group_data^ = {value = cast(^i32)&program.animation_mode}
-		ui.same_line()
-		ui.element(.ToggleGroup, toggle_group_dimensions, toggle_group_config, toggle_group_data)
-
-		ui.same_line()
-		ui.element(.Divider, divider_dimensions, divider_config)
-
-		toggle_config: ui.ElementConfiguration
-		toggle_dimensions := ui.Dimensions{top_bar_button_width, ui.Size_Percentage(1.0)}
-		toggle_data: ^UiElementData_Toggle
-
-		toggle_config = {margin = top_bar_element_margin, label = RAYGUI_ICON_SNAP, tooltip = "Snap to grid"}
-		toggle_data = new(UiElementData_Toggle, context.temp_allocator)
-		toggle_data^ = {value = &program.grid_snap}
-		ui.same_line()
-		ui.element(.Toggle, toggle_dimensions, toggle_config, toggle_data)
 	}
 	ui.container_end()
 
@@ -1039,30 +958,16 @@ program_handle_mouse :: proc(mouse_state: MouseState, top_bar_container, matrix_
 			break state_label
 		}
 		draggable := program.mouse_current_draggable
-		drag_to_position := matrix3_transform_xy(world_to_grid_matrix, mouse)
-		if program.grid_snap {
-			grid_line_sep := grid_get_line_separation(program.grid.zoom, program.grid.cell_size_px)
-			drag_to_position = linalg.floor(drag_to_position / grid_line_sep) * grid_line_sep
-		}
-
 		switch draggable in draggable {
 		case MouseDraggable_Point:
-			draggable.ref^ = drag_to_position
+			draggable.ref^ = matrix3_transform_xy(world_to_grid_matrix, mouse)
 		case MouseDraggable_RectangleCornerData:
-			corners := rectangle_corners_move_corner(draggable.corners_ref^, drag_to_position, draggable.corner)
+			position := matrix3_transform_xy(world_to_grid_matrix, mouse)
+			corners := rectangle_corners_move_corner(draggable.corners_ref^, position, draggable.corner)
 			draggable.corners_ref^ = corners
 		case MouseDraggable_RectangleData:
-			if program.grid_snap {
-
-				prev_tl := draggable.corners.tl
-				draggable.corners.tl = drag_to_position
-				draggable.corners.tr += draggable.corners.tl - prev_tl
-				draggable.corners.br += draggable.corners.tl - prev_tl
-				draggable.corners.bl += draggable.corners.tl - prev_tl
-			} else {
-				mouse_delta_grid := rl.GetMouseDelta() * grid_get_zoom(program.grid.zoom)
-				draggable.corners^ = rectangle_corners_add(draggable.corners^, mouse_delta_grid)
-			}
+			mouse_delta_grid := rl.GetMouseDelta() * grid_get_zoom(program.grid.zoom)
+			draggable.corners^ = rectangle_corners_add(draggable.corners^, mouse_delta_grid)
 		}
 	case .DraggingGrid:
 		program.grid.offset -= rl.GetMouseDelta() * grid_get_zoom(program.grid.zoom)
@@ -1117,7 +1022,8 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 					animation_matrix_index := animation_get_eased_progress(program.animation)
 					matrix_animation_distance := element_matrix_index - animation_matrix_index
 					alpha := max(0.0, 1.0 - abs(matrix_animation_distance))
-					rl.DrawRectangleRec(area, rl.Color{128, 255, 128, u8(alpha * 64.0)})
+					color := rl.Color{128, 255, 128, u8(alpha * 64.0)}
+					rl.DrawRectangleRec(area, color)
 
 					matrix_area := ui.rect_grow(ui.rect2(area), element.margin / 2.0)
 					tl, tr, br, bl := ui.rect_get_corners(matrix_area)
@@ -1145,7 +1051,7 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 				// TODO (synthas): implement keeping the rectangle within screen borders
 				tooltip_position = rl.GetMousePosition()
 			}
-			if rl.GuiButton(area, element.label) == 1 {
+			if rl.GuiButton(area, element.label) {
 				if element.data == nil do break
 				data := cast(^UiElementData_Button)element.data
 				switch data.type {
@@ -1169,7 +1075,6 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 				case .AddSkewMatrixConfirm:
 					inputs := program.dialog_data.input_float_values
 					program_add_skew_matrix(inputs[0], inputs[1])
-					program.state = .Normal
 				case .ExitDialog:
 					program.state = .Normal
 				case .StartTransformation:
@@ -1235,8 +1140,9 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 					program.grid.cell_size_px = 50.0
 				case .DismissError:
 					program.state = .Normal
-				case .CloseProgram:
-					program.window_should_close = true
+				}
+				if data.type in UiButtonRecalculateFinishGroup {
+					program.animation.matrix_count = program.matrix_count
 				}
 			}
 		case .Slider:
@@ -1244,12 +1150,16 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 			rl.GuiSlider(area, element.label, "", data.value, data.min, data.max)
 		case .InputFloat:
 			data := cast(^UiElementData_FloatInput)element.data
+			value_previous := data.value^
 			if rl.GuiValueBoxFloat(area, element.label, data.value_string, data.value, focus_element_id == element.id) == 1 {
 				focus_element_id = element.id
 			}
+			if value_previous != data.value^ && .UpdateMatrix in data.tag {
+				program.animation.matrix_count = program.matrix_count
+			}
 		case .InputText:
 			data := cast(^UiElementData_TextInput)element.data
-			if rl.GuiTextBox(area, data.str, i32(program.font_style.size), focus_element_id == element.id) == 1 {
+			if rl.GuiTextBox(area, data.str, i32(program.font_style.size), focus_element_id == element.id) {
 				focus_element_id = element.id
 			}
 		case .Label:
@@ -1258,25 +1168,7 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 			rl.DrawRectangleRec(rect2(ui.get_element_outer_area(element)), color)
 		case .ToggleGroup:
 			data := cast(^UiElementData_ToggleGroup)element.data
-			tooltips := strings.string_from_ptr(cast(^byte)element.tooltip, len(element.tooltip))
-			area_individual := area
-			area_individual.width /= f32(strings.count(tooltips, ";") + 1)
-			mouse := rl.GetMousePosition()
-			rl.GuiToggleGroup(area_individual, element.label, data.value)
-			if len(element.tooltip) > 0 && rect_has_point(area, mouse) {
-				tooltips_split := strings.split(tooltips, ";", context.temp_allocator)
-				tooltip_index := int((mouse.x - area_individual.x) / area_individual.width)
-				tooltip_text = strings.clone_to_cstring(tooltips_split[tooltip_index], context.temp_allocator)
-				tooltip_position = mouse
-			}
-		case .Toggle:
-			data := cast(^UiElementData_Toggle)element.data
-			rl.GuiToggle(area, element.label, data.value)
-			mouse := rl.GetMousePosition()
-			if rect_has_point(area, mouse) {
-				tooltip_text = element.tooltip
-				tooltip_position = mouse
-			}
+			rl.GuiToggleGroup(area, element.label, data.value)
 		case:
 			rl.DrawRectangleRec(area, rl.MAGENTA)
 		}
@@ -1299,11 +1191,11 @@ program_render_ui_and_handle_focus :: proc(ctx: ^ui.Context, focus_element_id: u
 	return focus_element_id
 }
 
-ui_confirm_and_cancel_buttons :: proc(confirm_label: cstring, button_type_add: UiButtonType, margin: f32) {
+ui_confirm_and_cancel_buttons :: proc(button_type_add: UiButtonType, margin: f32) {
 	button_data: ^UiElementData_Button
 	button_data = new(UiElementData_Button, context.temp_allocator)
 	button_data^ = {type = button_type_add}
-	ui.element(.Button, ui.dimensions_pixels(96.0, 32.0), {label = confirm_label, margin = margin}, button_data)
+	ui.element(.Button, ui.dimensions_pixels(96.0, 32.0), {label = "Add", margin = margin}, button_data)
 
 	button_data = new(UiElementData_Button, context.temp_allocator)
 	button_data^ = {type = .ExitDialog}
@@ -1351,7 +1243,7 @@ ui_mat3 :: proc(idx: int, mat: []f32, value_strings: []InputFloatField, dimensio
 			#unroll for row in 0..<3 {
 				data := new(UiElementData_FloatInput, allocator)
 				index := row * 3 + col
-				data^ = {value = &mat[index], value_string = cstring(&value_strings[index][0])}
+				data^ = {value = &mat[index], value_string = cstring(&value_strings[index][0]), tag = {.UpdateMatrix}}
 				ui.element(.InputFloat, matrix_input_dimensions, matrix_input_config, data)
 				ui.same_line()
 			}
@@ -1361,8 +1253,9 @@ ui_mat3 :: proc(idx: int, mat: []f32, value_strings: []InputFloatField, dimensio
 }
 
 ui_labeled_input_float_element :: proc(label: cstring, margin: f32, value: ^f32, value_string: ^InputFloatField, allocator := context.temp_allocator) -> ^ui.Element {
-	label_element := ui.element(.Label, {}, {label = fmt.ctprintf("%s: ", label), color = ui.col(rl.WHITE), margin = margin})
-	dimensions := ui.Dimensions{ui.Size_Pixels(128.0), ui.dimensions_pixels(ui.rect_get_size(ui.get_element_outer_area(label_element^))).height}
+	label := fmt.ctprintf("%s: ", label)
+	label_element := ui.element(.Label, {}, {label = label, color = ui.col(rl.WHITE), margin = margin})
+	dimensions := ui.Dimensions{ui.Size_Pixels(64.0), ui.dimensions_pixels(ui.rect_get_size(ui.get_element_outer_area(label_element^))).height}
 	ui.same_line()
 	input_data := new(UiElementData_FloatInput, context.temp_allocator)
 	input_data^ = {value = value, value_string = cstring(&value_string[0])}
@@ -1370,8 +1263,9 @@ ui_labeled_input_float_element :: proc(label: cstring, margin: f32, value: ^f32,
 }
 
 ui_labeled_input_text_element :: proc(label: cstring, margin: f32, str: []byte, allocator := context.temp_allocator) -> ^ui.Element {
-	label_element := ui.element(.Label, {}, {label = fmt.ctprintf("%s: ", label), color = ui.col(rl.WHITE), margin = margin})
-	dimensions := ui.Dimensions{ui.Size_Pixels(224.0), ui.dimensions_pixels(ui.rect_get_size(ui.get_element_outer_area(label_element^))).height}
+	label := fmt.ctprintf("%s: ", label)
+	label_element := ui.element(.Label, {}, {label = label, color = ui.col(rl.WHITE), margin = margin})
+	dimensions := ui.Dimensions{ui.Size_Pixels(64.0), ui.dimensions_pixels(ui.rect_get_size(ui.get_element_outer_area(label_element^))).height}
 	ui.same_line()
 	input_data := new(UiElementData_TextInput, context.temp_allocator)
 	input_data^ = {str = cstring(&str[0])}
diff --git a/src/project.odin b/src/project.odin
index 8d09a98..af8114a 100644
--- a/src/project.odin
+++ b/src/project.odin
@@ -1,4 +1,4 @@
-package game
+package main
 
 PROJECT_DATA_HEADER :: "WOWOWOW THIS IS HEADER WOWOWOW"
 PROJECT_DATA_VERSION :: 1
diff --git a/src/project_default.odin b/src/project_default.odin
index 9b7c61b..b4b3fa9 100644
--- a/src/project_default.odin
+++ b/src/project_default.odin
@@ -1,7 +1,7 @@
 #+build !wasm32
 #+build !wasm64p32
 
-package game
+package main
 
 import "core:os"
 import "core:io"
@@ -47,7 +47,7 @@ _project_read :: proc(project: ^ProjectData, path: string) -> ProjectReadError {
 	r := io.to_reader(os.to_stream(f))
 	header := PROJECT_DATA_HEADER
 	header_buffer: [len(PROJECT_DATA_HEADER)]byte
-	if _, err := io.read_full(r, header_buffer[:]); err != nil {
+	if num, err := io.read_full(r, header_buffer[:]); err != nil {
 		return ProjectReadErrorType.FailedReadingHeader
 	}
 	if mem.compare(transmute([]byte)header, header_buffer[:]) != 0 {
diff --git a/src/project_web.odin b/src/project_web.odin
index 1a35c02..0925e86 100644
--- a/src/project_web.odin
+++ b/src/project_web.odin
@@ -1,5 +1,5 @@
 #+build wasm32, wasm64p32
-package game
+package main
 
 ProjectReadErrorType :: enum {
 	LoadingProjectNotSupportedOnWeb,
diff --git a/src/signal_handler.odin b/src/signal_handler.odin
new file mode 100644
index 0000000..4a0d3a9
--- /dev/null
+++ b/src/signal_handler.odin
@@ -0,0 +1,5 @@
+package main
+
+register_illegal_instruction_handler :: proc() {
+	_register_illegal_instruction_handler()
+}
diff --git a/src/signal_handler_linux.odin b/src/signal_handler_linux.odin
new file mode 100644
index 0000000..d5cffdf
--- /dev/null
+++ b/src/signal_handler_linux.odin
@@ -0,0 +1,36 @@
+#+build linux
+
+package main
+
+import "libraries/back"
+import "core:sys/posix"
+import "base:runtime"
+import "core:mem"
+import "core:fmt"
+
+_register_illegal_instruction_handler :: proc() {
+	posix.signal(.SIGILL, proc "c" (code: posix.Signal) {
+		context = runtime.default_context()
+
+		space: [16*mem.Kilobyte]byte
+		arena: mem.Arena
+		mem.arena_init(&arena, space[:])
+		allocator := mem.arena_allocator(&arena)
+
+		context.allocator      = allocator
+		context.temp_allocator = allocator
+
+		backtrace: {
+			lines, err := back.lines(back.trace(), allocator, allocator)
+			if err != nil {
+				fmt.eprintf("Exception (Code: %i)\nCould not get backtrace: %v\n", code, err)
+				break backtrace
+			}
+
+			fmt.eprintf("Exception (Code: %i)\n[back trace]\n", code)
+			back.print(lines, temp_allocator=allocator)
+		}
+
+		runtime.exit(int(code))
+	})
+}
diff --git a/src/signal_handler_other.odin b/src/signal_handler_other.odin
new file mode 100644
index 0000000..f7b8afb
--- /dev/null
+++ b/src/signal_handler_other.odin
@@ -0,0 +1,5 @@
+#+build !linux
+
+package main
+
+_register_illegal_instruction_handler :: proc() {}
diff --git a/src/utils.odin b/src/utils.odin
index fcf1c23..1cb03af 100644
--- a/src/utils.odin
+++ b/src/utils.odin
@@ -1,4 +1,4 @@
-package game
+package main
 
 import rl "libraries/raylib"
 import "base:intrinsics"
@@ -132,7 +132,7 @@ V2_DOWN :: v2{0.0, 1.0}
 /// ### ENUM STRINGIFICATION ### ///
 enum_to_raygui_options_string :: proc($T: typeid, allocator: mem.Allocator) -> cstring where IS_ENUM(T) {
 	b := strings.builder_make(allocator)
-	for element in T {
+	for element, i in T {
 		option := fmt.aprint(element, allocator = allocator)
 		fmt.sbprint(&b, strings.to_ada_case(option, allocator), ";", sep = "")
 	}
diff --git a/src/utils_default.odin b/src/utils_default.odin
index d30e2b9..e29681a 100644
--- a/src/utils_default.odin
+++ b/src/utils_default.odin
@@ -1,7 +1,7 @@
 #+build !wasm32
 #+build !wasm64p32
 
-package game
+package main
 
 import "core:os"
 
diff --git a/src/utils_web.odin b/src/utils_web.odin
index 66f09b4..eaabd60 100644
--- a/src/utils_web.odin
+++ b/src/utils_web.odin
@@ -1,9 +1,10 @@
 // Implementations of `read_entire_file` and `write_entire_file` using the libc
 // stuff emscripten exposes. You can read the files that get bundled by
 // `--preload-file assets` in `build_web` script.
+
 #+build wasm32, wasm64p32
 
-package game
+package main
 
 import "base:runtime"
 import "core:log"
diff --git a/src/web/odin.js b/src/web/odin.js
deleted file mode 100644
index 071b0b4..0000000
--- a/src/web/odin.js
+++ /dev/null
@@ -1,2284 +0,0 @@
-"use strict";
-
-(function() {
-
-function getElement(name) {
-	if (name) {
-		return document.getElementById(name);
-	}
-	return undefined;
-}
-
-function stripNewline(str) {
-	return str.replace(/\n/, ' ')
-}
-
-class WasmMemoryInterface {
-	constructor() {
-		this.memory = null;
-		this.exports = null;
-		this.listenerMap = new Map();
-
-		// Size (in bytes) of the integer type, should be 4 on `js_wasm32` and 8 on `js_wasm64p32`
-		this.intSize = 4;
-	}
-
-	setIntSize(size) {
-		this.intSize = size;
-	}
-
-	setMemory(memory) {
-		this.memory = memory;
-	}
-
-	setExports(exports) {
-		this.exports = exports;
-	}
-
-	get mem() {
-		return new DataView(this.memory.buffer);
-	}
-
-
-	loadF32Array(addr, len) { return new Float32Array(this.memory.buffer, addr, len); }
-	loadF64Array(addr, len) { return new Float64Array(this.memory.buffer, addr, len); }
-	loadU32Array(addr, len) { return new Uint32Array(this.memory.buffer, addr, len); }
-	loadI32Array(addr, len) { return new Int32Array(this.memory.buffer, addr, len); }
-	loadU16Array(addr, len) { return new Uint16Array(this.memory.buffer, addr, len); }
-	loadI16Array(addr, len) { return new Int16Array(this.memory.buffer, addr, len); }
-	loadU8Array(addr, len) { return new Uint8Array(this.memory.buffer, addr, len); }
-	loadI8Array(addr, len) { return new Int8Array(this.memory.buffer, addr, len); }
-
-
-	loadU8(addr)  { return this.mem.getUint8  (addr); }
-	loadI8(addr)  { return this.mem.getInt8   (addr); }
-	loadU16(addr) { return this.mem.getUint16 (addr, true); }
-	loadI16(addr) { return this.mem.getInt16  (addr, true); }
-	loadU32(addr) { return this.mem.getUint32 (addr, true); }
-	loadI32(addr) { return this.mem.getInt32  (addr, true); }
-	loadU64(addr) {
-		const lo = this.mem.getUint32(addr + 0, true);
-		const hi = this.mem.getUint32(addr + 4, true);
-		return lo + hi*4294967296;
-	};
-	loadI64(addr) {
-		const lo = this.mem.getUint32(addr + 0, true);
-		const hi = this.mem.getInt32 (addr + 4, true);
-		return lo + hi*4294967296;
-	};
-	loadF32(addr) { return this.mem.getFloat32(addr, true); }
-	loadF64(addr) { return this.mem.getFloat64(addr, true); }
-	loadInt(addr) {
-		if (this.intSize == 8) {
-			return this.loadI64(addr);
-		} else if (this.intSize == 4) {
-			return this.loadI32(addr);
-		} else {
-			throw new Error('Unhandled `intSize`, expected `4` or `8`');
-		}
-	};
-	loadUint(addr) {
-		if (this.intSize == 8) {
-			return this.loadU64(addr);
-		} else if (this.intSize == 4) {
-			return this.loadU32(addr);
-		} else {
-			throw new Error('Unhandled `intSize`, expected `4` or `8`');
-		}
-	};
-	loadPtr(addr) { return this.loadU32(addr); }
-
-	loadB32(addr) {
-		return this.loadU32(addr) != 0;
-	}
-
-	loadBytes(ptr, len) {
-		return new Uint8Array(this.memory.buffer, ptr, Number(len));
-	}
-
-	loadString(ptr, len) {
-		const bytes = this.loadBytes(ptr, Number(len));
-		return new TextDecoder().decode(bytes);
-	}
-
-	loadCstring(ptr) {
-		if (ptr == 0) {
-			return null;
-		}
-		let len = 0;
-		for (; this.mem.getUint8(ptr+len) != 0; len += 1) {}
-		return this.loadString(ptr, len);
-	}
-
-	storeU8(addr, value)  { this.mem.setUint8  (addr, value); }
-	storeI8(addr, value)  { this.mem.setInt8   (addr, value); }
-	storeU16(addr, value) { this.mem.setUint16 (addr, value, true); }
-	storeI16(addr, value) { this.mem.setInt16  (addr, value, true); }
-	storeU32(addr, value) { this.mem.setUint32 (addr, value, true); }
-	storeI32(addr, value) { this.mem.setInt32  (addr, value, true); }
-	storeU64(addr, value) {
-		this.mem.setUint32(addr + 0, Number(value), true);
-
-		let div = 4294967296;
-		if (typeof value == 'bigint') {
-			div = BigInt(div);
-		}
-
-		this.mem.setUint32(addr + 4, Math.floor(Number(value / div)), true);
-	}
-	storeI64(addr, value) {
-		this.mem.setUint32(addr + 0, Number(value), true);
-
-		let div = 4294967296;
-		if (typeof value == 'bigint') {
-			div = BigInt(div);
-		}
-
-		this.mem.setInt32(addr + 4, Math.floor(Number(value / div)), true);
-	}
-	storeF32(addr, value) { this.mem.setFloat32(addr, value, true); }
-	storeF64(addr, value) { this.mem.setFloat64(addr, value, true); }
-	storeInt(addr, value) {
-		if (this.intSize == 8) {
-			this.storeI64(addr, value);
-		} else if (this.intSize == 4) {
-			this.storeI32(addr, value);
-		} else {
-			throw new Error('Unhandled `intSize`, expected `4` or `8`');
-		}
-	}
-	storeUint(addr, value) {
-		if (this.intSize == 8) {
-			this.storeU64(addr, value);
-		} else if (this.intSize == 4) {
-			this.storeU32(addr, value);
-		} else {
-			throw new Error('Unhandled `intSize`, expected `4` or `8`');
-		}
-	}
-
-	// Returned length might not be the same as `value.length` if non-ascii strings are given.
-	storeString(addr, value) {
-		const src = new TextEncoder().encode(value);
-		const dst = new Uint8Array(this.memory.buffer, addr, src.length);
-		dst.set(src);
-		return src.length;
-	}
-};
-
-class WebGLInterface {
-	constructor(wasmMemoryInterface) {
-		this.wasmMemoryInterface = wasmMemoryInterface;
-		this.ctxElement         = null;
-		this.ctx                = null;
-		this.ctxVersion         = 1.0;
-		this.counter            = 1;
-		this.lastError          = 0;
-		this.buffers            = [];
-		this.mappedBuffers      = {};
-		this.programs           = [];
-		this.framebuffers       = [];
-		this.renderbuffers      = [];
-		this.textures           = [];
-		this.uniforms           = [];
-		this.shaders            = [];
-		this.vaos               = [];
-		this.contexts           = [];
-		this.currentContext     = null;
-		this.offscreenCanvases  = {};
-		this.timerQueriesEXT    = [];
-		this.queries            = [];
-		this.samplers           = [];
-		this.transformFeedbacks = [];
-		this.syncs              = [];
-		this.programInfos       = {};
-		this.extensions         = [];
-	}
-
-	get mem() {
-		return this.wasmMemoryInterface
-	}
-
-	setCurrentContext(element, contextSettings) {
-		if (!element) {
-			return false;
-		}
-		if (this.ctxElement == element) {
-			return true;
-		}
-
-		contextSettings = contextSettings ?? {};
-		this.ctx = element.getContext("webgl2", contextSettings) || element.getContext("webgl", contextSettings);
-		if (!this.ctx) {
-			return false;
-		}
-		this.ctxElement = element;
-		if (this.ctx.getParameter(0x1F02).indexOf("WebGL 2.0") !== -1) {
-			this.ctxVersion = 2.0;
-		} else {
-			this.ctxVersion = 1.0;
-		}
-
-		this.extensions = this.ctx.getSupportedExtensions();
-
-		return true;
-	}
-
-	assertWebGL2() {
-		if (this.ctxVersion < 2) {
-			throw new Error("WebGL2 procedure called in a canvas without a WebGL2 context");
-		}
-	}
-	getNewId(table) {
-		for (var ret = this.counter++, i = table.length; i < ret; i++) {
-			table[i] = null;
-		}
-		return ret;
-	}
-	recordError(errorCode) {
-		this.lastError || (this.lastError = errorCode);
-	}
-	populateUniformTable(program) {
-		let p = this.programs[program];
-		this.programInfos[program] = {
-			uniforms: {},
-			maxUniformLength: 0,
-			maxAttributeLength: -1,
-			maxUniformBlockNameLength: -1,
-		};
-		for (let ptable = this.programInfos[program], utable = ptable.uniforms, numUniforms = this.ctx.getProgramParameter(p, this.ctx.ACTIVE_UNIFORMS), i = 0; i < numUniforms; ++i) {
-			let u = this.ctx.getActiveUniform(p, i);
-			let name = u.name;
-			if (ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length + 1), name.indexOf("]", name.length - 1) !== -1) {
-				name = name.slice(0, name.lastIndexOf("["));
-			}
-			let loc = this.ctx.getUniformLocation(p, name);
-			if (loc !== null) {
-				let id = this.getNewId(this.uniforms);
-				utable[name] = [u.size, id], this.uniforms[id] = loc;
-				for (let j = 1; j < u.size; ++j) {
-					let n = name + "[" + j + "]";
-					let loc = this.ctx.getUniformLocation(p, n);
-					let id = this.getNewId(this.uniforms);
-					this.uniforms[id] = loc;
-				}
-			}
-		}
-	}
-	getSource(shader, strings_ptr, strings_length) {
-		const stringSize = this.mem.intSize*2;
-		let source = "";
-		for (let i = 0; i < strings_length; i++) {
-			let ptr = this.mem.loadPtr(strings_ptr + i*stringSize);
-			let len = this.mem.loadPtr(strings_ptr + i*stringSize + 4);
-			let str = this.mem.loadString(ptr, len);
-			source += str;
-		}
-		return source;
-	}
-
-	loadTypedArrayFromTexelType(type, size, data) {
-		switch (type) {
-			case this.ctx.SHORT: return this.mem.loadI16Array(data, size/2);
-			case this.ctx.UNSIGNED_SHORT_5_5_5_1:
-			case this.ctx.UNSIGNED_SHORT_5_6_5:
-			case this.ctx.UNSIGNED_SHORT_4_4_4_4:
-			case this.ctx.UNSIGNED_SHORT:
-			case this.ctx.HALF_FLOAT: return this.mem.loadU16Array(data, size/2);
-			case this.ctx.FLOAT: return this.mem.loadF32Array(data, size/4);
-			case this.ctx.INT: return this.mem.loadI32Array(data, size/4)
-			case this.ctx.UNSIGNED_INT_24_8:
-			case this.ctx.UNSIGNED_INT_5_9_9_9_REV:
-			case this.ctx.UNSIGNED_INT_10F_11F_11F_REV:
-			case this.ctx.UNSIGNED_INT_2_10_10_10_REV:
-			case this.ctx.UNSIGNED_INT: return this.mem.loadU32Array(data, size/4)
-			case this.ctx.BYTE: return this.mem.loadI8Array(data, size);
-			case this.ctx.UNSIGNED_BYTE: return this.mem.loadU8Array(data, size);
-			case this.ctx.FLOAT_32_UNSIGNED_INT_24_8_REV:
-				throw new Error("Source data of type FLOAT_32_UNSIGNED_INT_24_8_REV must be null");
-		}
-
-		throw new Error(`Unsupported texture data type: 0x${type.toString(16)}`);
-	}
-
-	getWebGL1Interface() {
-		return {
-			SetCurrentContextById: (name_ptr, name_len) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				let element = getElement(name);
-				return this.setCurrentContext(element, {alpha: true, antialias: true, depth: true, premultipliedAlpha: true});
-			},
-			CreateCurrentContextById: (name_ptr, name_len, attributes) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				let element = getElement(name);
-
-				let contextSettings = {
-					alpha:                        !(attributes & (1<<0)),
-					antialias:                    !(attributes & (1<<1)),
-					depth:                        !(attributes & (1<<2)),
-					failIfMajorPerformanceCaveat: !!(attributes & (1<<3)),
-					premultipliedAlpha:           !(attributes & (1<<4)),
-					preserveDrawingBuffer:        !!(attributes & (1<<5)),
-					stencil:                      !!(attributes & (1<<6)),
-					desynchronized:               !!(attributes & (1<<7)),
-				};
-
-				return this.setCurrentContext(element, contextSettings);
-			},
-			GetCurrentContextAttributes: () => {
-				if (!this.ctx) {
-					return 0;
-				}
-				let attrs = this.ctx.getContextAttributes();
-				let res = 0;
-				if (!attrs.alpha)                        res |= 1<<0;
-				if (!attrs.antialias)                    res |= 1<<1;
-				if (!attrs.depth)                        res |= 1<<2;
-				if (attrs.failIfMajorPerformanceCaveat)  res |= 1<<3;
-				if (!attrs.premultipliedAlpha)           res |= 1<<4;
-				if (attrs.preserveDrawingBuffer)         res |= 1<<5;
-				if (attrs.stencil)                       res |= 1<<6;
-				if (attrs.desynchronized)                res |= 1<<7;
-				return res;
-			},
-
-			DrawingBufferWidth:  () => this.ctx.drawingBufferWidth,
-			DrawingBufferHeight: () => this.ctx.drawingBufferHeight,
-
-			IsExtensionSupported: (name_ptr, name_len) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				let extensions = this.extensions;
-				return extensions.indexOf(name) !== -1
-			},
-
-			GetSupportedExtensionFromIndex: (index, buf_ptr, buf_len, length_ptr) => {
-				let extensions = this.extensions;
-				if (index < 0 || index >= extensions.length) {
-					return false;
-				}
-
-				let ext = extensions[index];
-				const n = Math.min(buf_len, ext.length);
-				ext = ext.substring(0, n);
-				this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder().encode(ext));
-
-				this.mem.storeInt(length_ptr, n);
-
-				return true;
-			},
-
-			GetExtension: (name_ptr, name_len) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				this.ctx.getExtension(name);
-			},
-
-			GetError: () => {
-				let err = this.lastError;
-				this.recordError(0);
-				if (err) {
-					return err;
-				}
-				return this.ctx.getError();
-			},
-
-			GetWebGLVersion: (major_ptr, minor_ptr) => {
-				let version = this.ctx.getParameter(0x1F02);
-				if (version.indexOf("WebGL 2.0") !== -1) {
-					this.mem.storeI32(major_ptr, 2);
-					this.mem.storeI32(minor_ptr, 0);
-					return;
-				}
-
-				this.mem.storeI32(major_ptr, 1);
-				this.mem.storeI32(minor_ptr, 0);
-			},
-			GetESVersion: (major_ptr, minor_ptr) => {
-				let version = this.ctx.getParameter(0x1F02);
-				if (version.indexOf("OpenGL ES 3.0") !== -1) {
-					this.mem.storeI32(major_ptr, 3);
-					this.mem.storeI32(minor_ptr, 0);
-					return;
-				}
-
-				this.mem.storeI32(major_ptr, 2);
-				this.mem.storeI32(minor_ptr, 0);
-			},
-
-
-			ActiveTexture: (x) => {
-				this.ctx.activeTexture(x);
-			},
-			AttachShader: (program, shader) => {
-				this.ctx.attachShader(this.programs[program], this.shaders[shader]);
-			},
-			BindAttribLocation: (program, index, name_ptr, name_len) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				this.ctx.bindAttribLocation(this.programs[program], index, name)
-			},
-			BindBuffer: (target, buffer) => {
-				let bufferObj = buffer ? this.buffers[buffer] : null;
-				if (target == 35051) {
-					this.ctx.currentPixelPackBufferBinding = buffer;
-				} else {
-					if (target == 35052) {
-						this.ctx.currentPixelUnpackBufferBinding = buffer;
-					}
-					this.ctx.bindBuffer(target, bufferObj)
-				}
-			},
-			BindFramebuffer: (target, framebuffer) => {
-				this.ctx.bindFramebuffer(target, framebuffer ? this.framebuffers[framebuffer] : null)
-			},
-			BindTexture: (target, texture) => {
-				this.ctx.bindTexture(target, texture ? this.textures[texture] : null)
-			},
-			BindRenderbuffer: (target, renderbuffer) => {
-				this.ctx.bindRenderbuffer(target, renderbuffer ? this.renderbuffers[renderbuffer] : null)
-			},
-			BlendColor: (red, green, blue, alpha) => {
-				this.ctx.blendColor(red, green, blue, alpha);
-			},
-			BlendEquation: (mode) => {
-				this.ctx.blendEquation(mode);
-			},
-			BlendEquationSeparate: (modeRGB, modeAlpha) => {
-				this.ctx.blendEquationSeparate(modeRGB, modeAlpha);
-			},
-			BlendFunc: (sfactor, dfactor) => {
-				this.ctx.blendFunc(sfactor, dfactor);
-			},
-			BlendFuncSeparate: (srcRGB, dstRGB, srcAlpha, dstAlpha) => {
-				this.ctx.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
-			},
-
-
-			BufferData: (target, size, data, usage) => {
-				if (data) {
-					this.ctx.bufferData(target, this.mem.loadBytes(data, size), usage);
-				} else {
-					this.ctx.bufferData(target, size, usage);
-				}
-			},
-			BufferSubData: (target, offset, size, data) => {
-				if (data) {
-					this.ctx.bufferSubData(target, offset, this.mem.loadBytes(data, size));
-				} else {
-					this.ctx.bufferSubData(target, offset, null);
-				}
-			},
-
-
-			Clear: (x) => {
-				this.ctx.clear(x);
-			},
-			ClearColor: (r, g, b, a) => {
-				this.ctx.clearColor(r, g, b, a);
-			},
-			ClearDepth: (x) => {
-				this.ctx.clearDepth(x);
-			},
-			ClearStencil: (x) => {
-				this.ctx.clearStencil(x);
-			},
-			ColorMask: (r, g, b, a) => {
-				this.ctx.colorMask(!!r, !!g, !!b, !!a);
-			},
-			CompileShader: (shader) => {
-				this.ctx.compileShader(this.shaders[shader]);
-			},
-
-
-			CompressedTexImage2D: (target, level, internalformat, width, height, border, imageSize, data) => {
-				if (data) {
-					this.ctx.compressedTexImage2D(target, level, internalformat, width, height, border, this.mem.loadBytes(data, imageSize));
-				} else {
-					this.ctx.compressedTexImage2D(target, level, internalformat, width, height, border, null);
-				}
-			},
-			CompressedTexSubImage2D: (target, level, xoffset, yoffset, width, height, format, imageSize, data) => {
-				if (data) {
-					this.ctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.mem.loadBytes(data, imageSize));
-				} else {
-					this.ctx.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, null);
-				}
-			},
-
-			CopyTexImage2D: (target, level, internalformat, x, y, width, height, border) => {
-				this.ctx.copyTexImage2D(target, level, internalformat, x, y, width, height, border);
-			},
-			CopyTexSubImage2D: (target, level, xoffset, yoffset, x, y, width, height) => {
-				this.ctx.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-			},
-
-
-			CreateBuffer: () => {
-				let buffer = this.ctx.createBuffer();
-				if (!buffer) {
-					this.recordError(1282);
-					return 0;
-				}
-				let id = this.getNewId(this.buffers);
-				buffer.name = id
-				this.buffers[id] = buffer;
-				return id;
-			},
-			CreateFramebuffer: () => {
-				let buffer = this.ctx.createFramebuffer();
-				let id = this.getNewId(this.framebuffers);
-				buffer.name = id
-				this.framebuffers[id] = buffer;
-				return id;
-			},
-			CreateProgram: () => {
-				let program = this.ctx.createProgram();
-				let id = this.getNewId(this.programs);
-				program.name = id;
-				this.programs[id] = program;
-				return id;
-			},
-			CreateRenderbuffer: () => {
-				let buffer = this.ctx.createRenderbuffer();
-				let id = this.getNewId(this.renderbuffers);
-				buffer.name = id;
-				this.renderbuffers[id] = buffer;
-				return id;
-			},
-			CreateShader: (shaderType) => {
-				let shader = this.ctx.createShader(shaderType);
-				let id = this.getNewId(this.shaders);
-				shader.name = id;
-				this.shaders[id] = shader;
-				return id;
-			},
-			CreateTexture: () => {
-				let texture = this.ctx.createTexture();
-				if (!texture) {
-					this.recordError(1282)
-					return 0;
-				}
-				let id = this.getNewId(this.textures);
-				texture.name = id;
-				this.textures[id] = texture;
-				return id;
-			},
-
-
-			CullFace: (mode) => {
-				this.ctx.cullFace(mode);
-			},
-
-
-			DeleteBuffer: (id) => {
-				let obj = this.buffers[id];
-				if (obj && id != 0) {
-					this.ctx.deleteBuffer(obj);
-					this.buffers[id] = null;
-				}
-			},
-			DeleteFramebuffer: (id) => {
-				let obj = this.framebuffers[id];
-				if (obj && id != 0) {
-					this.ctx.deleteFramebuffer(obj);
-					this.framebuffers[id] = null;
-				}
-			},
-			DeleteProgram: (id) => {
-				let obj = this.programs[id];
-				if (obj && id != 0) {
-					this.ctx.deleteProgram(obj);
-					this.programs[id] = null;
-				}
-			},
-			DeleteRenderbuffer: (id) => {
-				let obj = this.renderbuffers[id];
-				if (obj && id != 0) {
-					this.ctx.deleteRenderbuffer(obj);
-					this.renderbuffers[id] = null;
-				}
-			},
-			DeleteShader: (id) => {
-				let obj = this.shaders[id];
-				if (obj && id != 0) {
-					this.ctx.deleteShader(obj);
-					this.shaders[id] = null;
-				}
-			},
-			DeleteTexture: (id) => {
-				let obj = this.textures[id];
-				if (obj && id != 0) {
-					this.ctx.deleteTexture(obj);
-					this.textures[id] = null;
-				}
-			},
-
-
-			DepthFunc: (func) => {
-				this.ctx.depthFunc(func);
-			},
-			DepthMask: (flag) => {
-				this.ctx.depthMask(!!flag);
-			},
-			DepthRange: (zNear, zFar) => {
-				this.ctx.depthRange(zNear, zFar);
-			},
-			DetachShader: (program, shader) => {
-				this.ctx.detachShader(this.programs[program], this.shaders[shader]);
-			},
-			Disable: (cap) => {
-				this.ctx.disable(cap);
-			},
-			DisableVertexAttribArray: (index) => {
-				this.ctx.disableVertexAttribArray(index);
-			},
-			DrawArrays: (mode, first, count) => {
-				this.ctx.drawArrays(mode, first, count);
-			},
-			DrawElements: (mode, count, type, indices) => {
-				this.ctx.drawElements(mode, count, type, indices);
-			},
-
-
-			Enable: (cap) => {
-				this.ctx.enable(cap);
-			},
-			EnableVertexAttribArray: (index) => {
-				this.ctx.enableVertexAttribArray(index);
-			},
-			Finish: () => {
-				this.ctx.finish();
-			},
-			Flush: () => {
-				this.ctx.flush();
-			},
-			FramebufferRenderbuffer: (target, attachment, renderbuffertarget, renderbuffer) => {
-				this.ctx.framebufferRenderbuffer(target, attachment, renderbuffertarget, this.renderbuffers[renderbuffer]);
-			},
-			FramebufferTexture2D: (target, attachment, textarget, texture, level) => {
-				this.ctx.framebufferTexture2D(target, attachment, textarget, this.textures[texture], level);
-			},
-			CheckFramebufferStatus: (target) => {
-				return this.ctx.checkFramebufferStatus(target)
-			},
-			FrontFace: (mode) => {
-				this.ctx.frontFace(mode);
-			},
-
-
-			GenerateMipmap: (target) => {
-				this.ctx.generateMipmap(target);
-			},
-
-			GetBufferParameter: (target, pname) => {
-				return this.ctx.getBufferParameter(target, pname);
-			},
-
-
-			GetActiveAttrib: (program, index, size_ptr, type_ptr, name_buf_ptr, name_buf_len, name_len_ptr) => {
-				const info = this.ctx.getActiveAttrib(this.programs[program], index);
-
-				if (size_ptr) {
-					this.mem.storeInt(size_ptr, info.size);
-				}
-
-				if (type_ptr) {
-					this.mem.storeI32(type_ptr, info.type);
-				}
-
-				if (name_buf_ptr && name_buf_len > 0) {
-					let n = Math.min(name_buf_len, info.name.length);
-					let name = info.name.substring(0, n);
-					this.mem.loadBytes(name_buf_ptr, name_buf_len).set(new TextEncoder().encode(name));
-					this.mem.storeInt(name_len_ptr, n);
-				} else if (name_len_ptr) {
-					this.mem.storeInt(name_len_ptr, info.name.length);
-				}
-			},
-
-			GetActiveUniform: (program, index, size_ptr, type_ptr, name_buf_ptr, name_buf_len, name_len_ptr) => {
-				let info = this.ctx.getActiveUniform(this.programs[program], index);
-
-				if (size_ptr) {
-					this.mem.storeInt(size_ptr, info.size);
-				}
-
-				if (type_ptr) {
-					this.mem.storeI32(type_ptr, info.type);
-				}
-
-				if (name_buf_ptr && name_buf_len > 0) {
-					let n = Math.min(name_buf_len, info.name.length);
-					let name = info.name.substring(0, n);
-					this.mem.loadBytes(name_buf_ptr, name_buf_len).set(new TextEncoder().encode(name));
-					this.mem.storeInt(name_len_ptr, n);
-				} else if (name_len_ptr) {
-					this.mem.storeInt(name_len_ptr, info.name.length);
-				}
-			},
-
-			GetAttribLocation: (program, name_ptr, name_len) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				return this.ctx.getAttribLocation(this.programs[program], name);
-			},
-
-
-			GetParameter: (pname) => {
-				return this.ctx.getParameter(pname);
-			},
-			GetParameter4i: (pname, v0, v1, v2, v3) => {
-				const i4 = this.ctx.getParameter(pname);
-				this.mem.storeI32(v0, i4[0]);
-				this.mem.storeI32(v1, i4[1]);
-				this.mem.storeI32(v2, i4[2]);
-				this.mem.storeI32(v3, i4[3]);
-			},
-			GetProgramParameter: (program, pname) => {
-				return this.ctx.getProgramParameter(this.programs[program], pname)
-			},
-			GetProgramInfoLog: (program, buf_ptr, buf_len, length_ptr) => {
-				let log = this.ctx.getProgramInfoLog(this.programs[program]);
-				if (log === null) {
-					log = "(unknown error)";
-				}
-				if (buf_len > 0 && buf_ptr) {
-					let n = Math.min(buf_len, log.length);
-					log = log.substring(0, n);
-					this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder().encode(log))
-
-					this.mem.storeInt(length_ptr, n);
-				}
-			},
-			GetShaderInfoLog: (shader, buf_ptr, buf_len, length_ptr) => {
-				let log = this.ctx.getShaderInfoLog(this.shaders[shader]);
-				if (log === null) {
-					log = "(unknown error)";
-				}
-				if (buf_len > 0 && buf_ptr) {
-					let n = Math.min(buf_len, log.length);
-					log = log.substring(0, n);
-					this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder().encode(log))
-
-					this.mem.storeInt(length_ptr, n);
-				}
-			},
-			GetShaderiv: (shader, pname, p) => {
-				if (p) {
-					if (pname == 35716) {
-						let log = this.ctx.getShaderInfoLog(this.shaders[shader]);
-						if (log === null) {
-							log = "(unknown error)";
-						}
-						this.mem.storeInt(p, log.length+1);
-					} else if (pname == 35720) {
-						let source = this.ctx.getShaderSource(this.shaders[shader]);
-						let sourceLength = (source === null || source.length == 0) ? 0 : source.length+1;
-						this.mem.storeInt(p, sourceLength);
-					} else {
-						let param = this.ctx.getShaderParameter(this.shaders[shader], pname);
-						this.mem.storeI32(p, param);
-					}
-				} else {
-					this.recordError(1281);
-				}
-			},
-
-
-			GetUniformLocation: (program, name_ptr, name_len) => {
-				let name = this.mem.loadString(name_ptr, name_len);
-				let arrayOffset = 0;
-				if (name.indexOf("]", name.length - 1) !== -1) {
-					let ls = name.lastIndexOf("["),
-					arrayIndex = name.slice(ls + 1, -1);
-					if (arrayIndex.length > 0 && (arrayOffset = parseInt(arrayIndex)) < 0) {
-						return -1;
-					}
-					name = name.slice(0, ls)
-				}
-				var ptable = this.programInfos[program];
-				if (!ptable) {
-					return -1;
-				}
-				var uniformInfo = ptable.uniforms[name];
-				return (uniformInfo && arrayOffset < uniformInfo[0]) ? uniformInfo[1] + arrayOffset : -1
-			},
-
-
-			GetVertexAttribOffset: (index, pname) => {
-				return this.ctx.getVertexAttribOffset(index, pname);
-			},
-
-
-			Hint: (target, mode) => {
-				this.ctx.hint(target, mode);
-			},
-
-
-			IsBuffer:       (buffer)       => this.ctx.isBuffer(this.buffers[buffer]),
-			IsEnabled:      (cap)          => this.ctx.isEnabled(cap),
-			IsFramebuffer:  (framebuffer)  => this.ctx.isFramebuffer(this.framebuffers[framebuffer]),
-			IsProgram:      (program)      => this.ctx.isProgram(this.programs[program]),
-			IsRenderbuffer: (renderbuffer) => this.ctx.isRenderbuffer(this.renderbuffers[renderbuffer]),
-			IsShader:       (shader)       => this.ctx.isShader(this.shaders[shader]),
-			IsTexture:      (texture)      => this.ctx.isTexture(this.textures[texture]),
-
-			LineWidth: (width) => {
-				this.ctx.lineWidth(width);
-			},
-			LinkProgram: (program) => {
-				this.ctx.linkProgram(this.programs[program]);
-				this.programInfos[program] = null;
-				this.populateUniformTable(program);
-			},
-			PixelStorei: (pname, param) => {
-				this.ctx.pixelStorei(pname, param);
-			},
-			PolygonOffset: (factor, units) => {
-				this.ctx.polygonOffset(factor, units);
-			},
-
-
-			ReadnPixels: (x, y, width, height, format, type, bufSize, data) => {
-				this.ctx.readPixels(x, y, width, height, format, type, this.mem.loadBytes(data, bufSize));
-			},
-			RenderbufferStorage: (target, internalformat, width, height) => {
-				this.ctx.renderbufferStorage(target, internalformat, width, height);
-			},
-			SampleCoverage: (value, invert) => {
-				this.ctx.sampleCoverage(value, !!invert);
-			},
-			Scissor: (x, y, width, height) => {
-				this.ctx.scissor(x, y, width, height);
-			},
-			ShaderSource: (shader, strings_ptr, strings_length) => {
-				let source = this.getSource(shader, strings_ptr, strings_length);
-				this.ctx.shaderSource(this.shaders[shader], source);
-			},
-
-			StencilFunc: (func, ref, mask) => {
-				this.ctx.stencilFunc(func, ref, mask);
-			},
-			StencilFuncSeparate: (face, func, ref, mask) => {
-				this.ctx.stencilFuncSeparate(face, func, ref, mask);
-			},
-			StencilMask: (mask) => {
-				this.ctx.stencilMask(mask);
-			},
-			StencilMaskSeparate: (face, mask) => {
-				this.ctx.stencilMaskSeparate(face, mask);
-			},
-			StencilOp: (fail, zfail, zpass) => {
-				this.ctx.stencilOp(fail, zfail, zpass);
-			},
-			StencilOpSeparate: (face, fail, zfail, zpass) => {
-				this.ctx.stencilOpSeparate(face, fail, zfail, zpass);
-			},
-
-
-			TexImage2D: (target, level, internalformat, width, height, border, format, type, size, data) => {
-				if (data) {
-					const texelData = this.loadTypedArrayFromTexelType(type, size, data);
-					this.ctx.texImage2D(target, level, internalformat, width, height, border, format, type, texelData);
-				} else {
-					this.ctx.texImage2D(target, level, internalformat, width, height, border, format, type, null);
-				}
-			},
-			TexParameterf: (target, pname, param) => {
-				this.ctx.texParameterf(target, pname, param);
-			},
-			TexParameteri: (target, pname, param) => {
-				this.ctx.texParameteri(target, pname, param);
-			},
-			TexSubImage2D: (target, level, xoffset, yoffset, width, height, format, type, size, data) => {
-				const texelData = this.loadTypedArrayFromTexelType(type, size, data);
-				this.ctx.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, texelData);
-			},
-
-
-			Uniform1f: (location, v0)             => { this.ctx.uniform1f(this.uniforms[location], v0);             },
-			Uniform2f: (location, v0, v1)         => { this.ctx.uniform2f(this.uniforms[location], v0, v1);         },
-			Uniform3f: (location, v0, v1, v2)     => { this.ctx.uniform3f(this.uniforms[location], v0, v1, v2);     },
-			Uniform4f: (location, v0, v1, v2, v3) => { this.ctx.uniform4f(this.uniforms[location], v0, v1, v2, v3); },
-
-			Uniform1i: (location, v0)             => { this.ctx.uniform1i(this.uniforms[location], v0);             },
-			Uniform2i: (location, v0, v1)         => { this.ctx.uniform2i(this.uniforms[location], v0, v1);         },
-			Uniform3i: (location, v0, v1, v2)     => { this.ctx.uniform3i(this.uniforms[location], v0, v1, v2);     },
-			Uniform4i: (location, v0, v1, v2, v3) => { this.ctx.uniform4i(this.uniforms[location], v0, v1, v2, v3); },
-
-			Uniform1fv: (location, count, addr) => {
-				let array = this.mem.loadF32Array(addr, 1*count);
-				this.ctx.uniform1fv(this.uniforms[location], array);
-			},
-			Uniform2fv: (location, count, addr) => {
-				let array = this.mem.loadF32Array(addr, 2*count);
-				this.ctx.uniform2fv(this.uniforms[location], array);
-			},
-			Uniform3fv: (location, count, addr) => {
-				let array = this.mem.loadF32Array(addr, 3*count);
-				this.ctx.uniform3fv(this.uniforms[location], array);
-			},
-			Uniform4fv: (location, count, addr) => {
-				let array = this.mem.loadF32Array(addr, 4*count);
-				this.ctx.uniform4fv(this.uniforms[location], array);
-			},
-
-			Uniform1iv: (location, count, addr) => {
-				let array = this.mem.loadI32Array(addr, 1*count);
-				this.ctx.uniform1iv(this.uniforms[location], array);
-			},
-			Uniform2iv: (location, count, addr) => {
-				let array = this.mem.loadI32Array(addr, 2*count);
-				this.ctx.uniform2iv(this.uniforms[location], array);
-			},
-			Uniform3iv: (location, count, addr) => {
-				let array = this.mem.loadI32Array(addr, 3*count);
-				this.ctx.uniform3iv(this.uniforms[location], array);
-			},
-			Uniform4iv: (location, count, addr) => {
-				let array = this.mem.loadI32Array(addr, 4*count);
-				this.ctx.uniform4iv(this.uniforms[location], array);
-			},
-
-			UniformMatrix2fv: (location, addr) => {
-				let array = this.mem.loadF32Array(addr, 2*2);
-				this.ctx.uniformMatrix2fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix3fv: (location, addr) => {
-				let array = this.mem.loadF32Array(addr, 3*3);
-				this.ctx.uniformMatrix3fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix4fv: (location, addr) => {
-				let array = this.mem.loadF32Array(addr, 4*4);
-				this.ctx.uniformMatrix4fv(this.uniforms[location], false, array);
-			},
-
-			UseProgram: (program) => {
-				if (program) this.ctx.useProgram(this.programs[program]);
-			},
-			ValidateProgram: (program) => {
-				if (program) this.ctx.validateProgram(this.programs[program]);
-			},
-
-
-			VertexAttrib1f: (index, x) => {
-				this.ctx.vertexAttrib1f(index, x);
-			},
-			VertexAttrib2f: (index, x, y) => {
-				this.ctx.vertexAttrib2f(index, x, y);
-			},
-			VertexAttrib3f: (index, x, y, z) => {
-				this.ctx.vertexAttrib3f(index, x, y, z);
-			},
-			VertexAttrib4f: (index, x, y, z, w) => {
-				this.ctx.vertexAttrib4f(index, x, y, z, w);
-			},
-			VertexAttribPointer: (index, size, type, normalized, stride, ptr) => {
-				this.ctx.vertexAttribPointer(index, size, type, !!normalized, stride, ptr);
-			},
-
-			Viewport: (x, y, w, h) => {
-				this.ctx.viewport(x, y, w, h);
-			},
-		};
-	}
-
-	getWebGL2Interface() {
-		return {
-			/* Buffer objects */
-			CopyBufferSubData: (readTarget, writeTarget, readOffset, writeOffset, size) => {
-				this.assertWebGL2();
-				this.ctx.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-			},
-			GetBufferSubData: (target, srcByteOffset, dst_buffer_ptr, dst_buffer_len, dstOffset, length) => {
-				this.assertWebGL2();
-				this.ctx.getBufferSubData(target, srcByteOffset, this.mem.loadBytes(dst_buffer_ptr, dst_buffer_len), dstOffset, length);
-			},
-
-			/* Framebuffer objects */
-			BlitFramebuffer: (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) => {
-				this.assertWebGL2();
-				this.ctx.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-			},
-			FramebufferTextureLayer: (target, attachment, texture, level, layer) => {
-				this.assertWebGL2();
-				this.ctx.framebufferTextureLayer(target, attachment, this.textures[texture], level, layer);
-			},
-			InvalidateFramebuffer: (target, attachments_ptr, attachments_len) => {
-				this.assertWebGL2();
-				let attachments = this.mem.loadU32Array(attachments_ptr, attachments_len);
-				this.ctx.invalidateFramebuffer(target, attachments);
-			},
-			InvalidateSubFramebuffer: (target, attachments_ptr, attachments_len, x, y, width, height) => {
-				this.assertWebGL2();
-				let attachments = this.mem.loadU32Array(attachments_ptr, attachments_len);
-				this.ctx.invalidateSubFramebuffer(target, attachments, x, y, width, height);
-			},
-			ReadBuffer: (src) => {
-				this.assertWebGL2();
-				this.ctx.readBuffer(src);
-			},
-
-			/* Renderbuffer objects */
-			RenderbufferStorageMultisample: (target, samples, internalformat, width, height) => {
-				this.assertWebGL2();
-				this.ctx.renderbufferStorageMultisample(target, samples, internalformat, width, height);
-			},
-
-			/* Texture objects */
-			TexStorage2D: (target, levels, internalformat, width, height) => {
-				this.assertWebGL2();
-				this.ctx.texStorage2D(target, levels, internalformat, width, height);
-			},
-			TexStorage3D: (target, levels, internalformat, width, height, depth) => {
-				this.assertWebGL2();
-				this.ctx.texStorage3D(target, levels, internalformat, width, height, depth);
-			},
-			TexImage3D: (target, level, internalformat, width, height, depth, border, format, type, size, data) => {
-				this.assertWebGL2();
-				if (data) {
-					const texelData = this.loadTypedArrayFromTexelType(type, size, data);
-					this.ctx.texImage3D(target, level, internalformat, width, height, depth, border, format, type, texelData);
-				} else {
-					this.ctx.texImage3D(target, level, internalformat, width, height, depth, border, format, type, null);
-				}
-			},
-			TexSubImage3D: (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, size, data) => {
-				this.assertWebGL2();
-				const texelData = this.loadTypedArrayFromTexelType(type, size, data);
-				this.ctx.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texelData);
-			},
-			CompressedTexImage3D: (target, level, internalformat, width, height, depth, border, imageSize, data) => {
-				this.assertWebGL2();
-				if (data) {
-					this.ctx.compressedTexImage3D(target, level, internalformat, width, height, depth, border, this.mem.loadBytes(data, imageSize));
-				} else {
-					this.ctx.compressedTexImage3D(target, level, internalformat, width, height, depth, border, null);
-				}
-			},
-			CompressedTexSubImage3D: (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) => {
-				this.assertWebGL2();
-				if (data) {
-					this.ctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, this.mem.loadBytes(data, imageSize));
-				} else {
-					this.ctx.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, null);
-				}
-			},
-
-			CopyTexSubImage3D: (target, level, xoffset, yoffset, zoffset, x, y, width, height) => {
-				this.assertWebGL2();
-				this.ctx.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-			},
-
-			/* Programs and shaders */
-			GetFragDataLocation: (program, name_ptr, name_len) => {
-				this.assertWebGL2();
-				return this.ctx.getFragDataLocation(this.programs[program], this.mem.loadString(name_ptr, name_len));
-			},
-
-			/* Uniforms */
-			Uniform1ui: (location, v0) => {
-				this.assertWebGL2();
-				this.ctx.uniform1ui(this.uniforms[location], v0);
-			},
-			Uniform2ui: (location, v0, v1) => {
-				this.assertWebGL2();
-				this.ctx.uniform2ui(this.uniforms[location], v0, v1);
-			},
-			Uniform3ui: (location, v0, v1, v2) => {
-				this.assertWebGL2();
-				this.ctx.uniform3ui(this.uniforms[location], v0, v1, v2);
-			},
-			Uniform4ui: (location, v0, v1, v2, v3) => {
-				this.assertWebGL2();
-				this.ctx.uniform4ui(this.uniforms[location], v0, v1, v2, v3);
-			},
-
-			UniformMatrix3x2fv: (location, addr) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(addr, 3*2);
-				this.ctx.uniformMatrix3x2fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix4x2fv: (location, addr) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(addr, 4*2);
-				this.ctx.uniformMatrix4x2fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix2x3fv: (location, addr) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(addr, 2*3);
-				this.ctx.uniformMatrix2x3fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix4x3fv: (location, addr) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(addr, 4*3);
-				this.ctx.uniformMatrix4x3fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix2x4fv: (location, addr) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(addr, 2*4);
-				this.ctx.uniformMatrix2x4fv(this.uniforms[location], false, array);
-			},
-			UniformMatrix3x4fv: (location, addr) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(addr, 3*4);
-				this.ctx.uniformMatrix3x4fv(this.uniforms[location], false, array);
-			},
-
-			/* Vertex attribs */
-			VertexAttribI4i: (index, x, y, z, w) => {
-				this.assertWebGL2();
-				this.ctx.vertexAttribI4i(index, x, y, z, w);
-			},
-			VertexAttribI4ui: (index, x, y, z, w) => {
-				this.assertWebGL2();
-				this.ctx.vertexAttribI4ui(index, x, y, z, w);
-			},
-			VertexAttribIPointer: (index, size, type, stride, offset) => {
-				this.assertWebGL2();
-				this.ctx.vertexAttribIPointer(index, size, type, stride, offset);
-			},
-
-			/* Writing to the drawing buffer */
-			VertexAttribDivisor: (index, divisor) => {
-				this.assertWebGL2();
-				this.ctx.vertexAttribDivisor(index, divisor);
-			},
-			DrawArraysInstanced: (mode, first, count, instanceCount) => {
-				this.assertWebGL2();
-				this.ctx.drawArraysInstanced(mode, first, count, instanceCount);
-			},
-			DrawElementsInstanced: (mode, count, type, offset, instanceCount) => {
-				this.assertWebGL2();
-				this.ctx.drawElementsInstanced(mode, count, type, offset, instanceCount);
-			},
-			DrawRangeElements: (mode, start, end, count, type, offset) => {
-				this.assertWebGL2();
-				this.ctx.drawRangeElements(mode, start, end, count, type, offset);
-			},
-
-			/* Multiple Render Targets */
-			DrawBuffers: (buffers_ptr, buffers_len) => {
-				this.assertWebGL2();
-				let array = this.mem.loadU32Array(buffers_ptr, buffers_len);
-				this.ctx.drawBuffers(array);
-			},
-			ClearBufferfv: (buffer, drawbuffer, values_ptr, values_len) => {
-				this.assertWebGL2();
-				let array = this.mem.loadF32Array(values_ptr, values_len);
-				this.ctx.clearBufferfv(buffer, drawbuffer, array);
-			},
-			ClearBufferiv: (buffer, drawbuffer, values_ptr, values_len) => {
-				this.assertWebGL2();
-				let array = this.mem.loadI32Array(values_ptr, values_len);
-				this.ctx.clearBufferiv(buffer, drawbuffer, array);
-			},
-			ClearBufferuiv: (buffer, drawbuffer, values_ptr, values_len) => {
-				this.assertWebGL2();
-				let array = this.mem.loadU32Array(values_ptr, values_len);
-				this.ctx.clearBufferuiv(buffer, drawbuffer, array);
-			},
-			ClearBufferfi: (buffer, drawbuffer, depth, stencil) => {
-				this.assertWebGL2();
-				this.ctx.clearBufferfi(buffer, drawbuffer, depth, stencil);
-			},
-
-			/* Query Objects */
-			CreateQuery: () => {
-				this.assertWebGL2();
-				let query = this.ctx.createQuery();
-				let id = this.getNewId(this.queries);
-				query.name = id;
-				this.queries[id] = query;
-				return id;
-			},
-			DeleteQuery: (id) => {
-				this.assertWebGL2();
-				let obj = this.queries[id];
-				if (obj && id != 0) {
-					this.ctx.deleteQuery(obj);
-					this.queries[id] = null;
-				}
-			},
-			IsQuery: (query) => {
-				this.assertWebGL2();
-				return this.ctx.isQuery(this.queries[query]);
-			},
-			BeginQuery: (target, query) => {
-				this.assertWebGL2();
-				this.ctx.beginQuery(target, this.queries[query])
-			},
-			EndQuery: (target) => {
-				this.assertWebGL2();
-				this.ctx.endQuery(target);
-			},
-			GetQuery: (target, pname) => {
-				this.assertWebGL2();
-				let query = this.ctx.getQuery(target, pname);
-				if (!query) {
-					return 0;
-				}
-				if (this.queries.indexOf(query) !== -1) {
-					return query.name;
-				}
-				let id = this.getNewId(this.queries);
-				query.name = id;
-				this.queries[id] = query;
-				return id;
-			},
-
-			/* Sampler Objects */
-			CreateSampler: () => {
-				this.assertWebGL2();
-				let sampler = this.ctx.createSampler();
-				let id = this.getNewId(this.samplers);
-				sampler.name = id;
-				this.samplers[id] = sampler;
-				return id;
-			},
-			DeleteSampler: (id) => {
-				this.assertWebGL2();
-				let obj = this.samplers[id];
-				if (obj && id != 0) {
-					this.ctx.deleteSampler(obj);
-					this.samplers[id] = null;
-				}
-			},
-			IsSampler: (sampler) => {
-				this.assertWebGL2();
-				return this.ctx.isSampler(this.samplers[sampler]);
-			},
-			BindSampler: (unit, sampler) => {
-				this.assertWebGL2();
-				this.ctx.bindSampler(unit, this.samplers[sampler]);
-			},
-			SamplerParameteri: (sampler, pname, param) => {
-				this.assertWebGL2();
-				this.ctx.samplerParameteri(this.samplers[sampler], pname, param);
-			},
-			SamplerParameterf: (sampler, pname, param) => {
-				this.assertWebGL2();
-				this.ctx.samplerParameterf(this.samplers[sampler], pname, param);
-			},
-
-			/* Sync objects */
-			FenceSync: (condition, flags) => {
-				this.assertWebGL2();
-				let sync = this.ctx.fenceSync(condition, flags);
-				let id = this.getNewId(this.syncs);
-				sync.name = id;
-				this.syncs[id] = sync;
-				return id;
-			},
-			IsSync: (sync) => {
-				this.assertWebGL2();
-				return this.ctx.isSync(this.syncs[sync]);
-			},
-			DeleteSync: (id) => {
-				this.assertWebGL2();
-				let obj = this.syncs[id];
-				if (obj && id != 0) {
-					this.ctx.deleteSampler(obj);
-					this.syncs[id] = null;
-				}
-			},
-			ClientWaitSync: (sync, flags, timeout) => {
-				this.assertWebGL2();
-				return this.ctx.clientWaitSync(this.syncs[sync], flags, timeout);
-			},
-			WaitSync: (sync, flags, timeout) => {
-				this.assertWebGL2();
-				this.ctx.waitSync(this.syncs[sync], flags, timeout)	;
-			},
-
-
-			/* Transform Feedback */
-			CreateTransformFeedback: () => {
-				this.assertWebGL2();
-				let transformFeedback = this.ctx.createTransformFeedback();
-				let id = this.getNewId(this.transformFeedbacks);
-				transformFeedback.name = id;
-				this.transformFeedbacks[id] = transformFeedback;
-				return id;
-			},
-			DeleteTransformFeedback: (id)  => {
-				this.assertWebGL2();
-				let obj = this.transformFeedbacks[id];
-				if (obj && id != 0) {
-					this.ctx.deleteTransformFeedback(obj);
-					this.transformFeedbacks[id] = null;
-				}
-			},
-			IsTransformFeedback: (tf) => {
-				this.assertWebGL2();
-				return this.ctx.isTransformFeedback(this.transformFeedbacks[tf]);
-			},
-			BindTransformFeedback: (target, tf) => {
-				this.assertWebGL2();
-				this.ctx.bindTransformFeedback(target, this.transformFeedbacks[tf]);
-			},
-			BeginTransformFeedback: (primitiveMode) => {
-				this.assertWebGL2();
-				this.ctx.beginTransformFeedback(primitiveMode);
-			},
-			EndTransformFeedback: () => {
-				this.assertWebGL2();
-				this.ctx.endTransformFeedback();
-			},
-			TransformFeedbackVaryings: (program, varyings_ptr, varyings_len, bufferMode) => {
-				this.assertWebGL2();
-				const stringSize = this.mem.intSize*2;
-				let varyings = [];
-				for (let i = 0; i < varyings_len; i++) {
-					let ptr = this.mem.loadPtr(varyings_ptr + i*stringSize + 0*4);
-					let len = this.mem.loadPtr(varyings_ptr + i*stringSize + 1*4);
-					varyings.push(this.mem.loadString(ptr, len));
-				}
-				this.ctx.transformFeedbackVaryings(this.programs[program], varyings, bufferMode);
-			},
-			PauseTransformFeedback: () => {
-				this.assertWebGL2();
-				this.ctx.pauseTransformFeedback();
-			},
-			ResumeTransformFeedback: () => {
-				this.assertWebGL2();
-				this.ctx.resumeTransformFeedback();
-			},
-
-
-			/* Uniform Buffer Objects and Transform Feedback Buffers */
-			BindBufferBase: (target, index, buffer) => {
-				this.assertWebGL2();
-				this.ctx.bindBufferBase(target, index, this.buffers[buffer]);
-			},
-			BindBufferRange: (target, index, buffer, offset, size) => {
-				this.assertWebGL2();
-				this.ctx.bindBufferRange(target, index, this.buffers[buffer], offset, size);
-			},
-			GetUniformBlockIndex: (program, uniformBlockName_ptr, uniformBlockName_len) => {
-				this.assertWebGL2();
-				return this.ctx.getUniformBlockIndex(this.programs[program], this.mem.loadString(uniformBlockName_ptr, uniformBlockName_len));
-			},
-			GetActiveUniformBlockName: (program, uniformBlockIndex, name_buf_ptr, name_buf_len, name_length_ptr) => {
-				this.assertWebGL2();
-				let name = this.ctx.getActiveUniformBlockName(this.programs[program], uniformBlockIndex);
-
-				if (name_buf_ptr && name_buf_len > 0) {
-					let n = Math.min(name_buf_len, name.length);
-					name = name.substring(0, n);
-					this.mem.loadBytes(name_buf_ptr, name_buf_len).set(new TextEncoder().encode(name));
-					this.mem.storeInt(name_length_ptr, n);
-				} else if (name_length_ptr) {
-					this.mem.storeInt(name_length_ptr, name.length);
-				}
-			},
-			GetActiveUniforms: (program, uniformIndices_ptr, uniformIndices_len, pname, res_ptr) => {
-				this.assertWebGL2();
-				let indices = this.mem.loadU32Array(uniformIndices_ptr, uniformIndices_len);
-				this.ctx.getActiveUniforms(this.programs[program], indices, pname)
-				this.mem.loadI32Array(res_ptr, indices.length).set(indices)
-			},
-			GetActiveUniformBlockParameter: (program, uniformBlockIndex, pname, params_ptr) => {
-				this.assertWebGL2();
-				let res = this.ctx.getActiveUniformBlockParameter(this.programs[program], uniformBlockIndex, pname);
-
-				if (res instanceof Uint32Array) { // for pname GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES
-					this.mem.loadU32Array(params_ptr, res.length).set(res)
-				} else {
-					this.mem.storeI32(params_ptr, res)
-				}
-			},
-			UniformBlockBinding: (program, uniformBlockIndex, uniformBlockBinding) => {
-				this.assertWebGL2();
-				this.ctx.uniformBlockBinding(this.programs[program], uniformBlockIndex, uniformBlockBinding);
-			},
-
-			/* Vertex Array Objects */
-			CreateVertexArray: () => {
-				this.assertWebGL2();
-				let vao = this.ctx.createVertexArray();
-				let id = this.getNewId(this.vaos);
-				vao.name = id;
-				this.vaos[id] = vao;
-				return id;
-			},
-			DeleteVertexArray: (id) => {
-				this.assertWebGL2();
-				let obj = this.vaos[id];
-				if (obj && id != 0) {
-					this.ctx.deleteVertexArray(obj);
-					this.vaos[id] = null;
-				}
-			},
-			IsVertexArray: (vertexArray) => {
-				this.assertWebGL2();
-				return this.ctx.isVertexArray(this.vaos[vertexArray]);
-			},
-			BindVertexArray: (vertexArray) => {
-				this.assertWebGL2();
-				this.ctx.bindVertexArray(this.vaos[vertexArray]);
-			},
-		};
-	}
-};
-
-
-function odinSetupDefaultImports(wasmMemoryInterface, consoleElement, memory) {
-	const MAX_INFO_CONSOLE_LINES = 512;
-	let infoConsoleLines = new Array();
-	let currentLine = {};
-	currentLine[false] = "";
-	currentLine[true] = "";
-	let prevIsError = false;
-
-	let event_temp = {};
-
-  const onEventReceived = (event_data, data, callback) => {
-		event_temp.data = event_data;
-
-		const exports = wasmMemoryInterface.exports;
-		const odin_ctx = exports.default_context_ptr();
-
-		exports.odin_dom_do_event_callback(data, callback, odin_ctx);
-
-		event_temp.data = null;
-	};
-
-	const writeToConsole = (line, isError) => {
-		if (!line) {
-			return;
-		}
-
-		const println = (text, forceIsError) => {
-			let style = [
-				"color: #eee",
-				"background-color: #d20",
-				"padding: 2px 4px",
-				"border-radius: 2px",
-			].join(";");
-			let doIsError = isError;
-			if (forceIsError !== undefined) {
-				doIsError = forceIsError;
-			}
-
-			if (doIsError) {
-				console.log("%c"+text, style);
-			} else {
-				console.log(text);
-			}
-
-		};
-
-		// Print to console
-		if (line == "\n") {
-			println(currentLine[isError]);
-			currentLine[isError] = "";
-		} else if (!line.includes("\n")) {
-			currentLine[isError] = currentLine[isError].concat(line);
-		} else {
-			let lines = line.trimEnd().split("\n");
-			let printLast = lines.length > 1 && line.endsWith("\n");
-			println(currentLine[isError].concat(lines[0]));
-			currentLine[isError] = "";
-			for (let i = 1; i < lines.length-1; i++) {
-				println(lines[i]);
-			}
-			if (lines.length > 1) {
-				let last = lines[lines.length-1];
-				if (printLast) {
-					println(last);
-				} else {
-					currentLine[isError] = last;
-				}
-			}
-		}
-
-		if (prevIsError != isError) {
-			if (prevIsError) {
-				println(currentLine[prevIsError], prevIsError);
-				currentLine[prevIsError] = "";
-			}
-		}
-		prevIsError = isError;
-
-
-		// HTML based console
-		if (!consoleElement) {
-			return;
-		}
-		const wrap = (x) => {
-			if (isError) {
-				return '<span style="color:#f21">'+x+'</span>';
-			}
-			return x;
-		};
-
-		if (line == "\n") {
-			infoConsoleLines.push(line);
-		} else if (!line.includes("\n")) {
-			let prevLine = "";
-			if (infoConsoleLines.length > 0) {
-				prevLine = infoConsoleLines.pop();
-			}
-			infoConsoleLines.push(prevLine.concat(wrap(line)));
-		} else {
-			let lines = line.split("\n");
-			let lastHasNewline = lines.length > 1 && line.endsWith("\n");
-
-			let prevLine = "";
-			if (infoConsoleLines.length > 0) {
-				prevLine = infoConsoleLines.pop();
-			}
-			infoConsoleLines.push(prevLine.concat(wrap(lines[0]).concat("\n")));
-
-			for (let i = 1; i < lines.length-1; i++) {
-				infoConsoleLines.push(wrap(lines[i]).concat("\n"));
-			}
-			let last = lines[lines.length-1];
-			if (lastHasNewline) {
-				infoConsoleLines.push(last.concat("\n"));
-			} else {
-				infoConsoleLines.push(last);
-			}
-		}
-
-		if (infoConsoleLines.length > MAX_INFO_CONSOLE_LINES) {
-			infoConsoleLines.shift(MAX_INFO_CONSOLE_LINES);
-		}
-
-		let data = "";
-		for (let i = 0; i < infoConsoleLines.length; i++) {
-			data = data.concat(infoConsoleLines[i]);
-		}
-
-		let info = consoleElement;
-		info.innerHTML = data;
-		info.scrollTop = info.scrollHeight;
-	};
-
-	const listener_key = (id, name, data, callback, useCapture) => {
-		return `${id}-${name}-data:${data}-callback:${callback}-useCapture:${useCapture}`;
-	};
-
-	let webglContext = new WebGLInterface(wasmMemoryInterface);
-
-	const env = {};
-
-	if (memory) {
-		env.memory = memory;
-	}
-
-	return {
-		env,
-		"odin_env": {
-			write: (fd, ptr, len) => {
-				const str = wasmMemoryInterface.loadString(ptr, len);
-				if (fd == 1) {
-					writeToConsole(str, false);
-					return;
-				} else if (fd == 2) {
-					writeToConsole(str, true);
-					return;
-				} else {
-					throw new Error("Invalid fd to 'write'" + stripNewline(str));
-				}
-			},
-			trap: () => { throw new Error() },
-			alert: (ptr, len) => { alert(wasmMemoryInterface.loadString(ptr, len)) },
-			abort: () => { Module.abort() },
-			evaluate: (str_ptr, str_len) => { eval.call(null, wasmMemoryInterface.loadString(str_ptr, str_len)); },
-
-			open: (url_ptr, url_len, name_ptr, name_len, specs_ptr, specs_len) => {
-				const url = wasmMemoryInterface.loadString(url_ptr, url_len);
-				const name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				const specs = wasmMemoryInterface.loadString(specs_ptr, specs_len);
-				window.open(url, name, specs);
-			},
-
-			// return a bigint to be converted to i64
-			time_now: () => BigInt(Date.now()),
-			tick_now: () => performance.now(),
-			time_sleep: (duration_ms) => {
-				if (duration_ms > 0) {
-					// TODO(bill): Does this even make any sense?
-				}
-			},
-
-			sqrt:    Math.sqrt,
-			sin:     Math.sin,
-			cos:     Math.cos,
-			pow:     Math.pow,
-			fmuladd: (x, y, z) => x*y + z,
-			ln:      Math.log,
-			exp:     Math.exp,
-			ldexp:   (x, exp) => x * Math.pow(2, exp),
-
-			rand_bytes: (ptr, len) => {
-				const view = new Uint8Array(wasmMemoryInterface.memory.buffer, ptr, len)
-				crypto.getRandomValues(view)
-			},
-		},
-		"odin_dom": {
-			init_event_raw: (ep) => {
-				const W = wasmMemoryInterface.intSize;
-				let offset = ep;
-				let off = (amount, alignment) => {
-					if (alignment === undefined) {
-						alignment = Math.min(amount, W);
-					}
-					if (offset % alignment != 0) {
-						offset += alignment - (offset%alignment);
-					}
-					let x = offset;
-					offset += amount;
-					return x;
-				};
-
-				let align = (alignment) => {
-					const modulo = offset & (alignment-1);
-					if (modulo != 0) {
-						offset += alignment - modulo
-					}
-				};
-
-				let wmi = wasmMemoryInterface;
-
-				if (!event_temp.data) {
-					return;
-				}
-
-				let e = event_temp.data.event;
-
-				wmi.storeU32(off(4), event_temp.data.name_code);
-				if (e.target == document) {
-					wmi.storeU32(off(4), 1);
-				} else if (e.target == window) {
-					wmi.storeU32(off(4), 2);
-				} else {
-					wmi.storeU32(off(4), 0);
-				}
-				if (e.currentTarget == document) {
-					wmi.storeU32(off(4), 1);
-				} else if (e.currentTarget == window) {
-					wmi.storeU32(off(4), 2);
-				} else {
-					wmi.storeU32(off(4), 0);
-				}
-
-				align(W);
-
-				wmi.storeI32(off(W), event_temp.data.id_ptr);
-				wmi.storeUint(off(W), event_temp.data.id_len);
-
-				align(8);
-				wmi.storeF64(off(8), e.timeStamp*1e-3);
-
-				wmi.storeU8(off(1), e.eventPhase);
-				let options = 0;
-				if (!!e.bubbles)    { options |= 1<<0; }
-				if (!!e.cancelable) { options |= 1<<1; }
-				if (!!e.composed)   { options |= 1<<2; }
-				wmi.storeU8(off(1), options);
-				wmi.storeU8(off(1), !!e.isComposing);
-				wmi.storeU8(off(1), !!e.isTrusted);
-
-				align(8);
-				if (e instanceof WheelEvent) {
-					wmi.storeF64(off(8), e.deltaX);
-					wmi.storeF64(off(8), e.deltaY);
-					wmi.storeF64(off(8), e.deltaZ);
-					wmi.storeU32(off(4), e.deltaMode);
-				} else if (e instanceof MouseEvent) {
-					wmi.storeI64(off(8), e.screenX);
-					wmi.storeI64(off(8), e.screenY);
-					wmi.storeI64(off(8), e.clientX);
-					wmi.storeI64(off(8), e.clientY);
-					wmi.storeI64(off(8), e.offsetX);
-					wmi.storeI64(off(8), e.offsetY);
-					wmi.storeI64(off(8), e.pageX);
-					wmi.storeI64(off(8), e.pageY);
-					wmi.storeI64(off(8), e.movementX);
-					wmi.storeI64(off(8), e.movementY);
-
-					wmi.storeU8(off(1), !!e.ctrlKey);
-					wmi.storeU8(off(1), !!e.shiftKey);
-					wmi.storeU8(off(1), !!e.altKey);
-					wmi.storeU8(off(1), !!e.metaKey);
-
-					wmi.storeI16(off(2), e.button);
-					wmi.storeU16(off(2), e.buttons);
-
-					if (e instanceof PointerEvent) {
-						wmi.storeF64(off(8), e.altitudeAngle);
-						wmi.storeF64(off(8), e.azimuthAngle);
-						wmi.storeInt(off(W), e.persistentDeviceId);
-						wmi.storeInt(off(W), e.pointerId);
-						wmi.storeInt(off(W), e.width);
-						wmi.storeInt(off(W), e.height);
-						wmi.storeF64(off(8), e.pressure);
-						wmi.storeF64(off(8), e.tangentialPressure);
-						wmi.storeF64(off(8), e.tiltX);
-						wmi.storeF64(off(8), e.tiltY);
-						wmi.storeF64(off(8), e.twist);
-						if (e.pointerType == "pen") {
-							wmi.storeU8(off(1), 1);
-						} else if (e.pointerType == "touch") {
-							wmi.storeU8(off(1), 2);
-						} else {
-							wmi.storeU8(off(1), 0);
-						}
-						wmi.storeU8(off(1), !!e.isPrimary);
-					}
-
-				} else if (e instanceof KeyboardEvent) {
-					// Note: those strings are constructed
-					// on the native side from buffers that
-					// are filled later, so skip them
-					const keyPtr  = off(W*2, W);
-					const codePtr = off(W*2, W);
-
-					wmi.storeU8(off(1), e.location);
-
-					wmi.storeU8(off(1), !!e.ctrlKey);
-					wmi.storeU8(off(1), !!e.shiftKey);
-					wmi.storeU8(off(1), !!e.altKey);
-					wmi.storeU8(off(1), !!e.metaKey);
-
-					wmi.storeU8(off(1), !!e.repeat);
-
-					wmi.storeI32(off(4), e.charCode);
-
-					wmi.storeInt(off(W, W), e.key.length)
-					wmi.storeInt(off(W, W), e.code.length)
-					wmi.storeString(off(32, 1), e.key);
-					wmi.storeString(off(32, 1), e.code);
-				} else if (e.type === 'scroll') {
-					wmi.storeF64(off(8, 8), window.scrollX);
-					wmi.storeF64(off(8, 8), window.scrollY);
-				} else if (e.type === 'visibilitychange') {
-					wmi.storeU8(off(1), !document.hidden);
-				} else if (e instanceof GamepadEvent) {
-					const idPtr      = off(W*2, W);
-					const mappingPtr = off(W*2, W);
-
-					wmi.storeI32(off(W, W), e.gamepad.index);
-					wmi.storeU8(off(1), !!e.gamepad.connected);
-					wmi.storeF64(off(8, 8), e.gamepad.timestamp);
-
-					wmi.storeInt(off(W, W), e.gamepad.buttons.length);
-					wmi.storeInt(off(W, W), e.gamepad.axes.length);
-
-					for (let i = 0; i < 64; i++) {
-						if (i < e.gamepad.buttons.length) {
-							let b = e.gamepad.buttons[i];
-							wmi.storeF64(off(8, 8), b.value);
-							wmi.storeU8(off(1),  !!b.pressed);
-							wmi.storeU8(off(1),  !!b.touched);
-						} else {
-							off(16, 8);
-						}
-					}
-					for (let i = 0; i < 16; i++) {
-						if (i < e.gamepad.axes.length) {
-							let a = e.gamepad.axes[i];
-							wmi.storeF64(off(8, 8), a);
-						} else {
-							off(8, 8);
-						}
-					}
-
-					let idLength = e.gamepad.id.length;
-					let id = e.gamepad.id;
-					if (idLength > 96) {
-						idLength = 96;
-						id = id.slice(0, 93) + '...';
-					}
-
-					let mappingLength = e.gamepad.mapping.length;
-					let mapping = e.gamepad.mapping;
-					if (mappingLength > 64) {
-						mappingLength = 61;
-						mapping = mapping.slice(0, 61) + '...';
-					}
-
-					wmi.storeInt(off(W, W), idLength);
-					wmi.storeInt(off(W, W), mappingLength);
-					wmi.storeString(off(96, 1), id);
-					wmi.storeString(off(64, 1), mapping);
-				}
-			},
-
-			add_event_listener: (id_ptr, id_len, name_ptr, name_len, name_code, data, callback, use_capture) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let element = getElement(id);
-				if (element == undefined) {
-					return false;
-				}
-				let key = listener_key(id, name, data, callback, !!use_capture);
-				if (wasmMemoryInterface.listenerMap.has(key)) {
-					return false;
-				}
-
-				let listener = (e) => {
-					let event_data = {};
-					event_data.id_ptr = id_ptr;
-					event_data.id_len = id_len;
-					event_data.event = e;
-					event_data.name_code = name_code;
-
-					onEventReceived(event_data, data, callback);
-				};
-				wasmMemoryInterface.listenerMap.set(key, listener);
-				element.addEventListener(name, listener, !!use_capture);
-				return true;
-			},
-
-			add_window_event_listener: (name_ptr, name_len, name_code, data, callback, use_capture) => {
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let element = window;
-				let key = listener_key('window', name, data, callback, !!use_capture);
-				if (wasmMemoryInterface.listenerMap.has(key)) {
-					return false;
-				}
-
-				let listener = (e) => {
-					let event_data = {};
-					event_data.id_ptr = 0;
-					event_data.id_len = 0;
-					event_data.event = e;
-					event_data.name_code = name_code;
-
-					onEventReceived(event_data, data, callback);
-				};
-				wasmMemoryInterface.listenerMap.set(key, listener);
-				element.addEventListener(name, listener, !!use_capture);
-				return true;
-			},
-
-			add_document_event_listener: (name_ptr, name_len, name_code, data, callback, use_capture) => {
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let element = document;
-				let key = listener_key('document', name, data, callback, !!use_capture);
-				if (wasmMemoryInterface.listenerMap.has(key)) {
-					return false;
-				}
-
-				let listener = (e) => {
-					let event_data = {};
-					event_data.id_ptr = 0;
-					event_data.id_len = 0;
-					event_data.event = e;
-					event_data.name_code = name_code;
-
-					onEventReceived(event_data, data, callback);
-				};
-				wasmMemoryInterface.listenerMap.set(key, listener);
-				element.addEventListener(name, listener, !!use_capture);
-				return true;
-			},
-
-			remove_event_listener: (id_ptr, id_len, name_ptr, name_len, data, callback, use_capture) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let element = getElement(id);
-				if (element == undefined) {
-					return false;
-				}
-
-				let key = listener_key(id, name, data, callback, !!use_capture);
-				let listener = wasmMemoryInterface.listenerMap.get(key);
-				if (listener === undefined) {
-					return false;
-				}
-				wasmMemoryInterface.listenerMap.delete(key);
-
-				element.removeEventListener(name, listener, !!use_capture);
-				return true;
-			},
-			remove_window_event_listener: (name_ptr, name_len, data, callback, use_capture) => {
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let element = window;
-
-				let key = listener_key('window', name, data, callback, !!use_capture);
-				let listener = wasmMemoryInterface.listenerMap.get(key);
-				if (listener === undefined) {
-					return false;
-				}
-				wasmMemoryInterface.listenerMap.delete(key);
-
-				element.removeEventListener(name, listener, !!use_capture);
-				return true;
-			},
-			remove_document_event_listener: (name_ptr, name_len, data, callback, use_capture) => {
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let element = document;
-
-				let key = listener_key('document', name, data, callback, !!use_capture);
-				let listener = wasmMemoryInterface.listenerMap.get(key);
-				if (listener === undefined) {
-					return false;
-				}
-				wasmMemoryInterface.listenerMap.delete(key);
-
-				element.removeEventListener(name, listener, !!use_capture);
-				return true;
-			},
-
-			event_stop_propagation: () => {
-				if (event_temp.data && event_temp.data.event) {
-					event_temp.data.event.stopPropagation();
-				}
-			},
-			event_stop_immediate_propagation: () => {
-				if (event_temp.data && event_temp.data.event) {
-					event_temp.data.event.stopImmediatePropagation();
-				}
-			},
-			event_prevent_default: () => {
-				if (event_temp.data && event_temp.data.event) {
-					event_temp.data.event.preventDefault();
-				}
-			},
-
-			dispatch_custom_event: (id_ptr, id_len, name_ptr, name_len, options_bits) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let name = wasmMemoryInterface.loadString(name_ptr, name_len);
-				let options = {
-					bubbles:    (options_bits & (1<<0)) !== 0,
-					cancelable: (options_bits & (1<<1)) !== 0,
-					composed:   (options_bits & (1<<2)) !== 0,
-				};
-
-				let element = getElement(id);
-				if (element) {
-					element.dispatchEvent(new Event(name, options));
-					return true;
-				}
-				return false;
-			},
-
-			// Writes a struct of type `Gamepad_State`, see `core/sys/wasm/js/events.odin`
-			get_gamepad_state: (gamepad_id, ep) => {
-				let index = gamepad_id;
-				let gps = navigator.getGamepads();
-				if (0 <= index && index < gps.length) {
-					let gamepad = gps[index];
-					if (!gamepad) {
-						return false;
-					}
-
-					const W = wasmMemoryInterface.intSize;
-					let offset = ep;
-					let off = (amount, alignment) => {
-						if (alignment === undefined) {
-							alignment = Math.min(amount, W);
-						}
-						if (offset % alignment != 0) {
-							offset += alignment - (offset%alignment);
-						}
-						let x = offset;
-						offset += amount;
-						return x;
-					};
-
-					let align = (alignment) => {
-						const modulo = offset & (alignment-1);
-						if (modulo != 0) {
-							offset += alignment - modulo
-						}
-					};
-
-					let wmi = wasmMemoryInterface;
-
-					const idPtr      = off(W*2, W);
-					const mappingPtr = off(W*2, W);
-
-					wmi.storeI32(off(W), gamepad.index);
-					wmi.storeU8(off(1), !!gamepad.connected);
-					wmi.storeF64(off(8), gamepad.timestamp);
-
-					wmi.storeInt(off(W), gamepad.buttons.length);
-					wmi.storeInt(off(W), gamepad.axes.length);
-
-					for (let i = 0; i < 64; i++) {
-						if (i < gamepad.buttons.length) {
-							let b = gamepad.buttons[i];
-							wmi.storeF64(off(8, 8), b.value);
-							wmi.storeU8(off(1),  !!b.pressed);
-							wmi.storeU8(off(1),  !!b.touched);
-						} else {
-							off(16, 8);
-						}
-					}
-					for (let i = 0; i < 16; i++) {
-						if (i < gamepad.axes.length) {
-							wmi.storeF64(off(8, 8), gamepad.axes[i]);
-						} else {
-							off(8, 8);
-						}
-					}
-
-					let idLength = gamepad.id.length;
-					let id = gamepad.id;
-					if (idLength > 96) {
-						idLength = 96;
-						id = id.slice(0, 93) + '...';
-					}
-
-					let mappingLength = gamepad.mapping.length;
-					let mapping = gamepad.mapping;
-					if (mappingLength > 64) {
-						mappingLength = 61;
-						mapping = mapping.slice(0, 61) + '...';
-					}
-
-					wmi.storeInt(off(W, W), idLength);
-					wmi.storeInt(off(W, W), mappingLength);
-					wmi.storeString(off(96, 1), id);
-					wmi.storeString(off(64, 1), mapping);
-
-					return true;
-				}
-				return false;
-			},
-
-			get_element_value_f64: (id_ptr, id_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let element = getElement(id);
-				return element ? element.value : 0;
-			},
-			get_element_value_string: (id_ptr, id_len, buf_ptr, buf_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let element = getElement(id);
-				if (element) {
-					let str = element.value;
-					if (buf_len > 0 && buf_ptr) {
-						let n = Math.min(buf_len, str.length);
-						str = str.substring(0, n);
-						wasmMemoryInterface.loadBytes(buf_ptr, buf_len).set(new TextEncoder().encode(str))
-						return n;
-					}
-				}
-				return 0;
-			},
-			get_element_value_string_length: (id_ptr, id_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let element = getElement(id);
-				if (element) {
-					return element.value.length;
-				}
-				return 0;
-			},
-			get_element_min_max: (ptr_array2_f64, id_ptr, id_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let element = getElement(id);
-				if (element) {
-					let values = wasmMemoryInterface.loadF64Array(ptr_array2_f64, 2);
-					values[0] = element.min;
-					values[1] = element.max;
-				}
-			},
-			set_element_value_f64: (id_ptr, id_len, value) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let element = getElement(id);
-				if (element) {
-					element.value = value;
-				}
-			},
-			set_element_value_string: (id_ptr, id_len, value_ptr, value_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let value = wasmMemoryInterface.loadString(value_ptr, value_len);
-				let element = getElement(id);
-				if (element) {
-					element.value = value;
-				}
-			},
-
-			set_element_style: (id_ptr, id_len, key_ptr, key_len, value_ptr, value_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let key = wasmMemoryInterface.loadString(key_ptr, key_len);
-				let value = wasmMemoryInterface.loadString(value_ptr, value_len);
-				let element = getElement(id);
-				if (element) {
-					element.style[key] = value;
-				}
-			},
-
-			set_document_title: (title_ptr, title_len) => {
-				let title = wasmMemoryInterface.loadString(title_ptr, title_len);
-				document.title = title;
-			},
-
-			get_element_key_f64: (id_ptr, id_len, key_ptr, key_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let key = wasmMemoryInterface.loadString(key_ptr, key_len);
-				let element = getElement(id);
-				return element ? element[key] : 0;
-			},
-			get_element_key_string: (id_ptr, id_len, key_ptr, key_len, buf_ptr, buf_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let key = wasmMemoryInterface.loadString(key_ptr, key_len);
-				let element = getElement(id);
-				if (element) {
-					let str = element[key];
-					if (buf_len > 0 && buf_ptr) {
-						let n = Math.min(buf_len, str.length);
-						str = str.substring(0, n);
-						wasmMemoryInterface.loadBytes(buf_ptr, buf_len).set(new TextEncoder().encode(str))
-						return n;
-					}
-				}
-				return 0;
-			},
-			get_element_key_string_length: (id_ptr, id_len, key_ptr, key_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let key = wasmMemoryInterface.loadString(key_ptr, key_len);
-				let element = getElement(id);
-				if (element && element[key]) {
-					return element[key].length;
-				}
-				return 0;
-			},
-
-			set_element_key_f64: (id_ptr, id_len, key_ptr, key_len, value) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let key = wasmMemoryInterface.loadString(key_ptr, key_len);
-				let element = getElement(id);
-				if (element) {
-					element[key] = value;
-				}
-			},
-			set_element_key_string: (id_ptr, id_len, key_ptr, key_len, value_ptr, value_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let key = wasmMemoryInterface.loadString(key_ptr, key_len);
-				let value = wasmMemoryInterface.loadString(value_ptr, value_len);
-				let element = getElement(id);
-				if (element) {
-					element[key] = value;
-				}
-			},
-
-
-			get_bounding_client_rect: (rect_ptr, id_ptr, id_len) => {
-				let id = wasmMemoryInterface.loadString(id_ptr, id_len);
-				let element = getElement(id);
-				if (element) {
-					let values = wasmMemoryInterface.loadF64Array(rect_ptr, 4);
-					let rect = element.getBoundingClientRect();
-					values[0] = rect.left;
-					values[1] = rect.top;
-					values[2] = rect.right  - rect.left;
-					values[3] = rect.bottom - rect.top;
-				}
-			},
-			window_get_rect: (rect_ptr) => {
-				let values = wasmMemoryInterface.loadF64Array(rect_ptr, 4);
-				values[0] = window.screenX;
-				values[1] = window.screenY;
-				values[2] = window.screen.width;
-				values[3] = window.screen.height;
-			},
-
-			window_get_scroll: (pos_ptr) => {
-				let values = wasmMemoryInterface.loadF64Array(pos_ptr, 2);
-				values[0] = window.scrollX;
-				values[1] = window.scrollY;
-			},
-			window_set_scroll: (x, y) => {
-				window.scroll(x, y);
-			},
-
-			device_pixel_ratio: () => {
-				return window.devicePixelRatio;
-			},
-
-		},
-
-		"webgl": webglContext.getWebGL1Interface(),
-		"webgl2": webglContext.getWebGL2Interface(),
-	};
-};
-
-/**
- * @param {string} wasmPath                          - Path to the WASM module to run
- * @param {?HTMLPreElement} consoleElement           - Optional console/pre element to append output to, in addition to the console
- * @param {any} extraForeignImports                  - Imports, in addition to the default runtime to provide the module
- * @param {?WasmMemoryInterface} wasmMemoryInterface - Optional memory to use instead of the defaults
- * @param {?int} intSize                             - Size (in bytes) of the integer type, should be 4 on `js_wasm32` and 8 on `js_wasm64p32`
- */
-async function runWasm(wasmPath, consoleElement, extraForeignImports, wasmMemoryInterface, intSize = 4) {
-	if (!wasmMemoryInterface) {
-		wasmMemoryInterface = new WasmMemoryInterface();
-	}
-	wasmMemoryInterface.setIntSize(intSize);
-
-	let imports = odinSetupDefaultImports(wasmMemoryInterface, consoleElement, wasmMemoryInterface.memory);
-	let exports = {};
-
-	if (extraForeignImports !== undefined) {
-		imports = {
-			...imports,
-			...extraForeignImports,
-		};
-	}
-
-	const response = await fetch(wasmPath);
-	const file = await response.arrayBuffer();
-	const wasm = await WebAssembly.instantiate(file, imports);
-	exports = wasm.instance.exports;
-	wasmMemoryInterface.setExports(exports);
-
-	if (exports.memory) {
-		if (wasmMemoryInterface.memory) {
-			console.warn('WASM module exports memory, but `runWasm` was given an interface with existing memory too. Did you mean to use `-extra-linker-flags:"--import-memory"` to tell the compiler not to export memory?');
-		}
-		wasmMemoryInterface.setMemory(exports.memory);
-	}
-
-	if (exports._start) {
-		exports._start();
-	}
-
-	// Define a `@export step :: proc(delta_time: f64) -> (keep_going: bool) {`
-	// in your app and it will get called every frame.
-	// return `false` to stop the execution of the module.
-	if (exports.step) {
-		const odin_ctx = exports.default_context_ptr();
-
-		let prevTimeStamp = undefined;
-		function step(currTimeStamp) {
-			if (prevTimeStamp == undefined) {
-				prevTimeStamp = currTimeStamp;
-			}
-
-			const dt = (currTimeStamp - prevTimeStamp)*0.001;
-			prevTimeStamp = currTimeStamp;
-
-			if (!exports.step(dt, odin_ctx)) {
-				if (exports._end) {
-					exports._end();
-				}
-				return;
-			}
-
-			window.requestAnimationFrame(step);
-		}
-
-		window.requestAnimationFrame(step);
-	} else {
-		if (exports._end) {
-			exports._end();
-		}
-	}
-
-	return;
-};
-
-window.odin = {
-	// Interface Types
-	WasmMemoryInterface: WasmMemoryInterface,
-	WebGLInterface:      WebGLInterface,
-
-	// Functions
-	setupDefaultImports: odinSetupDefaultImports,
-	runWasm:             runWasm,
-};
-})();