Move headers to kon/ and add per-lib implementation stubs

13 files changed, 3786 insertions, 0 deletions

diff --git a/kon/konfont.h b/kon/konfont.h
new file mode 100644
index 0000000..822e1f3
--- /dev/null
+++ b/kon/konfont.h
@@ -0,0 +1,197 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * konfont.h
+ *
+ * Copyright (c) 2026 KonAki
+ *
+ * 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.
+ */
+
+#ifndef KONFONT_H
+#define KONFONT_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "konsofren.h"
+
+#define KON_FONT_FIRST_CHAR 32
+#define KON_FONT_NUM_CHARS 95
+
+typedef struct kon_font kon_font_t;
+
+/*** font declarations ***/
+
+kon_font_t *kon_loadFont(const uint8_t *ttf_data, size_t size, float pixelHeight);
+void kon_freeFont(kon_font_t *font);
+
+kon_image *kon_fontGetAtlas(kon_font_t *font);
+
+/*** text draw declarations ***/
+
+void kon_drawText(kon_framebuffer_t *fb, kon_font_t *font, int x, int y, const char *text, uint32_t color);
+void kon_measureText(kon_font_t *font, const char *text, int *outWidth, int *outHeight);
+
+/*** implementatoin ***/
+
+#ifdef KONFONT_IMPLEMENTATION
+
+#include "stb_truetype.h"
+
+struct kon_font {
+	stbtt_bakedchar chardata[KON_FONT_NUM_CHARS];
+	uint8_t *atlasPixels;
+	int atlasSize;
+	float pixelHeight;
+};
+
+/*** private helpers ***/
+
+static bool kon_fontBakeAtlas(kon_font_t *font, const uint8_t *ttf_data, float pixelHeight) {
+	int sizes[] = {256, 512, 1024, 2048};
+	
+	for (int i = 0; i < 4; i++) {
+		int atlasSize = sizes[i];
+
+		uint8_t *bitmap = malloc((size_t)atlasSize * (size_t)atlasSize);
+		if (!bitmap) return false;
+
+		int result = stbtt_BakeFontBitmap(ttf_data, 0, pixelHeight, bitmap, atlasSize, atlasSize, KON_FONT_FIRST_CHAR, KON_FONT_NUM_CHARS, font->chardata);
+
+		if (result > 0) {
+			font->atlasPixels = bitmap;
+			font->atlasSize = atlasSize;
+			return true;
+		}
+
+		free(bitmap);
+	}
+
+	return false;
+}
+
+/*** font implementation ***/
+
+kon_font_t *kon_loadFont(const uint8_t *ttf_data, size_t size, float pixelHeight) {
+	(void)size;
+
+	if (!ttf_data || pixelHeight <= 0.0f) return NULL;
+
+	kon_font_t *font = malloc(sizeof(kon_font_t));
+	if (!font) return NULL;
+
+	font->atlasPixels = NULL;
+	font->pixelHeight = pixelHeight;
+
+	if (!kon_fontBakeAtlas(font, ttf_data, pixelHeight)) {
+		free(font);
+		return NULL;
+	}
+
+	return font;
+}
+
+void kon_freeFont(kon_font_t *font) {
+	if (!font) return;
+
+	free(font->atlasPixels);
+	free(font);
+}
+
+kon_image *kon_fontGetAtlas(kon_font_t *font) {
+	if (!font) return NULL;
+
+	int n = font->atlasSize * font->atlasSize;
+	uint8_t *rgba = malloc((size_t)n * 4);
+	if (!rgba) return NULL;
+
+	for (int i = 0; i < n; i++) {
+		uint8_t a = font->atlasPixels[i];
+		rgba[i * 4 + 0] = 255;
+		rgba[i * 4 + 1] = 255;
+		rgba[i * 4 + 2] = 255;
+		rgba[i * 4 + 3] = a;
+	}
+
+	kon_image *img = kon_loadImage(rgba, font->atlasSize, font->atlasSize, konFormatRGBA8);
+	free(rgba);
+	return img;
+}
+
+/*** text draw implementation ***/
+
+void kon_drawText(kon_framebuffer_t *fb, kon_font_t *font, int x, int y, const char *text, uint32_t color) {
+	if (!fb || !font || !text) return;
+
+	uint32_t baseColor = color & 0x00FFFFFF;
+
+	float cursorX = (float)x;
+	float cursorY = (float)y;
+
+	for (const char *p = text; *p; p++) {
+		unsigned char c = (unsigned char)*p;
+
+		if (c < KON_FONT_FIRST_CHAR || c >= KON_FONT_FIRST_CHAR + KON_FONT_NUM_CHARS) continue;
+
+		stbtt_aligned_quad q;
+		stbtt_GetBakedQuad(font->chardata, font->atlasSize, font->atlasSize, c - KON_FONT_FIRST_CHAR, &cursorX, &cursorY, &q, 0);
+
+		int src_x0 = (int)(q.s0 * font->atlasSize);
+		int src_y0 = (int)(q.t0 * font->atlasSize);
+		int glyphW = (int)(q.x1 - q.x0);
+		int glyphH = (int)(q.y1 - q.y0);
+
+		for (int gy = 0; gy < glyphH; gy++) {
+			for (int gx = 0; gx < glyphW; gx++) {
+				uint8_t alpha = font->atlasPixels[(src_y0 + gy) * font->atlasSize + (src_x0 + gx)];
+				if (alpha == 0) continue;
+
+				kon_putPixel(fb, (int)q.x0 + gx, (int)q.y0 + gy, ((uint32_t)alpha << 24) | baseColor);
+			}
+		}
+	}
+}
+
+void kon_measureText(kon_font_t *font, const char *text, int *outWidth, int *outHeight) {
+	if (!font || !text) return;
+
+	float cursorX = 0.0f;
+	float cursorY = 0.0f;
+	float maxX = 0.0f;
+
+	for (const char *p = text; *p; p++) {
+		unsigned char c = (unsigned char)*p;
+
+		if (c < KON_FONT_FIRST_CHAR || c >= KON_FONT_FIRST_CHAR + KON_FONT_NUM_CHARS) continue;
+
+		stbtt_aligned_quad q;
+		stbtt_GetBakedQuad(font->chardata, font->atlasSize, font->atlasSize, c - KON_FONT_FIRST_CHAR, &cursorX, &cursorY, &q, 0);
+
+		if (cursorX > maxX) maxX = cursorX;
+	}
+
+	if (outWidth) *outWidth = (int)maxX;
+	if (outHeight) *outHeight = (int)font->pixelHeight;
+}
+
+#endif /* KONFONT_IMPLEMENTATION */
+
+#endif /* KONFONT_H */
diff --git a/kon/koninput.h b/kon/koninput.h
new file mode 100644
index 0000000..5008c06
--- /dev/null
+++ b/kon/koninput.h
@@ -0,0 +1,142 @@
+/*
+
+MIT License
+
+Copyright (c) 2026 KonAki
+
+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.
+
+*/
+
+#ifndef KONINPUT_H
+#define KONINPUT_H
+
+#include "konwinlib.h"
+
+typedef struct kon_input {
+	bool down[KON_KEY_COUNT];
+	bool downPrev[KON_KEY_COUNT];
+
+	bool mouseDown[3];
+	bool mouseDownPrev[3];
+
+	int mouseX, mouseY;
+} kon_input_t;
+
+void kon_inputBeginFrame(kon_input_t *input);
+
+void kon_inputFeedEvent(kon_input_t *input, const kon_event_t *event);
+
+bool kon_isKeyDown(const kon_input_t *input, kon_key_t key);
+bool kon_isKeyPressed(const kon_input_t *input, kon_key_t key);
+bool kon_isKeyReleased(const kon_input_t *input, kon_key_t key);
+
+bool kon_isMouseDown(const kon_input_t *input, kon_mouseButton_t button);
+bool kon_isMousePressed(const kon_input_t *input, kon_mouseButton_t button);
+bool kon_isMouseReleased(const kon_input_t *input, kon_mouseButton_t button);
+
+void kon_getMousePos(const kon_input_t *input, int *x, int *y);
+
+/*** implementation ***/
+
+#ifdef KONINPUT_IMPLEMENTATION
+
+void kon_inputBeginFrame(kon_input_t *input) {
+	if (!input) return;
+
+	for (int i = 0; i < KON_KEY_COUNT; i++) {
+		input->downPrev[i] = input->down[i];
+	}
+	for (int i = 0; i < 3; i++) {
+		input->mouseDownPrev[i] = input->mouseDown[i];
+	}
+}
+
+void kon_inputFeedEvent(kon_input_t *input, const kon_event_t *event) {
+	if (!input || !event) return;
+
+	switch (event->type) {
+	case KON_EVENT_KEY_DOWN:
+		if (event->key >= 0 && event->key < KON_KEY_COUNT)
+			input->down[event->key] = true;
+		break;
+	case KON_EVENT_KEY_UP:
+		if (event->key >= 0 && event->key < KON_KEY_COUNT)
+			input->down[event->key] = false;
+		break;
+	case KON_EVENT_MOUSE_DOWN:
+		if (event->mouseButton >= 0 && event->mouseButton < 3)
+			input->mouseDown[event->mouseButton] = true;
+		input->mouseX = event->mouseX;
+		input->mouseY = event->mouseY;
+		break;
+	case KON_EVENT_MOUSE_UP:
+		if (event->mouseButton >= 0 && event->mouseButton < 3)
+			input->mouseDown[event->mouseButton] = false;
+		input->mouseX = event->mouseX;
+		input->mouseY = event->mouseY;
+		break;
+	case KON_EVENT_MOUSE_MOVE:
+		input->mouseX = event->mouseX;
+		input->mouseY = event->mouseY;
+		break;
+	default:
+		break;
+	}
+}
+
+bool kon_isKeyDown(const kon_input_t *input, kon_key_t key) {
+	if (!input || key < 0 || key >= KON_KEY_COUNT) return false;
+	return input->down[key];
+}
+
+bool kon_isKeyPressed(const kon_input_t *input, kon_key_t key) {
+	if (!input || key < 0 || key >= KON_KEY_COUNT) return false;
+	return input->down[key] && !input->downPrev[key];
+}
+
+bool kon_isKeyReleased(const kon_input_t *input, kon_key_t key) {
+	if (!input || key < 0 || key >= KON_KEY_COUNT) return false;
+	return !input->down[key] && input->downPrev[key];
+}
+
+bool kon_isMouseDown(const kon_input_t *input, kon_mouseButton_t button) {
+	if (!input || button < 0 || button >= 3) return false;
+	return input->mouseDown[button];
+}
+
+bool kon_isMousePressed(const kon_input_t *input, kon_mouseButton_t button) {
+	if (!input || button < 0 || button >= 3) return false;
+	return input->mouseDown[button] && !input->mouseDownPrev[button];
+}
+
+bool kon_isMouseReleased(const kon_input_t *input, kon_mouseButton_t button) {
+	if (!input || button < 0 || button >= 3) return false;
+	return !input->mouseDown[button] && input->mouseDownPrev[button];
+}
+
+void kon_getMousePos(const kon_input_t *input, int *x, int *y) {
+	if (!input) return;
+	if (x) *x = input->mouseX;
+	if (y) *y = input->mouseY;
+}
+
+#endif /* KONINPUT_IMPLEMENTATION */
+
+#endif /* KONINPUT_H */
diff --git a/kon/konsofren.h b/kon/konsofren.h
new file mode 100644
index 0000000..05e4bf5
--- /dev/null
+++ b/kon/konsofren.h
@@ -0,0 +1,1276 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * konsofren.h
+ *
+ * Copyright (c) 2026 KonAki
+ *
+ * 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.
+ */
+
+#ifndef KONSOFREN_H
+#define KONSOFREN_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <math.h>
+
+#define KON_BACKGROUND_COLOR 0xFF05050A
+
+typedef struct kon_framebuffer {
+	int width, height;
+	uint32_t *data;
+	float *depth; /* created the first time something is drawn with KON_RENDER_DEPTH */
+} kon_framebuffer_t;
+
+typedef kon_framebuffer_t kon_image;
+
+typedef enum kon_imageFormat {
+	konFormatRGBA8 = 0,
+	konFormatABGR8,
+	konFormatARGB8,
+	konFormatBGRA8
+} kon_imageFormat_t;
+
+#define KON_PI 3.14159265358979323846f
+#define KON_TAU (2.0f * KON_PI)
+
+#define KON_DEG2RAD(d) ((float)(d) * (KON_PI / 180.0f))
+#define KON_RAD2DEG(r) ((float)(r) * (180.0f / KON_PI))
+
+/* kon_vec3_t built from degrees, handy for rotations: KON_DEG3(0, 45, 0) */
+#define KON_DEG3(x, y, z) ((kon_vec3_t){KON_DEG2RAD(x), KON_DEG2RAD(y), KON_DEG2RAD(z)})
+
+#define KON_VEC2(x, y) ((kon_vec2_t){(float)(x), (float)(y)})
+#define KON_VEC3(x, y, z) ((kon_vec3_t){(float)(x), (float)(y), (float)(z)})
+#define KON_VEC4(x, y, z, w) ((kon_vec4_t){(float)(x), (float)(y), (float)(z), (float)(w)})
+
+#define KON_VEC3_ZERO KON_VEC3(0, 0, 0)
+#define KON_VEC3_ONE KON_VEC3(1, 1, 1)
+#define KON_VEC3_UP KON_VEC3(0, 1, 0)
+
+/* right-handed, +Y up, camera looks down -Z, column-major: m[column * 4 + row] */
+
+typedef struct kon_vec2 { float x, y; } kon_vec2_t;
+typedef struct kon_vec3 { float x, y, z; } kon_vec3_t;
+typedef struct kon_vec4 { float x, y, z, w; } kon_vec4_t;
+typedef struct kon_mat4 { float m[16]; } kon_mat4_t;
+
+/* game is the fixed-size framebuffer you draw into, screen always matches the window */
+typedef struct kon_display {
+	kon_framebuffer_t *game;
+	kon_framebuffer_t *screen;
+	int integerOnly;
+
+	/* where the game image sits inside screen, kept up to date by the functions below */
+	int viewX, viewY, viewWidth, viewHeight;
+	int *columnMap;
+} kon_display_t;
+
+typedef enum kon_projection {
+	KON_PROJECTION_PERSPECTIVE = 0,
+	KON_PROJECTION_ORTHOGRAPHIC
+} kon_projection_t;
+
+typedef struct kon_camera {
+	kon_vec3_t position;
+	kon_vec3_t target;
+	kon_vec3_t up;
+	kon_projection_t projection;
+	float fov;       /* vertical field of view in radians, perspective only */
+	float orthoSize; /* half the visible height in world units, orthographic only */
+	float nearZ, farZ;
+} kon_camera_t;
+
+/* edges holds pairs of indices into vertices */
+typedef struct kon_wireMesh {
+	const kon_vec3_t *vertices;
+	const uint16_t *edges;
+	int edgeCount;
+} kon_wireMesh_t;
+
+typedef enum kon_renderFlags {
+	KON_RENDER_NONE = 0,
+	KON_RENDER_WIREFRAME = 1 << 0,
+	KON_RENDER_DEPTH = 1 << 1,
+	KON_RENDER_CULL_BACK = 1 << 2
+} kon_renderFlags_t;
+
+#define KON_RENDER_DEFAULT ((kon_renderFlags_t)(KON_RENDER_DEPTH | KON_RENDER_CULL_BACK))
+
+/* uv (0, 0) is the top-left of the texture, (1, 1) the bottom-right */
+typedef struct kon_vertex {
+	kon_vec3_t position;
+	kon_vec2_t uv;
+} kon_vertex_t;
+
+/* front faces are counter-clockwise, indices hold three entries per triangle */
+typedef struct kon_mesh {
+	const kon_vertex_t *vertices;
+	const uint16_t *indices;
+	int triangleCount;
+} kon_mesh_t;
+
+/*** 2D declarations ***/
+
+/*** framebuffer declarations ***/
+
+kon_framebuffer_t *kon_createFramebuffer(int width, int height);
+void kon_freeFramebuffer(kon_framebuffer_t *fb);
+void kon_putPixel(kon_framebuffer_t *fb, int x, int y, uint32_t color);
+void kon_clearFramebuffer(kon_framebuffer_t *fb, uint32_t color);
+void kon_resizeFramebuffer(kon_framebuffer_t *fb, int width, int height);
+void kon_exportPixels(kon_framebuffer_t *fb, kon_imageFormat_t format, uint8_t *out);
+
+/*** image declarations ***/
+
+kon_image *kon_loadImage(const uint8_t *pixels, int width, int height, kon_imageFormat_t format);
+void kon_freeImage(kon_image *image);
+
+void kon_drawImage(kon_framebuffer_t *fb, int x, int y, int width, int height, kon_image *image);
+
+/*** draw function declarations ***/
+
+void kon_drawRectangle(kon_framebuffer_t *fb, int x, int y, int width, int height, uint32_t color);
+void kon_fillRectangle(kon_framebuffer_t *fb, int x, int y, int width, int height, uint32_t color);
+void kon_drawLine(kon_framebuffer_t *fb, int x0, int y0, int x1, int y1, uint32_t color);
+void kon_drawCircle(kon_framebuffer_t *fb, int center_x, int center_y, int radius, uint32_t color);
+void kon_fillCircle(kon_framebuffer_t *fb, int center_x, int center_y, int radius, uint32_t color);
+
+/*** math declarations ***/
+
+/*** scalar declarations ***/
+
+float kon_clamp(float v, float min, float max);
+float kon_lerp(float a, float b, float t);
+
+/*** vec2 declarations ***/
+
+kon_vec2_t kon_vec2Add(kon_vec2_t a, kon_vec2_t b);
+kon_vec2_t kon_vec2Sub(kon_vec2_t a, kon_vec2_t b);
+kon_vec2_t kon_vec2Scale(kon_vec2_t a, float s);
+float kon_vec2Dot(kon_vec2_t a, kon_vec2_t b);
+
+/*** vec3 declarations ***/
+
+kon_vec3_t kon_vec3Add(kon_vec3_t a, kon_vec3_t b);
+kon_vec3_t kon_vec3Sub(kon_vec3_t a, kon_vec3_t b);
+kon_vec3_t kon_vec3Scale(kon_vec3_t a, float s);
+float kon_vec3Dot(kon_vec3_t a, kon_vec3_t b);
+kon_vec3_t kon_vec3Cross(kon_vec3_t a, kon_vec3_t b);
+float kon_vec3Length(kon_vec3_t a);
+kon_vec3_t kon_vec3Normalize(kon_vec3_t a);
+kon_vec3_t kon_vec3Lerp(kon_vec3_t a, kon_vec3_t b, float t);
+
+/*** mat4 declarations ***/
+
+kon_mat4_t kon_mat4Identity(void);
+kon_mat4_t kon_mat4Mul(kon_mat4_t a, kon_mat4_t b);
+kon_vec4_t kon_mat4MulVec4(kon_mat4_t m, kon_vec4_t v);
+kon_vec3_t kon_mat4MulPoint(kon_mat4_t m, kon_vec3_t p);
+
+/* like blender's local/global: the plain versions work along the model's own axes,
+   the World versions along the world's axes. neither rotate nor scale ever moves the model's position.
+   angles are euler angles in radians (x = pitch, y = yaw, z = roll), see KON_DEG3 */
+kon_mat4_t kon_mat4Translate(kon_mat4_t m, kon_vec3_t v);
+kon_mat4_t kon_mat4Rotate(kon_mat4_t m, kon_vec3_t angles);
+kon_mat4_t kon_mat4Scale(kon_mat4_t m, kon_vec3_t v);
+kon_mat4_t kon_mat4TranslateWorld(kon_mat4_t m, kon_vec3_t v);
+kon_mat4_t kon_mat4RotateWorld(kon_mat4_t m, kon_vec3_t angles);
+kon_mat4_t kon_mat4ScaleWorld(kon_mat4_t m, kon_vec3_t v);
+
+kon_mat4_t kon_mat4FromTranslation(kon_vec3_t v);
+kon_mat4_t kon_mat4FromRotation(kon_vec3_t angles);
+kon_mat4_t kon_mat4FromAxisAngle(kon_vec3_t axis, float angle);
+kon_mat4_t kon_mat4FromScale(kon_vec3_t v);
+kon_mat4_t kon_mat4FromTransform(kon_vec3_t position, kon_vec3_t angles, kon_vec3_t scale);
+
+kon_mat4_t kon_mat4LookAt(kon_vec3_t eye, kon_vec3_t target, kon_vec3_t up);
+kon_mat4_t kon_mat4Perspective(float fovY, float aspect, float nearZ, float farZ);
+kon_mat4_t kon_mat4Ortho(float left, float right, float bottom, float top, float nearZ, float farZ);
+
+/*** display declarations ***/
+
+
+kon_display_t *kon_createDisplay(int gameWidth, int gameHeight, int windowWidth, int windowHeight);
+void kon_freeDisplay(kon_display_t *display);
+
+void kon_setGameResolution(kon_display_t *display, int gameWidth, int gameHeight);
+void kon_setIntegerScaling(kon_display_t *display, int integerOnly);
+void kon_resizeDisplay(kon_display_t *display, int windowWidth, int windowHeight);
+
+/* scales game into screen, then blit display->screen to the window */
+void kon_presentDisplay(kon_display_t *display);
+
+/* returns 0 if the window position is on a bar, outside the game image */
+int kon_windowToGame(const kon_display_t *display, int windowX, int windowY, int *gameX, int *gameY);
+
+/*** 3D declarations ***/
+
+/*** camera declarations ***/
+
+kon_camera_t kon_cameraDefault(void);
+kon_mat4_t kon_cameraView(const kon_camera_t *camera);
+kon_mat4_t kon_cameraProjection(const kon_camera_t *camera, int width, int height);
+kon_mat4_t kon_cameraViewProjection(const kon_camera_t *camera, int width, int height);
+
+/*** 3D draw declarations ***/
+
+/* returns 0 if the point is behind the camera */
+int kon_worldToScreen(const kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_vec3_t point, kon_vec2_t *out);
+
+void kon_drawLine3D(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_vec3_t a, kon_vec3_t b, uint32_t color);
+void kon_drawWireMesh(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_mat4_t model, const kon_wireMesh_t *mesh, uint32_t color);
+
+/* texture is used when it isn't NULL, otherwise the triangle is filled with color */
+void kon_drawTriangle3D(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_vertex_t a, kon_vertex_t b, kon_vertex_t c, const kon_image *texture, uint32_t color, kon_renderFlags_t flags);
+void kon_drawMesh(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_mat4_t model, const kon_mesh_t *mesh, const kon_image *texture, uint32_t color, kon_renderFlags_t flags);
+
+/* cube from -1 to 1 with every face mapped to the whole texture */
+extern const kon_mesh_t kon_cubeMesh;
+
+/*** implementation ***/
+
+#ifdef KONSOFREN_IMPLEMENTATION
+
+
+/*** private helper ***/
+
+static inline uint32_t kon_blendColor(uint32_t dst, uint32_t src) {
+	
+	uint8_t src_a = (uint8_t)((src >> 24) & 0xFF);
+	uint8_t src_r = (uint8_t)((src >> 16) & 0xFF);
+	uint8_t src_g = (uint8_t)((src >> 8)  & 0xFF);
+	uint8_t src_b = (uint8_t)((src >> 0)  & 0xFF);
+
+	if (src_a == 0xFF) {
+		return src;
+	}
+
+	uint8_t dst_a = (uint8_t)((dst >> 24) & 0xFF);
+	uint8_t dst_r = (uint8_t)((dst >> 16) & 0xFF);
+	uint8_t dst_g = (uint8_t)((dst >> 8)  & 0xFF);
+	uint8_t dst_b = (uint8_t)((dst >> 0)  & 0xFF);
+
+	uint8_t inv_a = (uint8_t)(255 - src_a);
+
+	uint8_t out_r = (uint8_t)((src_r * src_a + dst_r * inv_a) / 255);
+	uint8_t out_g = (uint8_t)((src_g * src_a + dst_g * inv_a) / 255);
+	uint8_t out_b = (uint8_t)((src_b * src_a + dst_b * inv_a) / 255);
+
+	return ((uint32_t)dst_a << 24) | ((uint32_t)out_r << 16) | ((uint32_t)out_g << 8) | (uint32_t)out_b;
+}
+
+/* Cohen-Sutherland: clips the line to the framebuffer, returns 0 if nothing is visible */
+static int kon_outCode_(double x, double y, int width, int height) {
+	int code = 0;
+	if (x < 0) code |= 1; else if (x > width - 1) code |= 2;
+	if (y < 0) code |= 4; else if (y > height - 1) code |= 8;
+	return code;
+}
+
+static int kon_clipLine_(int width, int height, int *x0, int *y0, int *x1, int *y1) {
+	double ax = *x0, ay = *y0, bx = *x1, by = *y1;
+	double maxX = width - 1, maxY = height - 1;
+	int ca = kon_outCode_(ax, ay, width, height);
+	int cb = kon_outCode_(bx, by, width, height);
+
+	while (ca | cb) {
+		if (ca & cb) return 0;
+
+		int out = ca ? ca : cb;
+		double x, y;
+
+		if (out & 8) {
+			x = ax + (bx - ax) * (maxY - ay) / (by - ay);
+			y = maxY;
+		} else if (out & 4) {
+			x = ax + (bx - ax) * (0 - ay) / (by - ay);
+			y = 0;
+		} else if (out & 2) {
+			y = ay + (by - ay) * (maxX - ax) / (bx - ax);
+			x = maxX;
+		} else {
+			y = ay + (by - ay) * (0 - ax) / (bx - ax);
+			x = 0;
+		}
+
+		if (out == ca) {
+			ax = x; ay = y;
+			ca = kon_outCode_(ax, ay, width, height);
+		} else {
+			bx = x; by = y;
+			cb = kon_outCode_(bx, by, width, height);
+		}
+	}
+
+	*x0 = (int)(ax + 0.5); *y0 = (int)(ay + 0.5);
+	*x1 = (int)(bx + 0.5); *y1 = (int)(by + 0.5);
+	return 1;
+}
+
+/*** framebuffer implementation ***/
+
+kon_framebuffer_t *kon_createFramebuffer(int width, int height) {
+	kon_framebuffer_t *fb = calloc(1, sizeof(kon_framebuffer_t));
+	if (!fb) return NULL;
+
+	fb->data = calloc((size_t)width * (size_t)height, sizeof(uint32_t));
+	if (!fb->data) {
+		free(fb);
+		return NULL;
+	}
+
+	fb->width = width;
+	fb->height = height;
+	return fb;
+}
+
+void kon_freeFramebuffer(kon_framebuffer_t *fb) {
+	if (!fb) return;
+
+	free(fb->data);
+	free(fb->depth);
+	free(fb);
+}
+
+void kon_putPixel(kon_framebuffer_t *fb, int x, int y, uint32_t color) {
+	if (!fb) return;
+
+	if (x < 0 || x >= fb->width || y < 0 || y >= fb->height) return;
+
+	uint32_t dst = fb->data[y * fb->width + x];
+	fb->data[y * fb->width + x] = kon_blendColor(dst, color);
+}
+
+void kon_clearFramebuffer(kon_framebuffer_t *fb, uint32_t color) {
+	if (!fb) return;
+
+	for (int i = 0; i < fb->width * fb->height; i++) {
+		/* did it directly to not check overhead because of the if in bounds check */
+		fb->data[i] = color;
+	}
+
+	if (fb->depth) {
+		for (int i = 0; i < fb->width * fb->height; i++) {
+			fb->depth[i] = 1.0f;
+		}
+	}
+}
+
+void kon_resizeFramebuffer(kon_framebuffer_t *fb, int width, int height) {
+	if (!fb) return;
+
+	uint32_t *tmp = realloc(fb->data, (size_t)width * (size_t)height * sizeof(uint32_t));
+	if (!tmp) return;
+
+	fb->data = tmp;
+	fb->width  = width;
+	fb->height = height;
+
+	if (fb->depth) {
+		float *depth = realloc(fb->depth, (size_t)width * (size_t)height * sizeof(float));
+		if (!depth) free(fb->depth);
+		fb->depth = depth;
+	}
+
+	kon_clearFramebuffer(fb, KON_BACKGROUND_COLOR);
+}
+
+void kon_exportPixels(kon_framebuffer_t *fb, kon_imageFormat_t format, uint8_t *out) {
+	if (!fb || !out) return;
+
+	int fbSize = fb->width * fb->height;
+
+	for (int i = 0; i < fbSize; i++) {
+		uint32_t color = fb->data[i];
+
+		uint8_t a = (color >> 24) & 0xFF;
+		uint8_t r = (color >> 16) & 0xFF;
+		uint8_t g = (color >> 8)  & 0xFF;
+		uint8_t b = (color >> 0)  & 0xFF;
+
+		switch (format) {
+		case konFormatRGBA8:
+			out[i * 4 + 0] = r;
+			out[i * 4 + 1] = g;
+			out[i * 4 + 2] = b;
+			out[i * 4 + 3] = a;
+			break;
+		case konFormatABGR8:
+			out[i * 4 + 0] = a;
+			out[i * 4 + 1] = b;
+			out[i * 4 + 2] = g;
+			out[i * 4 + 3] = r;
+			break;
+		case konFormatARGB8:
+			out[i * 4 + 0] = a;
+			out[i * 4 + 1] = r;
+			out[i * 4 + 2] = g;
+			out[i * 4 + 3] = b;
+			break;
+		case konFormatBGRA8:
+			out[i * 4 + 0] = b;
+			out[i * 4 + 1] = g;
+			out[i * 4 + 2] = r;
+			out[i * 4 + 3] = a;
+			break;
+		default:
+			return;
+		}
+	}
+}
+
+/*** draw functions implementation ***/
+
+void kon_drawRectangle(kon_framebuffer_t *fb, int x, int y, int width, int height, uint32_t color) {
+	if (!fb) return;
+
+	kon_drawLine(fb, x, y, x + width, y, color);
+	kon_drawLine(fb, x, y + height, x + width, y + height, color);
+	kon_drawLine(fb, x, y, x, y + height, color);
+	kon_drawLine(fb, x + width, y, x + width, y + height, color);
+}
+
+void kon_fillRectangle(kon_framebuffer_t *fb, int x, int y, int width, int height, uint32_t color) {
+	if (!fb) return;
+
+	if (width < 0 || height < 0) return;
+
+	if (x < 0) {
+		width += x;
+		x = 0;
+	}
+	if (y < 0) {
+		height += y;
+		y = 0;
+	}
+
+	if (x + width  > fb->width ) width  = fb->width  - x;
+	if (y + height > fb->height) height = fb->height - y;
+
+	for (int offset_y = 0; offset_y < height; offset_y++) {
+		for (int offset_x = 0; offset_x < width; offset_x++) {
+			uint32_t dst = fb->data[(offset_y + y) * fb->width + (offset_x + x)];
+			fb->data[(y + offset_y) * fb->width + (x + offset_x)] = kon_blendColor(dst, color);
+
+		}
+	}
+}
+
+void kon_drawLine(kon_framebuffer_t *fb, int x0, int y0, int x1, int y1, uint32_t color) {
+	if (!fb) return;
+
+	if (!kon_clipLine_(fb->width, fb->height, &x0, &y0, &x1, &y1)) return;
+
+	int dx = abs(x1 - x0);
+	int dy = abs(y1 - y0);
+
+	int sx = (x0 < x1) ? 1 : -1;
+	int sy = (y0 < y1) ? 1 : -1;
+	
+	int err = dx - dy;
+
+	for (;;) {
+		kon_putPixel(fb, x0, y0, color);
+
+		if (x0 == x1 && y0 == y1) break;
+
+		int e2 = 2 * err;
+
+		if (e2 > -dy) {
+			err -= dy;
+			x0 += sx;
+		}
+
+		if (e2 < dx) {
+			err += dx;
+			y0 += sy;
+		}
+	}
+}
+
+void kon_drawCircle(kon_framebuffer_t *fb, int center_x, int center_y, int radius, uint32_t color) {
+	if (!fb) return;
+	if (radius <= 0) return;
+
+	int x = radius;
+	int y = 0;
+	int err = 1 - radius;
+
+	while (x >= y) {
+		kon_putPixel(fb, center_x + x, center_y + y, color);
+		kon_putPixel(fb, center_x + y, center_y + x, color);
+		kon_putPixel(fb, center_x - y, center_y + x, color);
+		kon_putPixel(fb, center_x - x, center_y + y, color);
+		kon_putPixel(fb, center_x - x, center_y - y, color);
+		kon_putPixel(fb, center_x - y, center_y - x, color);
+		kon_putPixel(fb, center_x + y, center_y - x, color);
+		kon_putPixel(fb, center_x + x, center_y - y, color);
+
+		y += 1;
+
+		if (err < 0) {
+			err += 2 * y + 1;
+		} else {
+			x -= 1;
+			err += 2 * (y - x) + 1;
+		}
+	}
+}
+
+void kon_fillCircle(kon_framebuffer_t *fb, int center_x, int center_y, int radius, uint32_t color) {
+	if (!fb) return;
+	if (radius <= 0) return;
+
+	int x = radius;
+	int y = 0;
+	int err = 1 - radius;
+
+	while (x >= y) {
+		kon_drawLine(fb, center_x - x, center_y + y, center_x + x, center_y + y, color);
+		kon_drawLine(fb, center_x - x, center_y - y, center_x + x, center_y - y, color);
+		kon_drawLine(fb, center_x - y, center_y + x, center_x + y, center_y + x, color);
+		kon_drawLine(fb, center_x - y, center_y - x, center_x + y, center_y - x, color);
+
+		y += 1;
+
+		if (err < 0) {
+			err += 2 * y + 1;
+		} else {
+			x -= 1;
+			err += 2 * (y - x) + 1;
+		}
+	}
+}
+
+/*** image implementation ***/
+
+kon_image *kon_loadImage(const uint8_t *pixels, int width, int height, kon_imageFormat_t format) {
+	kon_image *image = calloc(1, sizeof(kon_image));
+	if (!image) return NULL;
+
+	image->data = malloc((size_t)width * (size_t)height * sizeof(uint32_t));
+	if (!image->data) {
+		free(image);
+		return NULL;
+	}
+
+	image->width = width;
+	image->height = height;
+
+	for (int i = 0; i < width * height; i++) {
+		uint8_t r, g, b, a;
+
+		switch(format) {
+		case konFormatRGBA8:
+			r = pixels[i * 4 + 0];
+			g = pixels[i * 4 + 1];
+			b = pixels[i * 4 + 2];
+			a = pixels[i * 4 + 3];
+			break;
+		case konFormatABGR8:
+			a = pixels[i * 4 + 0];
+			b = pixels[i * 4 + 1];
+			g = pixels[i * 4 + 2];
+			r = pixels[i * 4 + 3];
+			break;
+		case konFormatARGB8:
+			a = pixels[i * 4 + 0];
+			r = pixels[i * 4 + 1];
+			g = pixels[i * 4 + 2];
+			b = pixels[i * 4 + 3];
+			break;
+		case konFormatBGRA8:
+			b = pixels[i * 4 + 0];
+			g = pixels[i * 4 + 1];
+			r = pixels[i * 4 + 2];
+			a = pixels[i * 4 + 3];
+			break;
+		default:
+			free(image->data);
+			free(image);
+			return NULL;
+		}
+
+		image->data[i] = ((uint32_t)a << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | (uint32_t)b;
+	}
+
+	return image;
+}
+void kon_freeImage(kon_image *image) {
+	kon_freeFramebuffer(image);
+}
+
+void kon_drawImage(kon_framebuffer_t *fb, int x, int y, int width, int height, kon_image *image) {
+	if (!fb || !image) return;
+
+	/* just trying to not draw when it's unnecessary */
+	if (image->width <= 0 || image->height <= 0) return;
+	if (width <= 0 || height <= 0) return;
+	if (x >= fb->width || y >= fb->height) return;
+
+	/* using this loop to make sure we only the parts of the image that are on screen */
+	for (int iy = 0; iy < height; iy++) {
+		for (int ix = 0; ix < width; ix++) {
+			int src_x = ix * image->width  / width;
+			int src_y = iy * image->height / height;
+
+			uint32_t color = image->data[src_y * image->width + src_x];
+			kon_putPixel(fb, x+ix, y+iy, color);
+		}
+	}
+}
+
+/*** math implementation ***/
+
+
+/*** scalar ***/
+
+float kon_clamp(float v, float min, float max) { return v < min ? min : (v > max ? max : v); }
+float kon_lerp(float a, float b, float t) { return a + (b - a) * t; }
+
+/*** vec2 ***/
+
+kon_vec2_t kon_vec2Add(kon_vec2_t a, kon_vec2_t b) { return (kon_vec2_t){a.x + b.x, a.y + b.y}; }
+kon_vec2_t kon_vec2Sub(kon_vec2_t a, kon_vec2_t b) { return (kon_vec2_t){a.x - b.x, a.y - b.y}; }
+kon_vec2_t kon_vec2Scale(kon_vec2_t a, float s) { return (kon_vec2_t){a.x * s, a.y * s}; }
+float kon_vec2Dot(kon_vec2_t a, kon_vec2_t b) { return a.x * b.x + a.y * b.y; }
+
+/*** vec3 ***/
+
+kon_vec3_t kon_vec3Add(kon_vec3_t a, kon_vec3_t b) { return (kon_vec3_t){a.x + b.x, a.y + b.y, a.z + b.z}; }
+kon_vec3_t kon_vec3Sub(kon_vec3_t a, kon_vec3_t b) { return (kon_vec3_t){a.x - b.x, a.y - b.y, a.z - b.z}; }
+kon_vec3_t kon_vec3Scale(kon_vec3_t a, float s) { return (kon_vec3_t){a.x * s, a.y * s, a.z * s}; }
+float kon_vec3Dot(kon_vec3_t a, kon_vec3_t b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
+
+kon_vec3_t kon_vec3Cross(kon_vec3_t a, kon_vec3_t b) {
+	return (kon_vec3_t){
+		a.y * b.z - a.z * b.y,
+		a.z * b.x - a.x * b.z,
+		a.x * b.y - a.y * b.x
+	};
+}
+
+float kon_vec3Length(kon_vec3_t a) { return sqrtf(kon_vec3Dot(a, a)); }
+
+kon_vec3_t kon_vec3Normalize(kon_vec3_t a) {
+	float len = kon_vec3Length(a);
+	return len > 0.0f ? kon_vec3Scale(a, 1.0f / len) : a;
+}
+
+kon_vec3_t kon_vec3Lerp(kon_vec3_t a, kon_vec3_t b, float t) {
+	return (kon_vec3_t){kon_lerp(a.x, b.x, t), kon_lerp(a.y, b.y, t), kon_lerp(a.z, b.z, t)};
+}
+
+/*** mat4 ***/
+
+kon_mat4_t kon_mat4Identity(void) {
+	kon_mat4_t r = {{0}};
+	r.m[0] = r.m[5] = r.m[10] = r.m[15] = 1.0f;
+	return r;
+}
+
+/* returns a * b, b is applied first */
+kon_mat4_t kon_mat4Mul(kon_mat4_t a, kon_mat4_t b) {
+	kon_mat4_t r;
+	for (int c = 0; c < 4; c++) {
+		for (int row = 0; row < 4; row++) {
+			float sum = 0.0f;
+			for (int k = 0; k < 4; k++) {
+				sum += a.m[k * 4 + row] * b.m[c * 4 + k];
+			}
+			r.m[c * 4 + row] = sum;
+		}
+	}
+	return r;
+}
+
+kon_vec4_t kon_mat4MulVec4(kon_mat4_t m, kon_vec4_t v) {
+	return (kon_vec4_t){
+		m.m[0] * v.x + m.m[4] * v.y + m.m[8]  * v.z + m.m[12] * v.w,
+		m.m[1] * v.x + m.m[5] * v.y + m.m[9]  * v.z + m.m[13] * v.w,
+		m.m[2] * v.x + m.m[6] * v.y + m.m[10] * v.z + m.m[14] * v.w,
+		m.m[3] * v.x + m.m[7] * v.y + m.m[11] * v.z + m.m[15] * v.w
+	};
+}
+
+kon_vec3_t kon_mat4MulPoint(kon_mat4_t m, kon_vec3_t p) {
+	kon_vec4_t r = kon_mat4MulVec4(m, (kon_vec4_t){p.x, p.y, p.z, 1.0f});
+	return (kon_vec3_t){r.x, r.y, r.z};
+}
+
+kon_mat4_t kon_mat4FromTranslation(kon_vec3_t v) {
+	kon_mat4_t r = kon_mat4Identity();
+	r.m[12] = v.x;
+	r.m[13] = v.y;
+	r.m[14] = v.z;
+	return r;
+}
+
+kon_mat4_t kon_mat4FromScale(kon_vec3_t v) {
+	kon_mat4_t r = kon_mat4Identity();
+	r.m[0] = v.x;
+	r.m[5] = v.y;
+	r.m[10] = v.z;
+	return r;
+}
+
+kon_mat4_t kon_mat4FromAxisAngle(kon_vec3_t axis, float angle) {
+	kon_vec3_t a = kon_vec3Normalize(axis);
+	float c = cosf(angle), s = sinf(angle), t = 1.0f - c;
+	kon_mat4_t r = kon_mat4Identity();
+	r.m[0] = t * a.x * a.x + c;
+	r.m[1] = t * a.x * a.y + s * a.z;
+	r.m[2] = t * a.x * a.z - s * a.y;
+	r.m[4] = t * a.x * a.y - s * a.z;
+	r.m[5] = t * a.y * a.y + c;
+	r.m[6] = t * a.y * a.z + s * a.x;
+	r.m[8] = t * a.x * a.z + s * a.y;
+	r.m[9] = t * a.y * a.z - s * a.x;
+	r.m[10] = t * a.z * a.z + c;
+	return r;
+}
+
+/* applied in order roll (z), pitch (x), yaw (y) */
+kon_mat4_t kon_mat4FromRotation(kon_vec3_t angles) {
+	kon_mat4_t x = kon_mat4FromAxisAngle(KON_VEC3(1, 0, 0), angles.x);
+	kon_mat4_t y = kon_mat4FromAxisAngle(KON_VEC3(0, 1, 0), angles.y);
+	kon_mat4_t z = kon_mat4FromAxisAngle(KON_VEC3(0, 0, 1), angles.z);
+	return kon_mat4Mul(y, kon_mat4Mul(x, z));
+}
+
+kon_mat4_t kon_mat4FromTransform(kon_vec3_t position, kon_vec3_t angles, kon_vec3_t scale) {
+	kon_mat4_t r = kon_mat4Mul(kon_mat4FromRotation(angles), kon_mat4FromScale(scale));
+	return kon_mat4Mul(kon_mat4FromTranslation(position), r);
+}
+
+kon_mat4_t kon_mat4Translate(kon_mat4_t m, kon_vec3_t v) { return kon_mat4Mul(m, kon_mat4FromTranslation(v)); }
+kon_mat4_t kon_mat4Rotate(kon_mat4_t m, kon_vec3_t angles) { return kon_mat4Mul(m, kon_mat4FromRotation(angles)); }
+kon_mat4_t kon_mat4Scale(kon_mat4_t m, kon_vec3_t v) { return kon_mat4Mul(m, kon_mat4FromScale(v)); }
+kon_mat4_t kon_mat4TranslateWorld(kon_mat4_t m, kon_vec3_t v) { return kon_mat4Mul(kon_mat4FromTranslation(v), m); }
+
+/* pre-multiplying would also swing the position around the world origin, so put it back */
+kon_mat4_t kon_mat4RotateWorld(kon_mat4_t m, kon_vec3_t angles) {
+	kon_mat4_t r = kon_mat4Mul(kon_mat4FromRotation(angles), m);
+	r.m[12] = m.m[12];
+	r.m[13] = m.m[13];
+	r.m[14] = m.m[14];
+	return r;
+}
+
+kon_mat4_t kon_mat4ScaleWorld(kon_mat4_t m, kon_vec3_t v) {
+	kon_mat4_t r = kon_mat4Mul(kon_mat4FromScale(v), m);
+	r.m[12] = m.m[12];
+	r.m[13] = m.m[13];
+	r.m[14] = m.m[14];
+	return r;
+}
+
+kon_mat4_t kon_mat4LookAt(kon_vec3_t eye, kon_vec3_t target, kon_vec3_t up) {
+	kon_vec3_t f = kon_vec3Normalize(kon_vec3Sub(target, eye));
+	kon_vec3_t s = kon_vec3Normalize(kon_vec3Cross(f, up));
+	kon_vec3_t u = kon_vec3Cross(s, f);
+
+	kon_mat4_t r = kon_mat4Identity();
+	r.m[0] = s.x;  r.m[4] = s.y;  r.m[8]  = s.z;  r.m[12] = -kon_vec3Dot(s, eye);
+	r.m[1] = u.x;  r.m[5] = u.y;  r.m[9]  = u.z;  r.m[13] = -kon_vec3Dot(u, eye);
+	r.m[2] = -f.x; r.m[6] = -f.y; r.m[10] = -f.z; r.m[14] =  kon_vec3Dot(f, eye);
+	return r;
+}
+
+/* fovY in radians, aspect = width / height */
+kon_mat4_t kon_mat4Perspective(float fovY, float aspect, float nearZ, float farZ) {
+	kon_mat4_t r = {{0}};
+	float f = 1.0f / tanf(fovY * 0.5f);
+	r.m[0] = f / aspect;
+	r.m[5] = f;
+	r.m[10] = (farZ + nearZ) / (nearZ - farZ);
+	r.m[11] = -1.0f;
+	r.m[14] = (2.0f * farZ * nearZ) / (nearZ - farZ);
+	return r;
+}
+
+kon_mat4_t kon_mat4Ortho(float left, float right, float bottom, float top, float nearZ, float farZ) {
+	kon_mat4_t r = kon_mat4Identity();
+	r.m[0] = 2.0f / (right - left);
+	r.m[5] = 2.0f / (top - bottom);
+	r.m[10] = -2.0f / (farZ - nearZ);
+	r.m[12] = -(right + left) / (right - left);
+	r.m[13] = -(top + bottom) / (top - bottom);
+	r.m[14] = -(farZ + nearZ) / (farZ - nearZ);
+	return r;
+}
+
+
+/*** display implementation ***/
+
+static void kon_updateView_(kon_display_t *display) {
+	int gameWidth = display->game->width, gameHeight = display->game->height;
+	int windowWidth = display->screen->width, windowHeight = display->screen->height;
+
+	int scaleX = windowWidth / gameWidth;
+	int scaleY = windowHeight / gameHeight;
+	int scale = (scaleX < scaleY) ? scaleX : scaleY;
+
+	if (display->integerOnly && scale >= 1) {
+		display->viewWidth  = gameWidth  * scale;
+		display->viewHeight = gameHeight * scale;
+	} else if ((int64_t)windowWidth * gameHeight <= (int64_t)windowHeight * gameWidth) {
+		/* window is narrower than the game: bars on top and bottom */
+		display->viewWidth  = windowWidth;
+		display->viewHeight = (int)((int64_t)windowWidth * gameHeight / gameWidth);
+	} else {
+		/* window is wider than the game: bars on the sides */
+		display->viewHeight = windowHeight;
+		display->viewWidth  = (int)((int64_t)windowHeight * gameWidth / gameHeight);
+	}
+
+	display->viewX = (windowWidth  - display->viewWidth)  / 2;
+	display->viewY = (windowHeight - display->viewHeight) / 2;
+
+	/* which game column each view column shows, worked out once instead of for every pixel */
+	int *map = realloc(display->columnMap, (size_t)windowWidth * sizeof(int));
+	if (!map) {
+		display->viewWidth = 0;
+		return;
+	}
+	display->columnMap = map;
+
+	for (int x = 0; x < display->viewWidth; x++) {
+		map[x] = (int)((int64_t)x * gameWidth / display->viewWidth);
+	}
+}
+
+kon_display_t *kon_createDisplay(int gameWidth, int gameHeight, int windowWidth, int windowHeight) {
+	if (gameWidth <= 0 || gameHeight <= 0 || windowWidth <= 0 || windowHeight <= 0) return NULL;
+
+	kon_display_t *display = calloc(1, sizeof(kon_display_t));
+	if (!display) return NULL;
+
+	display->game   = kon_createFramebuffer(gameWidth, gameHeight);
+	display->screen = kon_createFramebuffer(windowWidth, windowHeight);
+	if (!display->game || !display->screen) {
+		kon_freeDisplay(display);
+		return NULL;
+	}
+
+	kon_clearFramebuffer(display->game, KON_BACKGROUND_COLOR);
+	kon_updateView_(display);
+	return display;
+}
+
+void kon_freeDisplay(kon_display_t *display) {
+	if (!display) return;
+
+	kon_freeFramebuffer(display->game);
+	kon_freeFramebuffer(display->screen);
+	free(display->columnMap);
+	free(display);
+}
+
+void kon_setGameResolution(kon_display_t *display, int gameWidth, int gameHeight) {
+	if (!display || gameWidth <= 0 || gameHeight <= 0) return;
+
+	kon_resizeFramebuffer(display->game, gameWidth, gameHeight);
+	kon_updateView_(display);
+}
+
+void kon_setIntegerScaling(kon_display_t *display, int integerOnly) {
+	if (!display) return;
+
+	display->integerOnly = integerOnly;
+	kon_updateView_(display);
+}
+
+void kon_resizeDisplay(kon_display_t *display, int windowWidth, int windowHeight) {
+	if (!display || windowWidth <= 0 || windowHeight <= 0) return;
+
+	kon_resizeFramebuffer(display->screen, windowWidth, windowHeight);
+	kon_updateView_(display);
+}
+
+void kon_presentDisplay(kon_display_t *display) {
+	if (!display) return;
+
+	const uint32_t barColor = 0xFF000000;
+	kon_framebuffer_t *game = display->game;
+	kon_framebuffer_t *screen = display->screen;
+	int rightX = display->viewX + display->viewWidth;
+
+	for (int y = 0; y < screen->height; y++) {
+		uint32_t *row = &screen->data[(size_t)y * (size_t)screen->width];
+
+		if (display->viewWidth <= 0 || y < display->viewY || y >= display->viewY + display->viewHeight) {
+			for (int x = 0; x < screen->width; x++) row[x] = barColor;
+			continue;
+		}
+
+		int srcY = (int)((int64_t)(y - display->viewY) * game->height / display->viewHeight);
+		const uint32_t *srcRow = &game->data[(size_t)srcY * (size_t)game->width];
+
+		for (int x = 0; x < display->viewX; x++) row[x] = barColor;
+		for (int x = 0; x < display->viewWidth; x++) row[display->viewX + x] = srcRow[display->columnMap[x]];
+		for (int x = rightX; x < screen->width; x++) row[x] = barColor;
+	}
+}
+
+int kon_windowToGame(const kon_display_t *display, int windowX, int windowY, int *gameX, int *gameY) {
+	if (!display || display->viewWidth <= 0 || display->viewHeight <= 0) return 0;
+
+	int localX = windowX - display->viewX;
+	int localY = windowY - display->viewY;
+	if (localX < 0 || localX >= display->viewWidth || localY < 0 || localY >= display->viewHeight) return 0;
+
+	if (gameX) *gameX = (int)((int64_t)localX * display->game->width  / display->viewWidth);
+	if (gameY) *gameY = (int)((int64_t)localY * display->game->height / display->viewHeight);
+	return 1;
+}
+
+/*** 3D implementation ***/
+
+
+/*** private helper ***/
+
+static kon_vec2_t kon_clipToScreen_(const kon_framebuffer_t *fb, kon_vec4_t clip) {
+	/* clamped so the later float to int conversion can't overflow */
+	float ndcX = kon_clamp(clip.x / clip.w, -1.0e5f, 1.0e5f);
+	float ndcY = kon_clamp(clip.y / clip.w, -1.0e5f, 1.0e5f);
+
+	/* screen +Y points down, NDC +Y points up */
+	return KON_VEC2((ndcX + 1.0f) * 0.5f * (float)fb->width, (1.0f - ndcY) * 0.5f * (float)fb->height);
+}
+
+/*** camera implementation ***/
+
+kon_camera_t kon_cameraDefault(void) {
+	kon_camera_t camera;
+	camera.position = KON_VEC3(0, 0, 5);
+	camera.target = KON_VEC3_ZERO;
+	camera.up = KON_VEC3_UP;
+	camera.projection = KON_PROJECTION_PERSPECTIVE;
+	camera.fov = KON_DEG2RAD(60);
+	camera.orthoSize = 5.0f;
+	camera.nearZ = 0.1f;
+	camera.farZ = 100.0f;
+	return camera;
+}
+
+kon_mat4_t kon_cameraView(const kon_camera_t *camera) {
+	return kon_mat4LookAt(camera->position, camera->target, camera->up);
+}
+
+kon_mat4_t kon_cameraProjection(const kon_camera_t *camera, int width, int height) {
+	float aspect = (height > 0) ? (float)width / (float)height : 1.0f;
+
+	if (camera->projection == KON_PROJECTION_ORTHOGRAPHIC) {
+		float halfH = camera->orthoSize;
+		float halfW = halfH * aspect;
+		return kon_mat4Ortho(-halfW, halfW, -halfH, halfH, camera->nearZ, camera->farZ);
+	}
+
+	return kon_mat4Perspective(camera->fov, aspect, camera->nearZ, camera->farZ);
+}
+
+kon_mat4_t kon_cameraViewProjection(const kon_camera_t *camera, int width, int height) {
+	return kon_mat4Mul(kon_cameraProjection(camera, width, height), kon_cameraView(camera));
+}
+
+/*** 3D draw implementation ***/
+
+int kon_worldToScreen(const kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_vec3_t point, kon_vec2_t *out) {
+	if (!fb || !out) return 0;
+
+	kon_vec4_t clip = kon_mat4MulVec4(viewProjection, KON_VEC4(point.x, point.y, point.z, 1));
+
+	/* in front of the near plane when z >= -w */
+	if (clip.z < -clip.w || clip.w <= 0.0f) return 0;
+
+	*out = kon_clipToScreen_(fb, clip);
+	return 1;
+}
+
+void kon_drawLine3D(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_vec3_t a, kon_vec3_t b, uint32_t color) {
+	if (!fb) return;
+
+	kon_vec4_t ca = kon_mat4MulVec4(viewProjection, KON_VEC4(a.x, a.y, a.z, 1));
+	kon_vec4_t cb = kon_mat4MulVec4(viewProjection, KON_VEC4(b.x, b.y, b.z, 1));
+
+	/* clip against the near plane (z + w >= 0) before dividing, so points behind the camera never get projected */
+	float da = ca.z + ca.w;
+	float db = cb.z + cb.w;
+
+	if (da < 0.0f && db < 0.0f) return;
+
+	if (da < 0.0f || db < 0.0f) {
+		float t = da / (da - db);
+		kon_vec4_t hit = KON_VEC4(
+			ca.x + (cb.x - ca.x) * t,
+			ca.y + (cb.y - ca.y) * t,
+			ca.z + (cb.z - ca.z) * t,
+			ca.w + (cb.w - ca.w) * t
+		);
+
+		if (da < 0.0f) ca = hit;
+		else cb = hit;
+	}
+
+	if (ca.w <= 0.0f || cb.w <= 0.0f) return;
+
+	kon_vec2_t sa = kon_clipToScreen_(fb, ca);
+	kon_vec2_t sb = kon_clipToScreen_(fb, cb);
+
+	kon_drawLine(fb, (int)sa.x, (int)sa.y, (int)sb.x, (int)sb.y, color);
+}
+
+void kon_drawWireMesh(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_mat4_t model, const kon_wireMesh_t *mesh, uint32_t color) {
+	if (!fb || !mesh) return;
+
+	kon_mat4_t mvp = kon_mat4Mul(viewProjection, model);
+
+	for (int i = 0; i < mesh->edgeCount; i++) {
+		kon_vec3_t a = mesh->vertices[mesh->edges[i * 2 + 0]];
+		kon_vec3_t b = mesh->vertices[mesh->edges[i * 2 + 1]];
+		kon_drawLine3D(fb, mvp, a, b, color);
+	}
+}
+
+/* the triangle rasterizer works in doubles so huge coordinates near the camera don't lose precision */
+typedef struct kon_rasterVertex {
+	double x, y, z, w; /* clip space */
+	double u, v;
+} kon_rasterVertex_t;
+
+static kon_rasterVertex_t kon_lerpRasterVertex_(kon_rasterVertex_t a, kon_rasterVertex_t b, double t) {
+	kon_rasterVertex_t r;
+	r.x = a.x + (b.x - a.x) * t;
+	r.y = a.y + (b.y - a.y) * t;
+	r.z = a.z + (b.z - a.z) * t;
+	r.w = a.w + (b.w - a.w) * t;
+	r.u = a.u + (b.u - a.u) * t;
+	r.v = a.v + (b.v - a.v) * t;
+	return r;
+}
+
+/* keeps the part of the triangle in front of the near plane (z + w >= 0), returns 0 to 4 vertices */
+static int kon_clipNear_(const kon_rasterVertex_t in[3], kon_rasterVertex_t out[4]) {
+	int count = 0;
+
+	for (int i = 0; i < 3; i++) {
+		kon_rasterVertex_t current = in[i];
+		kon_rasterVertex_t next = in[(i + 1) % 3];
+		double dc = current.z + current.w;
+		double dn = next.z + next.w;
+
+		if (dc >= 0.0) out[count++] = current;
+		if ((dc >= 0.0) != (dn >= 0.0)) out[count++] = kon_lerpRasterVertex_(current, next, dc / (dc - dn));
+	}
+
+	return count;
+}
+
+static double kon_edge_(double ax, double ay, double bx, double by, double px, double py) {
+	return (bx - ax) * (py - ay) - (by - ay) * (px - ax);
+}
+
+static void kon_rasterizeTriangle_(kon_framebuffer_t *fb, const kon_rasterVertex_t *a, const kon_rasterVertex_t *b, const kon_rasterVertex_t *c,
+		const kon_image *texture, uint32_t color, kon_renderFlags_t flags) {
+	const kon_rasterVertex_t *in[3] = {a, b, c};
+	double sx[3], sy[3], sz[3], invW[3], uw[3], vw[3];
+
+	for (int i = 0; i < 3; i++) {
+		if (in[i]->w <= 1.0e-12) return;
+		invW[i] = 1.0 / in[i]->w;
+		sx[i] = (in[i]->x * invW[i] + 1.0) * 0.5 * fb->width;
+		sy[i] = (1.0 - in[i]->y * invW[i]) * 0.5 * fb->height;
+		sz[i] = in[i]->z * invW[i];
+		uw[i] = in[i]->u * invW[i];
+		vw[i] = in[i]->v * invW[i];
+	}
+
+	/* screen +Y points down, so a counter-clockwise (front) triangle has a negative area here */
+	double area = kon_edge_(sx[0], sy[0], sx[1], sy[1], sx[2], sy[2]);
+	if (area == 0.0) return;
+
+	if (area > 0.0) {
+		if (flags & KON_RENDER_CULL_BACK) return;
+
+		/* back face with culling off: swap two vertices so the math below only deals with one winding */
+		double t;
+		t = sx[1]; sx[1] = sx[2]; sx[2] = t;
+		t = sy[1]; sy[1] = sy[2]; sy[2] = t;
+		t = sz[1]; sz[1] = sz[2]; sz[2] = t;
+		t = invW[1]; invW[1] = invW[2]; invW[2] = t;
+		t = uw[1]; uw[1] = uw[2]; uw[2] = t;
+		t = vw[1]; vw[1] = vw[2]; vw[2] = t;
+		area = -area;
+	}
+
+	double minX = sx[0], maxX = sx[0], minY = sy[0], maxY = sy[0];
+	for (int i = 1; i < 3; i++) {
+		if (sx[i] < minX) minX = sx[i];
+		if (sx[i] > maxX) maxX = sx[i];
+		if (sy[i] < minY) minY = sy[i];
+		if (sy[i] > maxY) maxY = sy[i];
+	}
+
+	/* pixel centers sit at +0.5, clamped to the framebuffer before turning into ints */
+	minX = ceil(minX - 0.5); maxX = floor(maxX - 0.5);
+	minY = ceil(minY - 0.5); maxY = floor(maxY - 0.5);
+	if (minX < 0) minX = 0;
+	if (minY < 0) minY = 0;
+	if (maxX > fb->width  - 1) maxX = fb->width  - 1;
+	if (maxY > fb->height - 1) maxY = fb->height - 1;
+	if (minX > maxX || minY > maxY) return;
+
+	int x0 = (int)minX, x1 = (int)maxX, y0 = (int)minY, y1 = (int)maxY;
+	double px = x0 + 0.5, py = y0 + 0.5;
+
+	/* edge i is opposite vertex i, inside means all three are <= 0 for this winding */
+	double e0Row = kon_edge_(sx[1], sy[1], sx[2], sy[2], px, py);
+	double e1Row = kon_edge_(sx[2], sy[2], sx[0], sy[0], px, py);
+	double e2Row = kon_edge_(sx[0], sy[0], sx[1], sy[1], px, py);
+	double e0Dx = -(sy[2] - sy[1]), e0Dy = sx[2] - sx[1];
+	double e1Dx = -(sy[0] - sy[2]), e1Dy = sx[0] - sx[2];
+	double e2Dx = -(sy[1] - sy[0]), e2Dy = sx[1] - sx[0];
+	double invArea = 1.0 / area;
+
+	int useDepth = (flags & KON_RENDER_DEPTH) != 0;
+
+	for (int y = y0; y <= y1; y++) {
+		double e0 = e0Row, e1 = e1Row, e2 = e2Row;
+
+		for (int x = x0; x <= x1; x++) {
+			if (e0 <= 0.0 && e1 <= 0.0 && e2 <= 0.0) {
+				double l0 = e0 * invArea, l1 = e1 * invArea, l2 = e2 * invArea;
+				size_t index = (size_t)y * (size_t)fb->width + (size_t)x;
+				double z = l0 * sz[0] + l1 * sz[1] + l2 * sz[2];
+
+				if (!useDepth || z < (double)fb->depth[index]) {
+					uint32_t texel = color;
+
+					if (texture) {
+						/* uv / w is what varies linearly on screen, dividing by 1 / w again undoes the perspective */
+						double iw = l0 * invW[0] + l1 * invW[1] + l2 * invW[2];
+						double u = (l0 * uw[0] + l1 * uw[1] + l2 * uw[2]) / iw;
+						double v = (l0 * vw[0] + l1 * vw[1] + l2 * vw[2]) / iw;
+
+						u -= floor(u);
+						v -= floor(v);
+
+						int tx = (int)(u * texture->width);
+						int ty = (int)(v * texture->height);
+						if (tx > texture->width  - 1) tx = texture->width  - 1;
+						if (ty > texture->height - 1) ty = texture->height - 1;
+
+						texel = texture->data[(size_t)ty * (size_t)texture->width + (size_t)tx];
+					}
+
+					uint32_t alpha = texel >> 24;
+					if (alpha == 0xFF) {
+						fb->data[index] = texel;
+						if (useDepth) fb->depth[index] = (float)z;
+					} else if (alpha != 0) {
+						fb->data[index] = kon_blendColor(fb->data[index], texel);
+					}
+				}
+			}
+
+			e0 += e0Dx; e1 += e1Dx; e2 += e2Dx;
+		}
+
+		e0Row += e0Dy; e1Row += e1Dy; e2Row += e2Dy;
+	}
+}
+
+void kon_drawTriangle3D(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_vertex_t a, kon_vertex_t b, kon_vertex_t c,
+		const kon_image *texture, uint32_t color, kon_renderFlags_t flags) {
+	if (!fb) return;
+
+	if (flags & KON_RENDER_WIREFRAME) {
+		kon_drawLine3D(fb, viewProjection, a.position, b.position, color);
+		kon_drawLine3D(fb, viewProjection, b.position, c.position, color);
+		kon_drawLine3D(fb, viewProjection, c.position, a.position, color);
+		return;
+	}
+
+	if ((flags & KON_RENDER_DEPTH) && !fb->depth) {
+		fb->depth = malloc((size_t)fb->width * (size_t)fb->height * sizeof(float));
+		if (!fb->depth) return;
+
+		for (int i = 0; i < fb->width * fb->height; i++) {
+			fb->depth[i] = 1.0f;
+		}
+	}
+
+	const kon_vertex_t *source[3] = {&a, &b, &c};
+	kon_rasterVertex_t in[3], clipped[4];
+
+	for (int i = 0; i < 3; i++) {
+		kon_vec4_t clip = kon_mat4MulVec4(viewProjection, KON_VEC4(source[i]->position.x, source[i]->position.y, source[i]->position.z, 1));
+		in[i].x = clip.x; in[i].y = clip.y; in[i].z = clip.z; in[i].w = clip.w;
+		in[i].u = source[i]->uv.x;
+		in[i].v = source[i]->uv.y;
+	}
+
+	int count = kon_clipNear_(in, clipped);
+	for (int i = 1; i + 1 < count; i++) {
+		kon_rasterizeTriangle_(fb, &clipped[0], &clipped[i], &clipped[i + 1], texture, color, flags);
+	}
+}
+
+void kon_drawMesh(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_mat4_t model, const kon_mesh_t *mesh,
+		const kon_image *texture, uint32_t color, kon_renderFlags_t flags) {
+	if (!fb || !mesh) return;
+
+	kon_mat4_t mvp = kon_mat4Mul(viewProjection, model);
+
+	for (int i = 0; i < mesh->triangleCount; i++) {
+		kon_drawTriangle3D(fb, mvp,
+			mesh->vertices[mesh->indices[i * 3 + 0]],
+			mesh->vertices[mesh->indices[i * 3 + 1]],
+			mesh->vertices[mesh->indices[i * 3 + 2]],
+			texture, color, flags);
+	}
+}
+
+/*** built-in meshes ***/
+
+static const kon_vertex_t kon_cubeVertices_[24] = {
+	/* +Z */ {{-1, -1,  1}, {0, 1}}, {{ 1, -1,  1}, {1, 1}}, {{ 1,  1,  1}, {1, 0}}, {{-1,  1,  1}, {0, 0}},
+	/* -Z */ {{ 1, -1, -1}, {0, 1}}, {{-1, -1, -1}, {1, 1}}, {{-1,  1, -1}, {1, 0}}, {{ 1,  1, -1}, {0, 0}},
+	/* +X */ {{ 1, -1,  1}, {0, 1}}, {{ 1, -1, -1}, {1, 1}}, {{ 1,  1, -1}, {1, 0}}, {{ 1,  1,  1}, {0, 0}},
+	/* -X */ {{-1, -1, -1}, {0, 1}}, {{-1, -1,  1}, {1, 1}}, {{-1,  1,  1}, {1, 0}}, {{-1,  1, -1}, {0, 0}},
+	/* +Y */ {{-1,  1,  1}, {0, 1}}, {{ 1,  1,  1}, {1, 1}}, {{ 1,  1, -1}, {1, 0}}, {{-1,  1, -1}, {0, 0}},
+	/* -Y */ {{-1, -1, -1}, {0, 1}}, {{ 1, -1, -1}, {1, 1}}, {{ 1, -1,  1}, {1, 0}}, {{-1, -1,  1}, {0, 0}}
+};
+
+static const uint16_t kon_cubeIndices_[36] = {
+	0, 1, 2,  0, 2, 3,
+	4, 5, 6,  4, 6, 7,
+	8, 9, 10,  8, 10, 11,
+	12, 13, 14,  12, 14, 15,
+	16, 17, 18,  16, 18, 19,
+	20, 21, 22,  20, 22, 23
+};
+
+const kon_mesh_t kon_cubeMesh = { kon_cubeVertices_, kon_cubeIndices_, 12 };
+
+#endif /* end of KONSOFREN_IMPLEMENTATION */
+
+#endif
diff --git a/kon/kontime.h b/kon/kontime.h
new file mode 100644
index 0000000..da46ddd
--- /dev/null
+++ b/kon/kontime.h
@@ -0,0 +1,85 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * kontime.h
+ *
+ * Copyright (c) 2026 KonAki
+ *
+ * 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.
+ */
+
+#ifndef KONTIME_H
+#define KONTIME_H
+
+/*** definition ***/
+
+typedef double kon_time;
+
+kon_time kon_getTime(void);
+
+void kon_sleep(kon_time seconds);
+
+/*** implementation ***/
+
+#ifdef KONTIME_IMPLEMENTATION
+
+#if defined(__linux__) || defined(__unix__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+
+#define _POSIX_C_SOURCE 200809L
+#include <time.h>
+
+kon_time kon_getTime(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+
+  return (kon_time)ts.tv_sec + (kon_time)ts.tv_nsec / 1e9; 
+}
+
+void kon_sleep(kon_time seconds) {
+	struct timespec ts;
+	ts.tv_sec  = (time_t)seconds;
+	ts.tv_nsec = (long)((seconds - ts.tv_sec) * 1e9);
+		
+	nanosleep(&ts, NULL);
+}
+
+#elif defined(_WIN32)
+
+#include <windows.h>
+
+kon_time kon_getTime(void) {
+	LARGE_INTEGER freq, now;
+	QueryPerformanceFrequency(&freq);
+	QueryPerformanceCounter(&now);
+
+	return (kon_time)now.QuadPart / (kon_time)freq.QuadPart;
+}
+
+void kon_sleep(kon_time seconds) {
+	Sleep((DWORD)(seconds * 1000.0));
+}
+
+#else
+#error "kontime.h: unsupported platform!"
+
+#endif
+
+#endif /* end of KONTIME_IMPLEMENTATION */
+
+
+#endif
diff --git a/kon/kontoml.h b/kon/kontoml.h
new file mode 100644
index 0000000..88a7e68
--- /dev/null
+++ b/kon/kontoml.h
@@ -0,0 +1,649 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * kontoml.h
+ *
+ * Copyright (c) 2026 KonAki
+ *
+ * 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.
+ */
+
+#ifndef KONTOML_H
+#define KONTOML_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef enum kon_tomlType {
+	konTomlString,
+	konTomlInt,
+	konTomlFloat,
+	konTomlBool,
+	konTomlArray
+} kon_tomlType_t;
+
+typedef struct kon_tomlEntry {
+	char *section;
+	char *key;
+	kon_tomlType_t type;
+	char *str_value;
+	long long int_value;
+	double float_value;
+	bool bool_value;
+
+	kon_tomlType_t array_type;
+	int array_count;
+	char **array_str;
+	long long *array_int;
+	double *array_float;
+	bool *array_bool;
+} kon_tomlEntry_t;
+
+typedef struct kon_toml {
+	kon_tomlEntry_t *entries;
+	int count;
+	int capacity;
+} kon_toml_t;
+
+kon_toml_t *kon_parseToml(const char *text);
+kon_toml_t *kon_parseTomlFile(const char *path);
+void kon_freeToml(kon_toml_t *toml);
+
+const char *kon_tomlGetString(kon_toml_t *toml, const char *section, const char *key, const char *def);
+long long kon_tomlGetInt(kon_toml_t *toml, const char *section, const char *key, long long def);
+double kon_tomlGetFloat(kon_toml_t *toml, const char *section, const char *key, double def);
+bool kon_tomlGetBool(kon_toml_t *toml, const char *section, const char *key, bool def);
+
+const char *const *kon_tomlGetStringArray(kon_toml_t *toml, const char *section, const char *key, int *out_count);
+const long long *kon_tomlGetIntArray(kon_toml_t *toml, const char *section, const char *key, int *out_count);
+const double *kon_tomlGetFloatArray(kon_toml_t *toml, const char *section, const char *key, int *out_count);
+const bool *kon_tomlGetBoolArray(kon_toml_t *toml, const char *section, const char *key, int *out_count);
+
+/*** implementation ***/
+
+#ifdef KONTOML_IMPLEMENTATION
+
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+
+static char *kon__tomlStrdup(const char *s) {
+	size_t len = strlen(s) + 1;
+	char *out = malloc(len);
+	if (!out) return NULL;
+	memcpy(out, s, len);
+	return out;
+}
+
+static char *kon__tomlStrndup(const char *s, size_t n) {
+	char *out = malloc(n + 1);
+	if (!out) return NULL;
+	memcpy(out, s, n);
+	out[n] = '\0';
+	return out;
+}
+
+static char *kon__tomlTrim(char *s) {
+	char *end;
+
+	while (*s == ' ' || *s == '\t') s++;
+	if (*s == '\0') return s;
+
+	end = s + strlen(s) - 1;
+	while (end > s && (*end == ' ' || *end == '\t' || *end == '\r' || *end == '\n')) {
+		*end = '\0';
+		end--;
+	}
+
+	return s;
+}
+
+static kon_tomlEntry_t *kon__tomlPushEntry(kon_toml_t *toml) {
+	if (toml->count == toml->capacity) {
+		int newCap = toml->capacity ? toml->capacity * 2 : 16;
+		kon_tomlEntry_t *tmp = realloc(toml->entries, (size_t)newCap * sizeof(kon_tomlEntry_t));
+		if (!tmp) return NULL;
+
+		toml->entries = tmp;
+		toml->capacity = newCap;
+	}
+
+	kon_tomlEntry_t *entry = &toml->entries[toml->count];
+	memset(entry, 0, sizeof(kon_tomlEntry_t));
+	toml->count++;
+
+	return entry;
+}
+
+static int kon__tomlParseString(const char **p, char **out) {
+	const char *s = *p;
+	char quote = *s;
+	int literal = (quote == '\'');
+	s++;
+
+	char *buf = malloc(strlen(s) + 1);
+	if (!buf) return -1;
+
+	size_t bi = 0;
+
+	while (*s && *s != quote) {
+		if (!literal && *s == '\\') {
+			s++;
+			switch (*s) {
+			case 'n':
+				buf[bi++] = '\n';
+				break;
+			case 't':
+				buf[bi++] = '\t';
+				break;
+			case 'r':
+				buf[bi++] = '\r';
+				break;
+			case '"':
+				buf[bi++] = '"';
+				break;
+			case '\\':
+				buf[bi++] = '\\';
+				break;
+			case '\0':
+				free(buf);
+				return -1;
+			default:
+				buf[bi++] = *s;
+				break;
+			}
+			s++;
+		} else {
+			buf[bi++] = *s;
+			s++;
+		}
+	}
+
+	if (*s != quote) {
+		free(buf);
+		return -1;
+	}
+	s++;
+
+	buf[bi] = '\0';
+	*out = buf;
+	*p = s;
+
+	return 0;
+}
+
+static char *kon__tomlStripUnderscores(const char *s) {
+	char *out = malloc(strlen(s) + 1);
+	if (!out) return NULL;
+
+	size_t oi = 0;
+	for (size_t i = 0; s[i]; i++) {
+		if (s[i] != '_') out[oi++] = s[i];
+	}
+	out[oi] = '\0';
+
+	return out;
+}
+
+static char **kon__tomlSplitArrayElements(const char *content, int *outCount) {
+	int cap = 8;
+	int count = 0;
+	char **elems = malloc((size_t)cap * sizeof(char *));
+	if (!elems) return NULL;
+
+	const char *start = content;
+	const char *p = content;
+	char inQuote = 0;
+
+	while (*p) {
+		if (inQuote) {
+			if (inQuote == '"' && *p == '\\' && *(p + 1) != '\0') {
+				p += 2;
+				continue;
+			}
+			if (*p == inQuote) inQuote = 0;
+			p++;
+			continue;
+		}
+
+		if (*p == '"' || *p == '\'') {
+			inQuote = *p;
+			p++;
+			continue;
+		}
+
+		if (*p == ',') {
+			if (count == cap) {
+				cap *= 2;
+				char **tmp = realloc(elems, (size_t)cap * sizeof(char *));
+				if (!tmp) { free(elems); return NULL; }
+				elems = tmp;
+			}
+			elems[count++] = kon__tomlStrndup(start, (size_t)(p - start));
+			p++;
+			start = p;
+			continue;
+		}
+
+		p++;
+	}
+
+	{
+		char *raw = kon__tomlStrndup(start, (size_t)(p - start));
+		char *checkTrim = raw ? kon__tomlTrim(raw) : NULL;
+
+		if (raw && *checkTrim != '\0') {
+			if (count == cap) {
+				cap += 1;
+				char **tmp = realloc(elems, (size_t)cap * sizeof(char *));
+				if (!tmp) { free(raw); free(elems); return NULL; }
+				elems = tmp;
+			}
+			elems[count++] = raw;
+		} else {
+			free(raw);
+		}
+	}
+
+	*outCount = count;
+	return elems;
+}
+
+static int kon__tomlParseArrayValue(kon_tomlEntry_t *entry, const char *valueStr) {
+	const char *open  = strchr(valueStr, '[');
+	const char *close = strchr(valueStr, ']');
+	if (!open || !close || close <= open) return -1;
+
+	char *content = kon__tomlStrndup(open + 1, (size_t)(close - open - 1));
+	if (!content) return -1;
+
+	int rawCount = 0;
+	char **rawElems = kon__tomlSplitArrayElements(content, &rawCount);
+	free(content);
+	if (!rawElems) return -1;
+
+	if (rawCount == 0) {
+		free(rawElems);
+		entry->type = konTomlArray;
+		entry->array_type = konTomlInt;
+		entry->array_count = 0;
+		return 0;
+	}
+
+	kon_tomlType_t elemType = konTomlInt;
+	char **strArr = NULL;
+	long long *intArr = NULL;
+	double *floatArr = NULL;
+	bool *boolArr = NULL;
+	int ok = 1;
+
+	for (int i = 0; i < rawCount && ok; i++) {
+		char *trimmed = kon__tomlTrim(rawElems[i]);
+
+		kon_tomlType_t thisType;
+		char *decodedStr = NULL;
+		long long thisInt = 0;
+		double thisFloat = 0.0;
+		bool thisBool = false;
+
+		if (*trimmed == '"' || *trimmed == '\'') {
+			const char *vp = trimmed;
+			thisType = konTomlString;
+			if (kon__tomlParseString(&vp, &decodedStr) != 0) { ok = 0; break; }
+		} else if (strcmp(trimmed, "true") == 0) {
+			thisType = konTomlBool;
+			thisBool = true;
+		} else if (strcmp(trimmed, "false") == 0) {
+			thisType = konTomlBool;
+			thisBool = false;
+		} else {
+			char *clean = kon__tomlStripUnderscores(trimmed);
+			if (!clean) { ok = 0; break; }
+
+			int isFloat = (strchr(clean, '.') || strchr(clean, 'e') || strchr(clean, 'E'));
+			if (isFloat) {
+				thisType = konTomlFloat;
+				thisFloat = strtod(clean, NULL);
+			} else {
+				thisType = konTomlInt;
+				thisInt = strtoll(clean, NULL, 10);
+			}
+			free(clean);
+		}
+
+		if (i == 0) {
+			elemType = thisType;
+			switch (elemType) {
+			case konTomlString:
+				strArr = malloc((size_t)rawCount * sizeof(char *));
+				break;
+			case konTomlInt:
+				intArr = malloc((size_t)rawCount * sizeof(long long));
+				break;
+			case konTomlFloat:
+				floatArr = malloc((size_t)rawCount * sizeof(double));
+				break;
+			case konTomlBool:
+				boolArr = malloc((size_t)rawCount * sizeof(bool));
+				break;
+			default:
+				break;
+			}
+		} else if (thisType != elemType) {
+			free(decodedStr);
+			ok = 0;
+			break;
+		}
+
+		switch (elemType) {
+		case konTomlString:
+			strArr[i] = decodedStr;
+			break;
+		case konTomlInt:
+			intArr[i] = thisInt;
+			break;
+		case konTomlFloat:
+			floatArr[i] = thisFloat;
+			break;
+		case konTomlBool:
+			boolArr[i] = thisBool;
+			break;
+		default:
+			break;
+		}
+	}
+
+	for (int i = 0; i < rawCount; i++) free(rawElems[i]);
+	free(rawElems);
+
+	if (!ok) {
+		if (strArr) {
+			for (int i = 0; i < rawCount; i++)
+				free(strArr[i]);
+
+			free(strArr);
+		}
+		free(intArr);
+		free(floatArr);
+		free(boolArr);
+		return -1;
+	}
+
+	entry->type = konTomlArray;
+	entry->array_type = elemType;
+	entry->array_count = rawCount;
+	entry->array_str = strArr;
+	entry->array_int = intArr;
+	entry->array_float = floatArr;
+	entry->array_bool = boolArr;
+
+	return 0;
+}
+
+static int kon__tomlParseLine(kon_toml_t *toml, char *line, char **currentSection) {
+	char *trimmed = kon__tomlTrim(line);
+
+	if (*trimmed == '\0' || *trimmed == '#') return 0;
+
+	if (*trimmed == '[') {
+		char *close = strchr(trimmed, ']');
+		if (!close) return -1;
+
+		free(*currentSection);
+		*currentSection = kon__tomlStrndup(trimmed + 1, (size_t)(close - trimmed - 1));
+
+		return 0;
+	}
+
+	char *eq = strchr(trimmed, '=');
+	if (!eq) return -1;
+
+	*eq = '\0';
+	char *key = kon__tomlTrim(trimmed);
+	char *valueStr = kon__tomlTrim(eq + 1);
+
+	if (*valueStr != '"' && *valueStr != '\'') {
+		char *hash = strchr(valueStr, '#');
+		if (hash) {
+			*hash = '\0';
+			valueStr = kon__tomlTrim(valueStr);
+		}
+	}
+
+	if (*key == '\0' || *valueStr == '\0') return -1;
+
+	kon_tomlEntry_t *entry = kon__tomlPushEntry(toml);
+	if (!entry) return -1;
+
+	entry->section = *currentSection ? kon__tomlStrdup(*currentSection) : kon__tomlStrdup("");
+	entry->key = kon__tomlStrdup(key);
+
+	if (*valueStr == '[') {
+		if (kon__tomlParseArrayValue(entry, valueStr) != 0) return -1;
+	} else if (*valueStr == '"' || *valueStr == '\'') {
+		const char *vp = valueStr;
+		char *decoded = NULL;
+
+		if (kon__tomlParseString(&vp, &decoded) != 0) return -1;
+
+		entry->type = konTomlString;
+		entry->str_value = decoded;
+	} else if (strcmp(valueStr, "true") == 0) {
+		entry->type = konTomlBool;
+		entry->bool_value = true;
+	} else if (strcmp(valueStr, "false") == 0) {
+		entry->type = konTomlBool;
+		entry->bool_value = false;
+	} else {
+		char *clean = kon__tomlStripUnderscores(valueStr);
+		if (!clean) return -1;
+
+		int isFloat = (strchr(clean, '.') || strchr(clean, 'e') || strchr(clean, 'E'));
+
+		if (isFloat) {
+			entry->type = konTomlFloat;
+			entry->float_value = strtod(clean, NULL);
+		} else {
+			entry->type = konTomlInt;
+			entry->int_value = strtoll(clean, NULL, 10);
+		}
+
+		free(clean);
+	}
+
+	return 0;
+}
+
+kon_toml_t *kon_parseToml(const char *text) {
+	if (!text) return NULL;
+
+	kon_toml_t *toml = malloc(sizeof(kon_toml_t));
+	if (!toml) return NULL;
+
+	toml->entries = NULL;
+	toml->count = 0;
+	toml->capacity = 0;
+
+	char *currentSection = NULL;
+
+	const char *lineStart = text;
+	while (*lineStart) {
+		const char *lineEnd = strchr(lineStart, '\n');
+		size_t len = lineEnd ? (size_t)(lineEnd - lineStart) : strlen(lineStart);
+
+		char *line = kon__tomlStrndup(lineStart, len);
+		if (line) {
+			kon__tomlParseLine(toml, line, &currentSection);
+			free(line);
+		}
+
+		if (!lineEnd) break;
+		lineStart = lineEnd + 1;
+	}
+
+	free(currentSection);
+
+	return toml;
+}
+
+kon_toml_t *kon_parseTomlFile(const char *path) {
+	FILE *f = fopen(path, "rb");
+	if (!f) return NULL;
+
+	fseek(f, 0, SEEK_END);
+	long size = ftell(f);
+	fseek(f, 0, SEEK_SET);
+
+	if (size < 0) {
+		fclose(f);
+		return NULL;
+	}
+
+	char *buf = malloc((size_t)size + 1);
+	if (!buf) {
+		fclose(f);
+		return NULL;
+	}
+
+	size_t read = fread(buf, 1, (size_t)size, f);
+	buf[read] = '\0';
+	fclose(f);
+
+	kon_toml_t *toml = kon_parseToml(buf);
+	free(buf);
+
+	return toml;
+}
+
+void kon_freeToml(kon_toml_t *toml) {
+	if (!toml) return;
+
+	for (int i = 0; i < toml->count; i++) {
+		kon_tomlEntry_t *e = &toml->entries[i];
+
+		free(e->section);
+		free(e->key);
+
+		if (e->type == konTomlString) {
+			free(e->str_value);
+		} else if (e->type == konTomlArray) {
+			if (e->array_str) {
+				for (int j = 0; j < e->array_count; j++) free(e->array_str[j]);
+				free(e->array_str);
+			}
+			free(e->array_int);
+			free(e->array_float);
+			free(e->array_bool);
+		}
+	}
+
+	free(toml->entries);
+	free(toml);
+}
+
+static kon_tomlEntry_t *kon__tomlFind(kon_toml_t *toml, const char *section, const char *key) {
+	if (!toml) return NULL;
+
+	const char *sec = section ? section : "";
+
+	for (int i = 0; i < toml->count; i++) {
+		kon_tomlEntry_t *e = &toml->entries[i];
+		if (strcmp(e->section, sec) == 0 && strcmp(e->key, key) == 0) {
+			return e;
+		}
+	}
+
+	return NULL;
+}
+
+const char *kon_tomlGetString(kon_toml_t *toml, const char *section, const char *key, const char *def) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e || e->type != konTomlString) return def;
+	return e->str_value;
+}
+
+long long kon_tomlGetInt(kon_toml_t *toml, const char *section, const char *key, long long def) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e) return def;
+
+	if (e->type == konTomlInt) return e->int_value;
+	if (e->type == konTomlFloat) return (long long)e->float_value;
+
+	return def;
+}
+
+double kon_tomlGetFloat(kon_toml_t *toml, const char *section, const char *key, double def) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e) return def;
+
+	if (e->type == konTomlFloat) return e->float_value;
+	if (e->type == konTomlInt) return (double)e->int_value;
+
+	return def;
+}
+
+bool kon_tomlGetBool(kon_toml_t *toml, const char *section, const char *key, bool def) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e || e->type != konTomlBool) return def;
+	return e->bool_value;
+}
+
+const char *const *kon_tomlGetStringArray(kon_toml_t *toml, const char *section, const char *key, int *out_count) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e || e->type != konTomlArray || e->array_type != konTomlString) {
+		if (out_count) *out_count = 0;
+		return NULL;
+	}
+	if (out_count) *out_count = e->array_count;
+	return (const char *const *)e->array_str;
+}
+
+const long long *kon_tomlGetIntArray(kon_toml_t *toml, const char *section, const char *key, int *out_count) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e || e->type != konTomlArray || e->array_type != konTomlInt) {
+		if (out_count) *out_count = 0;
+		return NULL;
+	}
+	if (out_count) *out_count = e->array_count;
+	return e->array_int;
+}
+
+const double *kon_tomlGetFloatArray(kon_toml_t *toml, const char *section, const char *key, int *out_count) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e || e->type != konTomlArray || e->array_type != konTomlFloat) {
+		if (out_count) *out_count = 0;
+		return NULL;
+	}
+	if (out_count) *out_count = e->array_count;
+	return e->array_float;
+}
+
+const bool *kon_tomlGetBoolArray(kon_toml_t *toml, const char *section, const char *key, int *out_count) {
+	kon_tomlEntry_t *e = kon__tomlFind(toml, section, key);
+	if (!e || e->type != konTomlArray || e->array_type != konTomlBool) {
+		if (out_count) *out_count = 0;
+		return NULL;
+	}
+	if (out_count) *out_count = e->array_count;
+	return e->array_bool;
+}
+
+#endif /* END of KONTOML_IMPLEMENTATION */
+
+#endif
diff --git a/kon/konwinlib.h b/kon/konwinlib.h
new file mode 100644
index 0000000..c50f828
--- /dev/null
+++ b/kon/konwinlib.h
@@ -0,0 +1,1357 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * konwinlib.h
+ *
+ * Copyright (c) 2026 KonAki
+ *
+ * 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.
+ */
+
+#ifndef KONWINLIB_H
+#define KONWINLIB_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/*** definitions ***/
+
+typedef struct kon_context kon_context_t;
+
+bool kon_init(void);
+void kon_deinit(void);
+
+typedef struct kon_window kon_window_t;
+
+typedef enum kon_windowFlags {
+	KON_WINDOW_NONE = 0,
+	KON_WINDOW_TRANSPARENT = 1 << 0,
+	KON_WINDOW_NO_DECOR = 1 << 1,
+	KON_WINDOW_ALWAYS_ONTOP = 1 << 2,
+	KON_WINDOW_CENTER = 1 << 3,
+	KON_WINDOW_RESIZABLE = 1 << 4
+} kon_windowFlags_t;
+
+typedef enum kon_eventType {
+	KON_EVENT_NONE = 0,
+	KON_EVENT_CLOSE,
+	KON_EVENT_RESIZE,
+	KON_EVENT_KEY_DOWN,
+	KON_EVENT_KEY_UP,
+	KON_EVENT_MOUSE_DOWN,
+	KON_EVENT_MOUSE_UP,
+	KON_EVENT_MOUSE_MOVE
+} kon_eventType_t;
+
+typedef enum kon_mouseButton {
+	KON_MOUSE_LEFT = 0,
+	KON_MOUSE_MIDDLE,
+	KON_MOUSE_RIGHT
+} kon_mouseButton_t;
+
+typedef enum kon_key {
+	KON_KEY_UNKNOWN = 0,
+
+	KON_KEY_A, KON_KEY_B, KON_KEY_C, KON_KEY_D, KON_KEY_E, KON_KEY_F, KON_KEY_G,
+	KON_KEY_H, KON_KEY_I, KON_KEY_J, KON_KEY_K, KON_KEY_L, KON_KEY_M, KON_KEY_N, KON_KEY_O, KON_KEY_P,
+	KON_KEY_Q, KON_KEY_R, KON_KEY_S, KON_KEY_T, KON_KEY_U, KON_KEY_V,
+	KON_KEY_W, KON_KEY_X, KON_KEY_Y, KON_KEY_Z,
+
+	KON_KEY_0, KON_KEY_1, KON_KEY_2, KON_KEY_3, KON_KEY_4, KON_KEY_5, KON_KEY_6, KON_KEY_7, KON_KEY_8, KON_KEY_9,
+
+	KON_KEY_F1, KON_KEY_F2, KON_KEY_F3, KON_KEY_F4,  KON_KEY_F5,  KON_KEY_F6,
+	KON_KEY_F7, KON_KEY_F8, KON_KEY_F9, KON_KEY_F10, KON_KEY_F11, KON_KEY_F12,
+
+	KON_KEY_LEFT, KON_KEY_RIGHT, KON_KEY_UP, KON_KEY_DOWN,
+
+	KON_KEY_SPACE,  KON_KEY_ENTER, KON_KEY_TAB, KON_KEY_BACKSPACE,
+	KON_KEY_ESCAPE, KON_KEY_DELETE,
+
+	KON_KEY_LEFT_SHIFT, KON_KEY_RIGHT_SHIFT,
+	KON_KEY_LEFT_CTRL,  KON_KEY_RIGHT_CTRL,
+	KON_KEY_LEFT_ALT,   KON_KEY_RIGHT_ALT,
+
+	KON_KEY_MINUS, KON_KEY_EQUAL,
+	KON_KEY_LEFT_BRACKET, KON_KEY_RIGHT_BRACKET,
+	KON_KEY_SEMICOLON, KON_KEY_APOSTROPHE,
+	KON_KEY_COMMA, KON_KEY_PERIOD, KON_KEY_SLASH, KON_KEY_BACKSLASH,
+	KON_KEY_GRAVE,
+
+	KON_KEY_COUNT
+} kon_key_t;
+
+typedef struct kon_event {
+	kon_eventType_t type;
+	int width, height; /* will be used to store data for resize events */
+	int key;
+	int mouseX, mouseY;
+	kon_mouseButton_t mouseButton;
+} kon_event_t;
+
+kon_window_t *kon_createWindow(const char *title, int x, int y, int width, int height, kon_windowFlags_t flags);
+void kon_destroyWindow(kon_window_t *window);
+
+bool kon_windowShouldClose(kon_window_t *window);
+
+void kon_setExitKey(kon_window_t *window, int key);
+
+void kon_setWindowPos(kon_window_t *window, int x, int y);
+void kon_setWindowSize(kon_window_t *window, int width, int height);
+
+void kon_getWindowPos(kon_window_t *window, int *x, int *y);
+void kon_getWindowSize(kon_window_t *window, int *width, int *height);
+
+int kon_pollEvent(kon_window_t *window, kon_event_t *event);
+void kon_blitPixels(kon_window_t *window, const uint32_t *pixels, int width, int height);
+
+// added these for web dev
+typedef void (*kon_mainLoopFn)(void *userData);
+void kon_runMainLoop(kon_window_t *window, kon_mainLoopFn callback, void *userData);
+
+/*** implementation ***/
+
+#ifdef KONWINLIB_IMPLEMENTATION
+
+static kon_context_t *kon_ctx;
+
+#define KON_EVENT_QUEUE_SIZE 256
+
+typedef struct kon_eventQueue {
+	kon_event_t events[KON_EVENT_QUEUE_SIZE];
+	int head, count;
+} kon_eventQueue_t;
+
+static void kon_pushEvent_(kon_eventQueue_t *q, const kon_event_t *event) {
+	/* only the newest mouse move or resize matters, so overwrite instead of piling up */
+	if (q->count > 0 && (event->type == KON_EVENT_MOUSE_MOVE || event->type == KON_EVENT_RESIZE)) {
+		kon_event_t *last = &q->events[(q->head + q->count - 1) % KON_EVENT_QUEUE_SIZE];
+		if (last->type == event->type) {
+			*last = *event;
+			return;
+		}
+	}
+
+	if (q->count == KON_EVENT_QUEUE_SIZE) return;
+	q->events[(q->head + q->count) % KON_EVENT_QUEUE_SIZE] = *event;
+	q->count++;
+}
+
+static bool kon_popEvent_(kon_eventQueue_t *q, kon_event_t *event) {
+	if (q->count == 0) return false;
+	*event = q->events[q->head];
+	q->head = (q->head + 1) % KON_EVENT_QUEUE_SIZE;
+	q->count--;
+	return true;
+}
+
+#ifdef __EMSCRIPTEN__
+
+#include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
+#include <string.h>
+
+struct kon_context {
+	int initialized;
+};
+
+struct kon_window {
+	char canvasID[64];
+	bool shouldClose;
+	int exitKey;
+
+	bool hasKeyEvent;
+	kon_eventType_t keyEventType;
+	int keyEventKey;
+
+	bool hasResizeEvent;
+	int resizeWidth, resizeHeight;
+
+	bool hasMouseEvent;
+	kon_eventType_t mouseEventType;
+	int mouseEventX, mouseEventY;
+	kon_mouseButton_t mouseEventButton;
+};
+
+static kon_key_t kon_translateEmKey_(int keyCode) {
+	switch (keyCode) {
+	case 65: return KON_KEY_A;
+	case 66: return KON_KEY_B;
+	case 67: return KON_KEY_C;
+	case 68: return KON_KEY_D;
+	case 69: return KON_KEY_E;
+	case 70: return KON_KEY_F;
+	case 71: return KON_KEY_G;
+	case 72: return KON_KEY_H;
+	case 73: return KON_KEY_I;
+	case 74: return KON_KEY_J;
+	case 75: return KON_KEY_K;
+	case 76: return KON_KEY_L;
+	case 77: return KON_KEY_M;
+	case 78: return KON_KEY_N;
+	case 79: return KON_KEY_O;
+	case 80: return KON_KEY_P;
+	case 81: return KON_KEY_Q;
+	case 82: return KON_KEY_R;
+	case 83: return KON_KEY_S;
+	case 84: return KON_KEY_T;
+	case 85: return KON_KEY_U;
+	case 86: return KON_KEY_V;
+	case 87: return KON_KEY_W;
+	case 88: return KON_KEY_X;
+	case 89: return KON_KEY_Y;
+	case 90: return KON_KEY_Z;
+
+	case 48: return KON_KEY_0;
+	case 49: return KON_KEY_1;
+	case 50: return KON_KEY_2;
+	case 51: return KON_KEY_3;
+	case 52: return KON_KEY_4;
+	case 53: return KON_KEY_5;
+	case 54: return KON_KEY_6;
+	case 55: return KON_KEY_7;
+	case 56: return KON_KEY_8;
+	case 57: return KON_KEY_9;
+
+	case 112: return KON_KEY_F1;
+	case 113: return KON_KEY_F2;
+	case 114: return KON_KEY_F3;
+	case 115: return KON_KEY_F4;
+	case 116: return KON_KEY_F5;
+	case 117: return KON_KEY_F6;
+	case 118: return KON_KEY_F7;
+	case 119: return KON_KEY_F8;
+	case 120: return KON_KEY_F9;
+	case 121: return KON_KEY_F10;
+	case 122: return KON_KEY_F11;
+	case 123: return KON_KEY_F12;
+
+	case 37: return KON_KEY_LEFT;
+	case 39: return KON_KEY_RIGHT;
+	case 38: return KON_KEY_UP;
+	case 40: return KON_KEY_DOWN;
+
+	case 32: return KON_KEY_SPACE;
+	case 13: return KON_KEY_ENTER;
+	case 9:  return KON_KEY_TAB;
+	case 8:  return KON_KEY_BACKSPACE;
+	case 27: return KON_KEY_ESCAPE;
+	case 46: return KON_KEY_DELETE;
+
+	case 16: return KON_KEY_LEFT_SHIFT;
+	case 17: return KON_KEY_LEFT_CTRL;
+	case 18: return KON_KEY_LEFT_ALT;
+
+	case 189: return KON_KEY_MINUS;
+	case 187: return KON_KEY_EQUAL;
+	case 219: return KON_KEY_LEFT_BRACKET;
+	case 221: return KON_KEY_RIGHT_BRACKET;
+	case 186: return KON_KEY_SEMICOLON;
+	case 222: return KON_KEY_APOSTROPHE;
+	case 188: return KON_KEY_COMMA;
+	case 190: return KON_KEY_PERIOD;
+	case 191: return KON_KEY_SLASH;
+	case 220: return KON_KEY_BACKSLASH;
+	case 192: return KON_KEY_GRAVE;
+
+	default: return KON_KEY_UNKNOWN;
+	}
+}
+bool kon_init(void) {
+	kon_context_t *ctx = malloc(sizeof(kon_context_t));
+	if (!ctx) return false;
+
+	ctx->initialized = 1;
+	kon_ctx = ctx;
+	return true;
+}
+
+void kon_deinit(void) {
+	if (!kon_ctx) return;
+
+	free(kon_ctx);
+	kon_ctx = NULL;
+}
+
+static EM_BOOL kon_keyDownCallback_(int eventType, const EmscriptenKeyboardEvent *e, void *userData) {
+	(void)eventType;
+	kon_window_t *window = (kon_window_t *)userData;
+
+	window->hasKeyEvent = true;
+	window->keyEventType = KON_EVENT_KEY_DOWN;
+	window->keyEventKey = kon_translateEmKey_(e->keyCode);
+
+	if (window->exitKey != 0 && window->keyEventKey == window->exitKey) {
+		window->shouldClose = true;
+	}
+
+	return EM_TRUE;
+}
+
+static EM_BOOL kon_keyUpCallback_(int eventType, const EmscriptenKeyboardEvent *e, void *userData) {
+	(void)eventType;
+	kon_window_t *window = (kon_window_t *)userData;
+
+	window->hasKeyEvent = true;
+	window->keyEventType = KON_EVENT_KEY_UP;
+	window->keyEventKey = kon_translateEmKey_(e->keyCode);
+
+	return EM_TRUE;
+}
+
+static EM_BOOL kon_mouseDownCallback_(int eventType, const EmscriptenMouseEvent *e, void *userData) {
+	(void)eventType;
+	kon_window_t *window = (kon_window_t *)userData;
+
+	if (e->button > KON_MOUSE_RIGHT) return EM_FALSE;
+
+	window->hasMouseEvent = true;
+	window->mouseEventType = KON_EVENT_MOUSE_DOWN;
+	window->mouseEventButton = (kon_windowButton_t)e->button;
+	window->mouseEventX = e->targetX;
+	window->mouseEventY = e->targetY;
+
+	return EM_TRUE;
+}
+
+static EM_BOOL kon_mouseUpCallback_(int eventType, const EmscriptenMouseEvent *e, void *userData) {
+	(void)eventType;
+	kon_window_t *window = (kon_window_t *)userData;
+
+	if (e->button > KON_MOUSE_RIGHT) return EM_FALSE:
+
+	window->hasMouseEvent = true;
+	window->mouseEventType = KON_EVENT_MOUSE_UP;
+	window->mouseEventButton = (kon_windowButton_t)e->button;
+	window->mouseEventX = e->targetX;
+	window->mouseEventY = e->targetY;
+
+	return EM_TRUE;
+}
+
+static EM_BOOL kon_mouseMoveCallback_(int eventType, const EmscriptenMouseEvent *e, void *userData) {
+	(void)eventType;
+	kon_window_t *window = (kon_window_t *)userData;
+
+	window->hasMouseEvent = true;
+	window->mouseEventType = KON_EVENT_MOUSE_MOVE;
+	window->mouseEventX = e->targetX;
+	window->mouseEventY = e->targetY;
+
+	return EM_TRUE;
+}
+
+kon_window_t *kon_createWindow(const char *title, int x, int y, int width, int height, kon_windowFlags_t flags) {
+	(void)x; (void)y; (void)flags;
+
+	if (!kon_ctx) {
+		fprintf(stderr, "kon_createWindow: error creating window, no ctx\n");
+		return NULL;
+	}
+
+	kon_window_t *window = malloc(sizeof(kon_window_t));
+	if (!window) return NULL;
+
+	strncpy(window->canvasID, "#canvas", sizeof(window->canvasID) - 1);
+	window->canvasID[sizeof(window->canvasID) - 1] = '\0';
+
+	window->shouldClose = false;
+	window->exitKey = 0;
+	window->hasKeyEvent = false;
+	window->hasResizeEvent = false;
+	window->hasMouseEvent = false;
+
+	emscripten_set_canvas_element_size(window->canvasID, width, height);
+
+	EM_ASM({
+			try { document.title = UTF8ToString($0); } catch (e) {}
+	}, title);
+
+	emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, window, EM_FALSE, kon_keyDownCallback_);
+	emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, window, EM_FALSE, kon_keyUpCallback_);
+	emscripten_set_mousedown_callback(window->canvasID, window, EM_FALSE, kon_mouseDownCallback_);
+	emscripten_set_mouseup_callback(window->canvasID, window, EM_FALSE, kon_mouseUpCallback_);
+	emscripten_set_mousemove_callback(window->canvasID, window, EM_FALSE, kon_mouseMoveCallback_);
+
+	return window;
+}
+
+void kon_destroyWindow(kon_window_t *window) {
+	if (!window) return;
+
+	emscripten_set_keydown_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, EM_FALSE, NULL);
+	emscripten_set_keyup_callback(EMSCRIPTEN_EVENT_TARGET_WINDOW, NULL, EM_FALSE, NULL);
+	emscripten_set_mousedown_callback(window->canvasID, NULL, EM_FALSE, NULL);
+	emscripten_set_mouseup_callback(window->canvasID, NULL, EM_FALSE, NULL);
+	emscripten_set_mousemove_callback(window->canvasID, NULL, EM_FALSE, NULL);
+
+	free(window);
+}
+
+bool kon_windowShouldClose(kon_window_t *window) {
+	if (!window) return true;
+	return window->shouldClose;
+}
+
+void kon_setExitKey(kon_window_t *window, int key) {
+	if (!window) return;
+	window->exitKey = key;
+}
+
+void kon_setWindowPos(kon_window_t *window, int x, int y) {
+	(void)window; (void)x; (void)y;
+}
+
+void kon_setWindowSize(kon_window_t *window, int width, int height) {
+	if (!window) return;
+	emscripten_set_canvas_element_size(window->canvasID, width, height);
+}
+
+void kon_getWindowPos(kon_window_t *window, int *x, int *y) {
+	(void)window;
+	if (x) *x = 0;
+	if (y) *y = 0;
+}
+
+void kon_getWindowSize(kon_window_t *window, int *width, int *height) {
+	if (!window || !width || !height) return;
+
+	double w, h;
+	emscripten_get_element_css_size(window->canvasID, &w, &h);
+	*width  = (int)w;
+	*height = (int)h;
+}
+
+int kon_pollEvent(kon_window_t *window, kon_event_t *event) {
+	if (!window || !event) return 0;
+
+	event->type = KON_EVENT_NONE;
+
+	if (window->hasResizeEvent) {
+		event->type = KON_EVENT_RESIZE;
+		event->width = window->resizeWidth;
+		event->height = window->resizeHeight;
+		window->hasResizeEvent = false;
+		return 1;
+	}
+
+	if (window->hasKeyEvent) {
+		event->type = window->keyEventType;
+		event->key  = window->keyEventKey;
+		window->hasKeyEvent = false;
+		return 1;
+	}
+
+	if (window->hasMouseEvent) {
+		event->type = window->mouseEventType;
+		event->mouseX = window->mouseEventX;
+		event->mouseY = window-<mouseEventY;
+		event->mouseButton = window->mouseEventButton;
+		window->hasMouseEvent = false;
+		return 1;
+	}
+
+	return 0;
+}
+
+EM_JS(void, kon_jsBlit_, (const char *canvasID, uint32_t *pixels, int width, int height), {
+	var sel = UTF8ToString(canvasID);
+	var canvas = document.querySelector(sel);
+	if (!canvas) return;
+	
+	if (!canvas.__konCtx) canvas.__konCtx = canvas.getContext('2d');
+	var ctx = canvas.__konCtx;
+
+	if (!canvas.__konImgData || canvas.__konImgData.width !== width || canvas.__konImgData.height !== height) {
+		canvas.__konImgData = ctx.createImageData(width, height);
+	}
+	var imgData = canvas.__konImgData;
+
+	var dst = new Uint32Array(imgData.data.buffer);
+	var srcIdx = pixels >> 2;
+	var count = width * height;
+
+	for (var i = 0; i < count; i++) {
+		var px = HEAPU32[srcIdx + i];
+		dst[i] = (px & 0xFF00FF00) | ((px & 0x00FF0000) >>> 16) | ((px & 0x000000FF) << 16);
+	}
+
+	ctx.putImageData(imgData, 0, 0);
+});
+
+void kon_blitPixels(kon_window_t *window, const uint32_t *pixels, int width, int height) {
+	if (!window || !pixels) return;
+	kon_jsBlit_(window->canvasID, (uint32_t *)pixels, width, height);
+}
+
+#elif defined(__linux__) || defined(__unix__)
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/Xrandr.h>
+#include <X11/keysym.h>
+#include <string.h>
+
+static kon_key_t kon_translateX11Key_(KeySym sym) {
+	switch (sym) {
+	case XK_a: return KON_KEY_A;
+	case XK_b: return KON_KEY_B;
+	case XK_c: return KON_KEY_C;
+	case XK_d: return KON_KEY_D;
+	case XK_e: return KON_KEY_E;
+	case XK_f: return KON_KEY_F;
+	case XK_g: return KON_KEY_G;
+	case XK_h: return KON_KEY_H;
+	case XK_i: return KON_KEY_I;
+	case XK_j: return KON_KEY_J;
+	case XK_k: return KON_KEY_K;
+	case XK_l: return KON_KEY_L;
+	case XK_m: return KON_KEY_M;
+	case XK_n: return KON_KEY_N;
+	case XK_o: return KON_KEY_O;
+	case XK_p: return KON_KEY_P;
+	case XK_q: return KON_KEY_Q;
+	case XK_r: return KON_KEY_R;
+	case XK_s: return KON_KEY_S;
+	case XK_t: return KON_KEY_T;
+	case XK_u: return KON_KEY_U;
+	case XK_v: return KON_KEY_V;
+	case XK_w: return KON_KEY_W;
+	case XK_x: return KON_KEY_X;
+	case XK_y: return KON_KEY_Y;
+	case XK_z: return KON_KEY_Z;
+
+	case XK_0: return KON_KEY_0;
+	case XK_1: return KON_KEY_1;
+	case XK_2: return KON_KEY_2;
+	case XK_3: return KON_KEY_3;
+	case XK_4: return KON_KEY_4;
+	case XK_5: return KON_KEY_5;
+	case XK_6: return KON_KEY_6;
+	case XK_7: return KON_KEY_7;
+	case XK_8: return KON_KEY_8;
+	case XK_9: return KON_KEY_9;
+
+	case XK_F1: return KON_KEY_F1;
+	case XK_F2: return KON_KEY_F2;
+	case XK_F3: return KON_KEY_F3;
+	case XK_F4: return KON_KEY_F4;
+	case XK_F5: return KON_KEY_F5;
+	case XK_F6: return KON_KEY_F6;
+	case XK_F7: return KON_KEY_F7;
+	case XK_F8: return KON_KEY_F8;
+	case XK_F9: return KON_KEY_F9;
+	case XK_F10: return KON_KEY_F10;
+	case XK_F11: return KON_KEY_F11;
+	case XK_F12: return KON_KEY_F12;
+
+	case XK_Left: return KON_KEY_LEFT;
+	case XK_Right: return KON_KEY_RIGHT;
+	case XK_Up: return KON_KEY_UP;
+	case XK_Down: return KON_KEY_DOWN;
+
+	case XK_space: return KON_KEY_SPACE;
+	case XK_Return: return KON_KEY_ENTER;
+	case XK_Tab: return KON_KEY_TAB;
+	case XK_BackSpace: return KON_KEY_BACKSPACE;
+	case XK_Escape: return KON_KEY_ESCAPE;
+	case XK_Delete: return KON_KEY_DELETE;
+
+	case XK_Shift_L: return KON_KEY_LEFT_SHIFT;
+	case XK_Shift_R: return KON_KEY_RIGHT_SHIFT;
+	case XK_Control_L: return KON_KEY_LEFT_CTRL;
+	case XK_Control_R: return KON_KEY_RIGHT_CTRL;
+	case XK_Alt_L: return KON_KEY_LEFT_ALT;
+	case XK_Alt_R: return KON_KEY_RIGHT_ALT;
+
+	case XK_minus: return KON_KEY_MINUS;
+	case XK_equal: return KON_KEY_EQUAL;
+	case XK_bracketleft: return KON_KEY_LEFT_BRACKET;
+	case XK_bracketright: return KON_KEY_RIGHT_BRACKET;
+	case XK_semicolon: return KON_KEY_SEMICOLON;
+	case XK_apostrophe: return KON_KEY_APOSTROPHE;
+	case XK_comma: return KON_KEY_COMMA;
+	case XK_period: return KON_KEY_PERIOD;
+	case XK_slash: return KON_KEY_SLASH;
+	case XK_backslash: return KON_KEY_BACKSLASH;
+	case XK_grave: return KON_KEY_GRAVE;
+
+	default: return KON_KEY_UNKNOWN;
+	}
+}
+
+struct kon_context {
+	Display *display;
+};
+
+bool kon_init(void) {
+	kon_context_t *ctx = malloc(sizeof(kon_context_t));
+	if (!ctx) return false;
+	ctx->display = XOpenDisplay(NULL);
+	if (!ctx->display) return false;
+	kon_ctx = ctx;
+	return true;
+}
+
+void kon_deinit(void) {
+	if (!kon_ctx) return;
+
+	XCloseDisplay(kon_ctx->display);
+	free(kon_ctx);
+	kon_ctx=NULL;
+}
+
+struct kon_window {
+	Window window;
+	GC gc;
+	Visual *visual;
+	int depth;
+	Colormap colormap;
+	bool owns_colormap;
+	Atom wm_delete;
+	bool shouldClose;
+	int exitKey;
+};
+
+kon_window_t *kon_createWindow(const char *title, int x, int y, int width, int height, kon_windowFlags_t flags) {
+	if (!kon_ctx) {
+		fprintf(stderr, "kon_createWindow: There appears to be no kon_ctx. \nPlease, do kon_init(); before doing anything with konwinlib, thank you.\n");
+		return NULL;
+	}
+
+	kon_window_t *window = malloc(sizeof(kon_window_t));
+	if (!window) return NULL;
+
+	int screen = DefaultScreen(kon_ctx->display);
+
+	if (flags & KON_WINDOW_CENTER) {
+		Window root = RootWindow(kon_ctx->display, screen);
+
+		int mon_x = 0, mon_y = 0;
+		int mon_width  = DisplayWidth(kon_ctx->display, screen);
+		int mon_height = DisplayHeight(kon_ctx->display, screen);
+
+		Window root_ret, child_ret;
+		int root_x, root_y, win_x, win_y;
+		unsigned int mask;
+		XQueryPointer(kon_ctx->display, root, &root_ret, &child_ret, &root_x, &root_y, &win_x, &win_y, &mask);
+
+		XRRScreenResources *res = XRRGetScreenResourcesCurrent(kon_ctx->display, root);
+		if (res) {
+			for (int i = 0; i < res->noutput; i++) {
+				XRROutputInfo *out_info = XRRGetOutputInfo(kon_ctx->display, res, res->outputs[i]);
+
+				if (out_info && out_info->crtc) {
+					XRRCrtcInfo *crtc = XRRGetCrtcInfo(kon_ctx->display, res, out_info->crtc);
+					if (crtc) {
+
+						if (root_x >= crtc->x && root_x < crtc->x + (int)crtc->width && 
+							root_y >= crtc->y && root_y < crtc->y + (int)crtc->height) {
+							mon_x = crtc->x;
+							mon_y = crtc->y;
+							mon_width = crtc->width;
+							mon_height = crtc->height;
+							XRRFreeCrtcInfo(crtc);
+							if (out_info) XRRFreeOutputInfo(out_info);
+							break;
+						}
+						XRRFreeCrtcInfo(crtc);
+					}
+				}
+				if (out_info) XRRFreeOutputInfo(out_info);
+			}
+			XRRFreeScreenResources(res);
+		}
+
+		x = mon_x + (mon_width  - width ) / 2;
+		y = mon_y + (mon_height - height) / 2;
+	}
+
+	if (flags & KON_WINDOW_TRANSPARENT) {
+		XVisualInfo vinfo;
+		if (!XMatchVisualInfo(kon_ctx->display, screen, 32, TrueColor, &vinfo)) {
+			free(window);
+			return NULL;
+		}
+
+		window->visual   = vinfo.visual;
+		window->depth    = vinfo.depth;
+		window->colormap = XCreateColormap(kon_ctx->display, RootWindow(kon_ctx->display, screen), window->visual, AllocNone);
+
+		XSetWindowAttributes attrs;
+		attrs.colormap = window->colormap;
+		attrs.background_pixel = 0;
+		attrs.border_pixel = 0;
+
+		window->window = XCreateWindow(
+									   kon_ctx->display, RootWindow(kon_ctx->display, screen),
+									   x, y, width, height, 0, window->depth, InputOutput,
+									   window->visual, CWColormap | CWBackPixel | CWBorderPixel, &attrs);
+
+		window->owns_colormap = true;
+	} else {
+		window->visual   = DefaultVisual(kon_ctx->display, screen);
+		window->depth    = DefaultDepth(kon_ctx->display, screen);
+		window->colormap = DefaultColormap(kon_ctx->display, screen);
+
+		window->window = XCreateSimpleWindow(
+											 kon_ctx->display, RootWindow(kon_ctx->display, screen),
+											 x, y, width, height, 0, 0, 0);
+
+		window->owns_colormap = false;
+	}
+
+	if (!window->window) {
+		if (window->owns_colormap) {
+			XFreeColormap(kon_ctx->display, window->colormap);
+		}
+		free(window);
+		return NULL;
+	}
+
+	XStoreName(kon_ctx->display, window->window, title);
+	XSelectInput(kon_ctx->display, window->window, ExposureMask | StructureNotifyMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask);
+
+	if (flags & KON_WINDOW_NO_DECOR) {
+		Atom motif_hints = XInternAtom(kon_ctx->display, "_MOTIF_WM_HINTS", False);
+		struct { unsigned long flags, functions, decorations; long input_mode; unsigned long status; } hints;
+		memset(&hints, 0, sizeof(hints));
+		hints.flags = 2;
+		hints.decorations = 0;
+		XChangeProperty(kon_ctx->display, window->window, motif_hints,
+						motif_hints, 32, PropModeReplace, (unsigned char *)&hints, 5);
+	}
+
+	if (flags & KON_WINDOW_ALWAYS_ONTOP) {
+		Atom wm_state = XInternAtom(kon_ctx->display, "_NET_WM_STATE", False);
+		Atom wm_above = XInternAtom(kon_ctx->display, "_NET_WM_STATE_ABOVE", False);
+		XChangeProperty(kon_ctx->display, window->window, wm_state, XA_ATOM, 32,
+						PropModeReplace, (unsigned char *)&wm_above, 1);
+	}
+
+	if (!(flags & KON_WINDOW_RESIZABLE)) {
+		XSizeHints hints;
+		hints.flags = PMinSize | PMaxSize;
+		hints.min_width  = hints.max_width  = width;
+		hints.min_height = hints.max_height = height;
+		XSetWMNormalHints(kon_ctx->display, window->window, &hints);
+	}
+
+	window->wm_delete = XInternAtom(kon_ctx->display, "WM_DELETE_WINDOW", False);
+	XSetWMProtocols(kon_ctx->display, window->window, &window->wm_delete, 1);
+
+	window->gc = XCreateGC(kon_ctx->display, window->window, 0, NULL);
+
+	XMapWindow(kon_ctx->display, window->window);
+	XFlush(kon_ctx->display);
+
+	window->exitKey = 0;
+
+	window->shouldClose = false;
+
+	return window;
+}
+
+void kon_destroyWindow(kon_window_t *window) {
+	if (!window) return;
+	if (!kon_ctx) { free(window); return; }
+
+	if (window->gc) XFreeGC(kon_ctx->display, window->gc);
+	if (window->window) XDestroyWindow(kon_ctx->display, window->window);
+	if (window->owns_colormap && window->colormap) XFreeColormap(kon_ctx->display, window->colormap);
+
+	XFlush(kon_ctx->display);
+
+	free(window);
+}
+
+void kon_setExitKey(kon_window_t *window, int key) {
+	if (!window) return;
+	window->exitKey = key;
+}
+
+void kon_setWindowPos(kon_window_t *window, int x, int y) {
+	if (!window || !kon_ctx) return;
+
+	XMoveWindow(kon_ctx->display, window->window, x, y);
+	XFlush(kon_ctx->display);
+}
+
+void kon_setWindowSize(kon_window_t *window, int width, int height) {
+	if (!window || !kon_ctx) return;
+
+	XResizeWindow(kon_ctx->display, window->window, width, height);
+	XFlush(kon_ctx->display);
+}
+
+void kon_getWindowPos(kon_window_t *window, int *x, int *y) {
+	if (!window || !kon_ctx || !x || !y) return;
+
+	Window child;
+	XTranslateCoordinates(kon_ctx->display, window->window, RootWindow(kon_ctx->display, DefaultScreen(kon_ctx->display)),
+						  0, 0, x, y, &child);
+}
+
+void kon_getWindowSize(kon_window_t *window, int *width, int *height) {
+	if (!window || !kon_ctx || !width || !height) return;
+
+	XWindowAttributes attrs;
+	XGetWindowAttributes(kon_ctx->display, window->window, &attrs);
+	*width  = attrs.width;
+	*height = attrs.height;
+}
+
+int kon_pollEvent(kon_window_t *window, kon_event_t *event) {
+	if (!window || !kon_ctx || !event) return 0;
+
+	event->type = KON_EVENT_NONE;
+
+	if (!XPending(kon_ctx->display)) return 0;
+
+	XEvent xev;
+	XNextEvent(kon_ctx->display, &xev);
+
+	if (xev.type == ClientMessage) {
+		if ((Atom)xev.xclient.data.l[0] == window->wm_delete) {
+			event->type = KON_EVENT_CLOSE;
+			window->shouldClose = true;
+		}
+	}
+
+	if (xev.type == ConfigureNotify) {
+		event->type = KON_EVENT_RESIZE;
+		event->width = xev.xconfigure.width;
+		event->height = xev.xconfigure.height;
+		return 1;
+	}
+
+	if (xev.type == KeyPress) {
+		event->type = KON_EVENT_KEY_DOWN;
+		event->key = (int)kon_translateX11Key_(XLookupKeysym(&xev.xkey, 0));
+		if (window->exitKey != 0 && event->key == window->exitKey) {
+			window->shouldClose = true;
+		}
+		return 1;
+	}
+
+	if (xev.type == KeyRelease) {
+		event->type = KON_EVENT_KEY_UP;
+		event->key = (int)kon_translateX11Key_(XLookupKeysym(&xev.xkey, 0));
+		return 1;
+	}
+
+	if (xev.type == ButtonPress || xev.type == ButtonRelease) {
+		int konButton = -1;
+		switch (xev.xbutton.button) {
+		case Button1:
+			konButton = KON_MOUSE_LEFT;
+			break;
+		case Button2:
+			konButton = KON_MOUSE_MIDDLE;
+			break;
+		case Button3:
+			konButton = KON_MOUSE_RIGHT;
+			break;
+		default:
+			break;
+		}
+
+		if (konButton != -1) {
+			event->type = (xev.type == ButtonPress) ? KON_EVENT_MOUSE_DOWN : KON_EVENT_MOUSE_UP;
+			event->mouseButton = (kon_mouseButton_t)konButton;
+			event->mouseX = xev.xbutton.x;
+			event->mouseY = xev.xbutton.y;
+		}
+		return 1;
+	}
+
+	if (xev.type == MotionNotify) {
+		event->type = KON_EVENT_MOUSE_MOVE;
+		event->mouseX = xev.xmotion.x;
+		event->mouseY = xev.xmotion.y;
+		return 1;
+	}
+
+	return 1;
+}
+
+bool kon_windowShouldClose(kon_window_t *window) {
+	if (!window || !kon_ctx) return true;
+	return window->shouldClose;
+}
+
+/* TODO: implement the rest of these */
+
+void kon_blitPixels(kon_window_t *window, const uint32_t *pixels, int width, int height) {
+	if (!window || !kon_ctx || !pixels) return;
+
+	XImage *ximg = XCreateImage(kon_ctx->display, window->visual, window->depth, ZPixmap, 0, (char *)pixels, width, height, 32, 0);
+	if (!ximg) return;
+
+	XPutImage(kon_ctx->display, window->window, window->gc, ximg, 0, 0, 0, 0, width, height);
+
+	ximg->data = NULL;
+	XDestroyImage(ximg);
+
+	XFlush(kon_ctx->display);
+}
+
+/*** windows implementation ***/
+
+#elif defined(_WIN32)
+
+#include <windows.h>
+#include <string.h>
+
+struct kon_context {
+	HINSTANCE hInstance;
+};
+
+struct kon_window {
+	HWND hwnd;
+	bool shouldClose;
+	bool isTransparent;
+	int exitKey;
+	kon_eventQueue_t queue;
+};
+
+static kon_key_t kon_translateWin32Key_(WPARAM vk, LPARAM lParam) {
+	if (vk == VK_SHIFT) {
+		UINT scancode = (lParam >> 16) &  0xFF;
+		UINT lshift = MapVirtualKey(VK_LSHIFT, MAPVK_VK_TO_VSC);
+		return (scancode == lshift) ? KON_KEY_LEFT_SHIFT : KON_KEY_RIGHT_SHIFT;
+	}
+	if (vk == VK_CONTROL) {
+		return (lParam & 0x01000000) ? KON_KEY_RIGHT_CTRL : KON_KEY_LEFT_CTRL;
+	}
+	if (vk == VK_MENU) {
+		return (lParam & 0x01000000) ? KON_KEY_RIGHT_ALT : KON_KEY_LEFT_ALT;
+	}
+
+	switch (vk) {
+	case 'A': return KON_KEY_A;
+	case 'B': return KON_KEY_B;
+	case 'C': return KON_KEY_C;
+	case 'D': return KON_KEY_D;
+	case 'E': return KON_KEY_E;
+	case 'F': return KON_KEY_F;
+	case 'G': return KON_KEY_G;
+	case 'H': return KON_KEY_H;
+	case 'I': return KON_KEY_I;
+	case 'J': return KON_KEY_J;
+	case 'K': return KON_KEY_K;
+	case 'L': return KON_KEY_L;
+	case 'M': return KON_KEY_M;
+	case 'N': return KON_KEY_N;
+	case 'O': return KON_KEY_O;
+	case 'P': return KON_KEY_P;
+	case 'Q': return KON_KEY_Q;
+	case 'R': return KON_KEY_R;
+	case 'S': return KON_KEY_S;
+	case 'T': return KON_KEY_T;
+	case 'U': return KON_KEY_U;
+	case 'V': return KON_KEY_V;
+	case 'W': return KON_KEY_W;
+	case 'X': return KON_KEY_X;
+	case 'Y': return KON_KEY_Y;
+	case 'Z': return KON_KEY_Z;
+
+	case '0': return KON_KEY_0;
+	case '1': return KON_KEY_1;
+	case '2': return KON_KEY_2;
+	case '3': return KON_KEY_3;
+	case '4': return KON_KEY_4;
+	case '5': return KON_KEY_5;
+	case '6': return KON_KEY_6;
+	case '7': return KON_KEY_7;
+	case '8': return KON_KEY_8;
+	case '9': return KON_KEY_9;
+
+	case VK_F1:  return KON_KEY_F1;
+	case VK_F2:  return KON_KEY_F2;
+	case VK_F3:  return KON_KEY_F3;
+	case VK_F4:  return KON_KEY_F4;
+	case VK_F5:  return KON_KEY_F5;
+	case VK_F6:  return KON_KEY_F6;
+	case VK_F7:  return KON_KEY_F7;
+	case VK_F8:  return KON_KEY_F8;
+	case VK_F9:  return KON_KEY_F9;
+	case VK_F10: return KON_KEY_F10;
+	case VK_F11: return KON_KEY_F11;
+	case VK_F12: return KON_KEY_F12;
+
+	case VK_LEFT: return KON_KEY_LEFT;
+	case VK_RIGHT: return KON_KEY_RIGHT;
+	case VK_UP: return KON_KEY_UP;
+	case VK_DOWN: return KON_KEY_DOWN;
+
+	case VK_SPACE: return KON_KEY_SPACE;
+	case VK_RETURN: return KON_KEY_ENTER;
+	case VK_TAB: return KON_KEY_TAB;
+	case VK_BACK: return KON_KEY_BACKSPACE;
+	case VK_ESCAPE: return KON_KEY_ESCAPE;
+	case VK_DELETE: return KON_KEY_DELETE;
+
+	case VK_OEM_MINUS: return KON_KEY_MINUS;
+	case VK_OEM_PLUS: return KON_KEY_EQUAL;
+	case VK_OEM_4: return KON_KEY_LEFT_BRACKET;
+	case VK_OEM_6: return KON_KEY_RIGHT_BRACKET;
+	case VK_OEM_1: return KON_KEY_SEMICOLON;
+	case VK_OEM_7: return KON_KEY_APOSTROPHE;
+	case VK_OEM_COMMA: return KON_KEY_COMMA;
+	case VK_OEM_PERIOD: return KON_KEY_PERIOD;
+	case VK_OEM_2: return KON_KEY_SLASH;
+	case VK_OEM_5: return KON_KEY_BACKSLASH;
+	case VK_OEM_3: return KON_KEY_GRAVE;
+
+	default: return KON_KEY_UNKNOWN;
+	}
+}
+
+LRESULT CALLBACK kon_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
+	kon_window_t *window = (kon_window_t *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
+
+	switch (msg) {
+	case WM_NCCREATE: {
+		CREATESTRUCT *cs = (CREATESTRUCT *)lParam;
+		SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)cs->lpCreateParams);
+		break;
+	}
+	case WM_KEYDOWN:
+		if (window) {
+			kon_event_t ev = {0};
+			ev.type = KON_EVENT_KEY_DOWN;
+			ev.key = (int)kon_translateWin32Key_(wParam, lParam);
+			kon_pushEvent_(&window->queue, &ev);
+			if (window->exitKey != 0 && ev.key == window->exitKey) {
+				window->shouldClose = true;
+				ev.type = KON_EVENT_CLOSE;
+				kon_pushEvent_(&window->queue, &ev);
+			}
+		}
+		break;
+	case WM_KEYUP:
+		if (window) {
+			kon_event_t ev = {0};
+			ev.type = KON_EVENT_KEY_UP;
+			ev.key = (int)kon_translateWin32Key_(wParam, lParam);
+			kon_pushEvent_(&window->queue, &ev);
+		}
+		break;
+	case WM_LBUTTONDOWN: case WM_LBUTTONUP:
+	case WM_RBUTTONDOWN: case WM_RBUTTONUP:
+	case WM_MBUTTONDOWN: case WM_MBUTTONUP:
+		if (window) {
+			kon_event_t ev = {0};
+			ev.type = (msg == WM_LBUTTONDOWN || msg == WM_RBUTTONDOWN || msg == WM_MBUTTONDOWN)
+				? KON_EVENT_MOUSE_DOWN : KON_EVENT_MOUSE_UP;
+			ev.mouseButton = (msg == WM_LBUTTONDOWN || msg == WM_LBUTTONUP) ? KON_MOUSE_LEFT
+				: (msg == WM_RBUTTONDOWN || msg == WM_RBUTTONUP) ? KON_MOUSE_RIGHT
+				: KON_MOUSE_MIDDLE;
+			ev.mouseX = (int)(short)LOWORD(lParam);
+			ev.mouseY = (int)(short)HIWORD(lParam);
+			kon_pushEvent_(&window->queue, &ev);
+		}
+		break;
+	case WM_MOUSEMOVE:
+		if (window) {
+			kon_event_t ev = {0};
+			ev.type = KON_EVENT_MOUSE_MOVE;
+			ev.mouseX = (int)(short)LOWORD(lParam);
+			ev.mouseY = (int)(short)HIWORD(lParam);
+			kon_pushEvent_(&window->queue, &ev);
+		}
+		break;
+	case WM_CLOSE:
+		if (window) {
+			kon_event_t ev = {0};
+			ev.type = KON_EVENT_CLOSE;
+			window->shouldClose = true;
+			kon_pushEvent_(&window->queue, &ev);
+		}
+		break;
+	case WM_SIZE:
+		/* minimizing reports 0x0, which would wreck the framebuffer */
+		if (window && wParam != SIZE_MINIMIZED && LOWORD(lParam) > 0 && HIWORD(lParam) > 0) {
+			kon_event_t ev = {0};
+			ev.type = KON_EVENT_RESIZE;
+			ev.width = LOWORD(lParam);
+			ev.height = HIWORD(lParam);
+			kon_pushEvent_(&window->queue, &ev);
+		}
+		break;
+	case WM_DESTROY:
+		PostQuitMessage(0);
+		return 0;
+		break;
+	case WM_ERASEBKGND:
+		return 1;
+	}
+	return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+bool kon_init(void) {
+	kon_context_t *ctx = malloc(sizeof(kon_context_t));
+	if (!ctx) return false;
+
+	ctx->hInstance = GetModuleHandle(NULL);
+
+	WNDCLASSEX wc = {0};
+	wc.cbSize = sizeof(WNDCLASSEX);
+	wc.lpfnWndProc = kon_wndProc;
+	wc.hInstance = ctx->hInstance;
+	wc.lpszClassName = "KonWinLibClass";
+	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+
+	if (!RegisterClassEx(&wc)) {
+		free(ctx);
+		return false;
+	}
+
+	kon_ctx = ctx;
+	return true;
+}
+
+void kon_deinit(void) {
+	if (!kon_ctx) return;
+
+	free(kon_ctx);
+	kon_ctx = NULL;
+}
+
+
+kon_window_t *kon_createWindow(const char *title, int x, int y, int width, int height, kon_windowFlags_t flags) {
+	if (!kon_ctx) return NULL;
+
+	kon_window_t *window = calloc(1, sizeof(kon_window_t));
+	if (!window) return NULL;
+
+	window->isTransparent = (flags & KON_WINDOW_TRANSPARENT);
+	window->exitKey = 0;
+
+	DWORD style;
+	if (flags & KON_WINDOW_NO_DECOR) {
+		style = WS_POPUP;
+	} else {
+		style = WS_OVERLAPPEDWINDOW;
+		if (!(flags & KON_WINDOW_RESIZABLE)) {
+			style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
+		}
+	}
+
+	DWORD exStyle = 0;
+	if (flags & KON_WINDOW_ALWAYS_ONTOP) exStyle |= WS_EX_TOPMOST;
+	if (flags & KON_WINDOW_TRANSPARENT)  exStyle |= WS_EX_LAYERED;
+
+	RECT adj = { 0, 0, width, height };
+	AdjustWindowRectEx(&adj, style, FALSE, exStyle);
+	int winW = adj.right - adj.left;
+	int winH = adj.bottom - adj.top;
+
+	if (flags & KON_WINDOW_CENTER) {
+		POINT cursor;
+		GetCursorPos(&cursor);
+
+		HMONITOR hmon = MonitorFromPoint(cursor, MONITOR_DEFAULTTONEAREST);
+
+		MONITORINFO mi;
+		mi.cbSize = sizeof(MONITORINFO);
+		GetMonitorInfo(hmon, &mi);
+
+		int mon_x = mi.rcMonitor.left;
+		int mon_y = mi.rcMonitor.top;
+		int mon_width = mi.rcMonitor.right - mi.rcMonitor.left;
+		int mon_height = mi.rcMonitor.bottom - mi.rcMonitor.top;
+
+		x = mon_x + (mon_width  - winW) / 2;
+		y = mon_y + (mon_height - winH) / 2;
+	}
+
+	window->hwnd = CreateWindowEx(exStyle, "KonWinLibClass", title, style, x, y, winW, winH, NULL, NULL, kon_ctx->hInstance, window);
+
+	if (!window->hwnd) {
+		free(window);
+		return NULL;
+	}
+
+	ShowWindow(window->hwnd, SW_SHOW);
+
+	return window;
+}
+
+void kon_destroyWindow(kon_window_t *window) {
+	if (!window) return;
+	if (window->hwnd) DestroyWindow(window->hwnd);
+	free(window);
+}
+
+bool kon_windowShouldClose(kon_window_t *window) {
+	if (!window) return true;
+	return window->shouldClose;
+}
+
+
+void kon_setExitKey(kon_window_t *window, int key) {
+	if (!window) return;
+	window->exitKey = key;
+}
+
+void kon_setWindowPos(kon_window_t *window, int x, int y) {
+	if (!window || !kon_ctx) return;
+
+	SetWindowPos(window->hwnd, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+}
+
+void kon_setWindowSize(kon_window_t *window, int width, int height) {
+	if (!window || !kon_ctx) return;
+
+	RECT r = { 0, 0, width, height };
+	AdjustWindowRectEx(&r, (DWORD)GetWindowLongPtr(window->hwnd, GWL_STYLE), FALSE, (DWORD)GetWindowLongPtr(window->hwnd, GWL_EXSTYLE));
+	SetWindowPos(window->hwnd, NULL, 0, 0, r.right - r.left, r.bottom - r.top, SWP_NOMOVE | SWP_NOZORDER);
+}
+
+
+void kon_getWindowPos(kon_window_t *window, int *x, int *y) {
+	if (!window || !x || !y) return;
+
+	RECT rect;
+	GetWindowRect(window->hwnd, &rect);
+	*x = rect.left;
+	*y = rect.top;
+}
+
+void kon_getWindowSize(kon_window_t *window, int *width, int *height) {
+	if (!window || !width || !height) return;
+
+	RECT rect;
+	GetClientRect(window->hwnd, &rect);
+	*width  = rect.right  - rect.left;
+	*height = rect.bottom - rect.top;
+}
+
+int kon_pollEvent(kon_window_t *window, kon_event_t *event) {
+	if (!window || !event) return 0;
+
+	MSG msg;
+	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+	}
+
+	if (!kon_popEvent_(&window->queue, event)) {
+		event->type = KON_EVENT_NONE;
+		return 0;
+	}
+	return 1;
+}
+
+void kon_blitPixels(kon_window_t *window, const uint32_t *pixels, int width, int height) {
+	if (!window || !pixels) return;
+
+	BITMAPINFO bmi = {0};
+	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+	bmi.bmiHeader.biWidth = width;
+	bmi.bmiHeader.biHeight = -height; /* top-down */
+	bmi.bmiHeader.biPlanes = 1;
+	bmi.bmiHeader.biBitCount = 32;
+	bmi.bmiHeader.biCompression = BI_RGB;
+
+	if (window->isTransparent) {
+		HDC screenDC = GetDC(NULL);
+		HDC memDC = CreateCompatibleDC(screenDC);
+
+		void *dibPixels;
+		HBITMAP hbm = CreateDIBSection(screenDC, &bmi, DIB_RGB_COLORS, &dibPixels, NULL, 0);
+		if (hbm) {
+			memcpy(dibPixels, pixels, (size_t)width * height * 4);
+			HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, hbm);
+
+			RECT winRect;
+			GetWindowRect(window->hwnd, &winRect);
+			POINT dstPos = { winRect.left, winRect.top };
+			POINT srcPos = { 0, 0 };
+			SIZE size = { width, height };
+			BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
+
+			UpdateLayeredWindow(window->hwnd, screenDC, &dstPos, &size, memDC, &srcPos, 0, &blend, ULW_ALPHA);
+
+			SelectObject(memDC, oldBmp);
+			DeleteObject(hbm);
+		}
+
+		DeleteDC(memDC);
+		ReleaseDC(NULL, screenDC);
+	} else {
+		HDC winDC = GetDC(window->hwnd);
+		SetDIBitsToDevice(winDC, 0, 0, width, height, 0, 0, 0, height, pixels, &bmi, DIB_RGB_COLORS);
+		ReleaseDC(window->hwnd, winDC);
+	}
+}
+
+#else
+	#error "konwinlib.h: unsupported platform"
+#endif /* end of platform switch */
+
+/*** main loop ***/
+
+#ifdef __EMSCRIPTEN__
+
+typedef struct {
+	kon_window_t *window;
+	kon_mainLoopFn callback;
+	void *userData;
+} kon_mainLoopCtx_;
+
+static void kon_mainLoopTrampoline_(void *arg) {
+	kon_mainLoopCtx_ *ctx = (kon_mainLoopCtx_ *)arg;
+
+	if (kon_windowShouldClose(ctx->window)) {
+		emscripten_cancel_main_loop();
+		free(ctx);
+		return;
+	}
+
+	ctx->callback(ctx->userData);
+}
+
+void kon_runMainLoop(kon_window_t *window, kon_mainLoopFn callback, void *userData) {
+	kon_mainLoopCtx_ *ctx = malloc(sizeof(kon_mainLoopCtx_));
+	if (!ctx) return;
+
+	ctx->window = window;
+	ctx->callback = callback;
+	ctx->userData = userData;
+
+	emscripten_set_main_loop_arg(kon_mainLoopTrampoline_, ctx, 0, 1);
+}
+
+#else
+
+void kon_runMainLoop(kon_window_t *window, kon_mainLoopFn callback, void *userData) {
+	while (!kon_windowShouldClose(window)) {
+		callback(userData);
+	}
+}
+
+#endif /* __EMSCRIPTEN__ */
+
+#endif /* end of KONWINLIB_IMPLEMENTATION */
+
+#endif
diff --git a/kon/src/engine.c b/kon/src/engine.c
new file mode 100644
index 0000000..06bac29
--- /dev/null
+++ b/kon/src/engine.c
@@ -0,0 +1,68 @@
+#include "konwinlib.h"
+#include "konsofren.h"
+#include "kontime.h"
+
+#define GAME_WIDTH 320
+#define GAME_HEIGHT 180
+
+int main(void)
+{
+	kon_window_t *window;
+	kon_display_t *display;
+	kon_camera_t camera;
+	kon_material_t material;
+	kon_light_t light;
+	kon_time last;
+	float angle = 0.0f;
+
+	if (!kon_init()) return 1;
+
+	window = kon_createWindow("engine", 0, 0, 800, 600, KON_WINDOW_CENTER | KON_WINDOW_RESIZABLE);
+	if (!window) return 1;
+	kon_setExitKey(window, KON_KEY_ESCAPE);
+
+	display = kon_createDisplay(GAME_WIDTH, GAME_HEIGHT, 800, 600);
+	if (!display) return 1;
+
+	camera = kon_cameraDefault();
+	camera.position = KON_VEC3(3, 3, 6);
+	material = kon_materialColor(0xFFC8C8FF);
+	light = kon_lightDefault();
+	last = kon_getTime();
+
+	while (!kon_windowShouldClose(window)) {
+		kon_event_t ev;
+		kon_time now;
+		kon_mat4_t model, viewProjection;
+
+		while (kon_pollEvent(window, &ev)) {
+			if (ev.type == KON_EVENT_RESIZE) {
+				kon_resizeDisplay(display, ev.width, ev.height);
+			}
+			if (ev.type == KON_EVENT_KEY_DOWN && ev.key == KON_KEY_O) {
+				camera.projection = (camera.projection == KON_PROJECTION_PERSPECTIVE)
+					? KON_PROJECTION_ORTHOGRAPHIC : KON_PROJECTION_PERSPECTIVE;
+			}
+		}
+
+		now = kon_getTime();
+		angle += (float)(now - last);
+		last = now;
+
+		model = kon_mat4Identity();
+		model = kon_mat4Rotate(model, KON_VEC3(angle * 0.5f, angle, 0));
+		viewProjection = kon_cameraViewProjection(&camera, display->game->width, display->game->height);
+
+		kon_clearFramebuffer(display->game, KON_BACKGROUND_COLOR);
+		kon_drawMesh(display->game, viewProjection, model, &kon_cubeMesh, &material, &light, KON_RENDER_DEFAULT);
+
+		kon_presentDisplay(display);
+		kon_blitPixels(window, display->screen->data, display->screen->width, display->screen->height);
+		kon_sleep(0.008);
+	}
+
+	kon_freeDisplay(display);
+	kon_destroyWindow(window);
+	kon_deinit();
+	return 0;
+}
diff --git a/kon/src/impl/konfont.c b/kon/src/impl/konfont.c
new file mode 100644
index 0000000..04c3bd8
--- /dev/null
+++ b/kon/src/impl/konfont.c
@@ -0,0 +1,2 @@
+#define KONFONT_IMPLEMENTATION
+#include "konfont.h"
diff --git a/kon/src/impl/koninput.c b/kon/src/impl/koninput.c
new file mode 100644
index 0000000..30f2479
--- /dev/null
+++ b/kon/src/impl/koninput.c
@@ -0,0 +1,2 @@
+#define KONINPUT_IMPLEMENTATION
+#include "koninput.h"
diff --git a/kon/src/impl/konsofren.c b/kon/src/impl/konsofren.c
new file mode 100644
index 0000000..9d7a5ea
--- /dev/null
+++ b/kon/src/impl/konsofren.c
@@ -0,0 +1,2 @@
+#define KONSOFREN_IMPLEMENTATION
+#include "konsofren.h"
diff --git a/kon/src/impl/kontime.c b/kon/src/impl/kontime.c
new file mode 100644
index 0000000..c7f00b6
--- /dev/null
+++ b/kon/src/impl/kontime.c
@@ -0,0 +1,2 @@
+#define KONTIME_IMPLEMENTATION
+#include "kontime.h"
diff --git a/kon/src/impl/kontoml.c b/kon/src/impl/kontoml.c
new file mode 100644
index 0000000..c0eca58
--- /dev/null
+++ b/kon/src/impl/kontoml.c
@@ -0,0 +1,2 @@
+#define KONTOML_IMPLEMENTATION
+#include "kontoml.h"
diff --git a/kon/src/impl/konwinlib.c b/kon/src/impl/konwinlib.c
new file mode 100644
index 0000000..89d791a
--- /dev/null
+++ b/kon/src/impl/konwinlib.c
@@ -0,0 +1,2 @@
+#define KONWINLIB_IMPLEMENTATION
+#include "konwinlib.h"