Playdate.

.gitignore

···
+.zig-cache/
+zig-out/
+.DS_Store

.prettierrc

···
+{
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 4,
+    "trailingComma": "none"
+}

.vscode/settings.json

···
+{
+    "zig.zls.enabled": "on",
+    // You can add more Zig and ZLS options here
+
+    // Whether to enable build-on-save diagnostics
+    //
+    // Further information about build-on save:
+    // https://zigtools.org/zls/guides/build-on-save/
+    // "zig.zls.enableBuildOnSave": true,
+
+    // All nested settings will only affect Zig files.
+    "[zig]": {
+        // The Zig FAQ answers some common questions about Zig's formatter (`zig fmt`)
+        // https://github.com/ziglang/zig/wiki/FAQ
+        //
+        "editor.formatOnSave": true,
+
+        "editor.inlayHints.enabled": "on",
+
+        // overwrite words when accepting completions
+
+        "editor.suggest.insertMode": "replace",
+        "editor.codeActionsOnSave": {
+            // Run code actions that currently supports adding and removing discards.
+            // "source.fixAll": "explicit",
+            // Run code actions that sorts @import declarations.
+            // "source.organizeImports": "explicit",
+        }
+    },
+    "editor.semanticTokenColorCustomizations": {
+        "rules": {
+            "*.deprecated": {
+                // highlight semantic tokens that are marked as "deprecated"
+                "strikethrough": true
+            }
+        }
+    },
+    "cSpell.words": [
+        "anyopaque",
+        "callconv",
+        "comptime",
+        "linenum",
+        "memcpy",
+        "orelse",
+        "pdapi",
+        "pdtools",
+        "playdate",
+        "repost",
+        "reposted",
+        "stringval",
+        "Sublist",
+        "Trunc",
+        "usize"
+    ]
+}

README.md

···
-# playdate-test
+# Playdate Bluesky client
+
+An experiment to learn Zig and the Playdate SDK.
+
+# Resources
+
+Thank you to https://github.com/DanB91/Zig-Playdate-Template for the starting point.

assets/fonts/Roobert-9-Mono-Condensed.fnt

···
+space	8
+!		8
+"		8
+#		8
+$		8
+%		8
+&		8
+'		8
+(		8
+)		8
+*		8
++		8
+,		8
+-		8
+.		8
+/		8
+0		8
+1		8
+2		8
+3		8
+4		8
+5		8
+6		8
+7		8
+8		8
+9		8
+:		8
+;		8
+<		8
+=		8
+>		8
+?		8
+@		8
+A		8
+B		8
+C		8
+D		8
+E		8
+F		8
+G		8
+H		8
+I		8
+J		8
+K		8
+L		8
+M		8
+N		8
+O		8
+P		8
+Q		8
+R		8
+S		8
+T		8
+U		8
+V		8
+W		8
+X		8
+Y		8
+Z		8
+[		8
+\		8
+]		8
+^		8
+_		8
+`		8
+a		8
+b		8
+c		8
+d		8
+e		8
+f		8
+g		8
+h		8
+i		8
+j		8
+k		8
+l		8
+m		8
+n		8
+o		8
+p		8
+q		8
+r		8
+s		8
+t		8
+u		8
+v		8
+w		8
+x		8
+y		8
+z		8
+{		8
+|		8
+}		8
+~		8

build.zig

···
+const std = @import("std");
+const builtin = @import("builtin");
+
+const name = "bluesky";
+pub fn build(b: *std.Build) !void {
+    const pdx_file_name = name ++ ".pdx";
+    const optimize = b.standardOptimizeOption(.{});
+
+    const writer = b.addWriteFiles();
+    const source_dir = writer.getDirectory();
+    writer.step.name = "write source directory";
+
+    const FORCE_COMPILE_M1_MAC = false;
+    const supported_targets = [_]std.Build.ResolvedTarget{
+        host_or_cross_target(
+            b,
+            .{
+                .abi = .msvc,
+                .os_tag = .windows,
+                .cpu_arch = .x86_64,
+            },
+            false,
+        ),
+        host_or_cross_target(
+            b,
+            .{
+                .abi = .none,
+                .os_tag = .macos,
+                .cpu_arch = .aarch64,
+            },
+            FORCE_COMPILE_M1_MAC,
+        ),
+        host_or_cross_target(
+            b,
+            .{
+                .abi = .gnu,
+                .os_tag = .linux,
+                .cpu_arch = .x86_64,
+            },
+            false,
+        ),
+    };
+    for (supported_targets) |target| {
+        try compile_simulator_binary(b, optimize, target, writer);
+    }
+
+    const playdate_target = b.resolveTargetQuery(try std.Target.Query.parse(.{
+        .arch_os_abi = "thumb-freestanding-eabihf",
+        .cpu_features = "cortex_m7+vfp4d16sp",
+    }));
+    const elf = b.addExecutable(.{
+        .name = "pdex.elf",
+        .root_source_file = b.path("src/main.zig"),
+        .target = playdate_target,
+        .optimize = optimize,
+        .pic = true,
+        .single_threaded = true,
+    });
+    elf.link_emit_relocs = true;
+    elf.entry = .{ .symbol_name = "eventHandler" };
+
+    elf.setLinkerScript(b.path("link_map.ld"));
+    if (optimize == .ReleaseFast) {
+        elf.root_module.omit_frame_pointer = true;
+    }
+    _ = writer.addCopyFile(elf.getEmittedBin(), "pdex.elf");
+    _ = writer.addCopyFile(b.path("pdxinfo"), "pdxinfo");
+
+    try addCopyDirectory(writer, "assets", "./assets");
+
+    const playdate_sdk_path = try std.process.getEnvVarOwned(b.allocator, "PLAYDATE_SDK_PATH");
+    const pdc_path = b.pathJoin(&.{ playdate_sdk_path, "bin", if (builtin.os.tag == .windows) "pdc.exe" else "pdc" });
+    const pd_simulator_path = switch (builtin.os.tag) {
+        .linux => b.pathJoin(&.{ playdate_sdk_path, "bin", "PlaydateSimulator" }),
+        .macos => "open", // `open` focuses the window, while running the simulator directry doesn't.
+        .windows => b.pathJoin(&.{ playdate_sdk_path, "bin", "PlaydateSimulator.exe" }),
+        else => @panic("Unsupported OS"),
+    };
+
+    const pdc = b.addSystemCommand(&.{pdc_path});
+    pdc.addDirectoryArg(source_dir);
+    pdc.setName("pdc");
+    const pdx = pdc.addOutputFileArg(pdx_file_name);
+
+    b.installDirectory(.{
+        .source_dir = pdx,
+        .install_dir = .prefix,
+        .install_subdir = pdx_file_name,
+    });
+    b.installDirectory(.{
+        .source_dir = source_dir,
+        .install_dir = .prefix,
+        .install_subdir = "pdx_source_dir",
+    });
+
+    const run_cmd = b.addSystemCommand(&.{pd_simulator_path});
+    run_cmd.addDirectoryArg(pdx);
+    run_cmd.setName("PlaydateSimulator");
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+    run_step.dependOn(b.getInstallStep());
+
+    const clean_step = b.step("clean", "Clean all artifacts");
+    clean_step.dependOn(&b.addRemoveDirTree(b.path("zig-out")).step);
+    if (builtin.os.tag != .windows) {
+        //Removing zig-cache from the Zig build script does not work on Windows: https://github.com/ziglang/zig/issues/9216
+        clean_step.dependOn(&b.addRemoveDirTree(b.path("zig-cache")).step);
+        clean_step.dependOn(&b.addRemoveDirTree(b.path(".zig-cache")).step);
+    }
+
+    // Add test step
+    const test_step = b.step("test", "Run unit tests");
+
+    // Create test executables for each test file
+    const test_files = [_][]const u8{
+        "src/test_memory.zig",
+        "src/test_json_parser.zig",
+        "src/test_network.zig",
+    };
+
+    for (test_files) |test_file| {
+        const test_exe = b.addTest(.{
+            .root_source_file = b.path(test_file),
+            .optimize = optimize,
+        });
+
+        const run_test = b.addRunArtifact(test_exe);
+        test_step.dependOn(&run_test.step);
+    }
+}
+
+//The purpose of this function is a result of:
+// 1) This script supports cross-compiling PDX's that work on Mac, Windows or Linux without having
+//    to compile on those OS's.
+//
+// 2) Inside of a PDX, there can only be 1 pdex executable per OS regardless of the CPU architecture.
+//    This has unexpected consequences where, say, a given PDX file can only work on M1 Macs,
+//    but not Intel ones. Or, vice versa.
+//
+//    So, in the build() function above, I hardcoded ".cpu_arch = .aarch64", which is for M1 Macs.
+//    What this means is that if you compiling your game on, say, Windows, it will generate a .pdx
+//    that will only work on M1 Macs, but not Intel Macs.
+//    BUT, cruicially, if you compiling your game on an Intel Mac, the resulting PDX will work
+//    on Intel Macs, but not M1 Macs.  Without this function, the game would fail
+//    to run on the machine your compiling the code on (Intel Mac), which I'd like to avoid.
+fn host_or_cross_target(
+    b: *std.Build,
+    cross_target: std.Target.Query,
+    force_use_cross_target: bool,
+) std.Build.ResolvedTarget {
+    const result =
+        if (!force_use_cross_target and b.graph.host.result.os.tag == cross_target.os_tag.?)
+            b.graph.host
+        else
+            b.resolveTargetQuery(cross_target);
+    return result;
+}
+
+fn compile_simulator_binary(
+    b: *std.Build,
+    optimize: std.builtin.OptimizeMode,
+    target: std.Build.ResolvedTarget,
+    writer: *std.Build.Step.WriteFile,
+) !void {
+    const os_tag = target.result.os.tag;
+    const lib = b.addSharedLibrary(.{
+        .name = "pdex",
+        .root_source_file = b.path("src/main.zig"),
+        .optimize = optimize,
+        .target = target,
+    });
+    const pdex_extension = switch (os_tag) {
+        .windows => "dll",
+        .macos => "dylib",
+        .linux => "so",
+        else => @panic("Unsupported OS"),
+    };
+    const pdex_filename = try std.fmt.allocPrint(b.allocator, "pdex.{s}", .{pdex_extension});
+    _ = writer.addCopyFile(lib.getEmittedBin(), pdex_filename);
+
+    if (os_tag == .windows) {
+        _ = writer.addCopyFile(lib.getEmittedPdb(), "pdex.pdb");
+    }
+}
+
+fn addCopyDirectory(
+    wf: *std.Build.Step.WriteFile,
+    src_path: []const u8,
+    dest_path: []const u8,
+) !void {
+    const b = wf.step.owner;
+    var dir = try b.build_root.handle.openDir(
+        src_path,
+        .{ .iterate = true },
+    );
+    defer dir.close();
+    var it = dir.iterate();
+    while (try it.next()) |entry| {
+        const new_src_path = b.pathJoin(&.{ src_path, entry.name });
+        const new_dest_path = b.pathJoin(&.{ dest_path, entry.name });
+        const new_src = b.path(new_src_path);
+        switch (entry.kind) {
+            .file => {
+                _ = wf.addCopyFile(new_src, new_dest_path);
+            },
+            .directory => {
+                try addCopyDirectory(
+                    wf,
+                    new_src_path,
+                    new_dest_path,
+                );
+            },
+            //TODO: possible support for sym links?
+            else => {},
+        }
+    }
+}

link_map.ld

···
+/*
+	NOTE(Daniel Bokser): It seems that due to the way the Zig now invokes the linker, 
+	the entry point name must be specified in build.zig. Thus, the ENTRY() call here is no longer needed. 
+
+	ENTRY(eventHandler)
+*/
+
+/*
+	NOTE(Daniel Bokser): This GROUP line is from the PlaydateSDK.  This doesn't seem to be required for Zig.
+	But, leaving it here just in case...
+
+	GROUP(libgcc.a libc.a libm.a)
+*/
+
+/*
+	NOTE(Daniel Bokser): Had to add this PHDRS contstruct in to force however Zig invokes the linker 
+	to make sure there is only one combined ELF segment, which is what PDC seems to expect.
+*/
+PHDRS
+{
+   global_segment PT_LOAD;
+}
+SECTIONS
+{
+	/*
+		NOTE(Daniel Bokser): Had to add this in to force however Zig now invokes the linker 
+		to make sure everything starts at address 0, which is what PDC seems to expect.
+	*/
+	. = 0;
+
+	.text :
+	{
+		*(.text)
+		*(.text.*)
+
+		KEEP(*(.init))
+		KEEP(*(.fini))
+
+		/* .ctors */
+		*crtbegin.o(.ctors)
+		*crtbegin?.o(.ctors)
+		*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
+		*(SORT(.ctors.*))
+		*(.ctors)
+
+		/* .dtors */
+ 		*crtbegin.o(.dtors)
+ 		*crtbegin?.o(.dtors)
+ 		*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
+ 		*(SORT(.dtors.*))
+ 		*(.dtors)
+
+		*(.rodata*)
+
+		KEEP(*(.eh_frame*))
+
+	}: global_segment
+
+	.data :
+	{
+		__etext = .;
+
+		__data_start__ = .;
+		*(vtable)
+		*(.data*)
+
+		. = ALIGN(4);
+		/* preinit data */
+		PROVIDE_HIDDEN (__preinit_array_start = .);
+		KEEP(*(.preinit_array))
+		PROVIDE_HIDDEN (__preinit_array_end = .);
+
+		. = ALIGN(4);
+		/* init data */
+		PROVIDE_HIDDEN (__init_array_start = .);
+		KEEP(*(SORT(.init_array.*)))
+		KEEP(*(.init_array))
+		PROVIDE_HIDDEN (__init_array_end = .);
+
+		. = ALIGN(4);
+		/* finit data */
+		PROVIDE_HIDDEN (__fini_array_start = .);
+		KEEP(*(SORT(.fini_array.*)))
+		KEEP(*(.fini_array))
+		PROVIDE_HIDDEN (__fini_array_end = .);
+
+		. = ALIGN(4);
+		/* All data end */
+		__data_end__ = .;
+
+	}: global_segment
+
+	.bss :
+	{
+		. = ALIGN(4);
+		__bss_start__ = .;
+		*(.bss*)
+		*(COMMON)
+		*(COM)
+		. = ALIGN(4);
+		__bss_end__ = .;
+
+	}: global_segment
+
+  /DISCARD/ :
+  {
+		*(.ARM.exidx)
+  }
+
+}

pdxinfo

···
+name=Bluesky
+author=Russley Shaw
+description=A bluesky client for the Playdate
+bundleID=dev.russley.zig-bluesky
+imagePath=assets/images

src/bsky_post.zig

···
+const pdapi = @import("playdate_api_definitions.zig");
+const std = @import("std");
+const pdtools = @import("pdtools/index.zig");
+const DrawableText = @import("pdtools/DrawableText.zig").DrawableText;
+const fonts = @import("fonts.zig");
+
+// Memory size constants
+pub const AUTHOR_BUFFER_SIZE = 32;
+pub const CONTENT_BUFFER_SIZE = 512;
+pub const ALT_TEXT_BUFFER_SIZE = 256;
+pub const MAX_POSTS = 50;
+
+pub const CURSOR_BUFFER_SIZE = 256;
+
+pub const PostType = enum {
+    normal,
+    repost,
+    reply,
+};
+
+pub const BskyPost = struct {
+    author: [AUTHOR_BUFFER_SIZE]u8,
+    author_len: usize,
+    content: [CONTENT_BUFFER_SIZE]u8,
+    content_len: usize,
+    alt_text: [ALT_TEXT_BUFFER_SIZE]u8,
+    alt_text_len: usize,
+
+    // Repost/Reply metadata
+    post_type: PostType,
+    repost_author: [AUTHOR_BUFFER_SIZE]u8,
+    repost_author_len: usize,
+    reply_author: [AUTHOR_BUFFER_SIZE]u8,
+    reply_author_len: usize,
+};
+
+/// Clean up text content by removing multiple consecutive newlines
+fn cleanupTextContent(buffer: []u8, content_len: usize) usize {
+    if (content_len == 0) return 0;
+
+    var write_pos: usize = 0;
+    var read_pos: usize = 0;
+    var consecutive_newlines: usize = 0;
+
+    while (read_pos < content_len) {
+        const char = buffer[read_pos];
+
+        if (char == '\n' or char == '\r') {
+            consecutive_newlines += 1;
+            // Allow max 2 consecutive newlines (one blank line)
+            if (consecutive_newlines <= 2) {
+                buffer[write_pos] = '\n'; // Normalize to \n
+                write_pos += 1;
+            }
+        } else {
+            consecutive_newlines = 0;
+            buffer[write_pos] = char;
+            write_pos += 1;
+        }
+
+        read_pos += 1;
+    }
+
+    return write_pos;
+}
+
+pub var g_playdate: *pdapi.PlaydateAPI = undefined;
+
+var g_posts_out: []BskyPost = undefined;
+var g_post_count: *usize = undefined;
+var g_post_max: usize = undefined;
+var g_parsing_feed: bool = false;
+var g_current_feed_index: i32 = -1;
+
+fn onDecodeError(decoder: ?*pdapi.JSONDecoder, err: ?[*:0]const u8, linenum: c_int) callconv(.C) void {
+    _ = decoder; // Unused in this context
+
+    const pd = g_playdate;
+    pd.system.logToConsole("JSON decoding error at line %d: %s", linenum, err);
+
+    // Log parsing context
+    pd.system.logToConsole("Parsing context: posts found so far = %d", @as(c_int, @intCast(g_post_count.*)));
+    pd.system.logToConsole("Current feed index: %d", g_current_feed_index);
+}
+
+fn debugDidDecodeSublist(decoder: ?*pdapi.JSONDecoder, name: ?[*:0]const u8, json_type: pdapi.JSONValueType) callconv(.C) ?*anyopaque {
+    _ = decoder;
+    _ = name;
+    _ = json_type;
+    return null;
+}
+
+fn author_didDecodeSublist(decoder: ?*pdapi.JSONDecoder, name: ?[*:0]const u8, json_type: pdapi.JSONValueType) callconv(.C) ?*anyopaque {
+    _ = name;
+    _ = json_type;
+
+    // Reset to post-level parsing
+    decoder.?.didDecodeTableValue = post_didDecodeTableValue;
+    decoder.?.willDecodeSublist = null;
+    decoder.?.didDecodeSublist = null;
+
+    return null;
+}
+
+fn record_didDecodeSublist(decoder: ?*pdapi.JSONDecoder, name: ?[*:0]const u8, json_type: pdapi.JSONValueType) callconv(.C) ?*anyopaque {
+    _ = name;
+    _ = json_type;
+
+    // Reset to post-level parsing
+    decoder.?.didDecodeTableValue = post_didDecodeTableValue;
+    decoder.?.willDecodeSublist = null;
+    decoder.?.didDecodeSublist = null;
+
+    return null;
+}
+
+fn author_didDecodeTableValue(decoder: ?*pdapi.JSONDecoder, key: ?[*:0]const u8, value: pdapi.JSONValue) callconv(.C) void {
+    if (key == null) return;
+
+    const key_str = std.mem.span(key.?);
+    const json_type: pdapi.JSONValueType = @enumFromInt(value.type);
+
+    // Extract handle from author object
+    if (std.mem.eql(u8, key_str, "handle") and json_type == pdapi.JSONValueType.JSONString) {
+        if (g_post_count.* < g_post_max) {
+            const author_str = std.mem.span(value.data.stringval);
+            const copy_len = @min(author_str.len, g_posts_out[g_post_count.*].author.len - 1);
+            @memcpy(g_posts_out[g_post_count.*].author[0..copy_len], author_str[0..copy_len]);
+            g_posts_out[g_post_count.*].author_len = copy_len;
+        }
+    }
+
+    if (false) {
+        debugDidDecodeTableValue(decoder, key, value);
+    }
+}
+
+fn record_didDecodeTableValue(decoder: ?*pdapi.JSONDecoder, key: ?[*:0]const u8, value: pdapi.JSONValue) callconv(.C) void {
+    if (key == null) return;
+
+    const key_str = std.mem.span(key.?);
+    const json_type: pdapi.JSONValueType = @enumFromInt(value.type);
+
+    // Extract text from record object
+    if (std.mem.eql(u8, key_str, "text") and json_type == pdapi.JSONValueType.JSONString) {
+        if (g_post_count.* < g_post_max) {
+            const content_str = std.mem.span(value.data.stringval);
+            const copy_len = @min(content_str.len, g_posts_out[g_post_count.*].content.len - 1);
+            @memcpy(g_posts_out[g_post_count.*].content[0..copy_len], content_str[0..copy_len]);
+
+            // Clean up multiple consecutive newlines
+            const cleaned_len = cleanupTextContent(g_posts_out[g_post_count.*].content[0..copy_len], copy_len);
+            g_posts_out[g_post_count.*].content_len = cleaned_len;
+        }
+    }
+
+    if (false) {
+        debugDidDecodeTableValue(decoder, key, value);
+    }
+}
+
+fn post_didDecodeTableValue(decoder: ?*pdapi.JSONDecoder, key: ?[*:0]const u8, value: pdapi.JSONValue) callconv(.C) void {
+    if (key == null) return;
+
+    const key_str = std.mem.span(key.?);
+    const json_type: pdapi.JSONValueType = @enumFromInt(value.type);
+
+    // Set up nested object parsing
+    if (std.mem.eql(u8, key_str, "author") and json_type == pdapi.JSONValueType.JSONTable) {
+        decoder.?.willDecodeSublist = null;
+        decoder.?.didDecodeSublist = author_didDecodeSublist;
+        decoder.?.didDecodeTableValue = author_didDecodeTableValue;
+        return;
+    }
+
+    if (std.mem.eql(u8, key_str, "record") and json_type == pdapi.JSONValueType.JSONTable) {
+        decoder.?.willDecodeSublist = null;
+        decoder.?.didDecodeSublist = record_didDecodeSublist;
+        decoder.?.didDecodeTableValue = record_didDecodeTableValue;
+        return;
+    }
+
+    debugDidDecodeTableValue(decoder, key, value);
+}
+
+fn feed_item_didDecodeTableValue(decoder: ?*pdapi.JSONDecoder, key: ?[*:0]const u8, value: pdapi.JSONValue) callconv(.C) void {
+    if (key == null) return;
+
+    const key_str = std.mem.span(key.?);
+    const json_type: pdapi.JSONValueType = @enumFromInt(value.type);
+
+    // Set up post object parsing
+    if (std.mem.eql(u8, key_str, "post") and json_type == pdapi.JSONValueType.JSONTable) {
+        decoder.?.willDecodeSublist = null;
+        decoder.?.didDecodeSublist = post_didDecodeSublist;
+        decoder.?.didDecodeTableValue = post_didDecodeTableValue;
+        return;
+    }
+
+    if (false) {
+        debugDidDecodeTableValue(decoder, key, value);
+    }
+}
+
+fn post_didDecodeSublist(decoder: ?*pdapi.JSONDecoder, name: ?[*:0]const u8, json_type: pdapi.JSONValueType) callconv(.C) ?*anyopaque {
+    _ = name;
+    _ = json_type;
+
+    // Reset to feed item level parsing
+    decoder.?.didDecodeTableValue = feed_item_didDecodeTableValue;
+    decoder.?.willDecodeSublist = null;
+    decoder.?.didDecodeSublist = null;
+
+    return null;
+}
+
+fn willDecodeFeedList(decoder: ?*pdapi.JSONDecoder, name: ?[*:0]const u8, json_type: pdapi.JSONValueType) callconv(.C) void {
+    _ = name;
+
+    // This is called when entering each element in the feed array
+    if (json_type == pdapi.JSONValueType.JSONTable) {
+        // Initialize new post with empty data at current index
+        if (g_post_count.* < g_post_max) {
+            g_posts_out[g_post_count.*] = BskyPost{
+                .author = [_]u8{0} ** AUTHOR_BUFFER_SIZE,
+                .author_len = 0,
+                .content = [_]u8{0} ** CONTENT_BUFFER_SIZE,
+                .content_len = 0,
+                .alt_text = [_]u8{0} ** ALT_TEXT_BUFFER_SIZE,
+                .alt_text_len = 0,
+                .post_type = .normal,
+                .repost_author = [_]u8{0} ** AUTHOR_BUFFER_SIZE,
+                .repost_author_len = 0,
+                .reply_author = [_]u8{0} ** AUTHOR_BUFFER_SIZE,
+                .reply_author_len = 0,
+            };
+        }
+
+        // Set up feed item parsing (looking for "post" object)
+        decoder.?.didDecodeTableValue = feed_item_didDecodeTableValue;
+    }
+}
+
+fn didDecodeFeedList(decoder: ?*pdapi.JSONDecoder, name: ?[*:0]const u8, json_type: pdapi.JSONValueType) callconv(.C) ?*anyopaque {
+    _ = name;
+
+    if (json_type != pdapi.JSONValueType.JSONTable) {
+        return null;
+    }
+
+    // Post parsing complete - increment count if we have valid data
+    if (g_post_count.* < g_post_max) {
+        const has_author = g_posts_out[g_post_count.*].author_len > 0;
+        const has_content = g_posts_out[g_post_count.*].content_len > 0;
+
+        if (has_author or has_content) {
+            g_post_count.* += 1;
+        }
+    }
+
+    // Reset decoder for root-level parsing (back to root after this feed item)
+    decoder.?.didDecodeTableValue = root_didDecodeTableValue;
+    decoder.?.willDecodeSublist = willDecodeFeedList;
+    decoder.?.didDecodeSublist = didDecodeFeedList;
+
+    return null;
+}
+
+fn root_didDecodeTableValue(decoder: ?*pdapi.JSONDecoder, key: ?[*:0]const u8, value: pdapi.JSONValue) callconv(.C) void {
+    const json_type: pdapi.JSONValueType = @enumFromInt(value.type);
+    const path_ptr = decoder.?.path orelse "_root";
+    const path = std.mem.span(path_ptr);
+
+    // Check if we're inside a feed item by looking at the path
+    if (key != null) {
+        const key_str = std.mem.span(key.?);
+
+        // Extract author handle
+        if (std.mem.eql(u8, key_str, "handle") and json_type == pdapi.JSONValueType.JSONString) {
+            // Check if we're in an author context (path should contain something like feed[n].post.author)
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.indexOf(u8, path, ".post.author") != null) {
+                if (g_post_count.* < g_post_max) {
+                    const author_str = std.mem.span(value.data.stringval);
+                    const copy_len = @min(author_str.len, g_posts_out[g_post_count.*].author.len - 1);
+                    @memcpy(g_posts_out[g_post_count.*].author[0..copy_len], author_str[0..copy_len]);
+                    g_posts_out[g_post_count.*].author_len = copy_len;
+                    g_playdate.system.logToConsole("Found author: %.*s", @as(c_int, @intCast(copy_len)), @as([*:0]const u8, @ptrCast(&g_posts_out[g_post_count.*].author)));
+                }
+                return;
+            }
+        }
+
+        // Extract post text content
+        if (std.mem.eql(u8, key_str, "text") and json_type == pdapi.JSONValueType.JSONString) {
+            // Check if we're in a record context (path should contain something like feed[n].post.record)
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.indexOf(u8, path, ".post.record") != null) {
+                if (g_post_count.* < g_post_max) {
+                    const content_str = std.mem.span(value.data.stringval);
+                    const copy_len = @min(content_str.len, g_posts_out[g_post_count.*].content.len - 1);
+                    @memcpy(g_posts_out[g_post_count.*].content[0..copy_len], content_str[0..copy_len]);
+                    g_posts_out[g_post_count.*].content_len = copy_len;
+                    const preview_len = @min(50, copy_len);
+                    g_playdate.system.logToConsole("Found text content (%d chars): %.*s...", @as(c_int, @intCast(copy_len)), @as(c_int, @intCast(preview_len)), @as([*:0]const u8, @ptrCast(&g_posts_out[g_post_count.*].content)));
+                }
+                return;
+            }
+        }
+
+        // Extract alt text from image embeds
+        if (std.mem.eql(u8, key_str, "alt") and json_type == pdapi.JSONValueType.JSONString) {
+            // Check if we're in an image embed context (path should contain something like feed[n].post.embed.images[])
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.indexOf(u8, path, ".post.embed.images[") != null) {
+                if (g_post_count.* < g_post_max) {
+                    const alt_str = std.mem.span(value.data.stringval);
+
+                    // Create alt text with [IMG]: prefix
+                    const prefix = "[IMG]: ";
+                    const prefix_len = prefix.len;
+                    const max_alt_len = g_posts_out[g_post_count.*].alt_text.len - prefix_len - 1;
+                    const alt_copy_len = @min(alt_str.len, max_alt_len);
+
+                    // Copy prefix first
+                    @memcpy(g_posts_out[g_post_count.*].alt_text[0..prefix_len], prefix);
+
+                    // Copy alt text after prefix
+                    @memcpy(g_posts_out[g_post_count.*].alt_text[prefix_len .. prefix_len + alt_copy_len], alt_str[0..alt_copy_len]);
+
+                    g_posts_out[g_post_count.*].alt_text_len = prefix_len + alt_copy_len;
+                }
+                return;
+            }
+        }
+
+        // Handle repost detection
+        if (std.mem.eql(u8, key_str, "$type") and json_type == pdapi.JSONValueType.JSONString) {
+            const type_str = std.mem.span(value.data.stringval);
+            // Check if we're in a reason context (indicating a repost)
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.indexOf(u8, path, ".reason") != null) {
+                if (std.mem.eql(u8, type_str, "app.bsky.feed.defs#reasonRepost")) {
+                    if (g_post_count.* < g_post_max) {
+                        g_posts_out[g_post_count.*].post_type = .repost;
+                        g_playdate.system.logToConsole("Detected repost");
+                    }
+                }
+                return;
+            }
+        }
+
+        // Handle repost author (the person who reposted)
+        if (std.mem.eql(u8, key_str, "handle") and json_type == pdapi.JSONValueType.JSONString) {
+            // Check if we're in a reason.by context (repost author)
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.indexOf(u8, path, ".reason.by") != null) {
+                if (g_post_count.* < g_post_max) {
+                    const repost_author_str = std.mem.span(value.data.stringval);
+                    const copy_len = @min(repost_author_str.len, g_posts_out[g_post_count.*].repost_author.len - 1);
+                    @memcpy(g_posts_out[g_post_count.*].repost_author[0..copy_len], repost_author_str[0..copy_len]);
+                    g_posts_out[g_post_count.*].repost_author_len = copy_len;
+                    g_playdate.system.logToConsole("Found repost author: %.*s", @as(c_int, @intCast(copy_len)), @as([*:0]const u8, @ptrCast(&g_posts_out[g_post_count.*].repost_author)));
+                }
+                return;
+            }
+        }
+
+        // Handle reply detection - look for reply field in record
+        if (std.mem.eql(u8, key_str, "reply") and json_type == pdapi.JSONValueType.JSONTable) {
+            // Check if we're in a post.record context
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.indexOf(u8, path, ".post.record") != null) {
+                if (g_post_count.* < g_post_max) {
+                    g_posts_out[g_post_count.*].post_type = .reply;
+                    g_playdate.system.logToConsole("Detected reply");
+                }
+                return;
+            }
+        }
+
+        // Handle feed item initialization and completion
+        if (std.mem.eql(u8, key_str, "post") and json_type == pdapi.JSONValueType.JSONTable) {
+            // Check if we're at feed[n].post level (not deeper)
+            if (std.mem.indexOf(u8, path, "feed[") != null and std.mem.count(u8, path, ".") == 0) {
+                // Extract the feed index from the path like "feed[5]"
+                const feed_start = std.mem.indexOf(u8, path, "feed[").? + 5;
+                const feed_end = std.mem.indexOf(u8, path[feed_start..], "]").? + feed_start;
+                const index_str = path[feed_start..feed_end];
+                const feed_index = std.fmt.parseInt(i32, index_str, 10) catch -1;
+
+                // If this is a new feed item, complete the previous post
+                if (g_current_feed_index != feed_index) {
+                    if (g_current_feed_index >= 0 and g_post_count.* < g_post_max) {
+                        // Complete previous post if it has data
+                        const has_author = g_posts_out[g_post_count.*].author_len > 0;
+                        const has_content = g_posts_out[g_post_count.*].content_len > 0;
+                        const has_alt_text = g_posts_out[g_post_count.*].alt_text_len > 0;
+                        if (has_author or has_content or has_alt_text) {
+                            g_post_count.* += 1;
+                        }
+                    }
+
+                    // Initialize new post
+                    g_current_feed_index = feed_index;
+                    if (g_post_count.* < g_post_max) {
+                        g_posts_out[g_post_count.*] = BskyPost{
+                            .author = [_]u8{0} ** AUTHOR_BUFFER_SIZE,
+                            .author_len = 0,
+                            .content = [_]u8{0} ** CONTENT_BUFFER_SIZE,
+                            .content_len = 0,
+                            .alt_text = [_]u8{0} ** ALT_TEXT_BUFFER_SIZE,
+                            .alt_text_len = 0,
+                            .post_type = .normal,
+                            .repost_author = [_]u8{0} ** AUTHOR_BUFFER_SIZE,
+                            .repost_author_len = 0,
+                            .reply_author = [_]u8{0} ** AUTHOR_BUFFER_SIZE,
+                            .reply_author_len = 0,
+                        };
+                        g_playdate.system.logToConsole("Initialized new post at feed index %d", feed_index);
+                    }
+                }
+                return;
+            }
+        }
+    }
+
+    if (false) {
+        debugDidDecodeTableValue(decoder, key, value);
+    }
+}
+
+fn debugDidDecodeArrayValue(decoder: ?*pdapi.JSONDecoder, pos: c_int, value: pdapi.JSONValue) callconv(.C) void {
+    _ = decoder;
+    _ = pos;
+    _ = value;
+}
+
+fn debugDidDecodeTableValue(decoder: ?*pdapi.JSONDecoder, key: ?[*:0]const u8, value: pdapi.JSONValue) callconv(.C) void {
+    _ = decoder;
+    _ = key;
+    _ = value;
+}
+
+pub fn decodePostsJson(
+    playdate: *pdapi.PlaydateAPI,
+    buffer: []const u8,
+    buffer_size: usize,
+    post_max: usize,
+    posts: []BskyPost,
+    post_count: *usize,
+    cursor_buffer: []u8,
+    cursor_len: *usize,
+) void {
+    // Initialize globals for parsing
+    g_playdate = playdate;
+    g_posts_out = posts;
+    g_post_count = post_count;
+    g_post_max = post_max;
+    _ = cursor_buffer;
+    _ = cursor_len;
+
+    const pd = playdate;
+
+    if (buffer_size == 0) {
+        pd.system.logToConsole("JSON decode called with empty buffer");
+        return;
+    }
+
+    // Reset parsing state
+    post_count.* = 0;
+    g_parsing_feed = false;
+    g_current_feed_index = -1;
+
+    // Log the first and last few characters of the JSON for debugging
+    pd.system.logToConsole("JSON buffer size: %d bytes", @as(c_int, @intCast(buffer_size)));
+
+    // Log first 100 characters
+    const preview_len = @min(100, buffer_size);
+    var preview_buffer: [101]u8 = undefined;
+    @memcpy(preview_buffer[0..preview_len], buffer[0..preview_len]);
+    preview_buffer[preview_len] = 0;
+    pd.system.logToConsole("JSON start: %s", @as([*:0]const u8, @ptrCast(&preview_buffer)));
+
+    // Log last 50 characters if buffer is large enough
+    if (buffer_size > 50) {
+        const tail_start = buffer_size - 50;
+        var tail_buffer: [51]u8 = undefined;
+        @memcpy(tail_buffer[0..50], buffer[tail_start..buffer_size]);
+        tail_buffer[50] = 0;
+        pd.system.logToConsole("JSON end: %s", @as([*:0]const u8, @ptrCast(&tail_buffer)));
+    }
+
+    if (false) {
+        pdtools.logLargeMessage(pd, buffer, buffer_size);
+    }
+
+    var decoder = pdapi.JSONDecoder{
+        .willDecodeSublist = null,
+        .shouldDecodeTableValueForKey = null,
+        .didDecodeTableValue = root_didDecodeTableValue,
+        .shouldDecodeArrayValueAtIndex = null,
+        .didDecodeArrayValue = null,
+        .didDecodeSublist = null,
+        .decodeError = onDecodeError,
+        .userdata = null,
+        .returnString = 0,
+        .path = null,
+    };
+
+    var jsonValue: pdapi.JSONValue = undefined;
+
+    pd.system.logToConsole("Starting JSON decoding...");
+    const decode_result = pd.json.decodeString(&decoder, @as(?[*:0]const u8, @ptrCast(buffer)), &jsonValue);
+    pd.system.logToConsole("JSON decoding finished with result: %d", decode_result);
+
+    // Complete the final post if we have one
+    if (g_current_feed_index >= 0 and g_post_count.* < g_post_max) {
+        const has_author = g_posts_out[g_post_count.*].author_len > 0;
+        const has_content = g_posts_out[g_post_count.*].content_len > 0;
+        const has_alt_text = g_posts_out[g_post_count.*].alt_text_len > 0;
+        pd.system.logToConsole("Final post check: author=%d content=%d alt=%d", @as(c_int, if (has_author) 1 else 0), @as(c_int, if (has_content) 1 else 0), @as(c_int, if (has_alt_text) 1 else 0));
+        if (has_author or has_content or has_alt_text) {
+            g_post_count.* += 1;
+            pd.system.logToConsole("Added final post, total count: %d", @as(c_int, @intCast(g_post_count.*)));
+        }
+    }
+
+    pd.system.logToConsole("JSON parsing complete - final post count: %d", @as(c_int, @intCast(g_post_count.*)));
+}
+
+pub fn renderPost(
+    pd: *pdapi.PlaydateAPI,
+    post: *const BskyPost,
+    x: c_int,
+    y: c_int,
+    width: c_int,
+    dry_run: bool,
+) usize {
+    const font = fonts.g_font;
+    const padding = 4;
+    const corner_radius = 4;
+
+    // Account for post padding
+    const content_width = @as(?c_int, @intCast(width - (padding * 2)));
+
+    // Author height
+    const author_len = std.mem.len(@as([*:0]const u8, @ptrCast(&post.author)));
+    const author_drawable = DrawableText{
+        .playdate = pd,
+        .text = post.author[0..author_len],
+        .max_width = content_width,
+        .font = font,
+        .wrapping_mode = .WrapWord,
+        .alignment = .AlignTextLeft,
+    };
+
+    // Content height
+    const content_len = std.mem.len(@as([*:0]const u8, @ptrCast(&post.content)));
+    const content_drawable = DrawableText{
+        .playdate = pd,
+        .text = post.content[0..content_len],
+        .max_width = content_width,
+        .font = font,
+        .wrapping_mode = .WrapWord,
+        .alignment = .AlignTextLeft,
+    };
+
+    // Alt text height
+    const alt_text_len = std.mem.len(@as([*:0]const u8, @ptrCast(&post.alt_text)));
+    var alt_drawable = DrawableText{
+        .playdate = pd,
+        .text = post.alt_text[0..alt_text_len],
+        .max_width = content_width,
+        .font = font,
+        .wrapping_mode = .WrapWord,
+        .alignment = .AlignTextLeft,
+    };
+
+    // Render the post (it's at least partially visible)
+
+    // Create DrawableText for @ symbol and author text
+    const at_symbol = "@";
+
+    const at_drawable = DrawableText{
+        .playdate = pd,
+        .text = at_symbol,
+        .max_width = content_width,
+        .font = font,
+        .wrapping_mode = .WrapWord,
+        .alignment = .AlignTextLeft,
+    };
+
+    var current_y = y + padding;
+    const current_x = x + padding;
+
+    // Draw @ symbol and author text
+    if (author_len > 0) {
+        at_drawable.render(current_x, current_y, dry_run);
+        const at_width = at_drawable.getWidth();
+        author_drawable.render(current_x + at_width, current_y, dry_run);
+        current_y += author_drawable.getHeight();
+    }
+
+    // Draw post content with text wrapping
+    content_drawable.render(current_x, current_y, dry_run);
+    current_y += content_drawable.getHeight();
+    current_y += padding;
+
+    // Draw alt text if available
+    if (alt_text_len > 0) {
+        alt_drawable.render(current_x, current_y, dry_run);
+        current_y += alt_drawable.getHeight();
+        current_y += padding;
+    }
+
+    const height = current_y - y;
+
+    if (!dry_run) {
+        pd.graphics.drawRoundRect(
+            x,
+            y,
+            width,
+            height,
+            corner_radius,
+            1,
+            @intFromEnum(pdapi.LCDSolidColor.ColorBlack),
+        );
+    }
+
+    return @as(usize, @intCast(height)); // Return total height of the rendered post
+}

src/definitions.zig

···
+pub const BSKY_USERNAME_SIZE = 64;
+pub const BSKY_PASSWORD_SIZE = 64;
+
+pub const EDITOR_BUFFER_SIZE = 256;
+pub const RESPONSE_BUFFER_SIZE = 1024 * 1024;
+
+pub const MARGIN = 4;
+
+pub const DEBUG_DONT_POST = true;
+
+// Credential storage constants
+pub const USERNAME_FILENAME = "bsky-username.txt";
+pub const PASSWORD_FILENAME = "bsky-password.txt";
+pub const MAX_CREDENTIAL_LENGTH = 128;

src/fonts.zig

···
+const pdapi = @import("playdate_api_definitions.zig");
+
+const g_font_path = "assets/fonts/Roobert-10-Bold.pft";
+
+pub var g_font: *pdapi.LCDFont = undefined;
+
+pub fn initializeFonts(pd: *pdapi.PlaydateAPI) void {
+
+    // Load the font
+    const font = pd.graphics.loadFont(g_font_path, null);
+
+    if (font) |f| {
+        pd.graphics.setFont(f);
+        g_font = f;
+        pd.system.logToConsole("Custom Roobert font loaded successfully");
+    } else {
+        pd.system.logToConsole("Failed to load custom font, using system default");
+    }
+}

src/main.zig

···
+const std = @import("std");
+const pdapi = @import("playdate_api_definitions.zig");
+const network = @import("network.zig");
+const bsky_post = @import("bsky_post.zig");
+const pdtools = @import("pdtools/index.zig");
+const ScrollingValue = @import("pdtools/ScrollingValue.zig").SlidingValue;
+const panic_handler = @import("panic_handler.zig");
+const defs = @import("definitions.zig");
+const keyboard_mod = @import("pdtools/keyboard.zig");
+const Keyboard = keyboard_mod.Keyboard(256);
+
+const fonts = @import("fonts.zig");
+
+// Global buffers to avoid large stack allocations
+var g_headers_buffer: [512]u8 = undefined;
+
+// Login input state
+const LoginInputState = enum {
+    username,
+    password,
+    ready,
+};
+
+// Login field selection
+const LoginFieldSelection = enum {
+    username,
+    password,
+    login_button,
+};
+
+// Post field selection
+const PostFieldSelection = enum {
+    edit_text,
+    confirm_post,
+};
+
+// Simple app state for timeline fetching
+const AppState = struct {
+    playdate: *pdapi.PlaydateAPI,
+    message: []const u8,
+    response_buffer: [defs.RESPONSE_BUFFER_SIZE]u8 = undefined,
+    response_length: usize,
+
+    posts: [bsky_post.MAX_POSTS]bsky_post.BskyPost,
+    post_count: usize,
+    cursor_buffer: [bsky_post.CURSOR_BUFFER_SIZE]u8,
+    cursor_len: usize,
+
+    network_access_requested: bool,
+    body_scroll: ScrollingValue,
+
+    // Login state
+    is_logged_in: bool,
+    access_token: [512]u8,
+    access_token_len: usize,
+    user_did: [256]u8,
+    user_did_len: usize,
+
+    keyboard: keyboard_mod.Keyboard(256),
+
+    // Login input state
+    login_input_state: LoginInputState,
+    login_field_selection: LoginFieldSelection,
+    username: [defs.MAX_CREDENTIAL_LENGTH]u8,
+    password: [defs.MAX_CREDENTIAL_LENGTH]u8,
+
+    previous_buttons: pdapi.PDButtons,
+
+    // Post composition state
+    post_field_selection: PostFieldSelection,
+    post_text: [defs.EDITOR_BUFFER_SIZE]u8,
+    post_text_len: usize,
+};
+
+var g_app: AppState = undefined;
+
+const Page = enum {
+    login,
+    home,
+    post,
+};
+
+var g_selected_page: Page = .login;
+
+const LCD_WIDTH = pdapi.LCD_COLUMNS;
+const LCD_HEIGHT = pdapi.LCD_ROWS;
+const MARGIN = 4;
+const CHUNK_SIZE = 512; // Read 512 bytes at a time
+
+// Credential storage functions
+fn saveCredentials(pd: *pdapi.PlaydateAPI) void {
+    pdtools.saveStringFile(pd, defs.USERNAME_FILENAME, &g_app.username);
+    pdtools.saveStringFile(pd, defs.PASSWORD_FILENAME, &g_app.password);
+}
+
+fn loadCredentials(pd: *pdapi.PlaydateAPI) void {
+    pd.system.logToConsole("Loading username from: %s", defs.USERNAME_FILENAME.ptr);
+    pdtools.loadStringFile(pd, defs.USERNAME_FILENAME, &g_app.username);
+    pd.system.logToConsole("Loading password from: %s", defs.PASSWORD_FILENAME.ptr);
+    pdtools.loadStringFile(pd, defs.PASSWORD_FILENAME, &g_app.password);
+}
+
+fn clearCredentials(pd: *pdapi.PlaydateAPI) void {
+    // Clear in-memory credentials
+    @memset(&g_app.username, 0);
+    @memset(&g_app.password, 0);
+    g_app.login_input_state = .username;
+    g_app.login_field_selection = .username;
+
+    pdtools.delStringFile(pd, defs.USERNAME_FILENAME);
+    pdtools.delStringFile(pd, defs.PASSWORD_FILENAME);
+
+    pd.system.logToConsole("Credentials cleared");
+    g_app.message = "Credentials cleared - enter new ones";
+}
+
+// Network callback functions
+fn onLoginSuccess(status_code: network.HttpStatusCode, response_data: []const u8) void {
+    const pd = g_app.playdate;
+    pd.system.logToConsole("Login successful with status: %d", status_code);
+
+    // Parse the JSON to extract access token
+    if (std.mem.indexOf(u8, response_data, "\"accessJwt\":\"")) |start_pos| {
+        const token_start = start_pos + 13; // Length of "accessJwt":"
+        if (std.mem.indexOfPos(u8, response_data, token_start, "\"")) |end_pos| {
+            const token_len = end_pos - token_start;
+            if (token_len < g_app.access_token.len) {
+                @memcpy(g_app.access_token[0..token_len], response_data[token_start..end_pos]);
+                g_app.access_token_len = token_len;
+
+                // Also parse the DID from the response
+                if (std.mem.indexOf(u8, response_data, "\"did\":\"")) |did_start_pos| {
+                    const did_token_start = did_start_pos + 7; // Length of "did":"
+                    if (std.mem.indexOfPos(u8, response_data, did_token_start, "\"")) |did_end_pos| {
+                        const did_len = did_end_pos - did_token_start;
+                        if (did_len < g_app.user_did.len) {
+                            @memcpy(g_app.user_did[0..did_len], response_data[did_token_start..did_end_pos]);
+                            g_app.user_did[did_len] = 0;
+                            g_app.user_did_len = did_len;
+                            pd.system.logToConsole("User DID extracted: %.*s", @as(c_int, @intCast(did_len)), @as([*c]const u8, @ptrCast(&g_app.user_did)));
+                        }
+                    }
+                }
+
+                g_app.is_logged_in = true;
+                g_app.message = "Login successful - fetching posts...";
+                g_selected_page = .home;
+                pd.system.logToConsole("Access token extracted successfully (length: %d)", @as(c_int, @intCast(token_len)));
+
+                // Automatically fetch posts after successful login
+                fetchBlueskyFeed();
+            } else {
+                g_app.message = "Access token too long";
+                pd.system.logToConsole("Access token too long: %d", @as(c_int, @intCast(token_len)));
+            }
+        } else {
+            g_app.message = "Failed to parse access token";
+            pd.system.logToConsole("Failed to find end of access token");
+        }
+    } else {
+        g_app.message = "Access token not found";
+        pd.system.logToConsole("Access token not found in response");
+    }
+}
+
+fn onLoginFailure(status_code: network.HttpStatusCode, error_message: []const u8) void {
+    const pd = g_app.playdate;
+    pd.system.logToConsole("Login failed with status: %d", status_code);
+    pd.system.logToConsole("Error: %.*s", @as(c_int, @intCast(error_message.len)), @as([*c]const u8, @ptrCast(error_message.ptr)));
+    g_app.message = if (status_code == 0) "Login connection error" else "Login failed";
+}
+
+fn onFeedSuccess(status_code: network.HttpStatusCode, response_data: []const u8) void {
+    const pd = g_app.playdate;
+    pd.system.logToConsole("Feed fetch successful with status: %d, %d bytes", status_code, response_data.len);
+
+    // The response_data is already pointing to our g_app.response_buffer
+    // So we just need to set the length - no copying needed
+    g_app.response_length = response_data.len;
+
+    // Ensure null termination
+    if (g_app.response_length < g_app.response_buffer.len) {
+        g_app.response_buffer[g_app.response_length] = 0;
+    }
+
+    g_app.message = "Feed data received";
+
+    // Parse the JSON response into posts
+    parseFeedResponseIntoPosts();
+}
+
+fn onFeedFailure(status_code: network.HttpStatusCode, error_message: []const u8) void {
+    const pd = g_app.playdate;
+    pd.system.logToConsole("Feed fetch failed with status: %d", status_code);
+
+    if (error_message.len > 0) {
+        pd.system.logToConsole("Error message: %.*s", @as(c_int, @intCast(error_message.len)), @as([*c]const u8, @ptrCast(error_message.ptr)));
+    } else {
+        pd.system.logToConsole("No error message provided");
+    }
+
+    // Clear any previous response data
+    g_app.response_length = 0;
+    g_app.post_count = 0;
+
+    if (status_code == 0) {
+        g_app.message = "Network connection failed";
+    } else if (status_code == 401) {
+        g_app.message = "Login expired - please re-login";
+    } else if (status_code >= 400 and status_code < 500) {
+        g_app.message = "Request error - check credentials";
+    } else if (status_code >= 500) {
+        g_app.message = "Server error - try again later";
+    } else {
+        g_app.message = "Feed fetch failed";
+    }
+}
+
+fn onPostSuccess(status_code: network.HttpStatusCode, response_data: []const u8) void {
+    const pd = g_app.playdate;
+    pd.system.logToConsole("Post successful with status: %d", status_code);
+
+    // Clear the post text since it was successfully posted
+    @memset(&g_app.post_text, 0);
+    g_app.post_text_len = 0;
+
+    // Reset to default text for next post
+    const default_post_text = "Hello World!\n\nPosted from my #playdate";
+    const default_len = @min(default_post_text.len, g_app.post_text.len - 1);
+    @memcpy(g_app.post_text[0..default_len], default_post_text[0..default_len]);
+    g_app.post_text[default_len] = 0;
+    g_app.post_text_len = default_len;
+
+    g_app.message = "Post published successfully!";
+
+    // Log response for debugging
+    if (response_data.len > 0) {
+        const preview_len = @min(100, response_data.len);
+        pd.system.logToConsole("Post response: %.*s", @as(c_int, @intCast(preview_len)), @as([*c]const u8, @ptrCast(response_data.ptr)));
+    }
+}
+
+fn onPostFailure(status_code: network.HttpStatusCode, error_message: []const u8) void {
+    const pd = g_app.playdate;
+    pd.system.logToConsole("Post failed with status: %d", status_code);
+
+    if (error_message.len > 0) {
+        pd.system.logToConsole("Post error: %.*s", @as(c_int, @intCast(error_message.len)), @as([*c]const u8, @ptrCast(error_message.ptr)));
+    }
+
+    if (status_code == 0) {
+        g_app.message = "Post failed - network error";
+    } else if (status_code == 401) {
+        g_app.message = "Post failed - please re-login";
+    } else if (status_code == 413) {
+        g_app.message = "Post too long - please shorten";
+    } else if (status_code >= 400 and status_code < 500) {
+        g_app.message = "Post failed - invalid request";
+    } else if (status_code >= 500) {
+        g_app.message = "Post failed - server error";
+    } else {
+        g_app.message = "Post failed - unknown error";
+    }
+}
+
+fn parseFeedResponseIntoPosts() void {
+    // Check if we have a valid response
+    if (g_app.response_length == 0) {
+        g_app.playdate.system.logToConsole("No response data to parse");
+        g_app.message = "No response data received";
+        return;
+    }
+
+    // Validate response length isn't too large
+    if (g_app.response_length >= g_app.response_buffer.len) {
+        g_app.playdate.system.logToConsole("WARNING: Response length %d exceeds buffer size %d", @as(c_int, @intCast(g_app.response_length)), @as(c_int, @intCast(g_app.response_buffer.len)));
+        g_app.response_length = g_app.response_buffer.len - 1;
+    }
+
+    g_app.playdate.system.logToConsole("Starting JSON parsing of %d bytes", @as(c_int, @intCast(g_app.response_length)));
+
+    // Log first few characters for debugging
+    const preview_len = @min(100, g_app.response_length);
+    g_app.playdate.system.logToConsole("Response preview (first %d chars): %.*s", @as(c_int, @intCast(preview_len)), @as(c_int, @intCast(preview_len)), @as([*]const u8, @ptrCast(&g_app.response_buffer)));
+
+    // Reset post count before parsing
+    g_app.post_count = 0;
+
+    // Add error handling around JSON parsing
+    bsky_post.decodePostsJson(
+        g_app.playdate,
+        &g_app.response_buffer,
+        g_app.response_length,
+        g_app.posts.len,
+        &g_app.posts,
+        &g_app.post_count,
+        &g_app.cursor_buffer,
+        &g_app.cursor_len,
+    );
+
+    g_app.playdate.system.logToConsole("JSON parsing completed, found %d posts", @as(c_int, @intCast(g_app.post_count)));
+
+    if (g_app.post_count == 0) {
+        g_app.message = "No posts found in response";
+    } else {
+        g_app.message = "Feed loaded successfully";
+    }
+}
+
+fn onScrollMaxThreshold() void {
+    // Handle scroll max threshold being reached
+    g_app.playdate.system.logToConsole("Scroll max threshold reached");
+}
+
+fn onScrollMinThreshold() void {
+    // Handle scroll min threshold being reached
+    g_app.playdate.system.logToConsole("Scroll min threshold reached");
+
+    // Refresh posts.
+    g_app.playdate.system.logToConsole("Refreshing posts...");
+    fetchBlueskyFeed();
+}
+
+pub export fn eventHandler(playdate: *pdapi.PlaydateAPI, event: pdapi.PDSystemEvent, arg: u32) callconv(.C) c_int {
+    _ = arg;
+    switch (event) {
+        .EventInit => {
+            playdate.system.logToConsole("Initializing timeline fetch app...");
+
+            // Initialize panic handler for better error reporting
+            panic_handler.init(playdate);
+
+            // Test basic memory allocation to catch early issues
+            playdate.system.logToConsole("Testing basic memory allocation...");
+
+            playdate.system.logToConsole("Memory test passed - AppState size: %d bytes", @as(c_int, @intCast(@sizeOf(AppState))));
+
+            playdate.system.logToConsole("Initializing full application");
+
+            // Initialize full app state
+            g_app.playdate = playdate;
+
+            fonts.initializeFonts(playdate);
+
+            // Initialize keyboard
+            g_app.keyboard = keyboard_mod.Keyboard(256){
+                .playdate = playdate,
+                .font = fonts.g_font,
+                .title = undefined,
+                .editor_buffer = undefined,
+                .output_buffer = undefined,
+            };
+
+            g_app.message = "Use ← → to navigate, B to interact";
+            g_app.response_length = 0;
+            g_app.post_count = 0;
+            g_app.cursor_len = 0;
+            g_app.network_access_requested = false;
+
+            // Initialize scrolling value for posts with reasonable bounds
+            g_app.body_scroll = ScrollingValue{
+                .playdate = playdate,
+                .soft_min_runout = 100, // Static runout distance from min_value
+                .soft_max_runout = 100, // Static runout distance from max_value
+                .runout_margin = 5.0, // Margin before callback detection
+                .min_value = -200, // Allow scrolling above top with hard limit
+                .max_value = 2000, // Hard limit - will be updated based on content
+                .current_value = 0,
+                .current_height = 0,
+                .crank_position_offset = 0,
+                .onScrollMaxThreshold = &onScrollMaxThreshold,
+                .onScrollMinThreshold = &onScrollMinThreshold,
+            };
+            g_app.is_logged_in = false;
+            g_app.access_token_len = 0;
+            g_app.user_did_len = 0;
+            // Initialize login state with default credentials for testing
+            g_app.login_input_state = .ready; // Start ready since we have default credentials
+            g_app.login_field_selection = .username; // Start with username selected
+
+            // Initialize with empty credentials first
+            @memset(&g_app.username, 0);
+            @memset(&g_app.password, 0);
+
+            g_app.previous_buttons = 0;
+
+            // Initialize post composition state with default text
+            g_app.post_field_selection = .edit_text;
+            const default_post_text = "Hello World!\n\nPosted from my #playdate";
+            const default_len = @min(default_post_text.len, g_app.post_text.len - 1);
+            @memcpy(g_app.post_text[0..default_len], default_post_text[0..default_len]);
+            g_app.post_text[default_len] = 0;
+            g_app.post_text_len = default_len;
+
+            // Set up real update callback with full functionality
+            playdate.system.setUpdateCallback(update_and_render, null);
+            playdate.system.logToConsole("Update callback set");
+
+            playdate.system.logToConsole("App initialized successfully");
+
+            playdate.graphics.clear(@intFromEnum(pdapi.LCDSolidColor.ColorWhite));
+
+            // Try to load saved credentials
+            playdate.system.logToConsole("Attempting to load saved credentials...");
+            loadCredentials(playdate);
+            g_app.login_input_state = .ready;
+            playdate.system.logToConsole("Credentials loaded - Username: %s", &g_app.username);
+            g_app.message = "Saved credentials loaded";
+        },
+
+        else => {},
+    }
+    return 0;
+}
+
+fn loginToBluesky() void {
+    const pd = g_app.playdate;
+
+    // Check if we're already busy with a network operation
+    if (!network.isNetworkIdle()) {
+        return;
+    }
+
+    // Request network access
+    if (!g_app.network_access_requested) {
+        pd.system.logToConsole("Requesting network access for https://bsky.social...");
+        const response = pd.network.playdate_http.requestAccess("https://bsky.social", 443, true, "login", null, null);
+        g_app.network_access_requested = true;
+
+        switch (response) {
+            .AccessAllow => {
+                pd.system.logToConsole("Network access GRANTED");
+            },
+            .AccessDeny => {
+                pd.system.logToConsole("Network access DENIED by user");
+                g_app.message = "Network access denied";
+                return;
+            },
+            else => {
+                pd.system.logToConsole("Network access request FAILED");
+                g_app.message = "Access request failed";
+                return;
+            },
+        }
+    } else {
+        pd.system.logToConsole("Network access already requested");
+    }
+
+    // Check if we have credentials
+    if (g_app.username[0] == 0 or g_app.password[0] == 0) {
+        g_app.message = "Please enter username and password";
+        g_app.login_input_state = if (g_app.username[0] == 0) .username else .password;
+        return;
+    }
+
+    // Prepare login request body using entered credentials
+    var login_body: [512]u8 = undefined;
+    const username = std.mem.span(@as([*:0]const u8, @ptrCast(&g_app.username)));
+    const password = std.mem.span(@as([*:0]const u8, @ptrCast(&g_app.password)));
+
+    // Debug logging for credentials
+    pd.system.logToConsole("Login credentials - Username: %s", @as([*:0]const u8, @ptrCast(&g_app.username)));
+    pd.system.logToConsole("Login credentials - Password: %s", @as([*:0]const u8, @ptrCast(&g_app.password)));
+    const login_json = std.fmt.bufPrint(&login_body, "{{\"identifier\":\"{s}\",\"password\":\"{s}\"}}", .{ username, password }) catch {
+        g_app.message = "Failed to format login request";
+        return;
+    };
+
+    // Create HTTP request
+    const request = network.HttpRequest{
+        .method = .POST,
+        .url = "https://bsky.social/xrpc/com.atproto.server.createSession",
+        .server = "bsky.social",
+        .port = 443,
+        .path = "/xrpc/com.atproto.server.createSession",
+        .use_https = true,
+        .bearer_token = null,
+        .body = login_json,
+        .response_buffer = &g_app.response_buffer,
+        .success_callback = onLoginSuccess,
+        .failure_callback = onLoginFailure,
+    };
+
+    if (network.makeHttpRequest(pd, request)) {
+        g_app.message = "Logging in...";
+    } else {
+        g_app.message = "Network connection failed - check internet";
+        pd.system.logToConsole("Troubleshooting suggestions:");
+        pd.system.logToConsole("- Check internet connection");
+        pd.system.logToConsole("- Try in Playdate simulator vs device");
+        pd.system.logToConsole("- Check firewall settings");
+        pd.system.logToConsole("- Verify DNS resolution works");
+    }
+}
+
+fn fetchBlueskyFeed() void {
+    const pd = g_app.playdate;
+
+    // Check if logged in
+    if (!g_app.is_logged_in) {
+        g_app.message = "Please log in first";
+        return;
+    }
+
+    // Check if we're already busy with a network operation
+    if (!network.isNetworkIdle()) {
+        return;
+    }
+
+    // Reset state for refetch
+    g_app.post_count = 0;
+    g_app.body_scroll.setValue(0);
+
+    // Request network access only once
+    if (!g_app.network_access_requested) {
+        pd.system.logToConsole("Requesting network access...");
+        const response = pd.network.playdate_http.requestAccess("https://bsky.social", 443, true, "timeline", null, null);
+        g_app.network_access_requested = true;
+
+        switch (response) {
+            .AccessAllow => {},
+            .AccessDeny => {
+                g_app.message = "Network access denied";
+                return;
+            },
+            else => {
+                g_app.message = "Access request failed";
+                return;
+            },
+        }
+    }
+
+    // Create HTTP request with bearer token
+    const bearer_token = g_app.access_token[0..g_app.access_token_len];
+    const request = network.HttpRequest{
+        .method = .GET,
+        .url = "https://bsky.social/xrpc/app.bsky.feed.getTimeline?limit=50",
+        .server = "bsky.social",
+        .port = 443,
+        .path = "/xrpc/app.bsky.feed.getTimeline?limit=50",
+        .use_https = true,
+        .bearer_token = bearer_token,
+        .body = null,
+        .response_buffer = &g_app.response_buffer,
+        .success_callback = onFeedSuccess,
+        .failure_callback = onFeedFailure,
+    };
+
+    if (network.makeHttpRequest(pd, request)) {
+        g_app.message = "Fetching feed data...";
+    } else {
+        g_app.message = "Failed to start feed request";
+    }
+}
+
+// Login keyboard callbacks
+fn usernameKeyboardCancelled() void {
+    g_app.playdate.system.logToConsole("Username input cancelled");
+    g_app.login_input_state = .username; // Stay on username input
+}
+
+fn usernameKeyboardConfirmed(text: []const u8) void {
+    g_app.playdate.system.logToConsole("Username entered: %.*s", @as(c_int, @intCast(text.len)), @as([*c]const u8, @ptrCast(text.ptr)));
+
+    // Copy username
+    const copy_len = @min(text.len, g_app.username.len - 1);
+    @memcpy(g_app.username[0..copy_len], text[0..copy_len]);
+    g_app.username[copy_len] = 0;
+
+    saveCredentials(g_app.playdate);
+
+    // Move to password input
+    g_app.login_input_state = .password;
+}
+
+fn passwordKeyboardCancelled() void {
+    g_app.playdate.system.logToConsole("Password input cancelled");
+    g_app.login_input_state = .username; // Go back to username input
+}
+
+fn passwordKeyboardConfirmed(text: []const u8) void {
+    g_app.playdate.system.logToConsole("Password entered (length: %d)", @as(c_int, @intCast(text.len)));
+
+    // Copy password
+    const copy_len = @min(text.len, g_app.password.len - 1);
+    @memcpy(g_app.password[0..copy_len], text[0..copy_len]);
+    g_app.password[copy_len] = 0;
+
+    saveCredentials(g_app.playdate);
+
+    g_app.login_input_state = .ready;
+}
+
+// JSON writer context for building post JSON
+const JsonWriteContext = struct {
+    buffer: []u8,
+    pos: usize,
+};
+
+// JSON write callback for Playdate JSON encoder
+fn jsonWriteCallback(userdata: ?*anyopaque, str: [*c]const u8, len: c_int) callconv(.C) void {
+    if (userdata == null) return;
+    const context: *JsonWriteContext = @ptrCast(@alignCast(userdata.?));
+    const string_len = @as(usize, @intCast(len));
+
+    if (context.pos + string_len > context.buffer.len) return; // Buffer overflow protection
+
+    const src_slice = @as([*]const u8, @ptrCast(str))[0..string_len];
+    @memcpy(context.buffer[context.pos .. context.pos + string_len], src_slice);
+    context.pos += string_len;
+}
+
+fn submitBlueskyPost() void {
+    const pd = g_app.playdate;
+
+    // Check if logged in
+    if (!g_app.is_logged_in) {
+        g_app.message = "Please log in first";
+        return;
+    }
+
+    // Check if we have post content
+    if (g_app.post_text_len == 0) {
+        g_app.message = "Please enter post content first";
+        return;
+    }
+
+    // Check if we're already busy with a network operation
+    if (!network.isNetworkIdle()) {
+        return;
+    }
+
+    // Request network access if not already done
+    if (!g_app.network_access_requested) {
+        const response = pd.network.playdate_http.requestAccess("https://bsky.social", 443, true, "post", null, null);
+        g_app.network_access_requested = true;
+
+        switch (response) {
+            .AccessAllow => {},
+            .AccessDeny => {
+                g_app.message = "Network access denied";
+                return;
+            },
+            else => {
+                g_app.message = "Access request failed";
+                return;
+            },
+        }
+    }
+
+    // Get current timestamp in ISO 8601 format using accurate Playdate API
+    const seconds_since_2000 = pd.system.getSecondsSinceEpoch(null);
+
+    // Convert to PDDateTime for formatting
+    var datetime: pdapi.PDDateTime = undefined;
+    pd.system.convertEpochToDateTime(seconds_since_2000, &datetime);
+
+    // Format as ISO 8601 using the utility function
+    const timestamp = pdtools.datetimeToISO(datetime);
+
+    // Check if we have user DID
+    if (g_app.user_did_len == 0) {
+        g_app.message = "Missing user DID - please re-login";
+        return;
+    }
+
+    // Prepare post request body using Playdate JSON encoder
+    var post_body: [1024]u8 = undefined;
+    var json_context = JsonWriteContext{ .buffer = &post_body, .pos = 0 };
+
+    var encoder: pdapi.JSONEncoder = undefined;
+    pd.json.initEncoder(&encoder, jsonWriteCallback, &json_context, 0);
+
+    const post_text = g_app.post_text[0..g_app.post_text_len];
+    const user_did = g_app.user_did[0..g_app.user_did_len];
+
+    // Build JSON: {"repo":"...", "collection":"...", "record":{"text":"...", "createdAt":"..."}}
+    encoder.startTable(&encoder);
+
+    // Add repo field
+    encoder.addTableMember(&encoder, "repo", 4);
+    encoder.writeString(&encoder, @as([*c]const u8, @ptrCast(user_did.ptr)), @as(c_int, @intCast(user_did.len)));
+
+    // Add collection field
+    encoder.addTableMember(&encoder, "collection", 10);
+    encoder.writeString(&encoder, "app.bsky.feed.post", 18);
+
+    // Add record field
+    encoder.addTableMember(&encoder, "record", 6);
+    encoder.startTable(&encoder);
+
+    // Add text field to record
+    encoder.addTableMember(&encoder, "text", 4);
+    encoder.writeString(&encoder, @as([*c]const u8, @ptrCast(post_text.ptr)), @as(c_int, @intCast(post_text.len)));
+
+    // Add createdAt field to record
+    encoder.addTableMember(&encoder, "createdAt", 9);
+    encoder.writeString(&encoder, @as([*c]const u8, @ptrCast(timestamp.ptr)), @as(c_int, @intCast(timestamp.len)));
+
+    encoder.endTable(&encoder); // End record
+    encoder.endTable(&encoder); // End root
+
+    const post_json = post_body[0..json_context.pos];
+
+    // Log json
+    pdtools.logLargeMessage(pd, post_json, post_json.len);
+
+    // Create HTTP request
+    if (defs.DEBUG_DONT_POST) {
+        g_app.message = "Debug mode - not posting";
+        return;
+    }
+
+    const bearer_token = g_app.access_token[0..g_app.access_token_len];
+    const request = network.HttpRequest{
+        .method = .POST,
+        .url = "https://bsky.social/xrpc/com.atproto.repo.createRecord",
+        .server = "bsky.social",
+        .port = 443,
+        .path = "/xrpc/com.atproto.repo.createRecord",
+        .use_https = true,
+        .bearer_token = bearer_token,
+        .body = post_json,
+        .response_buffer = &g_app.response_buffer,
+        .success_callback = onPostSuccess,
+        .failure_callback = onPostFailure,
+    };
+
+    if (network.makeHttpRequest(pd, request)) {
+        g_app.message = "Posting...";
+    } else {
+        g_app.message = "Failed to start post request";
+    }
+}
+
+// Post keyboard callbacks
+fn postKeyboardCancelled() void {
+    g_app.playdate.system.logToConsole("Post input cancelled");
+    // Stay on post page, don't change anything
+}
+
+// New callback for text editing that doesn't auto-submit
+fn postTextEditConfirmed(text: []const u8) void {
+    g_app.playdate.system.logToConsole("Post text edited (length: %d)", @as(c_int, @intCast(text.len)));
+
+    // Copy post text but don't submit automatically
+    const copy_len = @min(text.len, g_app.post_text.len - 1);
+    @memcpy(g_app.post_text[0..copy_len], text[0..copy_len]);
+    g_app.post_text[copy_len] = 0;
+    g_app.post_text_len = copy_len;
+
+    g_app.message = "Post text updated - use confirm button to post";
+}
+
+fn update_and_render(userdata: ?*anyopaque) callconv(.C) c_int {
+    _ = userdata; // Ignore userdata, use global state
+
+    // Safety check - ensure app is initialized
+    const pd = g_app.playdate;
+
+    // Update network processing
+    network.updateNetwork(pd);
+
+    if (g_app.keyboard.updateAndRender()) {
+        return 1;
+    }
+
+    // Handle button input
+    var current: pdapi.PDButtons = undefined;
+    var pushed: pdapi.PDButtons = undefined;
+    var released: pdapi.PDButtons = undefined;
+    pd.system.getButtonState(&current, &pushed, &released);
+
+    // Handle keyboard input first if keyboard is active
+
+    // Handle up/down navigation for login field selection
+    if (g_selected_page == .login and !g_app.is_logged_in) {
+        if (pushed & pdapi.BUTTON_UP != 0) {
+            g_app.login_field_selection = switch (g_app.login_field_selection) {
+                .username => .login_button,
+                .password => .username,
+                .login_button => .password,
+            };
+        } else if (pushed & pdapi.BUTTON_DOWN != 0) {
+            g_app.login_field_selection = switch (g_app.login_field_selection) {
+                .username => .password,
+                .password => .login_button,
+                .login_button => .username,
+            };
+        }
+    }
+
+    // Handle up/down navigation for post field selection
+    if (g_selected_page == .post and g_app.is_logged_in) {
+        if (pushed & pdapi.BUTTON_UP != 0) {
+            g_app.post_field_selection = switch (g_app.post_field_selection) {
+                .edit_text => .confirm_post,
+                .confirm_post => .edit_text,
+            };
+        } else if (pushed & pdapi.BUTTON_DOWN != 0) {
+            g_app.post_field_selection = switch (g_app.post_field_selection) {
+                .edit_text => .confirm_post,
+                .confirm_post => .edit_text,
+            };
+        }
+    }
+
+    // Check if left/right was pressed to change page selection
+    if (pushed & pdapi.BUTTON_LEFT != 0) {
+        g_selected_page = switch (g_selected_page) {
+            .login => if (g_app.is_logged_in) .post else .login,
+            .home => .login,
+            .post => .home,
+        };
+    } else if (pushed & pdapi.BUTTON_RIGHT != 0) {
+        g_selected_page = switch (g_selected_page) {
+            .login => if (g_app.is_logged_in) .home else .login,
+            .home => if (g_app.is_logged_in) .post else .login,
+            .post => .login,
+        };
+    }
+
+    // Check if B button was pushed (only if keyboard not active)
+    if (pushed & pdapi.BUTTON_B != 0) {
+        if (g_selected_page == .login and !g_app.is_logged_in) {
+            // Handle login input based on selected field
+            switch (g_app.login_field_selection) {
+                .username => {
+                    // Start username input
+                    const initial_text = if (g_app.username[0] != 0) std.mem.span(@as([*:0]const u8, @ptrCast(&g_app.username))) else null;
+                    g_app.keyboard.start(
+                        "Enter username:",
+                        g_app.username.len,
+                        initial_text,
+                        false,
+                        1,
+                        usernameKeyboardCancelled,
+                        usernameKeyboardConfirmed,
+                    );
+                },
+                .password => {
+                    // Start password input
+                    const initial_text = if (g_app.password[0] != 0) std.mem.span(@as([*:0]const u8, @ptrCast(&g_app.password))) else null;
+                    g_app.keyboard.start(
+                        "Enter password:",
+                        g_app.password.len,
+                        initial_text,
+                        false,
+                        1,
+                        passwordKeyboardCancelled,
+                        passwordKeyboardConfirmed,
+                    );
+                },
+                .login_button => {
+                    // Check if we can login
+                    if (g_app.username[0] > 0 and g_app.password[0] > 0) {
+                        loginToBluesky();
+                    } else {
+                        g_app.message = "Please enter username and password";
+                    }
+                },
+            }
+        } else if (g_selected_page == .home) {
+            fetchBlueskyFeed();
+        } else if (g_selected_page == .post) {
+            // Check if user is logged in before allowing post creation
+            if (!g_app.is_logged_in) {
+                g_app.message = "Please log in first to create posts";
+                g_selected_page = .login;
+            } else {
+                // Handle post field selection
+                switch (g_app.post_field_selection) {
+                    .edit_text => {
+                        // Start post composition with keyboard (multiline enabled)
+                        const initial_text = if (g_app.post_text_len > 0) g_app.post_text[0..g_app.post_text_len] else null;
+                        g_app.keyboard.start("Enter your post:", 300, initial_text, true, 5, postKeyboardCancelled, postTextEditConfirmed);
+                    },
+                    .confirm_post => {
+                        // Submit the post directly
+                        if (g_app.post_text_len > 0) {
+                            submitBlueskyPost();
+                        } else {
+                            g_app.message = "Please enter some text first";
+                        }
+                    },
+                }
+            }
+        }
+    }
+
+    // Render keyboard if active, otherwise render the selected page
+    switch (g_selected_page) {
+        .login => render_login(0, 20, LCD_WIDTH, LCD_HEIGHT - 20),
+        .home => render_home(0, 20, LCD_WIDTH, LCD_HEIGHT - 20),
+        .post => render_create_post(0, 20, LCD_WIDTH, LCD_HEIGHT - 20),
+    }
+    render_header(0, 0, LCD_WIDTH);
+
+    return 1;
+}
+
+fn render_header(x: c_int, y: c_int, w: c_int) void {
+    const pd = g_app.playdate;
+
+    const header_height = pd.graphics.getFontHeight(fonts.g_font) + MARGIN * 2;
+
+    // Draw header background
+    pd.graphics.fillRect(
+        x,
+        y,
+        w + MARGIN * 2,
+        header_height,
+        @intFromEnum(pdapi.LCDSolidColor.ColorBlack),
+    );
+
+    // Set draw mode for white text on black background
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeFillWhite);
+
+    // Draw header text
+    const header_text = "Bluesky";
+    _ = pd.graphics.drawText(
+        header_text.ptr,
+        header_text.len,
+        pdapi.PDStringEncoding.UTF8Encoding,
+        x + MARGIN,
+        y + MARGIN,
+    );
+
+    const text_width = pd.graphics.getTextWidth(
+        fonts.g_font,
+        header_text.ptr,
+        header_text.len,
+        pdapi.PDStringEncoding.UTF8Encoding,
+        0,
+    );
+
+    // spinning loading indicator.
+    // Spinning loading indicator based on network state
+    const current_network_state = network.getNetworkState();
+    if (current_network_state == .connecting or current_network_state == .requesting) {
+        pdtools.renderSpinner(pd, x + w - 20, y + 2, pdapi.LCDSolidColor.ColorWhite);
+    }
+
+    // Reset draw mode to normal
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+
+    // Show all available pages
+    var temp_w: c_int = 0;
+    var curr_x = text_width + x + MARGIN * 2;
+
+    // Login button (always available)
+    pdtools.renderButton(
+        pd,
+        curr_x,
+        y,
+        "Login",
+        g_selected_page == .login,
+        &temp_w,
+        null,
+    );
+
+    if (g_app.is_logged_in) {
+        curr_x += temp_w;
+        pdtools.renderButton(
+            pd,
+            curr_x,
+            y,
+            "Home",
+            g_selected_page == .home,
+            &temp_w,
+            null,
+        );
+
+        curr_x += temp_w;
+        pdtools.renderButton(
+            pd,
+            curr_x,
+            y,
+            "Post",
+            g_selected_page == .post,
+            null,
+            null,
+        );
+    }
+}
+
+fn render_post_list(x: c_int, y: c_int, w: c_int, h: c_int) void {
+    const scrollbar_width = 10;
+    const post_gap = 4;
+    const padding = 4;
+    const pd = g_app.playdate;
+
+    // Clip the whole thing so we don't go out of bounds
+    pd.graphics.setClipRect(x, y, w, h);
+
+    const posts_width = w - scrollbar_width - (padding * 2);
+
+    const start_y = @as(c_int, @intFromFloat(@as(f32, @floatFromInt(y)) - g_app.body_scroll.getValue()));
+    var current_y = start_y + padding;
+    const current_x = x + padding;
+
+    // Now render each post with actual positions
+    for (0..g_app.post_count) |i| {
+        const post = &g_app.posts[i];
+        const post_height = bsky_post.renderPost(
+            pd,
+            post,
+            current_x,
+            current_y,
+            posts_width,
+            false,
+        );
+        current_y += @as(c_int, @intCast(post_height));
+        current_y += post_gap;
+    }
+    current_y += padding;
+
+    // current_y is the scrolled position, so we need to add back the scroll offset to get true content height
+    const content_height = current_y - start_y;
+
+    g_app.body_scroll.current_height = @as(f32, @floatFromInt(h));
+    g_app.body_scroll.min_value = 0;
+    g_app.body_scroll.max_value = @floatFromInt(content_height);
+
+    // Render scrollbar on the right side (below header, taking remaining height)
+    const scrollbar_x = pdapi.LCD_COLUMNS - scrollbar_width;
+    pdtools.renderScrollbar(
+        pd,
+        scrollbar_x,
+        y,
+        scrollbar_width,
+        h,
+        g_app.body_scroll.getValue(),
+        @as(f32, @floatFromInt(content_height)),
+        @as(f32, @floatFromInt(h)),
+    );
+
+    pd.graphics.clearClipRect();
+}
+
+fn render_home(x: i32, y: i32, w: usize, h: usize) void {
+    const pd = g_app.playdate;
+
+    // #region Body
+
+    // Update scrolling value with crank input
+    g_app.body_scroll.update();
+
+    pd.graphics.fillRect(
+        @intCast(x),
+        @intCast(y),
+        @intCast(w),
+        @intCast(h),
+        @intFromEnum(pdapi.LCDSolidColor.ColorWhite),
+    );
+
+    // Set draw mode for black text on white background
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeFillBlack);
+
+    // Show login prompt if not logged in
+    if (!g_app.is_logged_in) {
+        _ = pd.graphics.drawText("Please log in first", 19, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, y + MARGIN);
+        pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+        return;
+    }
+
+    // Get current network state
+    const current_network_state = network.getNetworkState();
+
+    // Show loading progress if network is active
+    if (current_network_state == .connecting or current_network_state == .requesting) {
+        const progress_msg = "Loading feed...";
+        _ = pd.graphics.drawText(progress_msg.ptr, progress_msg.len, pdapi.PDStringEncoding.UTF8Encoding, x, y);
+
+        // Reset draw mode to normal
+        pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+        return;
+    }
+
+    // If we have parsed posts, display them formatted
+    if (g_app.post_count > 0) {
+        render_post_list(@intCast(x), @intCast(y), @intCast(w), @intCast(h));
+    } else if (current_network_state == .success or current_network_state == .idle) {
+        // Show message when no posts are available
+        const no_posts_msg = "No posts found - Press B to refresh";
+        _ = pd.graphics.drawText(no_posts_msg.ptr, no_posts_msg.len, pdapi.PDStringEncoding.UTF8Encoding, x, y);
+    } else {
+        // Show current status message
+        _ = pd.graphics.drawText(g_app.message.ptr, g_app.message.len, pdapi.PDStringEncoding.UTF8Encoding, x, y);
+    }
+
+    // Reset draw mode to normal
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+}
+
+fn render_login(x: c_int, y: c_int, w: c_int, h: c_int) void {
+    const pd = g_app.playdate;
+
+    pd.graphics.fillRect(x, y, w, h, @intFromEnum(pdapi.LCDSolidColor.ColorWhite));
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeFillBlack);
+
+    const line_height = pd.graphics.getFontHeight(fonts.g_font) + 4;
+    var current_y = y + MARGIN;
+
+    const current_network_state = network.getNetworkState();
+
+    if (current_network_state == .requesting or current_network_state == .connecting) {
+        _ = pd.graphics.drawText("Logging in...", 12, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+    } else if (current_network_state == .network_error) {
+        _ = pd.graphics.drawText("Login failed!", 13, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height;
+        _ = pd.graphics.drawText("Press B to retry", 16, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+    } else {
+        _ = pd.graphics.drawText("Welcome to Bluesky!", 20, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height * 2;
+
+        // Show current username with selection indicator
+        var username_text: [200]u8 = undefined;
+        const username_prefix = if (g_app.login_field_selection == .username) pdtools.SELECTION_ARROW ++ " Username: " else "  Username: ";
+        const username_value = if (g_app.username[0] != 0) std.mem.span(@as([*:0]const u8, @ptrCast(&g_app.username))) else "(not entered)";
+        const username_display = std.fmt.bufPrint(&username_text, "{s}{s}", .{ username_prefix, username_value }) catch "Username: (error)";
+        _ = pd.graphics.drawText(username_display.ptr, username_display.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height;
+
+        // Show password status with selection indicator
+        const password_prefix = if (g_app.login_field_selection == .password) pdtools.SELECTION_ARROW ++ " Password: " else "  Password: ";
+        var password_text: [200]u8 = undefined;
+        const password_display = if (g_app.password[0] != 0) blk: {
+            // Generate dots based on actual password length using safe ASCII dots
+            var dots_buffer: [64]u8 = undefined;
+            const password_span = std.mem.span(@as([*:0]const u8, @ptrCast(&g_app.password)));
+            const dots_len = @min(password_span.len, dots_buffer.len);
+            @memset(dots_buffer[0..dots_len], '*');
+            const dots_str = dots_buffer[0..dots_len];
+            break :blk std.fmt.bufPrint(&password_text, "{s}{s}", .{ password_prefix, dots_str }) catch "Password: (error)";
+        } else std.fmt.bufPrint(&password_text, "{s}(not entered)", .{password_prefix}) catch "Password: (error)";
+        _ = pd.graphics.drawText(password_display.ptr, password_display.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height;
+
+        // Show login button with selection indicator
+        const login_prefix = if (g_app.login_field_selection == .login_button) pdtools.SELECTION_ARROW ++ " " else "  ";
+        const login_text = if (g_app.username[0] != 0 and g_app.password[0] != 0) "Login" else "Login (enter credentials first)";
+        var login_button_text: [200]u8 = undefined;
+        const login_display = std.fmt.bufPrint(&login_button_text, "{s}{s}", .{ login_prefix, login_text }) catch "Login";
+        _ = pd.graphics.drawText(login_display.ptr, login_display.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height * 2;
+
+        // Show navigation instructions
+        const instruction = pdtools.UP_ARROW_EMOJI ++ pdtools.DOWN_ARROW_EMOJI ++ ": Select field  B: Edit/Login";
+        _ = pd.graphics.drawText(instruction.ptr, instruction.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height;
+    }
+
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+}
+
+fn render_create_post(x: c_int, y: c_int, w: c_int, h: c_int) void {
+    const pd = g_app.playdate;
+
+    pd.graphics.fillRect(x, y, w, h, @intFromEnum(pdapi.LCDSolidColor.ColorWhite));
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeFillBlack);
+
+    const line_height = pd.graphics.getFontHeight(fonts.g_font) + 4;
+    var current_y = y + MARGIN;
+
+    // Check if user is logged in
+    if (!g_app.is_logged_in) {
+        _ = pd.graphics.drawText("Please log in first to create posts", 34, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+        return;
+    }
+
+    // Post composition page
+    _ = pd.graphics.drawText("Create a Post", 13, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+    current_y += line_height;
+
+    // Show character count
+    var char_count_text: [50]u8 = undefined;
+    const char_count_display = std.fmt.bufPrint(&char_count_text, "Characters: {d}/300", .{g_app.post_text_len}) catch "Characters: 0/300";
+    _ = pd.graphics.drawText(char_count_display.ptr, char_count_display.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+    current_y += line_height;
+
+    // Show current post text if any
+    if (g_app.post_text_len > 0) {
+        _ = pd.graphics.drawText("Current post:", 13, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height;
+
+        // Draw a border around the post text area
+        const text_area_height = line_height * 6; // Space for multiple lines
+        pd.graphics.drawRect(x + MARGIN, current_y, w - MARGIN * 2, text_area_height, @intFromEnum(pdapi.LCDSolidColor.ColorBlack));
+
+        // Render multiline post text
+        const post_text = g_app.post_text[0..g_app.post_text_len];
+        var text_y = current_y + 4;
+        var line_start: usize = 0;
+        var displayed_lines: usize = 0;
+        const max_lines = 5;
+
+        for (post_text, 0..) |char, i| {
+            if (char == '\n' or i == post_text.len - 1) {
+                if (displayed_lines >= max_lines) break;
+
+                const line_end = if (char == '\n') i else i + 1;
+                const line_text = post_text[line_start..line_end];
+
+                _ = pd.graphics.drawText(line_text.ptr, line_text.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN + 4, text_y);
+                text_y += line_height;
+                displayed_lines += 1;
+                line_start = i + 1;
+            }
+        }
+
+        // If no newlines, display as single line
+        if (displayed_lines == 0) {
+            _ = pd.graphics.drawText(post_text.ptr, post_text.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN + 4, current_y + 4);
+        }
+
+        current_y += text_area_height + line_height;
+    } else {
+        current_y += line_height * 2;
+        _ = pd.graphics.drawText("No post drafted yet", 19, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+        current_y += line_height * 2;
+    }
+
+    // Show field selection options
+    const edit_prefix = if (g_app.post_field_selection == .edit_text) pdtools.SELECTION_ARROW ++ " " else "  ";
+    var edit_text: [100]u8 = undefined;
+    const edit_display = std.fmt.bufPrint(&edit_text, "{s}Edit Post Text", .{edit_prefix}) catch "Edit Post Text";
+    _ = pd.graphics.drawText(edit_display.ptr, edit_display.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+    current_y += line_height;
+
+    const confirm_prefix = if (g_app.post_field_selection == .confirm_post) pdtools.SELECTION_ARROW ++ " " else "  ";
+    var confirm_text: [100]u8 = undefined;
+    const confirm_display = std.fmt.bufPrint(&confirm_text, "{s}Confirm & Post", .{confirm_prefix}) catch "Confirm & Post";
+    _ = pd.graphics.drawText(confirm_display.ptr, confirm_display.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+    current_y += line_height * 2;
+
+    // Show navigation instructions
+    const instruction = pdtools.UP_ARROW_EMOJI ++ pdtools.DOWN_ARROW_EMOJI ++ ": Select action  B: Execute  " ++ pdtools.LEFT_ARROW_EMOJI ++ pdtools.RIGHT_ARROW_EMOJI ++ ": Navigate tabs";
+    _ = pd.graphics.drawText(instruction.ptr, instruction.len, pdapi.PDStringEncoding.UTF8Encoding, x + MARGIN, current_y);
+
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+}

src/network.zig

···
+const std = @import("std");
+const pdapi = @import("playdate_api_definitions.zig");
+
+pub const NetworkState = enum {
+    idle,
+    connecting,
+    authenticating,
+    requesting,
+    fetching_posts,
+    success,
+    network_error,
+};
+
+// HTTP method types
+pub const HttpMethod = enum {
+    GET,
+    POST,
+    PUT,
+    DELETE,
+    PATCH,
+};
+
+// HTTP status code ranges
+pub const HttpStatusCode = u16;
+
+// Callback function types
+pub const SuccessCallback = *const fn (status_code: HttpStatusCode, response_data: []const u8) void;
+pub const FailureCallback = *const fn (status_code: HttpStatusCode, error_message: []const u8) void;
+
+// Request configuration
+pub const HttpRequest = struct {
+    method: HttpMethod,
+    url: []const u8,
+    server: []const u8,
+    port: u16,
+    path: []const u8,
+    use_https: bool,
+    bearer_token: ?[]const u8,
+    body: ?[]const u8,
+    response_buffer: []u8,
+    success_callback: ?SuccessCallback,
+    failure_callback: ?FailureCallback,
+};
+
+// Network request state
+pub const NetworkRequestState = struct {
+    state: NetworkState,
+    connection: ?*pdapi.HTTPConnection,
+    request: ?HttpRequest,
+    bytes_read: usize,
+    is_reading_chunks: bool,
+    total_bytes_read: usize,
+    expected_content_length: usize,
+    network_access_requested: bool,
+};
+
+// Global network state
+var g_network_state = NetworkRequestState{
+    .state = .idle,
+    .connection = null,
+    .request = null,
+    .bytes_read = 0,
+    .is_reading_chunks = false,
+    .total_bytes_read = 0,
+    .expected_content_length = 0,
+    .network_access_requested = false,
+};
+
+// Global buffers to avoid large stack allocations
+var g_headers_buffer: [512]u8 = undefined;
+
+/// Convert HttpMethod enum to string
+fn httpMethodToString(method: HttpMethod) []const u8 {
+    return switch (method) {
+        .GET => "GET",
+        .POST => "POST",
+        .PUT => "PUT",
+        .DELETE => "DELETE",
+        .PATCH => "PATCH",
+    };
+}
+
+/// Create HTTP connection with proper configuration
+pub fn createConnection(playdate: *pdapi.PlaydateAPI, server: []const u8, port: u16, use_https: bool) ?*pdapi.HTTPConnection {
+    // Create a null-terminated buffer for the server name
+    var server_buffer: [256]u8 = undefined;
+    if (server.len >= server_buffer.len) {
+        playdate.system.logToConsole("ERROR: Server name too long: %d", @as(c_int, @intCast(server.len)));
+        return null;
+    }
+    @memcpy(server_buffer[0..server.len], server);
+    server_buffer[server.len] = 0;
+
+    playdate.system.logToConsole("Attempting to create connection to %s:%d", @as([*:0]const u8, @ptrCast(&server_buffer)), port);
+    if (use_https) {
+        playdate.system.logToConsole("Using HTTPS connection");
+    } else {
+        playdate.system.logToConsole("Using HTTP connection");
+    }
+    const connection = playdate.network.playdate_http.newConnection(@as([*:0]const u8, @ptrCast(&server_buffer)), port, use_https);
+
+    // Set connection timeout - increase to 30 seconds for more reliability
+    playdate.network.playdate_http.setConnectTimeout(connection, 30000); // 30 seconds
+    playdate.network.playdate_http.setReadTimeout(connection, 30000); // 30 seconds
+    playdate.system.logToConsole("HTTP connection created with 30s timeouts");
+
+    return connection;
+}
+
+/// Start an HTTP request with optional bearer token
+pub fn makeHttpRequest(playdate: *pdapi.PlaydateAPI, request: HttpRequest) bool {
+    // Check if already processing a request
+    if (g_network_state.state != .idle) {
+        playdate.system.logToConsole("ERROR: Network request already in progress");
+        return false;
+    }
+
+    // Create connection
+    const connection = createConnection(playdate, request.server, request.port, request.use_https);
+    if (connection == null) {
+        return false;
+    }
+
+    // Store request info
+    g_network_state.connection = connection;
+    g_network_state.request = request;
+    g_network_state.state = .connecting;
+    g_network_state.bytes_read = 0;
+    g_network_state.total_bytes_read = 0;
+    g_network_state.is_reading_chunks = false;
+
+    // Build headers
+    var headers_len: usize = 0;
+
+    // Add Authorization header if bearer token provided
+    if (request.bearer_token) |token| {
+        const auth_header = std.fmt.bufPrint(g_headers_buffer[headers_len..], "Authorization: Bearer {s}\r\n", .{token}) catch {
+            playdate.system.logToConsole("ERROR: Failed to format authorization header");
+            return false;
+        };
+        headers_len += auth_header.len;
+    }
+
+    // Add Content-Type header for POST/PUT/PATCH requests
+    if (request.method == .POST or request.method == .PUT or request.method == .PATCH) {
+        const content_type = std.fmt.bufPrint(g_headers_buffer[headers_len..], "Content-Type: application/json\r\n", .{}) catch {
+            playdate.system.logToConsole("ERROR: Failed to format content-type header");
+            return false;
+        };
+        headers_len += content_type.len;
+    }
+
+    // Null terminate headers
+    if (headers_len < g_headers_buffer.len) {
+        g_headers_buffer[headers_len] = 0;
+    }
+
+    // Send request using query method
+    const method_str = httpMethodToString(request.method);
+    const headers_ptr = if (headers_len > 0) @as([*:0]const u8, @ptrCast(&g_headers_buffer)) else null;
+    const body_ptr = if (request.body) |body| @as([*:0]const u8, @ptrCast(body.ptr)) else null;
+    const body_len = if (request.body) |body| body.len else 0;
+
+    const result = playdate.network.playdate_http.query(connection, @as([*:0]const u8, @ptrCast(method_str.ptr)), @as([*:0]const u8, @ptrCast(request.path.ptr)), headers_ptr, if (headers_len > 0) headers_len else 0, body_ptr, body_len);
+
+    if (result != .NET_OK) {
+        playdate.system.logToConsole("ERROR: Failed to send HTTP request");
+        g_network_state.state = .network_error;
+        return false;
+    }
+
+    g_network_state.state = .requesting;
+    playdate.system.logToConsole("HTTP %s request sent to %s%s", @as([*:0]const u8, @ptrCast(method_str.ptr)), @as([*:0]const u8, @ptrCast(request.server.ptr)), @as([*:0]const u8, @ptrCast(request.path.ptr)));
+
+    return true;
+}
+
+/// Process network responses and handle callbacks
+pub fn updateNetwork(playdate: *pdapi.PlaydateAPI) void {
+    if (g_network_state.state == .idle or g_network_state.connection == null) {
+        return;
+    }
+
+    const connection = g_network_state.connection.?;
+    _ = g_network_state.request.?;
+
+    // Check for errors
+    const net_error = playdate.network.playdate_http.getError(connection);
+    if (net_error != .NET_OK) {
+        playdate.system.logToConsole("ERROR: HTTP network error: %d", @intFromEnum(net_error));
+        handleNetworkError(playdate, "Network error");
+        return;
+    }
+
+    // Read available data if we're in requesting state
+    if (g_network_state.state == .requesting) {
+        const bytes_available = playdate.network.playdate_http.getBytesAvailable(connection);
+        if (bytes_available > 0) {
+            readResponseData(playdate);
+        } else {
+            // Check if request is complete by trying to get response status
+            const status_code = playdate.network.playdate_http.getResponseStatus(connection);
+            if (status_code > 0) {
+                // We have a response, process it
+                processResponse(playdate);
+            }
+        }
+    }
+}
+
+/// Read response data into the provided buffer
+fn readResponseData(playdate: *pdapi.PlaydateAPI) void {
+    const connection = g_network_state.connection.?;
+    const request = g_network_state.request.?;
+    const available_space = request.response_buffer.len - g_network_state.bytes_read;
+
+    if (available_space == 0) {
+        playdate.system.logToConsole("WARNING: Response buffer full, stopping read");
+        processResponse(playdate);
+        return;
+    }
+
+    const bytes_to_read = @min(available_space, 1024); // Read in chunks of 1KB or less
+    const buffer_ptr = request.response_buffer[g_network_state.bytes_read .. g_network_state.bytes_read + bytes_to_read];
+
+    const bytes_read = playdate.network.playdate_http.read(connection, @as([*]u8, @ptrCast(buffer_ptr.ptr)), @intCast(bytes_to_read));
+
+    if (bytes_read > 0) {
+        g_network_state.bytes_read += @intCast(bytes_read);
+        g_network_state.total_bytes_read += @intCast(bytes_read);
+        playdate.system.logToConsole("Read %d bytes, total: %d", bytes_read, g_network_state.total_bytes_read);
+    }
+}
+
+/// Process the completed response and call appropriate callback
+fn processResponse(playdate: *pdapi.PlaydateAPI) void {
+    const connection = g_network_state.connection.?;
+    const request = g_network_state.request.?;
+
+    // Get HTTP status code
+    const status_code = playdate.network.playdate_http.getResponseStatus(connection);
+    playdate.system.logToConsole("HTTP response status: %d", status_code);
+
+    // Null-terminate response data
+    if (g_network_state.bytes_read < request.response_buffer.len) {
+        request.response_buffer[g_network_state.bytes_read] = 0;
+    }
+
+    const response_data = request.response_buffer[0..g_network_state.bytes_read];
+
+    // Determine if this is a success (2xx) or failure (4xx/5xx)
+    if (status_code >= 200 and status_code < 300) {
+        // Success (2xx)
+        g_network_state.state = .success;
+        if (request.success_callback) |callback| {
+            callback(@intCast(status_code), response_data);
+        }
+    } else if (status_code >= 400) {
+        // Client/Server error (4xx/5xx)
+        g_network_state.state = .network_error;
+        if (request.failure_callback) |callback| {
+            callback(@intCast(status_code), response_data);
+        }
+    } else {
+        // Other status codes (1xx, 3xx) - treat as success for now
+        g_network_state.state = .success;
+        if (request.success_callback) |callback| {
+            callback(@intCast(status_code), response_data);
+        }
+    }
+
+    // Cleanup
+    cleanup(playdate);
+}
+
+/// Handle network errors
+fn handleNetworkError(playdate: *pdapi.PlaydateAPI, error_message: []const u8) void {
+    g_network_state.state = .network_error;
+
+    if (g_network_state.request) |request| {
+        if (request.failure_callback) |callback| {
+            callback(0, error_message); // Status code 0 indicates network error
+        }
+    }
+
+    cleanup(playdate);
+}
+
+/// Clean up network resources
+fn cleanup(playdate: *pdapi.PlaydateAPI) void {
+    if (g_network_state.connection) |connection| {
+        playdate.network.playdate_http.close(connection);
+        g_network_state.connection = null;
+    }
+
+    g_network_state.request = null;
+    g_network_state.bytes_read = 0;
+    g_network_state.total_bytes_read = 0;
+    g_network_state.is_reading_chunks = false;
+    g_network_state.state = .idle;
+}
+
+/// Get current network state
+pub fn getNetworkState() NetworkState {
+    return g_network_state.state;
+}
+
+/// Check if network is idle
+pub fn isNetworkIdle() bool {
+    return g_network_state.state == .idle;
+}
+
+/// Force cleanup network resources
+pub fn forceCleanup(playdate: *pdapi.PlaydateAPI) void {
+    cleanup(playdate);
+}

src/panic_handler.zig

···
+const std = @import("std");
+const pdapi = @import("playdate_api_definitions.zig");
+const builtin = @import("builtin");
+
+var global_playdate: *pdapi.PlaydateAPI = undefined;
+pub fn init(playdate: *pdapi.PlaydateAPI) void {
+    global_playdate = playdate;
+}
+
+pub fn panic(
+    msg: []const u8,
+    error_return_trace: ?*std.builtin.StackTrace,
+    return_address: ?usize,
+) noreturn {
+    _ = error_return_trace;
+    _ = return_address;
+
+    switch (comptime builtin.os.tag) {
+        .freestanding => {
+            //Playdate hardware
+
+            //TODO: The Zig std library does not yet support stacktraces on Playdate hardware.
+            //We will need to do this manually. Some notes on trying to get it working:
+            //Frame pointer is R7
+            //Next Frame pointer is *R7
+            //Return address is *(R7+4)
+            //To print out the trace corrently,
+            //We need to know the load address and it doesn't seem to be exactly
+            //0x6000_0000 as originally thought
+
+            global_playdate.system.logToConsole("PANIC: %s", msg.ptr);
+            global_playdate.system.@"error"("PANIC: %s", msg.ptr);
+        },
+        else => {
+            //playdate simulator
+            var stack_trace_buffer = [_]u8{0} ** 4096;
+            var buffer = [_]u8{0} ** 4096;
+            var stream = std.io.fixedBufferStream(&stack_trace_buffer);
+
+            const stack_trace_string = b: {
+                if (builtin.strip_debug_info) {
+                    break :b "Unable to dump stack trace: Debug info stripped";
+                }
+                const debug_info = std.debug.getSelfDebugInfo() catch |err| {
+                    const to_print = std.fmt.bufPrintZ(
+                        &buffer,
+                        "Unable to dump stack trace: Unable to open debug info: {s}\n",
+                        .{@errorName(err)},
+                    ) catch break :b "Unable to dump stack trace: Unable to open debug info due unknown error";
+                    break :b to_print;
+                };
+                std.debug.writeCurrentStackTrace(
+                    stream.writer(),
+                    debug_info,
+                    .no_color,
+                    null,
+                ) catch break :b "Unable to dump stack trace: Unknown error writng stack trace";
+
+                //NOTE: playdate.system.error (and all Playdate APIs that deal with strings) require a null termination
+                const null_char_index = @min(stream.pos, stack_trace_buffer.len - 1);
+                stack_trace_buffer[null_char_index] = 0;
+
+                break :b &stack_trace_buffer;
+            };
+            global_playdate.system.@"error"(
+                "PANIC: %s\n\n%s",
+                msg.ptr,
+                stack_trace_string.ptr,
+            );
+        },
+    }
+
+    while (true) {}
+}

src/pdtools/DrawableText.zig

···
+const pdapi = @import("../playdate_api_definitions.zig");
+
+pub const DrawableText = struct {
+    playdate: *pdapi.PlaydateAPI,
+    text: []const u8,
+    max_width: ?c_int = null,
+    max_height: ?c_int = null,
+    font: ?*pdapi.LCDFont = null,
+    wrapping_mode: pdapi.PDTextWrappingMode = .WrapWord,
+    alignment: pdapi.PDTextAlignment = .AlignTextLeft,
+
+    pub fn getWidth(self: *const DrawableText) c_int {
+        const natural_width = self.playdate.graphics.getTextWidth(
+            self.font,
+            @as(?[*:0]const u8, @ptrCast(self.text.ptr)),
+            self.text.len,
+            pdapi.PDStringEncoding.UTF8Encoding,
+            0,
+        );
+
+        // If a max width is set, return the minimum of the two
+        if (self.max_width) |max_w| {
+            return @min(max_w, natural_width);
+        }
+
+        return natural_width;
+    }
+
+    pub fn getHeight(self: *const DrawableText) c_int {
+        const width_constraint = self.max_width orelse 0;
+
+        const natural_height = self.playdate.graphics.getTextHeightForMaxWidth(
+            self.font,
+            @as(?[*:0]const u8, @ptrCast(self.text.ptr)),
+            self.text.len,
+            width_constraint,
+            pdapi.PDStringEncoding.UTF8Encoding,
+            self.wrapping_mode,
+            0,
+            0,
+        );
+
+        // If a max height is set, return the minimum of the two
+        if (self.max_height) |max_h| {
+            return @min(max_h, natural_height);
+        }
+
+        return natural_height;
+    }
+
+    pub fn render(self: *const DrawableText, x: c_int, y: c_int, dry_run: bool) void {
+        if (dry_run) return;
+
+        const width = self.getWidth();
+        const height = self.getHeight();
+
+        if (self.max_width != null) {
+            // Use drawTextInRect for constrained rendering
+            _ = self.playdate.graphics.drawTextInRect(
+                @as(?[*:0]const u8, @ptrCast(self.text.ptr)),
+                self.text.len,
+                pdapi.PDStringEncoding.UTF8Encoding,
+                x,
+                y,
+                width,
+                height,
+                self.wrapping_mode,
+                self.alignment,
+            );
+        } else {
+            // Use simple drawText for unconstrained rendering
+            _ = self.playdate.graphics.drawText(
+                @as(?[*:0]const u8, @ptrCast(self.text.ptr)),
+                self.text.len,
+                pdapi.PDStringEncoding.UTF8Encoding,
+                x,
+                y,
+            );
+        }
+    }
+};

src/pdtools/ScrollingValue.zig

···
+const pdapi = @import("../playdate_api_definitions.zig");
+
+// A representation of a scrolling or sliding value with soft limits and springback behavior
+pub const SlidingValue = struct {
+    playdate: *pdapi.PlaydateAPI,
+
+    // Soft runout distances for the scrolling value
+    soft_min_runout: f32,
+    soft_max_runout: f32,
+
+    // Margin before runout callback detection happens
+    runout_margin: f32 = 5.0,
+
+    min_value: f32,
+    max_value: f32,
+
+    current_value: f32,
+    current_height: f32,
+
+    // Rate at which the value springs back to the min/max
+    spring_rate: f32 = 0.5,
+
+    // ms until lack of movement causes spring back to min/max or ticks
+    spring_back_ms: u32 = 250,
+
+    // Called when the scroll max threshold is reached
+    scroll_max_threshold_ms: ?u32 = 1000,
+    ms_since_scroll_max: u32 = 0,
+    onScrollMaxThreshold: ?*const fn () void,
+    called_scroll_max: bool = false,
+
+    // Called when the scroll min threshold is reached
+    scroll_min_threshold_ms: ?u32 = 1000,
+    ms_since_scroll_min: u32 = 0,
+    called_scroll_min: bool = false,
+    onScrollMinThreshold: ?*const fn () void,
+
+    crank_position_offset: f32,
+    crank_multiplier: f32 = 1.0,
+
+    last_update_time: u32 = 0,
+    last_movement_time: u32 = 0,
+
+    /// Updates the scrolling value based on crank input and applies constraints
+    pub fn update(self: *SlidingValue) void {
+        const current_time = self.playdate.system.getCurrentTimeMilliseconds();
+
+        const crank_change = self.playdate.system.getCrankChange();
+        const adjusted_change = crank_change * self.crank_multiplier;
+
+        // Update current value
+        self.current_value += adjusted_change;
+
+        // Calculate hard limits based on soft limits + runout distances
+        // For max limit, account for viewport height
+        const hard_min_limit = self.min_value - self.soft_min_runout;
+        const effective_max_soft_limit = self.max_value - self.current_height;
+        const hard_max_limit = effective_max_soft_limit + self.soft_max_runout;
+
+        // Hard clamp to absolute hard limits
+        self.current_value = @max(hard_min_limit, @min(hard_max_limit, self.current_value));
+
+        // Track if we moved
+        const moved = @abs(adjusted_change) > 0.01;
+        if (moved) {
+            self.last_movement_time = current_time;
+        }
+
+        // Handle spring back behavior when beyond soft limits (min_value and max_value)
+        // For max value, account for viewport height
+        const effective_max_for_spring = self.max_value - self.current_height;
+        const time_since_last_movement = current_time - self.last_movement_time;
+        if (time_since_last_movement >= self.spring_back_ms) {
+            if (self.current_value > effective_max_for_spring) {
+                // Spring back towards effective max (soft limit accounting for viewport)
+                const spring_force = (self.current_value - effective_max_for_spring) * self.spring_rate;
+                self.current_value -= spring_force;
+                if (self.current_value < effective_max_for_spring) {
+                    self.current_value = effective_max_for_spring;
+                }
+            } else if (self.current_value < self.min_value) {
+                // Spring back towards min_value (soft limit)
+                const spring_force = (self.min_value - self.current_value) * self.spring_rate;
+                self.current_value += spring_force;
+                if (self.current_value > self.min_value) {
+                    self.current_value = self.min_value;
+                }
+            }
+        }
+
+        // Handle scroll thresholds with margin and debouncing
+        // In the new paradigm, min_value and max_value ARE the soft limits
+        // Thresholds trigger when beyond these soft limits
+        // For max threshold, account for viewport height - the effective max is when content bottom is visible
+        const effective_max_value = self.max_value - self.current_height;
+
+        if (self.current_value >= effective_max_value + self.runout_margin) {
+            self.ms_since_scroll_max += current_time - self.last_update_time;
+            if (self.scroll_max_threshold_ms) |threshold| {
+                if (self.ms_since_scroll_max >= threshold and self.onScrollMaxThreshold != null and !self.called_scroll_max) {
+                    self.onScrollMaxThreshold.?();
+                    self.called_scroll_max = true;
+                    self.ms_since_scroll_max = 0; // Reset after triggering
+                }
+            }
+        } else {
+            self.ms_since_scroll_max = 0;
+            // Reset debounce flag when we're back within normal range
+            if (self.current_value <= effective_max_value - self.runout_margin) {
+                self.called_scroll_max = false;
+            }
+        }
+
+        if (self.current_value <= self.min_value - self.runout_margin) {
+            self.ms_since_scroll_min += current_time - self.last_update_time;
+            if (self.scroll_min_threshold_ms) |threshold| {
+                if (self.ms_since_scroll_min >= threshold and self.onScrollMinThreshold != null and !self.called_scroll_min) {
+                    self.onScrollMinThreshold.?();
+                    self.called_scroll_min = true;
+                    self.ms_since_scroll_min = 0; // Reset after triggering
+                }
+            }
+        } else {
+            self.ms_since_scroll_min = 0;
+            // Reset debounce flag when we're back within normal range
+            if (self.current_value >= self.min_value + self.runout_margin) {
+                self.called_scroll_min = false;
+            }
+        }
+
+        self.last_update_time = current_time;
+    }
+
+    /// Sets the current value and resets movement tracking
+    pub fn setValue(self: *SlidingValue, value: f32) void {
+        // Calculate hard limits and clamp to them, accounting for viewport height
+        const hard_min_limit = self.min_value - self.soft_min_runout;
+        const effective_max_soft_limit = self.max_value - self.current_height;
+        const hard_max_limit = effective_max_soft_limit + self.soft_max_runout;
+        self.current_value = @max(hard_min_limit, @min(hard_max_limit, value));
+        self.last_movement_time = self.playdate.system.getCurrentTimeMilliseconds();
+
+        // Reset debounce flags when value is explicitly set
+        self.called_scroll_max = false;
+        self.called_scroll_min = false;
+        self.ms_since_scroll_max = 0;
+        self.ms_since_scroll_min = 0;
+    }
+
+    /// Gets the current constrained value
+    pub fn getValue(self: *SlidingValue) f32 {
+        return self.current_value;
+    }
+
+    /// Returns true if the value is beyond soft limits (min_value and effective max_value)
+    pub fn isBeyondSoftLimits(self: *SlidingValue) bool {
+        const effective_max_value = self.max_value - self.current_height;
+        return self.current_value < self.min_value or self.current_value > effective_max_value;
+    }
+};

src/pdtools/index.zig

···
+const pdapi = @import("../playdate_api_definitions.zig");
+const fonts = @import("../fonts.zig");
+const std = @import("std");
+
+pub const CRANK_EMOJI = "🎣";
+pub const UP_ARROW_EMOJI = "⬆️";
+pub const DOWN_ARROW_EMOJI = "⬇️";
+pub const LEFT_ARROW_EMOJI = "⬅️";
+pub const RIGHT_ARROW_EMOJI = "➡️";
+pub const SELECTION_ARROW = ">";
+
+pub fn drawText(
+    pd: *pdapi.PlaydateAPI,
+    font: ?*pdapi.LCDFont,
+    text: []const u8,
+    x: c_int,
+    y: c_int,
+    out_width: *c_int,
+    out_height: *c_int,
+) void {
+    out_width.* = pd.graphics.getTextWidth(font, text.ptr, text.len, pdapi.PDStringEncoding.UTF8Encoding, 0);
+    out_height.* = pd.graphics.getFontHeight(font);
+
+    _ = pd.graphics.drawText(
+        text.ptr,
+        text.len,
+        pdapi.PDStringEncoding.UTF8Encoding,
+        x,
+        y,
+    );
+}
+
+pub fn logLargeMessage(pd: *pdapi.PlaydateAPI, buffer: []const u8, buffer_size: usize) void {
+
+    // Log the complete response for debugging
+    pd.system.logToConsole("========== COMPLETE JSON RESPONSE START ==========");
+
+    // Log in chunks to avoid truncation
+    const chunk_size = 512; // Log 512 chars at a time
+    var offset: usize = 0;
+    var chunk_num: usize = 1;
+
+    while (offset < buffer_size) {
+        const remaining = buffer_size - offset;
+        const current_chunk_size = @min(chunk_size, remaining);
+
+        pd.system.logToConsole("%.*s", @as(c_int, @intCast(current_chunk_size)), &buffer[offset]);
+
+        offset += current_chunk_size;
+        chunk_num += 1;
+    }
+
+    pd.system.logToConsole("========== COMPLETE JSON RESPONSE END ==========");
+}
+
+pub fn renderScrollbar(
+    pd: *pdapi.PlaydateAPI,
+    x: c_int,
+    y: c_int,
+    width: c_int,
+    height: c_int,
+    scroll_offset: f32,
+    content_height: f32,
+    viewport_height: f32,
+) void {
+    // Calculate scrollbar thumb position and size relative to the given bounds
+    const thumb_y = y + @as(c_int, @intFromFloat(scroll_offset / content_height * @as(f32, @floatFromInt(height))));
+    const thumb_height = @as(c_int, @intFromFloat(viewport_height / content_height * @as(f32, @floatFromInt(height))));
+
+    // Draw scrollbar background (white background)
+    pd.graphics.fillRect(x, y, width, height, @as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorWhite))));
+
+    // Draw scrollbar thumb (black thumb)
+    pd.graphics.fillRect(x, thumb_y, width, thumb_height, @as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorBlack))));
+}
+
+pub fn renderButton(
+    pd: *pdapi.PlaydateAPI,
+    x: c_int,
+    y: c_int,
+    label: []const u8,
+    active: bool,
+    out_width: ?*c_int,
+    out_height: ?*c_int,
+) void {
+    const MARGIN: c_int = 4;
+    const BG_COLOR = if (active) pdapi.LCDSolidColor.ColorWhite else pdapi.LCDSolidColor.ColorBlack;
+
+    const text_width = pd.graphics.getTextWidth(
+        fonts.g_font,
+        label.ptr,
+        label.len,
+        pdapi.PDStringEncoding.UTF8Encoding,
+        0,
+    );
+    const text_height = pd.graphics.getFontHeight(fonts.g_font);
+    const btn_width = text_width + MARGIN * 2;
+    const btn_height = text_height + MARGIN * 2;
+
+    if (out_width) |w| w.* = btn_width;
+    if (out_height) |h| h.* = btn_height;
+
+    // Draw button background
+    pd.graphics.fillRect(
+        x,
+        y,
+        text_width + MARGIN * 2,
+        text_height + MARGIN * 2,
+        @as(usize, @intCast(@intFromEnum(BG_COLOR))),
+    );
+
+    pd.graphics.drawRect(
+        x,
+        y,
+        text_width + MARGIN * 2,
+        text_height + MARGIN * 2,
+        @as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorBlack))),
+    );
+
+    // Draw button label with appropriate draw mode for text color
+    if (active) {
+        pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeFillBlack);
+    } else {
+        pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeFillWhite);
+    }
+    _ = pd.graphics.drawText(
+        label.ptr,
+        label.len,
+        pdapi.PDStringEncoding.UTF8Encoding,
+        x + MARGIN,
+        y + MARGIN,
+    );
+
+    // Reset draw mode to normal
+    pd.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+}
+
+pub fn renderSpinner(pd: *pdapi.PlaydateAPI, x: c_int, y: c_int, color: ?pdapi.LCDSolidColor) void {
+    const time = pd.system.getCurrentTimeMilliseconds();
+    const c = color orelse pdapi.LCDSolidColor.ColorBlack;
+    const rotation = @as(f32, @floatFromInt(time % 2000)) / 2000.0 * 360.0;
+    pd.graphics.drawEllipse(
+        x,
+        y,
+        16,
+        16,
+        2,
+        rotation,
+        rotation + 90,
+        @as(usize, @intCast(@intFromEnum(c))),
+    );
+}
+
+pub fn datetimeToISO(datetime: pdapi.PDDateTime) []const u8 {
+    var buffer: [32]u8 = undefined;
+    const result = std.fmt.bufPrint(
+        &buffer,
+        "{d:0>4}-{d:0>2}-{d:0>2}T{d:0>2}:{d:0>2}:{d:0>2}.000Z",
+        .{ datetime.year, datetime.month, datetime.day, datetime.hour, datetime.minute, datetime.second },
+    ) catch return "2025-08-27T00:00:00.000Z"; // Fallback
+
+    return buffer[0..result.len];
+}
+
+pub fn saveStringFile(playdate: *pdapi.PlaydateAPI, path: [:0]const u8, data: []const u8) void {
+    const file = playdate.file.open(path.ptr, pdapi.FILE_WRITE) orelse {
+        playdate.system.logToConsole("Failed to open file for writing: %s", path.ptr);
+        return;
+    };
+    defer _ = playdate.file.close(file);
+
+    const bytes_written = playdate.file.write(file, data.ptr, @intCast(data.len));
+    if (bytes_written != @as(c_int, @intCast(data.len))) {
+        playdate.system.logToConsole("Failed to write all data to file");
+    }
+}
+
+pub fn loadStringFile(playdate: *pdapi.PlaydateAPI, path: [:0]const u8, output: []u8) void {
+    const file = playdate.file.open(path.ptr, pdapi.FILE_READ_DATA) orelse {
+        const err = playdate.file.geterr();
+        playdate.system.logToConsole("Failed to open file for reading: %s, Error: %s", path.ptr, err);
+        return;
+    };
+    defer _ = playdate.file.close(file);
+
+    const bytes_read = playdate.file.read(file, output.ptr, @intCast(output.len - 1));
+    if (bytes_read <= 0) {
+        playdate.system.logToConsole("Failed to read from file");
+        return;
+    }
+
+    const read_len = @as(usize, @intCast(bytes_read));
+    output[read_len] = 0; // Null terminate
+}
+
+pub fn delStringFile(playdate: *pdapi.PlaydateAPI, path: [:0]const u8) void {
+    _ = playdate.file.unlink(path.ptr, 0);
+}

src/pdtools/keyboard.zig

···
+const pdapi = @import("../playdate_api_definitions.zig");
+const std = @import("std");
+const pdtools = @import("index.zig");
+const defs = @import("../definitions.zig");
+
+// Keyboard configuration constants
+const VISIBLE_CHARS = 13; // More characters for better context
+const ROW_HEIGHT = 26;
+const CHAR_WIDTH = 25;
+const CHAR_SPACING = 2;
+const START_Y = 80;
+const SCREEN_WIDTH = 400;
+const CENTER_X = SCREEN_WIDTH / 2;
+const BUTTON_WIDTH = 80;
+const BUTTON_HEIGHT = 25;
+const BUTTON_Y_OFFSET = 160;
+
+const KeyboardState = enum {
+    inactive,
+    active,
+    completed,
+    cancelled,
+};
+
+const Selected = enum {
+    uppercase,
+    lowercase,
+    special,
+    cancel,
+    confirm,
+};
+
+// Callback function types
+pub const KeyboardCancelCallback = *const fn () void;
+pub const KeyboardConfirmCallback = *const fn (text: []const u8) void;
+
+// Character sets - each row is a complete character set that can be scrolled through
+const UPPERCASE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
+const LOWERCASE_CHARS = "abcdefghijklmnopqrstuvwxyz ";
+const SPECIAL_CHARS = "0123456789!@#$%^&*()_+-=[]{}\\|;':\",./<>?~` ";
+const SPECIAL_CHARS_WITH_NEWLINE = "0123456789!@#$%^&*()_+-=[]{}\\|;':\",./<>?~` \n";
+
+const SelectionMode = enum {
+    characters,
+    buttons,
+};
+
+// Keyboard struct definition
+pub fn Keyboard(comptime buffer_size: usize) type {
+    return struct {
+        playdate: *pdapi.PlaydateAPI,
+        font: *pdapi.LCDFont,
+
+        state: KeyboardState = .inactive,
+        selected: Selected = .uppercase,
+        selection_mode: SelectionMode = .characters,
+        title: [*:0]const u8,
+        editor_buffer: [buffer_size]u8,
+        output_buffer: [buffer_size]u8 = undefined,
+        input_len: usize = 0,
+
+        // Absolute crank position for smooth scrolling
+        crank_position: f32 = 0.0,
+        initial_crank_position: f32 = 0.0,
+
+        // Text cursor position within input_buffer
+        cursor_pos: usize = 0,
+
+        // Callback functions
+        cancel_callback: ?KeyboardCancelCallback = null,
+        confirm_callback: ?KeyboardConfirmCallback = null,
+
+        editor_lines: usize = 1,
+        allow_newlines: bool = false,
+
+        max_length: usize = 0,
+
+        // Sound effects for UI feedback
+        click_synth: ?*pdapi.PDSynth = null,
+        previous_selected_char_index: usize = 0,
+
+        pub fn setup(self: *Keyboard(buffer_size), pd: *pdapi.PlaydateAPI, font: *pdapi.LCDFont) void {
+            self.playdate = pd;
+            self.font = font;
+
+            // Initialize click sound synth
+            self.click_synth = pd.sound.synth.newSynth();
+            if (self.click_synth) |synth| {
+                // Set up a short pulse wave for clicking
+                pd.sound.synth.setWaveform(synth, pdapi.SoundWaveform.kWaveformSquare);
+                pd.sound.synth.setVolume(synth, 0.1, 0.1); // Low volume
+            }
+        }
+
+        // Initialize and show the keyboard
+        pub fn start(
+            self: *Keyboard(buffer_size),
+            title: []const u8,
+            max_length: usize,
+            initial_value: ?[]const u8,
+            allow_newlines: bool,
+            editor_lines: usize,
+            cancel_callback: ?KeyboardCancelCallback,
+            confirm_callback: ?KeyboardConfirmCallback,
+        ) void {
+            // Clear the screen when entering keyboard mode
+            self.playdate.graphics.clear(@as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorWhite))));
+
+            // Reset keyboard state
+            self.state = .active;
+            self.selected = .uppercase;
+            self.selection_mode = .characters;
+            self.input_len = 0;
+            self.cursor_pos = 0;
+            self.allow_newlines = allow_newlines;
+            self.editor_lines = editor_lines;
+            self.cancel_callback = cancel_callback;
+            self.confirm_callback = confirm_callback;
+
+            // Set title (assuming title is null-terminated string literal)
+            self.title = @as([*:0]const u8, @ptrCast(title.ptr));
+
+            // Initialize with initial value
+            if (initial_value) |value| {
+                const copy_len = @min(value.len, self.editor_buffer.len - 1);
+                @memcpy(self.editor_buffer[0..copy_len], value[0..copy_len]);
+                self.input_len = copy_len;
+                self.cursor_pos = copy_len;
+            } else {
+                self.input_len = 0;
+                self.cursor_pos = 0;
+            }
+
+            // Record initial crank position for absolute positioning
+            self.initial_crank_position = self.playdate.system.getCrankAngle();
+            self.crank_position = self.initial_crank_position;
+            self.max_length = @min(max_length, self.editor_buffer.len - 1); // Leave room for null terminator
+
+            // Reset character tracking for sound
+            self.previous_selected_char_index = 0;
+        }
+
+        // Render the keyboard interface
+        pub fn updateAndRender(self: *Keyboard(buffer_size)) bool {
+            if (self.state != .active) return false;
+
+            self.handleInput();
+
+            // Clear screen
+            self.playdate.graphics.clear(@as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorWhite))));
+
+            const font_height = self.playdate.graphics.getFontHeight(self.font);
+
+            // Draw title
+            var temp_width: c_int = 0;
+            var temp_height: c_int = 0;
+            var curr_y: c_int = defs.MARGIN;
+            const prompt_y = curr_y;
+            const title_slice = std.mem.span(self.title);
+            _ = pdtools.drawText(
+                self.playdate,
+                self.font,
+                title_slice,
+                defs.MARGIN,
+                defs.MARGIN,
+                &temp_width,
+                &temp_height,
+            );
+
+            curr_y += temp_height + defs.MARGIN;
+
+            // Draw current input
+            const line_count = if (self.allow_newlines) self.editor_lines else 1;
+            const rectHeight = font_height * @as(c_int, @intCast(line_count)) + defs.MARGIN * 2;
+            const rectWidth = pdapi.LCD_COLUMNS - defs.MARGIN * 2;
+            var input_x: c_int = defs.MARGIN;
+            var input_y: c_int = curr_y;
+            self.playdate.graphics.drawRect(input_x, input_y, rectWidth, rectHeight, @as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorBlack))));
+            input_y += defs.MARGIN;
+            input_x += defs.MARGIN;
+            curr_y += rectHeight + defs.MARGIN;
+
+            // Render multiline text if newlines are allowed
+            if (self.allow_newlines) {
+                const input_text = self.editor_buffer[0..self.input_len];
+                var line_y = input_y;
+                var line_start: usize = 0;
+                var current_line: usize = 0;
+
+                // Split text by newlines and draw each line
+                for (input_text, 0..) |char, i| {
+                    if (char == '\n' or i == input_text.len - 1) {
+                        const line_end = if (char == '\n') i else i + 1;
+                        const line_text = input_text[line_start..line_end];
+
+                        if (current_line < line_count) {
+                            _ = pdtools.drawText(
+                                self.playdate,
+                                self.font,
+                                line_text,
+                                input_x,
+                                line_y,
+                                &temp_width,
+                                &temp_height,
+                            );
+                            line_y += font_height;
+                            current_line += 1;
+                        }
+                        line_start = i + 1;
+                    }
+                }
+
+                // If no newlines in text, draw as single line
+                if (current_line == 0) {
+                    _ = pdtools.drawText(
+                        self.playdate,
+                        self.font,
+                        input_text,
+                        input_x,
+                        input_y,
+                        &temp_width,
+                        &temp_height,
+                    );
+                }
+            } else {
+                const input_text = self.editor_buffer[0..self.input_len];
+                _ = pdtools.drawText(
+                    self.playdate,
+                    self.font,
+                    input_text,
+                    input_x,
+                    input_y,
+                    &temp_width,
+                    &temp_height,
+                );
+            }
+
+            curr_y += font_height * @as(c_int, @intCast(line_count)) + defs.MARGIN;
+
+            // Draw character counter above input area on the right
+            var counter_buffer: [32]u8 = undefined;
+            const counter_text = std.fmt.bufPrint(counter_buffer[0..], "{d}/{d}", .{ self.input_len, self.max_length }) catch "0/0";
+            const counter_width = self.playdate.graphics.getTextWidth(self.font, counter_text.ptr, counter_text.len, pdapi.PDStringEncoding.UTF8Encoding, 0);
+            const counter_x = rectWidth - counter_width; // Right-aligned with some margin
+            const counter_y = prompt_y; // Above the input box
+            _ = self.playdate.graphics.drawText(counter_text.ptr, counter_text.len, pdapi.PDStringEncoding.UTF8Encoding, counter_x, counter_y);
+
+            // Draw cursor in input field at cursor position
+            var cursor_x: c_int = 0;
+            var cursor_y: c_int = input_y;
+
+            if (self.allow_newlines) {
+                // Calculate cursor position accounting for newlines
+                const text_before_cursor = self.editor_buffer[0..self.cursor_pos];
+                var current_line: usize = 0;
+                var line_start: usize = 0;
+
+                // Find which line the cursor is on
+                for (text_before_cursor, 0..) |char, i| {
+                    if (char == '\n') {
+                        current_line += 1;
+                        line_start = i + 1;
+                    }
+                }
+
+                // Calculate cursor position within the current line
+                const line_text = text_before_cursor[line_start..];
+                cursor_x = self.playdate.graphics.getTextWidth(self.font, @ptrCast(line_text), line_text.len, pdapi.PDStringEncoding.UTF8Encoding, 0);
+                cursor_y = input_y + @as(c_int, @intCast(current_line)) * font_height;
+            } else {
+                cursor_x = self.playdate.graphics.getTextWidth(self.font, @ptrCast(&self.editor_buffer), self.cursor_pos, pdapi.PDStringEncoding.UTF8Encoding, 0);
+            }
+
+            self.playdate.graphics.fillRect(cursor_x + defs.MARGIN + 2, cursor_y, 2, 14, @as(usize, @intCast(@intFromEnum(pdapi.LCDSolidColor.ColorBlack))));
+
+            // Draw the 3 character set rows
+            const row_configs = [3]struct {
+                row: Selected,
+                y_pos: c_int,
+            }{
+                .{ .row = .uppercase, .y_pos = START_Y },
+                .{ .row = .lowercase, .y_pos = START_Y + ROW_HEIGHT },
+                .{ .row = .special, .y_pos = START_Y + ROW_HEIGHT * 2 },
+            };
+
+            for (row_configs) |config| {
+                const is_selected_row = (self.selected == config.row and self.selection_mode == .characters);
+                const chars = self.getCharacterSet(config.row);
+
+                // Draw visible characters centered around the current crank position
+                const center_pos = VISIBLE_CHARS / 2; // Position 6 for 13 chars (0-12)
+
+                // Calculate selected character index from crank position
+                const relative_position = self.crank_position - self.initial_crank_position;
+                const chars_per_360 = @as(f32, @floatFromInt(chars.len));
+                const position_factor = relative_position / 360.0;
+                const selected_char_index = @as(usize, @intCast(@mod(@as(i32, @intFromFloat(position_factor * chars_per_360)), @as(i32, @intCast(chars.len)))));
+
+                // Play click sound when character changes (only for the currently selected row)
+                if (is_selected_row and selected_char_index != self.previous_selected_char_index) {
+                    self.playClickSound();
+                    self.previous_selected_char_index = selected_char_index;
+                }
+
+                for (0..VISIBLE_CHARS) |i| {
+                    // Calculate character index relative to center
+                    const offset = @as(i32, @intCast(i)) - @as(i32, @intCast(center_pos));
+                    var char_index = @as(i32, @intCast(selected_char_index)) + offset;
+
+                    // Wrap around character set bounds
+                    if (char_index < 0) {
+                        char_index += @as(i32, @intCast(chars.len));
+                    }
+                    char_index = @rem(char_index, @as(i32, @intCast(chars.len)));
+
+                    const char = chars[@as(usize, @intCast(char_index))];
+
+                    // Center the entire character row on screen
+                    const total_width = VISIBLE_CHARS * CHAR_WIDTH + (VISIBLE_CHARS - 1) * CHAR_SPACING;
+                    const start_x = CENTER_X - @divTrunc(total_width, 2);
+                    const x = start_x + @as(c_int, @intCast(i * (CHAR_WIDTH + CHAR_SPACING)));
+
+                    // The center character is selected when this row is active
+                    const is_selected_char = (is_selected_row and i == center_pos);
+
+                    // Draw character box with better sizing
+                    const box_height = 24;
+                    const char_color = if (is_selected_char) pdapi.LCDSolidColor.ColorBlack else pdapi.LCDSolidColor.ColorWhite;
+                    const border_color = if (is_selected_row) pdapi.LCDSolidColor.ColorBlack else pdapi.LCDSolidColor.ColorXOR;
+
+                    self.playdate.graphics.fillRect(x, config.y_pos, CHAR_WIDTH, box_height, @as(usize, @intCast(@intFromEnum(char_color))));
+                    self.playdate.graphics.drawRect(x, config.y_pos, CHAR_WIDTH, box_height, @as(usize, @intCast(@intFromEnum(border_color))));
+
+                    // Draw character with improved centering
+                    if (char == ' ') {
+                        const space_text = "SPC";
+                        const text_width = self.playdate.graphics.getTextWidth(self.font, space_text.ptr, space_text.len, pdapi.PDStringEncoding.UTF8Encoding, 0);
+                        const text_height = 12; // Approximate font height
+                        const text_x = x + @divTrunc(CHAR_WIDTH - text_width, 2);
+                        const text_y = config.y_pos + @divTrunc(box_height - text_height, 2);
+
+                        if (is_selected_char) {
+                            self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeInverted);
+                        }
+                        _ = self.playdate.graphics.drawText(space_text.ptr, space_text.len, pdapi.PDStringEncoding.UTF8Encoding, text_x, text_y);
+                        if (is_selected_char) {
+                            self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+                        }
+                    } else if (char == '\n') {
+                        const newline_text = "NL";
+                        const text_width = self.playdate.graphics.getTextWidth(self.font, newline_text.ptr, newline_text.len, pdapi.PDStringEncoding.UTF8Encoding, 0);
+                        const text_height = 12; // Approximate font height
+                        const text_x = x + @divTrunc(CHAR_WIDTH - text_width, 2);
+                        const text_y = config.y_pos + @divTrunc(box_height - text_height, 2);
+
+                        if (is_selected_char) {
+                            self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeInverted);
+                        }
+                        _ = self.playdate.graphics.drawText(newline_text.ptr, newline_text.len, pdapi.PDStringEncoding.UTF8Encoding, text_x, text_y);
+                        if (is_selected_char) {
+                            self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+                        }
+                    } else {
+                        var char_str = [2]u8{ char, 0 };
+                        const text_width = self.playdate.graphics.getTextWidth(self.font, @ptrCast(&char_str), 1, pdapi.PDStringEncoding.UTF8Encoding, 0);
+                        const text_height = 12; // Approximate font height
+                        const text_x = x + @divTrunc(CHAR_WIDTH - text_width, 2);
+                        const text_y = config.y_pos + @divTrunc(box_height - text_height, 2);
+
+                        if (is_selected_char) {
+                            self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeInverted);
+                        }
+                        _ = self.playdate.graphics.drawText(@ptrCast(&char_str), 1, pdapi.PDStringEncoding.UTF8Encoding, text_x, text_y);
+                        if (is_selected_char) {
+                            self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+                        }
+                    }
+                }
+            }
+
+            // Draw Cancel and Confirm buttons
+            const button_names = [2][]const u8{ "Cancel", "Confirm" };
+            const button_spacing = 20;
+            const total_button_width = 2 * BUTTON_WIDTH + button_spacing;
+            const buttons_start_x = CENTER_X - @divTrunc(total_button_width, 2);
+
+            for (0..2) |i| {
+                const x = buttons_start_x + @as(c_int, @intCast(i * (BUTTON_WIDTH + button_spacing)));
+                const y = BUTTON_Y_OFFSET;
+
+                const is_selected = (self.selection_mode == .buttons and
+                    ((i == 0 and self.selected == .cancel) or (i == 1 and self.selected == .confirm)));
+                const button_color = if (is_selected) pdapi.LCDSolidColor.ColorBlack else pdapi.LCDSolidColor.ColorWhite;
+                const border_color = pdapi.LCDSolidColor.ColorBlack;
+
+                self.playdate.graphics.fillRect(x, y, BUTTON_WIDTH, BUTTON_HEIGHT, @as(usize, @intCast(@intFromEnum(button_color))));
+                self.playdate.graphics.drawRect(x, y, BUTTON_WIDTH, BUTTON_HEIGHT, @as(usize, @intCast(@intFromEnum(border_color))));
+
+                // Draw button text
+                const text = button_names[i];
+                const text_width = self.playdate.graphics.getTextWidth(self.font, text.ptr, text.len, pdapi.PDStringEncoding.UTF8Encoding, 0);
+                const text_x = x + @divTrunc(BUTTON_WIDTH - text_width, 2);
+                const text_y = y + @divTrunc(BUTTON_HEIGHT - 12, 2);
+
+                if (is_selected) {
+                    self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeInverted);
+                }
+                _ = self.playdate.graphics.drawText(text.ptr, text.len, pdapi.PDStringEncoding.UTF8Encoding, text_x, text_y);
+                if (is_selected) {
+                    self.playdate.graphics.setDrawMode(pdapi.LCDBitmapDrawMode.DrawModeCopy);
+                }
+            }
+
+            // Draw instructions below the buttons
+            const instruction_y = BUTTON_Y_OFFSET + BUTTON_HEIGHT + 5; // 5 pixels below buttons
+            const instr1 = "A: Select  B: Backspace  " ++ pdtools.LEFT_ARROW_EMOJI ++ pdtools.RIGHT_ARROW_EMOJI ++ ": Move Cursor";
+            const instr2 = pdtools.UP_ARROW_EMOJI ++ pdtools.DOWN_ARROW_EMOJI ++ ": Switch Rows  " ++ pdtools.CRANK_EMOJI ++ ": Scroll Characters";
+            _ = self.playdate.graphics.drawText(instr1.ptr, instr1.len, pdapi.PDStringEncoding.UTF8Encoding, 10, instruction_y);
+            _ = self.playdate.graphics.drawText(instr2.ptr, instr2.len, pdapi.PDStringEncoding.UTF8Encoding, 10, instruction_y + 15);
+
+            return true;
+        }
+
+        // Check if keyboard is currently active
+        pub fn isKeyboardActive(self: *Keyboard(buffer_size)) bool {
+            return self.state == .active;
+        }
+
+        // Get the current keyboard state
+        pub fn getKeyboardState(self: *Keyboard(buffer_size)) KeyboardState {
+            return self.state;
+        }
+
+        // Get the entered text (call after keyboard is completed)
+        pub fn getEnteredText(self: *Keyboard(buffer_size)) []const u8 {
+            if (self.state == .completed) {
+                return self.output_buffer[0..std.mem.len(@as([*:0]const u8, @ptrCast(self.output_buffer)))];
+            }
+            return "";
+        }
+
+        // Close the keyboard and clean up
+        pub fn closeKeyboard(self: *Keyboard(buffer_size)) void {
+            self.state = .inactive;
+            self.input_len = 0;
+            self.cursor_pos = 0;
+            self.cancel_callback = null;
+            self.confirm_callback = null;
+            @memset(&self.editor_buffer, 0);
+
+            // Clean up synth
+            if (self.click_synth) |synth| {
+                self.playdate.sound.synth.freeSynth(synth);
+                self.click_synth = null;
+            }
+        }
+
+        pub fn renderKeyboard(self: *Keyboard(buffer_size), pd: *pdapi.PlaydateAPI, font: ?*pdapi.LCDFont) void {
+            _ = pd; // We use self.playdate
+            self.font = font; // Update font
+            self.render();
+        }
+
+        // Helper functions for character set access
+        fn getCharacterSet(self: *Keyboard(buffer_size), row: Selected) []const u8 {
+            return switch (row) {
+                .uppercase => UPPERCASE_CHARS,
+                .lowercase => LOWERCASE_CHARS,
+                .special => if (self.allow_newlines) SPECIAL_CHARS_WITH_NEWLINE else SPECIAL_CHARS,
+                .cancel, .confirm => "", // These don't have character sets
+            };
+        }
+
+        // Play a short click sound
+        fn playClickSound(self: *Keyboard(buffer_size)) void {
+            if (self.click_synth) |synth| {
+                // Play a short click at 800Hz for 50ms
+                self.playdate.sound.synth.playNote(synth, 800.0, 1.0, 0.05, 0);
+            }
+        }
+
+        fn getCurrentCharacter(self: *Keyboard(buffer_size)) u8 {
+            const chars = self.getCharacterSet(self.selected);
+            if (chars.len == 0) return ' '; // Default for non-character selections
+
+            // Convert crank position to character index
+            const relative_position = self.crank_position - self.initial_crank_position;
+            const chars_per_360 = @as(f32, @floatFromInt(chars.len));
+            const position_factor = relative_position / 360.0; // Full rotation = full character set
+            const char_index = @as(usize, @intCast(@mod(@as(i32, @intFromFloat(position_factor * chars_per_360)), @as(i32, @intCast(chars.len)))));
+            return chars[char_index];
+        }
+
+        // Handle button input for keyboard navigation and text entry
+        pub fn handleInput(self: *Keyboard(buffer_size)) void {
+            if (self.state != .active) return;
+
+            // Handle button input
+            var current: pdapi.PDButtons = undefined;
+            var pushed: pdapi.PDButtons = undefined;
+            var released: pdapi.PDButtons = undefined;
+            self.playdate.system.getButtonState(&current, &pushed, &released);
+
+            // Up/Down: Switch between character rows OR move between character/button selection
+            if (pushed & pdapi.BUTTON_UP != 0) {
+                if (self.selection_mode == .characters) {
+                    // Switch to previous character row
+                    self.selected = switch (self.selected) {
+                        .uppercase => .special,
+                        .lowercase => .uppercase,
+                        .special => .lowercase,
+                        .cancel, .confirm => .uppercase, // Reset to characters if on buttons
+                    };
+                    // Reset character tracking when switching rows
+                    self.previous_selected_char_index = 0;
+                } else {
+                    // Switch from buttons to characters
+                    self.selection_mode = .characters;
+                    self.selected = .uppercase;
+                    // Reset character tracking when switching to characters
+                    self.previous_selected_char_index = 0;
+                }
+            }
+
+            if (pushed & pdapi.BUTTON_DOWN != 0) {
+                if (self.selection_mode == .characters) {
+                    // Check if we should move to buttons (if we're at bottom row)
+                    self.selected = switch (self.selected) {
+                        .uppercase => .lowercase,
+                        .lowercase => .special,
+                        .special => {
+                            // Move to button selection instead
+                            self.selection_mode = .buttons;
+                            self.selected = .cancel;
+                            return;
+                        },
+                        .cancel, .confirm => .cancel, // Stay on buttons
+                    };
+                    // Reset character tracking when switching rows
+                    self.previous_selected_char_index = 0;
+                }
+            }
+
+            // Left/Right: Move text cursor or navigate buttons
+            if (pushed & pdapi.BUTTON_LEFT != 0) {
+                if (self.selection_mode == .characters) {
+                    // Move cursor left in text
+                    if (self.cursor_pos > 0) {
+                        self.cursor_pos -= 1;
+                    }
+                } else {
+                    // Navigate buttons
+                    self.selected = if (self.selected == .cancel) .confirm else .cancel;
+                }
+            }
+
+            if (pushed & pdapi.BUTTON_RIGHT != 0) {
+                if (self.selection_mode == .characters) {
+                    // Move cursor right in text
+                    if (self.cursor_pos < self.input_len) {
+                        self.cursor_pos += 1;
+                    }
+                } else {
+                    // Navigate buttons
+                    self.selected = if (self.selected == .cancel) .confirm else .cancel;
+                }
+            }
+
+            // A button: Select current character OR activate button
+            if (pushed & pdapi.BUTTON_A != 0) {
+                if (self.selection_mode == .characters) {
+                    const char = self.getCurrentCharacter();
+
+                    // Insert character at cursor position if there's space
+                    if (self.input_len < self.max_length) {
+                        // Shift characters to the right to make room for new character
+                        var i = self.input_len;
+                        while (i > self.cursor_pos) {
+                            self.editor_buffer[i] = self.editor_buffer[i - 1];
+                            i -= 1;
+                        }
+
+                        // Insert the new character at cursor position
+                        self.editor_buffer[self.cursor_pos] = char;
+                        self.input_len += 1;
+                        self.cursor_pos += 1; // Move cursor to after inserted character
+                    }
+                } else {
+                    // Button selection
+                    if (self.selected == .cancel) {
+                        // Cancel
+                        self.state = .cancelled;
+                        if (self.cancel_callback) |callback| {
+                            callback();
+                        }
+                    } else if (self.selected == .confirm) {
+                        // Confirm
+                        const copy_len = @min(self.input_len, self.output_buffer.len - 1);
+                        @memcpy(self.output_buffer[0..copy_len], self.editor_buffer[0..copy_len]);
+                        self.output_buffer[copy_len] = 0; // Null terminate
+                        self.state = .completed;
+
+                        if (self.confirm_callback) |callback| {
+                            // Pass the entered text to the callback
+                            const entered_text = self.editor_buffer[0..self.input_len];
+                            callback(entered_text);
+                        }
+                    }
+                }
+            }
+
+            // B button: Backspace (delete character before cursor)
+            if (pushed & pdapi.BUTTON_B != 0) {
+                if (self.cursor_pos > 0 and self.input_len > 0) {
+                    // Shift characters to the left to remove character before cursor
+                    var i = self.cursor_pos - 1;
+                    while (i < self.input_len - 1) {
+                        self.editor_buffer[i] = self.editor_buffer[i + 1];
+                        i += 1;
+                    }
+
+                    // Clear the last character and update lengths
+                    self.input_len -= 1;
+                    self.cursor_pos -= 1;
+                    self.editor_buffer[self.input_len] = 0;
+                }
+            }
+
+            // Crank: Update absolute position for smooth character scrolling
+            self.crank_position = self.playdate.system.getCrankAngle();
+        }
+    };
+}

src/playdate_api_definitions.zig

···
+const std = @import("std");
+const builtin = @import("builtin");
+
+pub const PlaydateAPI = extern struct {
+    system: *const PlaydateSys,
+    file: *const PlaydateFile,
+    graphics: *const PlaydateGraphics,
+    sprite: *const PlaydateSprite,
+    display: *const PlaydateDisplay,
+    sound: *const PlaydateSound,
+    lua: *const PlaydateLua,
+    json: *const PlaydateJSON,
+    scoreboards: *const PlaydateScoreboards,
+    network: *const PlaydateNetwork,
+};
+
+/////////Zig Utility Functions///////////
+pub fn is_compiling_for_playdate_hardware() bool {
+    return builtin.os.tag == .freestanding and builtin.cpu.arch.isThumb();
+}
+
+////////Buttons//////////////
+pub const PDButtons = c_int;
+pub const BUTTON_LEFT = (1 << 0);
+pub const BUTTON_RIGHT = (1 << 1);
+pub const BUTTON_UP = (1 << 2);
+pub const BUTTON_DOWN = (1 << 3);
+pub const BUTTON_B = (1 << 4);
+pub const BUTTON_A = (1 << 5);
+
+///////////////System/////////////////////////
+pub const PDMenuItem = opaque {};
+pub const PDCallbackFunction = *const fn (userdata: ?*anyopaque) callconv(.C) c_int;
+pub const PDMenuItemCallbackFunction = *const fn (userdata: ?*anyopaque) callconv(.C) void;
+pub const PDButtonCallbackFunction = *const fn (
+    button: PDButtons,
+    down: c_int,
+    when: u32,
+    userdata: ?*anyopaque,
+) callconv(.C) c_int;
+pub const PDSystemEvent = enum(c_int) {
+    EventInit,
+    EventInitLua,
+    EventLock,
+    EventUnlock,
+    EventPause,
+    EventResume,
+    EventTerminate,
+    EventKeyPressed, // arg is keycode
+    EventKeyReleased,
+    EventLowPower,
+};
+pub const PDLanguage = enum(c_int) {
+    PDLanguageEnglish,
+    PDLanguageJapanese,
+    PDLanguageUnknown,
+};
+
+pub const AccessRequestCallback = ?*const fn (allowed: bool, userdata: ?*anyopaque) callconv(.C) void;
+pub const AccessReply = enum(c_int) {
+    AccessAsk = 0,
+    AccessDeny,
+    AccessAllow,
+};
+
+pub const PDPeripherals = c_int;
+pub const PERIPHERAL_NONE = 0;
+pub const PERIPHERAL_ACCELEROMETER = (1 << 0);
+// ...
+pub const PERIPHERAL_ALL = 0xFFFF;
+
+pub const PDStringEncoding = enum(c_int) {
+    ASCIIEncoding,
+    UTF8Encoding,
+    @"16BitLEEncoding",
+};
+
+pub const PDDateTime = extern struct {
+    year: u16,
+    month: u8, // 1-12
+    day: u8, // 1-31
+    weekday: u8, // 1=monday-7=sunday
+    hour: u8, // 0-23
+    minute: u8,
+    second: u8,
+};
+
+pub const PlaydateSys = extern struct {
+    realloc: *const fn (ptr: ?*anyopaque, size: usize) callconv(.C) ?*anyopaque,
+    formatString: *const fn (ret: ?*[*c]u8, fmt: ?[*:0]const u8, ...) callconv(.C) c_int,
+    logToConsole: *const fn (fmt: ?[*:0]const u8, ...) callconv(.C) void,
+    @"error": *const fn (fmt: ?[*:0]const u8, ...) callconv(.C) void,
+    getLanguage: *const fn () callconv(.C) PDLanguage,
+    getCurrentTimeMilliseconds: *const fn () callconv(.C) c_uint,
+    getSecondsSinceEpoch: *const fn (milliseconds: ?*c_uint) callconv(.C) c_uint,
+    drawFPS: *const fn (x: c_int, y: c_int) callconv(.C) void,
+
+    setUpdateCallback: *const fn (update: ?PDCallbackFunction, userdata: ?*anyopaque) callconv(.C) void,
+    getButtonState: *const fn (current: ?*PDButtons, pushed: ?*PDButtons, released: ?*PDButtons) callconv(.C) void,
+    setPeripheralsEnabled: *const fn (mask: PDPeripherals) callconv(.C) void,
+    getAccelerometer: *const fn (outx: ?*f32, outy: ?*f32, outz: ?*f32) callconv(.C) void,
+    getCrankChange: *const fn () callconv(.C) f32,
+    getCrankAngle: *const fn () callconv(.C) f32,
+    isCrankDocked: *const fn () callconv(.C) c_int,
+    setCrankSoundsDisabled: *const fn (flag: c_int) callconv(.C) c_int, // returns previous setting
+
+    getFlipped: *const fn () callconv(.C) c_int,
+    setAutoLockDisabled: *const fn (disable: c_int) callconv(.C) void,
+
+    setMenuImage: *const fn (bitmap: ?*LCDBitmap, xOffset: c_int) callconv(.C) void,
+    addMenuItem: *const fn (title: ?[*:0]const u8, callback: ?PDMenuItemCallbackFunction, userdata: ?*anyopaque) callconv(.C) ?*PDMenuItem,
+    addCheckmarkMenuItem: *const fn (title: ?[*:0]const u8, value: c_int, callback: ?PDMenuItemCallbackFunction, userdata: ?*anyopaque) callconv(.C) ?*PDMenuItem,
+    addOptionsMenuItem: *const fn (title: ?[*:0]const u8, optionTitles: [*c]?[*:0]const u8, optionsCount: c_int, f: ?PDMenuItemCallbackFunction, userdata: ?*anyopaque) callconv(.C) ?*PDMenuItem,
+    removeAllMenuItems: *const fn () callconv(.C) void,
+    removeMenuItem: *const fn (menuItem: ?*PDMenuItem) callconv(.C) void,
+    getMenuItemValue: *const fn (menuItem: ?*PDMenuItem) callconv(.C) c_int,
+    setMenuItemValue: *const fn (menuItem: ?*PDMenuItem, value: c_int) callconv(.C) void,
+    getMenuItemTitle: *const fn (menuItem: ?*PDMenuItem) callconv(.C) ?[*:0]const u8,
+    setMenuItemTitle: *const fn (menuItem: ?*PDMenuItem, title: ?[*:0]const u8) callconv(.C) void,
+    getMenuItemUserdata: *const fn (menuItem: ?*PDMenuItem) callconv(.C) ?*anyopaque,
+    setMenuItemUserdata: *const fn (menuItem: ?*PDMenuItem, ud: ?*anyopaque) callconv(.C) void,
+
+    getReduceFlashing: *const fn () callconv(.C) c_int,
+
+    // 1.1
+    getElapsedTime: *const fn () callconv(.C) f32,
+    resetElapsedTime: *const fn () callconv(.C) void,
+
+    // 1.4
+    getBatteryPercentage: *const fn () callconv(.C) f32,
+    getBatteryVoltage: *const fn () callconv(.C) f32,
+
+    // 1.13
+    getTimezoneOffset: *const fn () callconv(.C) i32,
+    shouldDisplay24HourTime: *const fn () callconv(.C) c_int,
+    convertEpochToDateTime: *const fn (epoch: u32, datetime: ?*PDDateTime) callconv(.C) void,
+    convertDateTimeToEpoch: *const fn (datetime: ?*PDDateTime) callconv(.C) u32,
+
+    //2.0
+    clearICache: *const fn () callconv(.C) void,
+
+    // 2.4
+    setButtonCallback: *const fn (
+        cb: ?PDButtonCallbackFunction,
+        buttonud: ?*anyopaque,
+        queuesize: c_int,
+    ) callconv(.C) void,
+    setSerialMessageCallback: *const fn (
+        callback: *const fn (data: ?[*:0]const u8) callconv(.C) void,
+    ) callconv(.C) void,
+    vaFormatString: *const fn (
+        outstr: [*c][*c]u8,
+        fmt: ?[*:0]const u8,
+        args: VaList,
+    ) callconv(.C) c_int,
+    parseString: *const fn (
+        str: ?[*:0]const u8,
+        format: ?[*:0]const u8,
+        ...,
+    ) callconv(.C) c_int,
+
+    // ???
+    delay: *const fn (milliseconds: u32) callconv(.C) void,
+
+    // 2.7
+    getServerTime: *const fn (callback: *const fn (time: ?[*:0]const u8, err: ?[*:0]const u8) callconv(.C) void) callconv(.C) void,
+    restartGame: *const fn (launchargs: ?[*:0]const u8) callconv(.C) void,
+    getLaunchArgs: *const fn (outpath: [*c][*:0]const u8) callconv(.C) ?[*:0]const u8,
+    sendMirrorData: *const fn (command: u8, data: [*c]u8, len: c_int) callconv(.C) bool,
+
+    //NOTE(Daniel Bokser): std.builtin.VaList is not available when targeting Playdate hardware,
+    //      so we need to directly include it
+    const VaList = if (is_compiling_for_playdate_hardware() or builtin.os.tag == .windows)
+        @cImport({
+            @cInclude("stdarg.h");
+        }).va_list
+    else
+        //NOTE(Daniel Bokser):
+        //  We must use std.builtin.VaList when building for the Linux simulator.
+        //  Using stdarg.h results in a compiler error otherwise.
+        std.builtin.VaList;
+};
+
+////////LCD and Graphics///////////////////////
+pub const LCD_COLUMNS = 400;
+pub const LCD_ROWS = 240;
+pub const LCD_ROWSIZE = 52;
+pub const LCDBitmap = opaque {};
+pub const LCDVideoPlayer = opaque {};
+pub const LCDStreamPlayer = opaque {};
+pub const PlaydateVideo = extern struct {
+    loadVideo: *const fn (?[*:0]const u8) callconv(.C) ?*LCDVideoPlayer,
+    freePlayer: *const fn (?*LCDVideoPlayer) callconv(.C) void,
+    setContext: *const fn (?*LCDVideoPlayer, ?*LCDBitmap) callconv(.C) c_int,
+    useScreenContext: *const fn (?*LCDVideoPlayer) callconv(.C) void,
+    renderFrame: *const fn (?*LCDVideoPlayer, c_int) callconv(.C) c_int,
+    getError: *const fn (?*LCDVideoPlayer) callconv(.C) ?[*:0]const u8,
+    getInfo: *const fn (?*LCDVideoPlayer, [*c]c_int, [*c]c_int, [*c]f32, [*c]c_int, [*c]c_int) callconv(.C) void,
+    getContext: *const fn (?*LCDVideoPlayer) callconv(.C) ?*LCDBitmap,
+};
+
+pub const LCDPattern = [16]u8;
+pub const LCDColor = usize; //Pointer to LCDPattern or a LCDSolidColor value
+pub const LCDSolidColor = enum(c_int) {
+    ColorBlack,
+    ColorWhite,
+    ColorClear,
+    ColorXOR,
+};
+pub const LCDBitmapDrawMode = enum(c_int) {
+    DrawModeCopy,
+    DrawModeWhiteTransparent,
+    DrawModeBlackTransparent,
+    DrawModeFillWhite,
+    DrawModeFillBlack,
+    DrawModeXOR,
+    DrawModeNXOR,
+    DrawModeInverted,
+};
+pub const LCDLineCapStyle = enum(c_int) {
+    LineCapStyleButt,
+    LineCapStyleSquare,
+    LineCapStyleRound,
+};
+
+pub const LCDFontLanguage = enum(c_int) {
+    LCDFontLanguageEnglish,
+    LCDFontLanguageJapanese,
+    LCDFontLanguageUnknown,
+};
+
+pub const LCDBitmapFlip = enum(c_int) {
+    BitmapUnflipped,
+    BitmapFlippedX,
+    BitmapFlippedY,
+    BitmapFlippedXY,
+};
+
+pub const LCDPolygonFillRule = enum(c_int) {
+    PolygonFillNonZero,
+    PolygonFillEvenOdd,
+};
+
+pub const PDTextWrappingMode = enum(c_int) {
+    WrapClip,
+    WrapCharacter,
+    WrapWord,
+};
+
+pub const PDTextAlignment = enum(c_int) {
+    AlignTextLeft,
+    AlignTextCenter,
+    AlignTextRight,
+};
+
+pub const LCDTileMap = opaque {};
+pub const LCDBitmapTable = opaque {};
+pub const LCDFont = opaque {};
+pub const LCDFontPage = opaque {};
+pub const LCDFontGlyph = opaque {};
+pub const LCDFontData = opaque {};
+pub const LCDRect = extern struct {
+    left: c_int,
+    right: c_int,
+    top: c_int,
+    bottom: c_int,
+};
+
+pub const PlaydateVideostream = extern struct {
+    newPlayer: *const fn () callconv(.C) ?*LCDStreamPlayer,
+    freePlayer: *const fn (p: ?*LCDStreamPlayer) callconv(.C) void,
+
+    setBufferSize: *const fn (p: ?*LCDStreamPlayer, video: c_int, audio: c_int) callconv(.C) void,
+
+    setFile: *const fn (p: ?*LCDStreamPlayer, file: ?*SDFile) callconv(.C) void,
+
+    setHTTPConnection: *const fn (p: ?*LCDStreamPlayer, conn: ?*HTTPConnection) callconv(.C) void,
+
+    getFilePlayer: *const fn (p: ?*LCDStreamPlayer) callconv(.C) ?*FilePlayer,
+
+    getVideoPlayer: *const fn (p: ?*LCDStreamPlayer) callconv(.C) ?*LCDVideoPlayer,
+
+    // returns true if it drew a frame, else false
+    update: *const fn (p: ?*LCDStreamPlayer) callconv(.C) bool,
+
+    getBufferedFrameCount: *const fn (p: ?*LCDStreamPlayer) callconv(.C) c_int,
+
+    //     uint32_t (*getBytesRead)(LCDStreamPlayer* p);
+    getBytesRead: *const fn (p: ?*LCDStreamPlayer) callconv(.C) u32,
+
+    // 3.0
+    setTCPConnection: *const fn (p: ?*LCDStreamPlayer, conn: ?*TCPConnection) callconv(.C) void,
+};
+
+pub const PlaydateTilemap = extern struct {
+    newTilemap: *const fn () callconv(.C) ?*LCDTileMap,
+    freeTilemap: *const fn (m: ?*LCDTileMap) callconv(.C) void,
+
+    setImageTable: *const fn (m: ?*LCDTileMap, table: ?*LCDBitmapTable) callconv(.C) void,
+    getImageTable: *const fn (m: ?*LCDTileMap) callconv(.C) ?*LCDBitmapTable,
+
+    setSize: *const fn (m: ?*LCDTileMap, tilesWide: c_int, tilesHigh: c_int) callconv(.C) void,
+    getSize: *const fn (m: ?*LCDTileMap, tilesWide: ?*c_int, tilesHigh: ?*c_int) callconv(.C) void,
+    getPixelSize: *const fn (m: ?*LCDTileMap, outWidth: ?*u32, outHeight: ?*u32) callconv(.C) void,
+
+    setTiles: *const fn (m: ?*LCDTileMap, indexes: [*c]u16, count: c_int, rowwidth: c_int) callconv(.C) void,
+
+    setTileAtPosition: *const fn (m: ?*LCDTileMap, x: c_int, y: c_int, idx: u16) callconv(.C) void,
+    getTileAtPosition: *const fn (m: ?*LCDTileMap, x: c_int, y: c_int) callconv(.C) c_int,
+
+    drawAtPoint: *const fn (m: ?*LCDTileMap, x: f32, y: f32) callconv(.C) void,
+};
+
+pub const PlaydateGraphics = extern struct {
+    video: *const PlaydateVideo,
+    // Drawing Functions
+    clear: *const fn (color: LCDColor) callconv(.C) void,
+    setBackgroundColor: *const fn (color: LCDSolidColor) callconv(.C) void,
+    setStencil: *const fn (stencil: ?*LCDBitmap) callconv(.C) void, // deprecated in favor of setStencilImage, which adds a "tile" flag
+    setDrawMode: *const fn (mode: LCDBitmapDrawMode) callconv(.C) void,
+    setDrawOffset: *const fn (dx: c_int, dy: c_int) callconv(.C) void,
+    setClipRect: *const fn (x: c_int, y: c_int, width: c_int, height: c_int) callconv(.C) void,
+    clearClipRect: *const fn () callconv(.C) void,
+    setLineCapStyle: *const fn (endCapStyle: LCDLineCapStyle) callconv(.C) void,
+    setFont: *const fn (font: ?*LCDFont) callconv(.C) void,
+    setTextTracking: *const fn (tracking: c_int) callconv(.C) void,
+    pushContext: *const fn (target: ?*LCDBitmap) callconv(.C) void,
+    popContext: *const fn () callconv(.C) void,
+
+    drawBitmap: *const fn (bitmap: ?*LCDBitmap, x: c_int, y: c_int, flip: LCDBitmapFlip) callconv(.C) void,
+    tileBitmap: *const fn (bitmap: ?*LCDBitmap, x: c_int, y: c_int, width: c_int, height: c_int, flip: LCDBitmapFlip) callconv(.C) void,
+    drawLine: *const fn (x1: c_int, y1: c_int, x2: c_int, y2: c_int, width: c_int, color: LCDColor) callconv(.C) void,
+    fillTriangle: *const fn (x1: c_int, y1: c_int, x2: c_int, y2: c_int, x3: c_int, y3: c_int, color: LCDColor) callconv(.C) void,
+    drawRect: *const fn (x: c_int, y: c_int, width: c_int, height: c_int, color: LCDColor) callconv(.C) void,
+    fillRect: *const fn (x: c_int, y: c_int, width: c_int, height: c_int, color: LCDColor) callconv(.C) void,
+    drawEllipse: *const fn (x: c_int, y: c_int, width: c_int, height: c_int, lineWidth: c_int, startAngle: f32, endAngle: f32, color: LCDColor) callconv(.C) void,
+    fillEllipse: *const fn (x: c_int, y: c_int, width: c_int, height: c_int, startAngle: f32, endAngle: f32, color: LCDColor) callconv(.C) void,
+    drawScaledBitmap: *const fn (bitmap: ?*LCDBitmap, x: c_int, y: c_int, xscale: f32, yscale: f32) callconv(.C) void,
+    drawText: *const fn (text: ?*const anyopaque, len: usize, encoding: PDStringEncoding, x: c_int, y: c_int) callconv(.C) c_int,
+
+    // LCDBitmap
+    newBitmap: *const fn (width: c_int, height: c_int, color: LCDColor) callconv(.C) ?*LCDBitmap,
+    freeBitmap: *const fn (bitmap: ?*LCDBitmap) callconv(.C) void,
+    loadBitmap: *const fn (path: ?[*:0]const u8, outerr: ?*?[*:0]const u8) callconv(.C) ?*LCDBitmap,
+    copyBitmap: *const fn (bitmap: ?*LCDBitmap) callconv(.C) ?*LCDBitmap,
+    loadIntoBitmap: *const fn (path: ?[*:0]const u8, bitmap: ?*LCDBitmap, outerr: ?*?[*:0]const u8) callconv(.C) void,
+    getBitmapData: *const fn (bitmap: ?*LCDBitmap, width: ?*c_int, height: ?*c_int, rowbytes: ?*c_int, mask: ?*[*c]u8, data: ?*[*c]u8) callconv(.C) void,
+    clearBitmap: *const fn (bitmap: ?*LCDBitmap, bgcolor: LCDColor) callconv(.C) void,
+    rotatedBitmap: *const fn (bitmap: ?*LCDBitmap, rotation: f32, xscale: f32, yscale: f32, allocedSize: ?*c_int) callconv(.C) ?*LCDBitmap,
+
+    // LCDBitmapTable
+    newBitmapTable: *const fn (count: c_int, width: c_int, height: c_int) callconv(.C) ?*LCDBitmapTable,
+    freeBitmapTable: *const fn (table: ?*LCDBitmapTable) callconv(.C) void,
+    loadBitmapTable: *const fn (path: ?[*:0]const u8, outerr: ?*?[*:0]const u8) callconv(.C) ?*LCDBitmapTable,
+    loadIntoBitmapTable: *const fn (path: ?[*:0]const u8, table: ?*LCDBitmapTable, outerr: ?*?[*:0]const u8) callconv(.C) void,
+    getTableBitmap: *const fn (table: ?*LCDBitmapTable, idx: c_int) callconv(.C) ?*LCDBitmap,
+
+    // LCDFont
+    loadFont: *const fn (path: ?[*:0]const u8, outErr: ?*?[*:0]const u8) callconv(.C) ?*LCDFont,
+    getFontPage: *const fn (font: ?*LCDFont, c: u32) callconv(.C) ?*LCDFontPage,
+    getPageGlyph: *const fn (page: ?*LCDFontPage, c: u32, bitmap: ?**LCDBitmap, advance: ?*c_int) callconv(.C) ?*LCDFontGlyph,
+    getGlyphKerning: *const fn (glyph: ?*LCDFontGlyph, glyphcode: u32, nextcode: u32) callconv(.C) c_int,
+    getTextWidth: *const fn (font: ?*LCDFont, text: ?*const anyopaque, len: usize, encoding: PDStringEncoding, tracking: c_int) callconv(.C) c_int,
+
+    // raw framebuffer access
+    getFrame: *const fn () callconv(.C) [*c]u8, // row stride = LCD_ROWSIZE
+    getDisplayFrame: *const fn () callconv(.C) [*c]u8, // row stride = LCD_ROWSIZE
+    getDebugBitmap: *const fn () callconv(.C) ?*LCDBitmap, // valid in simulator only, function is null on device
+    copyFrameBufferBitmap: *const fn () callconv(.C) ?*LCDBitmap,
+    markUpdatedRows: *const fn (start: c_int, end: c_int) callconv(.C) void,
+    display: *const fn () callconv(.C) void,
+
+    // misc util.
+    setColorToPattern: *const fn (color: ?*LCDColor, bitmap: ?*LCDBitmap, x: c_int, y: c_int) callconv(.C) void,
+    checkMaskCollision: *const fn (bitmap1: ?*LCDBitmap, x1: c_int, y1: c_int, flip1: LCDBitmapFlip, bitmap2: ?*LCDBitmap, x2: c_int, y2: c_int, flip2: LCDBitmapFlip, rect: LCDRect) callconv(.C) c_int,
+
+    // 1.1
+    setScreenClipRect: *const fn (x: c_int, y: c_int, width: c_int, height: c_int) callconv(.C) void,
+
+    // 1.1.1
+    fillPolygon: *const fn (nPoints: c_int, coords: [*c]c_int, color: LCDColor, fillRule: LCDPolygonFillRule) callconv(.C) void,
+    getFontHeight: *const fn (font: ?*LCDFont) callconv(.C) u8,
+
+    // 1.7
+    getDisplayBufferBitmap: *const fn () callconv(.C) ?*LCDBitmap,
+    drawRotatedBitmap: *const fn (bitmap: ?*LCDBitmap, x: c_int, y: c_int, rotation: f32, centerx: f32, centery: f32, xscale: f32, yscale: f32) callconv(.C) void,
+    setTextLeading: *const fn (lineHeightAdustment: c_int) callconv(.C) void,
+
+    // 1.8
+    setBitmapMask: *const fn (bitmap: ?*LCDBitmap, mask: ?*LCDBitmap) callconv(.C) c_int,
+    getBitmapMask: *const fn (bitmap: ?*LCDBitmap) callconv(.C) ?*LCDBitmap,
+
+    // 1.10
+    setStencilImage: *const fn (stencil: ?*LCDBitmap, tile: c_int) callconv(.C) void,
+
+    // 1.12
+    makeFontFromData: *const fn (data: ?*LCDFontData, wide: c_int) callconv(.C) *LCDFont,
+
+    // 2.1
+    getTextTracking: *const fn () callconv(.C) c_int,
+
+    // 2.5
+    setPixel: *const fn (x: c_int, y: c_int, c: LCDColor) callconv(.C) void,
+    getBitmapPixel: *const fn (bitmap: ?*LCDBitmap, x: c_int, y: c_int) callconv(.C) LCDSolidColor,
+    getBitmapTableInfo: *const fn (table: ?*LCDBitmapTable, count: ?*c_int, width: ?*c_int) callconv(.C) void,
+
+    // 2.6
+    drawTextInRect: *const fn (text: ?*const anyopaque, len: usize, encoding: PDStringEncoding, x: c_int, y: c_int, width: c_int, height: c_int, wrap: PDTextWrappingMode, @"align": PDTextAlignment) callconv(.C) void,
+
+    // 2.7
+    getTextHeightForMaxWidth: *const fn (font: ?*LCDFont, text: ?[*:0]const u8, len: usize, maxwidth: c_int, encoding: PDStringEncoding, wrap: PDTextWrappingMode, tracking: c_int, extraLeading: c_int) callconv(.C) c_int,
+    drawRoundRect: *const fn (x: c_int, y: c_int, width: c_int, height: c_int, radius: c_int, lineWidth: c_int, color: LCDColor) callconv(.C) void,
+    fillRoundRect: *const fn (x: c_int, y: c_int, width: c_int, height: c_int, radius: c_int, color: LCDColor) callconv(.C) void,
+
+    // 3.0
+    tilemap: *const PlaydateTilemap,
+    videostream: *const PlaydateVideostream,
+};
+pub const PlaydateDisplay = struct {
+    getWidth: *const fn () callconv(.C) c_int,
+    getHeight: *const fn () callconv(.C) c_int,
+
+    setRefreshRate: *const fn (rate: f32) callconv(.C) void,
+
+    setInverted: *const fn (flag: c_int) callconv(.C) void,
+    setScale: *const fn (s: c_uint) callconv(.C) void,
+    setMosaic: *const fn (x: c_uint, y: c_uint) callconv(.C) void,
+    setFlipped: *const fn (x: c_int, y: c_int) callconv(.C) void,
+    setOffset: *const fn (x: c_int, y: c_int) callconv(.C) void,
+
+    // 2.7
+    getRefreshRate: *const fn () callconv(.C) f32,
+    getFPS: *const fn () callconv(.C) f32,
+};
+
+//////File System/////
+pub const SDFile = opaque {};
+
+pub const FileOptions = c_int;
+pub const FILE_READ = (1 << 0);
+pub const FILE_READ_DATA = (1 << 1);
+pub const FILE_WRITE = (1 << 2);
+pub const FILE_APPEND = (2 << 2);
+
+pub const SEEK_SET = 0;
+pub const SEEK_CUR = 1;
+pub const SEEK_END = 2;
+
+pub const FileStat = extern struct {
+    isdir: c_int,
+    size: c_uint,
+    m_year: c_int,
+    m_month: c_int,
+    m_day: c_int,
+    m_hour: c_int,
+    m_minute: c_int,
+    m_second: c_int,
+};
+
+pub const PlaydateFile = extern struct {
+    geterr: *const fn () callconv(.C) ?[*:0]const u8,
+
+    listfiles: *const fn (
+        path: ?[*:0]const u8,
+        callback: *const fn (path: ?[*:0]const u8, userdata: ?*anyopaque) callconv(.C) void,
+        userdata: ?*anyopaque,
+        showhidden: c_int,
+    ) callconv(.C) c_int,
+    stat: *const fn (path: ?[*:0]const u8, stat: ?*FileStat) callconv(.C) c_int,
+    mkdir: *const fn (path: ?[*:0]const u8) callconv(.C) c_int,
+    unlink: *const fn (name: ?[*:0]const u8, recursive: c_int) callconv(.C) c_int,
+    rename: *const fn (from: ?[*:0]const u8, to: ?[*:0]const u8) callconv(.C) c_int,
+
+    open: *const fn (name: ?[*:0]const u8, mode: FileOptions) callconv(.C) ?*SDFile,
+    close: *const fn (file: ?*SDFile) callconv(.C) c_int,
+    read: *const fn (file: ?*SDFile, buf: ?*anyopaque, len: c_uint) callconv(.C) c_int,
+    write: *const fn (file: ?*SDFile, buf: ?*const anyopaque, len: c_uint) callconv(.C) c_int,
+    flush: *const fn (file: ?*SDFile) callconv(.C) c_int,
+    tell: *const fn (file: ?*SDFile) callconv(.C) c_int,
+    seek: *const fn (file: ?*SDFile, pos: c_int, whence: c_int) callconv(.C) c_int,
+};
+
+/////////Audio//////////////
+pub const MicSource = enum(c_int) {
+    kMicInputAutodetect = 0,
+    kMicInputInternal = 1,
+    kMicInputHeadset = 2,
+};
+pub const PlaydateSound = extern struct {
+    channel: *const PlaydateSoundChannel,
+    fileplayer: *const PlaydateSoundFileplayer,
+    sample: *const PlaydateSoundSample,
+    sampleplayer: *const PlaydateSoundSampleplayer,
+    synth: *const PlaydateSoundSynth,
+    sequence: *const PlaydateSoundSequence,
+    effect: *const PlaydateSoundEffect,
+    lfo: *const PlaydateSoundLFO,
+    envelope: *const PlaydateSoundEnvelope,
+    source: *const PlaydateSoundSource,
+    controlsignal: *const PlaydateControlSignal,
+    track: *const PlaydateSoundTrack,
+    instrument: *const PlaydateSoundInstrument,
+
+    getCurrentTime: *const fn () callconv(.C) u32,
+    addSource: *const fn (callback: AudioSourceFunction, context: ?*anyopaque, stereo: c_int) callconv(.C) ?*SoundSource,
+
+    getDefaultChannel: *const fn () callconv(.C) ?*SoundChannel,
+
+    addChannel: *const fn (channel: ?*SoundChannel) callconv(.C) void,
+    removeChannel: *const fn (channel: ?*SoundChannel) callconv(.C) void,
+
+    setMicCallback: *const fn (callback: RecordCallback, context: ?*anyopaque, source: MicSource) callconv(.C) void,
+    getHeadphoneState: *const fn (
+        headphone: ?*c_int,
+        headsetmic: ?*c_int,
+        changeCallback: ?*const fn (headphone: c_int, mic: c_int) callconv(.C) void,
+    ) callconv(.C) void,
+    setOutputsActive: *const fn (headphone: c_int, mic: c_int) callconv(.C) void,
+
+    // 1.5
+    removeSource: *const fn (?*SoundSource) callconv(.C) void,
+
+    // 1.12
+    signal: *const PlaydateSoundSignal,
+
+    // 2.2
+    getError: *const fn () callconv(.C) ?[*:0]const u8,
+};
+
+//data is mono
+pub const RecordCallback = *const fn (context: ?*anyopaque, buffer: [*c]i16, length: c_int) callconv(.C) c_int;
+// len is # of samples in each buffer, function should return 1 if it produced output
+pub const AudioSourceFunction = *const fn (context: ?*anyopaque, left: [*c]i16, right: [*c]i16, len: c_int) callconv(.C) c_int;
+pub const SndCallbackProc = *const fn (c: ?*SoundSource, userdata: ?*anyopaque) callconv(.C) void;
+
+pub const SoundChannel = opaque {};
+pub const SoundSource = opaque {};
+pub const SoundEffect = opaque {};
+pub const PDSynthSignalValue = opaque {};
+
+pub const PlaydateSoundChannel = extern struct {
+    newChannel: *const fn () callconv(.C) ?*SoundChannel,
+    freeChannel: *const fn (channel: ?*SoundChannel) callconv(.C) void,
+    addSource: *const fn (channel: ?*SoundChannel, source: ?*SoundSource) callconv(.C) c_int,
+    removeSource: *const fn (channel: ?*SoundChannel, source: ?*SoundSource) callconv(.C) c_int,
+    addCallbackSource: *const fn (?*SoundChannel, AudioSourceFunction, ?*anyopaque, c_int) callconv(.C) ?*SoundSource,
+    addEffect: *const fn (channel: ?*SoundChannel, effect: ?*SoundEffect) callconv(.C) void,
+    removeEffect: *const fn (channel: ?*SoundChannel, effect: ?*SoundEffect) callconv(.C) void,
+    setVolume: *const fn (channel: ?*SoundChannel, f32) callconv(.C) void,
+    getVolume: *const fn (channel: ?*SoundChannel) callconv(.C) f32,
+    setVolumeModulator: *const fn (channel: ?*SoundChannel, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getVolumeModulator: *const fn (channel: ?*SoundChannel) callconv(.C) ?*PDSynthSignalValue,
+    setPan: *const fn (channel: ?*SoundChannel, pan: f32) callconv(.C) void,
+    setPanModulator: *const fn (channel: ?*SoundChannel, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getPanModulator: *const fn (channel: ?*SoundChannel) callconv(.C) ?*PDSynthSignalValue,
+    getDryLevelSignal: *const fn (channe: ?*SoundChannel) callconv(.C) ?*PDSynthSignalValue,
+    getWetLevelSignal: *const fn (channel: ?*SoundChannel) callconv(.C) ?*PDSynthSignalValue,
+};
+
+pub const FilePlayer = SoundSource;
+pub const PlaydateSoundFileplayer = extern struct {
+    newPlayer: *const fn () callconv(.C) ?*FilePlayer,
+    freePlayer: *const fn (player: ?*FilePlayer) callconv(.C) void,
+    loadIntoPlayer: *const fn (player: ?*FilePlayer, path: ?[*:0]const u8) callconv(.C) c_int,
+    setBufferLength: *const fn (player: ?*FilePlayer, bufferLen: f32) callconv(.C) void,
+    play: *const fn (player: ?*FilePlayer, repeat: c_int) callconv(.C) c_int,
+    isPlaying: *const fn (player: ?*FilePlayer) callconv(.C) c_int,
+    pause: *const fn (player: ?*FilePlayer) callconv(.C) void,
+    stop: *const fn (player: ?*FilePlayer) callconv(.C) void,
+    setVolume: *const fn (player: ?*FilePlayer, left: f32, right: f32) callconv(.C) void,
+    getVolume: *const fn (player: ?*FilePlayer, left: ?*f32, right: ?*f32) callconv(.C) void,
+    getLength: *const fn (player: ?*FilePlayer) callconv(.C) f32,
+    setOffset: *const fn (player: ?*FilePlayer, offset: f32) callconv(.C) void,
+    setRate: *const fn (player: ?*FilePlayer, rate: f32) callconv(.C) void,
+    setLoopRange: *const fn (player: ?*FilePlayer, start: f32, end: f32) callconv(.C) void,
+    didUnderrun: *const fn (player: ?*FilePlayer) callconv(.C) c_int,
+    setFinishCallback: *const fn (
+        player: ?*FilePlayer,
+        callback: ?SndCallbackProc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    setLoopCallback: *const fn (
+        player: ?*FilePlayer,
+        callback: ?SndCallbackProc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    getOffset: *const fn (player: ?*FilePlayer) callconv(.C) f32,
+    getRate: *const fn (player: ?*FilePlayer) callconv(.C) f32,
+    setStopOnUnderrun: *const fn (player: ?*FilePlayer, flag: c_int) callconv(.C) void,
+    fadeVolume: *const fn (
+        player: ?*FilePlayer,
+        left: f32,
+        right: f32,
+        len: i32,
+        finishCallback: ?SndCallbackProc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    setMP3StreamSource: *const fn (
+        player: ?*FilePlayer,
+        dataSource: *const fn (data: [*c]u8, bytes: c_int, userdata: ?*anyopaque) callconv(.C) c_int,
+        userdata: ?*anyopaque,
+        bufferLen: f32,
+    ) callconv(.C) void,
+};
+
+pub const AudioSample = opaque {};
+pub const SamplePlayer = SoundSource;
+
+pub const SoundFormat = enum(c_uint) {
+    kSound8bitMono = 0,
+    kSound8bitStereo = 1,
+    kSound16bitMono = 2,
+    kSound16bitStereo = 3,
+    kSoundADPCMMono = 4,
+    kSoundADPCMStereo = 5,
+};
+pub inline fn SoundFormatIsStereo(f: SoundFormat) bool {
+    return @intFromEnum(f) & 1;
+}
+pub inline fn SoundFormatIs16bit(f: SoundFormat) bool {
+    return switch (f) {
+        .kSound16bitMono,
+        .kSound16bitStereo,
+        .kSoundADPCMMono,
+        .kSoundADPCMStereo,
+        => true,
+        else => false,
+    };
+}
+pub inline fn SoundFormat_bytesPerFrame(fmt: SoundFormat) u32 {
+    return (if (SoundFormatIsStereo(fmt)) 2 else 1) *
+        (if (SoundFormatIs16bit(fmt)) 2 else 1);
+}
+
+pub const PlaydateSoundSample = extern struct {
+    newSampleBuffer: *const fn (byteCount: c_int) callconv(.C) ?*AudioSample,
+    loadIntoSample: *const fn (sample: ?*AudioSample, path: ?[*:0]const u8) callconv(.C) c_int,
+    load: *const fn (path: ?[*:0]const u8) callconv(.C) ?*AudioSample,
+    newSampleFromData: *const fn (data: [*c]u8, format: SoundFormat, sampleRate: u32, byteCount: c_int, shouldFreeData: c_int) callconv(.C) ?*AudioSample,
+    getData: *const fn (sample: ?*AudioSample, data: ?*[*c]u8, format: [*c]SoundFormat, sampleRate: ?*u32, byteLength: ?*u32) callconv(.C) void,
+    freeSample: *const fn (sample: ?*AudioSample) callconv(.C) void,
+    getLength: *const fn (sample: ?*AudioSample) callconv(.C) f32,
+
+    // 2.4
+    decompress: *const fn (sample: ?*AudioSample) callconv(.C) c_int,
+};
+
+pub const PlaydateSoundSampleplayer = extern struct {
+    newPlayer: *const fn () callconv(.C) ?*SamplePlayer,
+    freePlayer: *const fn (?*SamplePlayer) callconv(.C) void,
+    setSample: *const fn (player: ?*SamplePlayer, sample: ?*AudioSample) callconv(.C) void,
+    play: *const fn (player: ?*SamplePlayer, repeat: c_int, rate: f32) callconv(.C) c_int,
+    isPlaying: *const fn (player: ?*SamplePlayer) callconv(.C) c_int,
+    stop: *const fn (player: ?*SamplePlayer) callconv(.C) void,
+    setVolume: *const fn (player: ?*SamplePlayer, left: f32, right: f32) callconv(.C) void,
+    getVolume: *const fn (player: ?*SamplePlayer, left: ?*f32, right: ?*f32) callconv(.C) void,
+    getLength: *const fn (player: ?*SamplePlayer) callconv(.C) f32,
+    setOffset: *const fn (player: ?*SamplePlayer, offset: f32) callconv(.C) void,
+    setRate: *const fn (player: ?*SamplePlayer, rate: f32) callconv(.C) void,
+    setPlayRange: *const fn (player: ?*SamplePlayer, start: c_int, end: c_int) callconv(.C) void,
+    setFinishCallback: *const fn (
+        player: ?*SamplePlayer,
+        callback: ?SndCallbackProc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    setLoopCallback: *const fn (
+        player: ?*SamplePlayer,
+        callback: ?SndCallbackProc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    getOffset: *const fn (player: ?*SamplePlayer) callconv(.C) f32,
+    getRate: *const fn (player: ?*SamplePlayer) callconv(.C) f32,
+    setPaused: *const fn (player: ?*SamplePlayer, flag: c_int) callconv(.C) void,
+};
+
+pub const PDSynth = SoundSource;
+pub const SoundWaveform = enum(c_uint) {
+    kWaveformSquare = 0,
+    kWaveformTriangle = 1,
+    kWaveformSine = 2,
+    kWaveformNoise = 3,
+    kWaveformSawtooth = 4,
+    kWaveformPOPhase = 5,
+    kWaveformPODigital = 6,
+    kWaveformPOVosim = 7,
+};
+pub const NOTE_C4 = 60.0;
+pub const MIDINote = f32;
+pub inline fn pd_noteToFrequency(n: MIDINote) f32 {
+    return 440 * std.math.pow(f32, 2, (n - 69) / 12.0);
+}
+pub inline fn pd_frequencyToNote(f: f32) MIDINote {
+    return 12 * std.math.log(f32, 2, f) - 36.376316562;
+}
+
+// generator render callback
+// samples are in Q8.24 format. left is either the left channel or the single mono channel,
+// right is non-NULL only if the stereo flag was set in the setGenerator() call.
+// nsamples is at most 256 but may be shorter
+// rate is Q0.32 per-frame phase step, drate is per-frame rate step (i.e., do rate += drate every frame)
+// return value is the number of sample frames rendered
+pub const SynthRenderFunc = *const fn (userdata: ?*anyopaque, left: [*c]i32, right: [*c]i32, nsamples: c_int, rate: u32, drate: i32) callconv(.C) c_int;
+
+// generator event callbacks
+
+// len == -1 if indefinite
+pub const SynthNoteOnFunc = *const fn (userdata: ?*anyopaque, note: MIDINote, velocity: f32, len: f32) callconv(.C) void;
+
+pub const SynthReleaseFunc = *const fn (userdata: ?*anyopaque, stop: c_int) callconv(.C) void;
+pub const SynthSetParameterFunc = *const fn (userdata: ?*anyopaque, parameter: c_int, value: f32) callconv(.C) c_int;
+pub const SynthDeallocFunc = *const fn (userdata: ?*anyopaque) callconv(.C) void;
+pub const SynthCopyUserdata = *const fn (userdata: ?*anyopaque) callconv(.C) ?*anyopaque;
+
+pub const PlaydateSoundSynth = extern struct {
+    newSynth: *const fn () callconv(.C) ?*PDSynth,
+    freeSynth: *const fn (synth: ?*PDSynth) callconv(.C) void,
+
+    setWaveform: *const fn (synth: ?*PDSynth, wave: SoundWaveform) callconv(.C) void,
+    setGenerator_deprecated: *const fn (
+        synth: ?*PDSynth,
+        stereo: c_int,
+        render: SynthRenderFunc,
+        note_on: SynthNoteOnFunc,
+        release: SynthReleaseFunc,
+        set_param: SynthSetParameterFunc,
+        dealloc: SynthDeallocFunc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    setSample: *const fn (
+        synth: ?*PDSynth,
+        sample: ?*AudioSample,
+        sustain_start: u32,
+        sustain_end: u32,
+    ) callconv(.C) void,
+
+    setAttackTime: *const fn (synth: ?*PDSynth, attack: f32) callconv(.C) void,
+    setDecayTime: *const fn (synth: ?*PDSynth, decay: f32) callconv(.C) void,
+    setSustainLevel: *const fn (synth: ?*PDSynth, sustain: f32) callconv(.C) void,
+    setReleaseTime: *const fn (synth: ?*PDSynth, release: f32) callconv(.C) void,
+
+    setTranspose: *const fn (synth: ?*PDSynth, half_steps: f32) callconv(.C) void,
+
+    setFrequencyModulator: *const fn (synth: ?*PDSynth, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getFrequencyModulator: *const fn (synth: ?*PDSynth) callconv(.C) ?*PDSynthSignalValue,
+    setAmplitudeModulator: *const fn (synth: ?*PDSynth, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getAmplitudeModulator: *const fn (synth: ?*PDSynth) callconv(.C) ?*PDSynthSignalValue,
+
+    getParameterCount: *const fn (synth: ?*PDSynth) callconv(.C) c_int,
+    setParameter: *const fn (synth: ?*PDSynth, parameter: c_int, value: f32) callconv(.C) c_int,
+    setParameterModulator: *const fn (synth: ?*PDSynth, parameter: c_int, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getParameterModulator: *const fn (synth: ?*PDSynth, parameter: c_int) callconv(.C) ?*PDSynthSignalValue,
+
+    playNote: *const fn (synth: ?*PDSynth, freq: f32, vel: f32, len: f32, when: u32) callconv(.C) void,
+    playMIDINote: *const fn (synth: ?*PDSynth, note: MIDINote, vel: f32, len: f32, when: u32) callconv(.C) void,
+    noteOff: *const fn (synth: ?*PDSynth, when: u32) callconv(.C) void,
+    stop: *const fn (synth: ?*PDSynth) callconv(.C) void,
+
+    setVolume: *const fn (synth: ?*PDSynth, left: f32, right: f32) callconv(.C) void,
+    getVolume: *const fn (synth: ?*PDSynth, left: ?*f32, right: ?*f32) callconv(.C) void,
+
+    isPlaying: *const fn (synth: ?*PDSynth) callconv(.C) c_int,
+
+    // 1.13
+    getEnvelope: *const fn (synth: ?*PDSynth) callconv(.C) ?*PDSynthEnvelope, // synth keeps ownership--don't free this!
+
+    // 2.2
+    setWavetable: *const fn (synth: ?*PDSynth, sample: ?*AudioSample, log2size: c_int, columns: c_int, rows: c_int) callconv(.C) c_int,
+
+    // 2.4
+    setGenerator: *const fn (
+        synth: ?*PDSynth,
+        stereo: c_int,
+        render: SynthRenderFunc,
+        noteOn: SynthNoteOnFunc,
+        release: SynthReleaseFunc,
+        setparam: SynthSetParameterFunc,
+        dealloc: SynthDeallocFunc,
+        copyUserdata: SynthCopyUserdata,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+    copy: *const fn (synth: ?*PDSynth) callconv(.C) ?*PDSynth,
+
+    // 2.6
+    clearEnvelope: *const fn (synth: ?*PDSynth) callconv(.C) void,
+};
+
+pub const SequenceTrack = opaque {};
+pub const SoundSequence = opaque {};
+pub const SequenceFinishedCallback = *const fn (seq: ?*SoundSequence, userdata: ?*anyopaque) callconv(.C) void;
+
+pub const PlaydateSoundSequence = extern struct {
+    newSequence: *const fn () callconv(.C) ?*SoundSequence,
+    freeSequence: *const fn (sequence: ?*SoundSequence) callconv(.C) void,
+
+    loadMidiFile: *const fn (seq: ?*SoundSequence, path: ?[*:0]const u8) callconv(.C) c_int,
+    getTime: *const fn (seq: ?*SoundSequence) callconv(.C) u32,
+    setTime: *const fn (seq: ?*SoundSequence, time: u32) callconv(.C) void,
+    setLoops: *const fn (seq: ?*SoundSequence, loopstart: c_int, loopend: c_int, loops: c_int) callconv(.C) void,
+    getTempo_deprecated: *const fn (seq: ?*SoundSequence) callconv(.C) c_int,
+    setTempo: *const fn (seq: ?*SoundSequence, stepsPerSecond: c_int) callconv(.C) void,
+    getTrackCount: *const fn (seq: ?*SoundSequence) callconv(.C) c_int,
+    addTrack: *const fn (seq: ?*SoundSequence) callconv(.C) ?*SequenceTrack,
+    getTrackAtIndex: *const fn (seq: ?*SoundSequence, track: c_uint) callconv(.C) ?*SequenceTrack,
+    setTrackAtIndex: *const fn (seq: ?*SoundSequence, ?*SequenceTrack, idx: c_uint) callconv(.C) void,
+    allNotesOff: *const fn (seq: ?*SoundSequence) callconv(.C) void,
+
+    // 1.1
+    isPlaying: *const fn (seq: ?*SoundSequence) callconv(.C) c_int,
+    getLength: *const fn (seq: ?*SoundSequence) callconv(.C) u32,
+    play: *const fn (seq: ?*SoundSequence, finishCallback: SequenceFinishedCallback, userdata: ?*anyopaque) callconv(.C) void,
+    stop: *const fn (seq: ?*SoundSequence) callconv(.C) void,
+    getCurrentStep: *const fn (seq: ?*SoundSequence, timeOffset: ?*c_int) callconv(.C) c_int,
+    setCurrentStep: *const fn (seq: ?*SoundSequence, step: c_int, timeOffset: c_int, playNotes: c_int) callconv(.C) void,
+
+    // 2.5
+    getTempo: *const fn (seq: ?*SoundSequence) callconv(.C) f32,
+};
+
+pub const EffectProc = *const fn (e: ?*SoundEffect, left: [*c]i32, right: [*c]i32, nsamples: c_int, bufactive: c_int) callconv(.C) c_int;
+
+pub const PlaydateSoundEffect = extern struct {
+    newEffect: *const fn (proc: ?*const EffectProc, userdata: ?*anyopaque) callconv(.C) ?*SoundEffect,
+    freeEffect: *const fn (effect: ?*SoundEffect) callconv(.C) void,
+
+    setMix: *const fn (effect: ?*SoundEffect, level: f32) callconv(.C) void,
+    setMixModulator: *const fn (effect: ?*SoundEffect, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getMixModulator: *const fn (effect: ?*SoundEffect) callconv(.C) ?*PDSynthSignalValue,
+
+    setUserdata: *const fn (effect: ?*SoundEffect, userdata: ?*anyopaque) callconv(.C) void,
+    getUserdata: *const fn (effect: ?*SoundEffect) callconv(.C) ?*anyopaque,
+
+    twopolefilter: *const PlaydateSoundEffectTwopolefilter,
+    onepolefilter: *const PlaydateSoundEffectOnepolefilter,
+    bitcrusher: *const PlaydateSoundEffectBitcrusher,
+    ringmodulator: *const PlaydateSoundEffectRingmodulator,
+    delayline: *const PlaydateSoundEffectDelayline,
+    overdrive: *const PlaydateSoundEffectOverdrive,
+};
+pub const LFOType = enum(c_uint) {
+    kLFOTypeSquare = 0,
+    kLFOTypeTriangle = 1,
+    kLFOTypeSine = 2,
+    kLFOTypeSampleAndHold = 3,
+    kLFOTypeSawtoothUp = 4,
+    kLFOTypeSawtoothDown = 5,
+    kLFOTypeArpeggiator = 6,
+    kLFOTypeFunction = 7,
+};
+pub const PDSynthLFO = opaque {};
+pub const PlaydateSoundLFO = extern struct {
+    newLFO: *const fn (LFOType) callconv(.C) ?*PDSynthLFO,
+    freeLFO: *const fn (lfo: ?*PDSynthLFO) callconv(.C) void,
+
+    setType: *const fn (lfo: ?*PDSynthLFO, type: LFOType) callconv(.C) void,
+    setRate: *const fn (lfo: ?*PDSynthLFO, rate: f32) callconv(.C) void,
+    setPhase: *const fn (lfo: ?*PDSynthLFO, phase: f32) callconv(.C) void,
+    setCenter: *const fn (lfo: ?*PDSynthLFO, center: f32) callconv(.C) void,
+    setDepth: *const fn (lfo: ?*PDSynthLFO, depth: f32) callconv(.C) void,
+    setArpeggiation: *const fn (lfo: ?*PDSynthLFO, nSteps: c_int, steps: [*c]f32) callconv(.C) void,
+    setFunction: *const fn (
+        lfo: ?*PDSynthLFO,
+        lfoFunc: *const fn (lfo: ?*PDSynthLFO, userdata: ?*anyopaque) callconv(.C) f32,
+        userdata: ?*anyopaque,
+        interpolate: c_int,
+    ) callconv(.C) void,
+    setDelay: *const fn (lfo: ?*PDSynthLFO, holdoff: f32, ramptime: f32) callconv(.C) void,
+    setRetrigger: *const fn (lfo: ?*PDSynthLFO, flag: c_int) callconv(.C) void,
+
+    getValue: *const fn (lfo: ?*PDSynthLFO) callconv(.C) f32,
+
+    // 1.10
+    setGlobal: *const fn (lfo: ?*PDSynthLFO, global: c_int) callconv(.C) void,
+};
+
+pub const PDSynthEnvelope = opaque {};
+pub const PlaydateSoundEnvelope = extern struct {
+    newEnvelope: *const fn (attack: f32, decay: f32, sustain: f32, release: f32) callconv(.C) ?*PDSynthEnvelope,
+    freeEnvelope: *const fn (env: ?*PDSynthEnvelope) callconv(.C) void,
+
+    setAttack: *const fn (env: ?*PDSynthEnvelope, attack: f32) callconv(.C) void,
+    setDecay: *const fn (env: ?*PDSynthEnvelope, decay: f32) callconv(.C) void,
+    setSustain: *const fn (env: ?*PDSynthEnvelope, sustain: f32) callconv(.C) void,
+    setRelease: *const fn (env: ?*PDSynthEnvelope, release: f32) callconv(.C) void,
+
+    setLegato: *const fn (env: ?*PDSynthEnvelope, flag: c_int) callconv(.C) void,
+    setRetrigger: *const fn (env: ?*PDSynthEnvelope, flag: c_int) callconv(.C) void,
+
+    getValue: *const fn (env: ?*PDSynthEnvelope) callconv(.C) f32,
+
+    // 1.13
+    setCurvature: *const fn (env: ?*PDSynthEnvelope, amount: f32) callconv(.C) void,
+    setVelocitySensitivity: *const fn (env: ?*PDSynthEnvelope, velsens: f32) callconv(.C) void,
+    setRateScaling: *const fn (env: ?*PDSynthEnvelope, scaling: f32, start: MIDINote, end: MIDINote) callconv(.C) void,
+};
+
+pub const PlaydateSoundSource = extern struct {
+    setVolume: *const fn (c: ?*SoundSource, lvol: f32, rvol: f32) callconv(.C) void,
+    getVolume: *const fn (c: ?*SoundSource, outl: ?*f32, outr: ?*f32) callconv(.C) void,
+    isPlaying: *const fn (c: ?*SoundSource) callconv(.C) c_int,
+    setFinishCallback: *const fn (
+        c: ?*SoundSource,
+        callback: SndCallbackProc,
+        userdata: ?*anyopaque,
+    ) callconv(.C) void,
+};
+
+pub const ControlSignal = opaque {};
+pub const PlaydateControlSignal = extern struct {
+    newSignal: *const fn () callconv(.C) ?*ControlSignal,
+    freeSignal: *const fn (signal: ?*ControlSignal) callconv(.C) void,
+    clearEvents: *const fn (control: ?*ControlSignal) callconv(.C) void,
+    addEvent: *const fn (control: ?*ControlSignal, step: c_int, value: f32, c_int) callconv(.C) void,
+    removeEvent: *const fn (control: ?*ControlSignal, step: c_int) callconv(.C) void,
+    getMIDIControllerNumber: *const fn (control: ?*ControlSignal) callconv(.C) c_int,
+};
+
+pub const PlaydateSoundTrack = extern struct {
+    newTrack: *const fn () callconv(.C) ?*SequenceTrack,
+    freeTrack: *const fn (track: ?*SequenceTrack) callconv(.C) void,
+
+    setInstrument: *const fn (track: ?*SequenceTrack, inst: ?*PDSynthInstrument) callconv(.C) void,
+    getInstrument: *const fn (track: ?*SequenceTrack) callconv(.C) ?*PDSynthInstrument,
+
+    addNoteEvent: *const fn (track: ?*SequenceTrack, step: u32, len: u32, note: MIDINote, velocity: f32) callconv(.C) void,
+    removeNoteEvent: *const fn (track: ?*SequenceTrack, step: u32, note: MIDINote) callconv(.C) void,
+    clearNotes: *const fn (track: ?*SequenceTrack) callconv(.C) void,
+
+    getControlSignalCount: *const fn (track: ?*SequenceTrack) callconv(.C) c_int,
+    getControlSignal: *const fn (track: ?*SequenceTrack, idx: c_int) callconv(.C) ?*ControlSignal,
+    clearControlEvents: *const fn (track: ?*SequenceTrack) callconv(.C) void,
+
+    getPolyphony: *const fn (track: ?*SequenceTrack) callconv(.C) c_int,
+    activeVoiceCount: *const fn (track: ?*SequenceTrack) callconv(.C) c_int,
+
+    setMuted: *const fn (track: ?*SequenceTrack, mute: c_int) callconv(.C) void,
+
+    // 1.1
+    getLength: *const fn (track: ?*SequenceTrack) callconv(.C) u32,
+    getIndexForStep: *const fn (track: ?*SequenceTrack, step: u32) callconv(.C) c_int,
+    getNoteAtIndex: *const fn (track: ?*SequenceTrack, index: c_int, outSteo: ?*u32, outLen: ?*u32, outeNote: ?*MIDINote, outVelocity: ?*f32) callconv(.C) c_int,
+
+    //1.10
+    getSignalForController: *const fn (track: ?*SequenceTrack, controller: c_int, create: c_int) callconv(.C) ?*ControlSignal,
+};
+
+pub const PDSynthInstrument = SoundSource;
+pub const PlaydateSoundInstrument = extern struct {
+    newInstrument: *const fn () callconv(.C) ?*PDSynthInstrument,
+    freeInstrument: *const fn (inst: ?*PDSynthInstrument) callconv(.C) void,
+    addVoice: *const fn (inst: ?*PDSynthInstrument, synth: ?*PDSynth, rangeStart: MIDINote, rangeEnd: MIDINote, transpose: f32) callconv(.C) c_int,
+    playNote: *const fn (inst: ?*PDSynthInstrument, frequency: f32, vel: f32, len: f32, when: u32) callconv(.C) ?*PDSynth,
+    playMIDINote: *const fn (inst: ?*PDSynthInstrument, note: MIDINote, vel: f32, len: f32, when: u32) callconv(.C) ?*PDSynth,
+    setPitchBend: *const fn (inst: ?*PDSynthInstrument, bend: f32) callconv(.C) void,
+    setPitchBendRange: *const fn (inst: ?*PDSynthInstrument, halfSteps: f32) callconv(.C) void,
+    setTranspose: *const fn (inst: ?*PDSynthInstrument, halfSteps: f32) callconv(.C) void,
+    noteOff: *const fn (inst: ?*PDSynthInstrument, note: MIDINote, when: u32) callconv(.C) void,
+    allNotesOff: *const fn (inst: ?*PDSynthInstrument, when: u32) callconv(.C) void,
+    setVolume: *const fn (inst: ?*PDSynthInstrument, left: f32, right: f32) callconv(.C) void,
+    getVolume: *const fn (inst: ?*PDSynthInstrument, left: ?*f32, right: ?*f32) callconv(.C) void,
+    activeVoiceCount: *const fn (inst: ?*PDSynthInstrument) callconv(.C) c_int,
+};
+
+pub const PDSynthSignal = opaque {};
+pub const SignalStepFunc = *const fn (userdata: ?*anyopaque, ioframes: [*c]c_int, ifval: ?*f32) callconv(.C) f32;
+// len = -1 for indefinite
+pub const SignalNoteOnFunc = *const fn (userdata: ?*anyopaque, note: MIDINote, vel: f32, len: f32) callconv(.C) void;
+// ended = 0 for note release, = 1 when note stops playing
+pub const SignalNoteOffFunc = *const fn (userdata: ?*anyopaque, stopped: c_int, offset: c_int) callconv(.C) void;
+pub const SignalDeallocFunc = *const fn (userdata: ?*anyopaque) callconv(.C) void;
+pub const PlaydateSoundSignal = struct {
+    newSignal: *const fn (step: SignalStepFunc, noteOn: SignalNoteOnFunc, noteOff: SignalNoteOffFunc, dealloc: SignalDeallocFunc, userdata: ?*anyopaque) callconv(.C) ?*PDSynthSignal,
+    freeSignal: *const fn (signal: ?*PDSynthSignal) callconv(.C) void,
+    getValue: *const fn (signal: ?*PDSynthSignal) callconv(.C) f32,
+    setValueScale: *const fn (signal: ?*PDSynthSignal, scale: f32) callconv(.C) void,
+    setValueOffset: *const fn (signal: ?*PDSynthSignal, offset: f32) callconv(.C) void,
+};
+
+// EFFECTS
+
+// A SoundEffect processes the output of a channel's SoundSources
+
+pub const TwoPoleFilter = SoundEffect;
+pub const TwoPoleFilterType = enum(c_int) {
+    FilterTypeLowPass,
+    FilterTypeHighPass,
+    FilterTypeBandPass,
+    FilterTypeNotch,
+    FilterTypePEQ,
+    FilterTypeLowShelf,
+    FilterTypeHighShelf,
+};
+pub const PlaydateSoundEffectTwopolefilter = extern struct {
+    newFilter: *const fn () callconv(.C) ?*TwoPoleFilter,
+    freeFilter: *const fn (filter: ?*TwoPoleFilter) callconv(.C) void,
+    setType: *const fn (filter: ?*TwoPoleFilter, type: TwoPoleFilterType) callconv(.C) void,
+    setFrequency: *const fn (filter: ?*TwoPoleFilter, frequency: f32) callconv(.C) void,
+    setFrequencyModulator: *const fn (filter: ?*TwoPoleFilter, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getFrequencyModulator: *const fn (filter: ?*TwoPoleFilter) callconv(.C) ?*PDSynthSignalValue,
+    setGain: *const fn (filter: ?*TwoPoleFilter, f32) callconv(.C) void,
+    setResonance: *const fn (filter: ?*TwoPoleFilter, f32) callconv(.C) void,
+    setResonanceModulator: *const fn (filter: ?*TwoPoleFilter, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getResonanceModulator: *const fn (filter: ?*TwoPoleFilter) callconv(.C) ?*PDSynthSignalValue,
+};
+
+pub const OnePoleFilter = SoundEffect;
+pub const PlaydateSoundEffectOnepolefilter = extern struct {
+    newFilter: *const fn () callconv(.C) ?*OnePoleFilter,
+    freeFilter: *const fn (filter: ?*OnePoleFilter) callconv(.C) void,
+    setParameter: *const fn (filter: ?*OnePoleFilter, parameter: f32) callconv(.C) void,
+    setParameterModulator: *const fn (filter: ?*OnePoleFilter, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getParameterModulator: *const fn (filter: ?*OnePoleFilter) callconv(.C) ?*PDSynthSignalValue,
+};
+
+pub const BitCrusher = SoundEffect;
+pub const PlaydateSoundEffectBitcrusher = extern struct {
+    newBitCrusher: *const fn () callconv(.C) ?*BitCrusher,
+    freeBitCrusher: *const fn (filter: ?*BitCrusher) callconv(.C) void,
+    setAmount: *const fn (filter: ?*BitCrusher, amount: f32) callconv(.C) void,
+    setAmountModulator: *const fn (filter: ?*BitCrusher, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getAmountModulator: *const fn (filter: ?*BitCrusher) callconv(.C) ?*PDSynthSignalValue,
+    setUndersampling: *const fn (filter: ?*BitCrusher, undersampling: f32) callconv(.C) void,
+    setUndersampleModulator: *const fn (filter: ?*BitCrusher, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getUndersampleModulator: *const fn (filter: ?*BitCrusher) callconv(.C) ?*PDSynthSignalValue,
+};
+
+pub const RingModulator = SoundEffect;
+pub const PlaydateSoundEffectRingmodulator = extern struct {
+    newRingmod: *const fn () callconv(.C) ?*RingModulator,
+    freeRingmod: *const fn (filter: ?*RingModulator) callconv(.C) void,
+    setFrequency: *const fn (filter: ?*RingModulator, frequency: f32) callconv(.C) void,
+    setFrequencyModulator: *const fn (filter: ?*RingModulator, signal: ?*PDSynthSignalValue) callconv(.C) void,
+    getFrequencyModulator: *const fn (filter: ?*RingModulator) callconv(.C) ?*PDSynthSignalValue,
+};
+
+pub const DelayLine = SoundEffect;
+pub const DelayLineTap = SoundSource;
+pub const PlaydateSoundEffectDelayline = extern struct {
+    newDelayLine: *const fn (length: c_int, stereo: c_int) callconv(.C) ?*DelayLine,
+    freeDelayLine: *const fn (filter: ?*DelayLine) callconv(.C) void,
+    setLength: *const fn (filter: ?*DelayLine, frames: c_int) callconv(.C) void,
+    setFeedback: *const fn (filter: ?*DelayLine, fb: f32) callconv(.C) void,
+    addTap: *const fn (filter: ?*DelayLine, delay: c_int) callconv(.C) ?*DelayLineTap,
+
+    // note that DelayLineTap is a SoundSource, not a SoundEffect
+    freeTap: *const fn (tap: ?*DelayLineTap) callconv(.C) void,
+    setTapDelay: *const fn (t: ?*DelayLineTap, frames: c_int) callconv(.C) void,
+    setTapDelayModulator: *const fn (t: ?*DelayLineTap, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getTapDelayModulator: *const fn (t: ?*DelayLineTap) callconv(.C) ?*PDSynthSignalValue,
+    setTapChannelsFlipped: *const fn (t: ?*DelayLineTap, flip: c_int) callconv(.C) void,
+};
+
+pub const Overdrive = SoundEffect;
+pub const PlaydateSoundEffectOverdrive = extern struct {
+    newOverdrive: *const fn () callconv(.C) ?*Overdrive,
+    freeOverdrive: *const fn (filter: ?*Overdrive) callconv(.C) void,
+    setGain: *const fn (o: ?*Overdrive, gain: f32) callconv(.C) void,
+    setLimit: *const fn (o: ?*Overdrive, limit: f32) callconv(.C) void,
+    setLimitModulator: *const fn (o: ?*Overdrive, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getLimitModulator: *const fn (o: ?*Overdrive) callconv(.C) ?*PDSynthSignalValue,
+    setOffset: *const fn (o: ?*Overdrive, offset: f32) callconv(.C) void,
+    setOffsetModulator: *const fn (o: ?*Overdrive, mod: ?*PDSynthSignalValue) callconv(.C) void,
+    getOffsetModulator: *const fn (o: ?*Overdrive) callconv(.C) ?*PDSynthSignalValue,
+};
+
+//////Sprite/////
+pub const SpriteCollisionResponseType = enum(c_int) {
+    CollisionTypeSlide,
+    CollisionTypeFreeze,
+    CollisionTypeOverlap,
+    CollisionTypeBounce,
+};
+pub const PDRect = extern struct {
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+};
+
+pub fn PDRectMake(x: f32, y: f32, width: f32, height: f32) callconv(.C) PDRect {
+    return .{
+        .x = x,
+        .y = y,
+        .width = width,
+        .height = height,
+    };
+}
+
+pub const CollisionPoint = extern struct {
+    x: f32,
+    y: f32,
+};
+pub const CollisionVector = extern struct {
+    x: c_int,
+    y: c_int,
+};
+
+pub const SpriteCollisionInfo = extern struct {
+    sprite: ?*LCDSprite, // The sprite being moved
+    other: ?*LCDSprite, // The sprite being moved
+    responseType: SpriteCollisionResponseType, // The result of collisionResponse
+    overlaps: u8, // True if the sprite was overlapping other when the collision started. False if it didn’t overlap but tunneled through other.
+    ti: f32, // A number between 0 and 1 indicating how far along the movement to the goal the collision occurred
+    move: CollisionPoint, // The difference between the original coordinates and the actual ones when the collision happened
+    normal: CollisionVector, // The collision normal; usually -1, 0, or 1 in x and y. Use this value to determine things like if your character is touching the ground.
+    touch: CollisionPoint, // The coordinates where the sprite started touching other
+    spriteRect: PDRect, // The rectangle the sprite occupied when the touch happened
+    otherRect: PDRect, // The rectangle the sprite being collided with occupied when the touch happened
+};
+
+pub const SpriteQueryInfo = extern struct {
+    sprite: ?*LCDSprite, // The sprite being intersected by the segment
+    // ti1 and ti2 are numbers between 0 and 1 which indicate how far from the starting point of the line segment the collision happened
+    ti1: f32, // entry point
+    ti2: f32, // exit point
+    entryPoint: CollisionPoint, // The coordinates of the first intersection between sprite and the line segment
+    exitPoint: CollisionPoint, // The coordinates of the second intersection between sprite and the line segment
+};
+
+pub const LCDSprite = opaque {};
+pub const CWCollisionInfo = opaque {};
+pub const CWItemInfo = opaque {};
+
+pub const LCDSpriteDrawFunction = ?*const fn (sprite: ?*LCDSprite, bounds: PDRect, drawrect: PDRect) callconv(.C) void;
+pub const LCDSpriteUpdateFunction = ?*const fn (sprite: ?*LCDSprite) callconv(.C) void;
+pub const LCDSpriteCollisionFilterProc = ?*const fn (sprite: ?*LCDSprite, other: ?*LCDSprite) callconv(.C) SpriteCollisionResponseType;
+
+pub const PlaydateSprite = extern struct {
+    setAlwaysRedraw: *const fn (flag: c_int) callconv(.C) void,
+    addDirtyRect: *const fn (dirtyRect: LCDRect) callconv(.C) void,
+    drawSprites: *const fn () callconv(.C) void,
+    updateAndDrawSprites: *const fn () callconv(.C) void,
+
+    newSprite: *const fn () callconv(.C) ?*LCDSprite,
+    freeSprite: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+    copy: *const fn (sprite: ?*LCDSprite) callconv(.C) ?*LCDSprite,
+
+    addSprite: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+    removeSprite: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+    removeSprites: *const fn (sprite: [*c]?*LCDSprite, count: c_int) callconv(.C) void,
+    removeAllSprites: *const fn () callconv(.C) void,
+    getSpriteCount: *const fn () callconv(.C) c_int,
+
+    setBounds: *const fn (sprite: ?*LCDSprite, bounds: PDRect) callconv(.C) void,
+    getBounds: *const fn (sprite: ?*LCDSprite) callconv(.C) PDRect,
+    moveTo: *const fn (sprite: ?*LCDSprite, x: f32, y: f32) callconv(.C) void,
+    moveBy: *const fn (sprite: ?*LCDSprite, dx: f32, dy: f32) callconv(.C) void,
+
+    setImage: *const fn (sprite: ?*LCDSprite, image: ?*LCDBitmap, flip: LCDBitmapFlip) callconv(.C) void,
+    getImage: *const fn (sprite: ?*LCDSprite) callconv(.C) ?*LCDBitmap,
+    setSize: *const fn (s: ?*LCDSprite, width: f32, height: f32) callconv(.C) void,
+    setZIndex: *const fn (s: ?*LCDSprite, zIndex: i16) callconv(.C) void,
+    getZIndex: *const fn (sprite: ?*LCDSprite) callconv(.C) i16,
+
+    setDrawMode: *const fn (sprite: ?*LCDSprite, mode: LCDBitmapDrawMode) callconv(.C) LCDBitmapDrawMode,
+    setImageFlip: *const fn (sprite: ?*LCDSprite, flip: LCDBitmapFlip) callconv(.C) void,
+    getImageFlip: *const fn (sprite: ?*LCDSprite) callconv(.C) LCDBitmapFlip,
+    setStencil: *const fn (sprite: ?*LCDSprite, mode: ?*LCDBitmap) callconv(.C) void, // deprecated in favor of setStencilImage()
+
+    setClipRect: *const fn (sprite: ?*LCDSprite, clipRect: LCDRect) callconv(.C) void,
+    clearClipRect: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+    setClipRectsInRange: *const fn (clipRect: LCDRect, startZ: c_int, endZ: c_int) callconv(.C) void,
+    clearClipRectsInRange: *const fn (startZ: c_int, endZ: c_int) callconv(.C) void,
+
+    setUpdatesEnabled: *const fn (sprite: ?*LCDSprite, flag: c_int) callconv(.C) void,
+    updatesEnabled: *const fn (sprite: ?*LCDSprite) callconv(.C) c_int,
+    setCollisionsEnabled: *const fn (sprite: ?*LCDSprite, flag: c_int) callconv(.C) void,
+    collisionsEnabled: *const fn (sprite: ?*LCDSprite) callconv(.C) c_int,
+    setVisible: *const fn (sprite: ?*LCDSprite, flag: c_int) callconv(.C) void,
+    isVisible: *const fn (sprite: ?*LCDSprite) callconv(.C) c_int,
+    setOpaque: *const fn (sprite: ?*LCDSprite, flag: c_int) callconv(.C) void,
+    markDirty: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+
+    setTag: *const fn (sprite: ?*LCDSprite, tag: u8) callconv(.C) void,
+    getTag: *const fn (sprite: ?*LCDSprite) callconv(.C) u8,
+
+    setIgnoresDrawOffset: *const fn (sprite: ?*LCDSprite, flag: c_int) callconv(.C) void,
+
+    setUpdateFunction: *const fn (sprite: ?*LCDSprite, func: LCDSpriteUpdateFunction) callconv(.C) void,
+    setDrawFunction: *const fn (sprite: ?*LCDSprite, func: LCDSpriteDrawFunction) callconv(.C) void,
+
+    getPosition: *const fn (s: ?*LCDSprite, x: ?*f32, y: ?*f32) callconv(.C) void,
+
+    // Collisions
+    resetCollisionWorld: *const fn () callconv(.C) void,
+
+    setCollideRect: *const fn (sprite: ?*LCDSprite, collideRect: PDRect) callconv(.C) void,
+    getCollideRect: *const fn (sprite: ?*LCDSprite) callconv(.C) PDRect,
+    clearCollideRect: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+
+    // caller is responsible for freeing the returned array for all collision methods
+    setCollisionResponseFunction: *const fn (sprite: ?*LCDSprite, func: LCDSpriteCollisionFilterProc) callconv(.C) void,
+    checkCollisions: *const fn (sprite: ?*LCDSprite, goalX: f32, goalY: f32, actualX: ?*f32, actualY: ?*f32, len: ?*c_int) callconv(.C) [*c]SpriteCollisionInfo, // access results using const info = &results[i];
+    moveWithCollisions: *const fn (sprite: ?*LCDSprite, goalX: f32, goalY: f32, actualX: ?*f32, actualY: ?*f32, len: ?*c_int) callconv(.C) [*c]SpriteCollisionInfo,
+    querySpritesAtPoint: *const fn (x: f32, y: f32, len: ?*c_int) callconv(.C) [*c]?*LCDSprite,
+    querySpritesInRect: *const fn (x: f32, y: f32, width: f32, height: f32, len: ?*c_int) callconv(.C) [*c]?*LCDSprite,
+    querySpritesAlongLine: *const fn (x1: f32, y1: f32, x2: f32, y2: f32, len: ?*c_int) callconv(.C) [*c]?*LCDSprite,
+    querySpriteInfoAlongLine: *const fn (x1: f32, y1: f32, x2: f32, y2: f32, len: ?*c_int) callconv(.C) [*c]SpriteQueryInfo, // access results using const info = &results[i];
+    overlappingSprites: *const fn (sprite: ?*LCDSprite, len: ?*c_int) callconv(.C) [*c]?*LCDSprite,
+    allOverlappingSprites: *const fn (len: ?*c_int) callconv(.C) [*c]?*LCDSprite,
+
+    // added in 1.7
+    setStencilPattern: *const fn (sprite: ?*LCDSprite, pattern: [*c]u8) callconv(.C) void, //pattern is 8 bytes
+    clearStencil: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+
+    setUserdata: *const fn (sprite: ?*LCDSprite, userdata: ?*anyopaque) callconv(.C) void,
+    getUserdata: *const fn (sprite: ?*LCDSprite) callconv(.C) ?*anyopaque,
+
+    // added in 1.10
+    setStencilImage: *const fn (sprite: ?*LCDSprite, stencil: ?*LCDBitmap, tile: c_int) callconv(.C) void,
+
+    // 2.1
+    setCenter: *const fn (s: ?*LCDSprite, x: f32, y: f32) callconv(.C) void,
+    getCenter: *const fn (s: ?*LCDSprite, x: ?*f32, y: ?*f32) callconv(.C) void,
+
+    // 2.7
+    setTilemap: *const fn (s: ?*LCDSprite, tilemap: ?*LCDTileMap) callconv(.C) void,
+    getTilemap: *const fn (s: ?*LCDSprite) callconv(.C) ?*LCDTileMap,
+};
+
+////////Lua///////
+pub const LuaState = ?*anyopaque;
+pub const LuaCFunction = ?*const fn (state: ?*LuaState) callconv(.C) c_int;
+pub const LuaUDObject = opaque {};
+
+//literal value
+pub const LValType = enum(c_int) {
+    Int = 0,
+    Float = 1,
+    Str = 2,
+};
+pub const LuaReg = extern struct {
+    name: ?[*:0]const u8,
+    func: LuaCFunction,
+};
+pub const LuaType = enum(c_int) {
+    TypeNil = 0,
+    TypeBool = 1,
+    TypeInt = 2,
+    TypeFloat = 3,
+    TypeString = 4,
+    TypeTable = 5,
+    TypeFunction = 6,
+    TypeThread = 7,
+    TypeObject = 8,
+};
+pub const LuaVal = extern struct {
+    name: ?[*:0]const u8,
+    type: LValType,
+    v: extern union {
+        intval: c_uint,
+        floatval: f32,
+        strval: ?[*:0]const u8,
+    },
+};
+pub const PlaydateLua = extern struct {
+    // these two return 1 on success, else 0 with an error message in outErr
+    addFunction: *const fn (f: LuaCFunction, name: ?[*:0]const u8, outErr: ?*?[*:0]const u8) callconv(.C) c_int,
+    registerClass: *const fn (name: ?[*:0]const u8, reg: ?*const LuaReg, vals: [*c]const LuaVal, isstatic: c_int, outErr: ?*?[*:0]const u8) callconv(.C) c_int,
+
+    pushFunction: *const fn (f: LuaCFunction) callconv(.C) void,
+    indexMetatable: *const fn () callconv(.C) c_int,
+
+    stop: *const fn () callconv(.C) void,
+    start: *const fn () callconv(.C) void,
+
+    // stack operations
+    getArgCount: *const fn () callconv(.C) c_int,
+    getArgType: *const fn (pos: c_int, outClass: ?*?[*:0]const u8) callconv(.C) LuaType,
+
+    argIsNil: *const fn (pos: c_int) callconv(.C) c_int,
+    getArgBool: *const fn (pos: c_int) callconv(.C) c_int,
+    getArgInt: *const fn (pos: c_int) callconv(.C) c_int,
+    getArgFloat: *const fn (pos: c_int) callconv(.C) f32,
+    getArgString: *const fn (pos: c_int) callconv(.C) ?[*:0]const u8,
+    getArgBytes: *const fn (pos: c_int, outlen: ?*usize) callconv(.C) [*c]const u8,
+    getArgObject: *const fn (pos: c_int, type: ?*i8, ?*?*LuaUDObject) callconv(.C) ?*anyopaque,
+
+    getBitmap: *const fn (c_int) callconv(.C) ?*LCDBitmap,
+    getSprite: *const fn (c_int) callconv(.C) ?*LCDSprite,
+
+    // for returning values back to Lua
+    pushNil: *const fn () callconv(.C) void,
+    pushBool: *const fn (val: c_int) callconv(.C) void,
+    pushInt: *const fn (val: c_int) callconv(.C) void,
+    pushFloat: *const fn (val: f32) callconv(.C) void,
+    pushString: *const fn (str: ?[*:0]const u8) callconv(.C) void,
+    pushBytes: *const fn (str: [*c]const u8, len: usize) callconv(.C) void,
+    pushBitmap: *const fn (bitmap: ?*LCDBitmap) callconv(.C) void,
+    pushSprite: *const fn (sprite: ?*LCDSprite) callconv(.C) void,
+
+    pushObject: *const fn (obj: ?*anyopaque, type: ?*i8, nValues: c_int) callconv(.C) ?*LuaUDObject,
+    retainObject: *const fn (obj: ?*LuaUDObject) callconv(.C) ?*LuaUDObject,
+    releaseObject: *const fn (obj: ?*LuaUDObject) callconv(.C) void,
+
+    setObjectValue: *const fn (obj: ?*LuaUDObject, slot: c_int) callconv(.C) void,
+    getObjectValue: *const fn (obj: ?*LuaUDObject, slot: c_int) callconv(.C) c_int,
+
+    // calling lua from C has some overhead. use sparingly!
+    callFunction_deprecated: *const fn (name: ?[*:0]const u8, nargs: c_int) callconv(.C) void,
+    callFunction: *const fn (name: ?[*:0]const u8, nargs: c_int, outerr: ?*?[*:0]const u8) callconv(.C) c_int,
+};
+
+///////JSON///////
+pub const JSONValueType = enum(c_int) {
+    JSONNull = 0,
+    JSONTrue = 1,
+    JSONFalse = 2,
+    JSONInteger = 3,
+    JSONFloat = 4,
+    JSONString = 5,
+    JSONArray = 6,
+    JSONTable = 7,
+};
+pub const JSONValue = extern struct {
+    type: u8,
+    data: extern union {
+        intval: c_int,
+        floatval: f32,
+        stringval: [*c]u8,
+        arrayval: ?*anyopaque,
+        tableval: ?*anyopaque,
+    },
+};
+pub inline fn json_intValue(value: JSONValue) c_int {
+    switch (@intFromEnum(value.type)) {
+        .JSONInteger => return value.data.intval,
+        .JSONFloat => return @intFromFloat(value.data.floatval),
+        .JSONString => return std.fmt.parseInt(c_int, std.mem.span(value.data.stringval), 10) catch 0,
+        .JSONTrue => return 1,
+        else => return 0,
+    }
+}
+pub inline fn json_floatValue(value: JSONValue) f32 {
+    switch (@as(JSONValueType, @enumFromInt(value.type))) {
+        .JSONInteger => return @floatFromInt(value.data.intval),
+        .JSONFloat => return value.data.floatval,
+        .JSONString => return 0,
+        .JSONTrue => 1.0,
+        else => return 0.0,
+    }
+}
+pub inline fn json_boolValue(value: JSONValue) c_int {
+    return if (@as(JSONValueType, @enumFromInt(value.type)) == .JSONString)
+        @intFromBool(value.data.stringval[0] != 0)
+    else
+        json_intValue(value);
+}
+pub inline fn json_stringValue(value: JSONValue) [*c]u8 {
+    return if (@as(JSONValueType, @enumFromInt(value.type)) == .JSONString)
+        value.data.stringval
+    else
+        null;
+}
+
+// decoder
+
+pub const JSONDecoder = extern struct {
+    decodeError: *const fn (decoder: ?*JSONDecoder, @"error": ?[*:0]const u8, linenum: c_int) callconv(.C) void,
+
+    // the following functions are each optional
+    willDecodeSublist: ?*const fn (decoder: ?*JSONDecoder, name: ?[*:0]const u8, type: JSONValueType) callconv(.C) void,
+    shouldDecodeTableValueForKey: ?*const fn (decoder: ?*JSONDecoder, key: ?[*:0]const u8) callconv(.C) c_int,
+    didDecodeTableValue: ?*const fn (decoder: ?*JSONDecoder, key: ?[*:0]const u8, value: JSONValue) callconv(.C) void,
+    shouldDecodeArrayValueAtIndex: ?*const fn (decoder: ?*JSONDecoder, pos: c_int) callconv(.C) c_int,
+    didDecodeArrayValue: ?*const fn (decoder: ?*JSONDecoder, pos: c_int, value: JSONValue) callconv(.C) void,
+    didDecodeSublist: ?*const fn (decoder: ?*JSONDecoder, name: ?[*:0]const u8, type: JSONValueType) callconv(.C) ?*anyopaque,
+
+    userdata: ?*anyopaque,
+    returnString: c_int, // when set, the decoder skips parsing and returns the current subtree as a string
+    path: ?[*:0]const u8, // updated during parsing, reflects current position in tree
+};
+
+// convenience functions for setting up a table-only or array-only decoder
+
+pub inline fn json_setTableDecode(
+    decoder: ?*JSONDecoder,
+    willDecodeSublist: ?*const fn (decoder: ?*JSONDecoder, name: ?[*:0]const u8, type: JSONValueType) callconv(.C) void,
+    didDecodeTableValue: ?*const fn (decoder: ?*JSONDecoder, key: ?[*:0]const u8, value: JSONValue) callconv(.C) void,
+    didDecodeSublist: ?*const fn (decoder: ?*JSONDecoder, name: ?[*:0]const u8, name: JSONValueType) callconv(.C) ?*anyopaque,
+) void {
+    decoder.?.didDecodeTableValue = didDecodeTableValue;
+    decoder.?.didDecodeArrayValue = null;
+    decoder.?.willDecodeSublist = willDecodeSublist;
+    decoder.?.didDecodeSublist = didDecodeSublist;
+}
+
+pub inline fn json_setArrayDecode(
+    decoder: ?*JSONDecoder,
+    willDecodeSublist: ?*const fn (decoder: ?*JSONDecoder, name: ?[*:0]const u8, type: JSONValueType) callconv(.C) void,
+    didDecodeArrayValue: ?*const fn (decoder: ?*JSONDecoder, pos: c_int, value: JSONValue) callconv(.C) void,
+    didDecodeSublist: ?*const fn (decoder: ?*JSONDecoder, name: ?[*:0]const u8, type: JSONValueType) callconv(.C) ?*anyopaque,
+) void {
+    decoder.?.didDecodeTableValue = null;
+    decoder.?.didDecodeArrayValue = didDecodeArrayValue;
+    decoder.?.willDecodeSublist = willDecodeSublist;
+    decoder.?.didDecodeSublist = didDecodeSublist;
+}
+
+pub const JSONReader = extern struct {
+    read: *const fn (userdata: ?*anyopaque, buf: [*c]u8, bufsize: c_int) callconv(.C) c_int,
+    userdata: ?*anyopaque,
+};
+pub const writeFunc = *const fn (userdata: ?*anyopaque, str: [*c]const u8, len: c_int) callconv(.C) void;
+
+pub const JSONEncoder = extern struct {
+    writeStringFunc: writeFunc,
+    userdata: ?*anyopaque,
+
+    state: u32, //this is pretty, startedTable, startedArray and depth bitfields combined
+
+    startArray: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    addArrayMember: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    endArray: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    startTable: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    addTableMember: *const fn (encoder: ?*JSONEncoder, name: [*c]const u8, len: c_int) callconv(.C) void,
+    endTable: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    writeNull: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    writeFalse: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    writeTrue: *const fn (encoder: ?*JSONEncoder) callconv(.C) void,
+    writeInt: *const fn (encoder: ?*JSONEncoder, num: c_int) callconv(.C) void,
+    writeDouble: *const fn (encoder: ?*JSONEncoder, num: f64) callconv(.C) void,
+    writeString: *const fn (encoder: ?*JSONEncoder, str: [*c]const u8, len: c_int) callconv(.C) void,
+};
+
+pub const PlaydateJSON = extern struct {
+    initEncoder: *const fn (encoder: ?*JSONEncoder, write: writeFunc, userdata: ?*anyopaque, pretty: c_int) callconv(.C) void,
+
+    decode: *const fn (functions: ?*JSONDecoder, reader: JSONReader, outval: ?*JSONValue) callconv(.C) c_int,
+    decodeString: *const fn (functions: ?*JSONDecoder, jsonString: ?[*:0]const u8, outval: ?*JSONValue) callconv(.C) c_int,
+};
+
+///////Scoreboards///////////
+pub const PDScore = extern struct {
+    rank: u32,
+    value: u32,
+    player: [*c]u8,
+};
+pub const PDScoresList = extern struct {
+    boardID: [*c]u8,
+    count: c_uint,
+    lastUpdated: u32,
+    playerIncluded: c_int,
+    limit: c_uint,
+    scores: [*c]PDScore,
+};
+pub const PDBoard = extern struct {
+    boardID: [*c]u8,
+    name: [*c]u8,
+};
+pub const PDBoardsList = extern struct {
+    count: c_uint,
+    lastUpdated: u32,
+    boards: [*c]PDBoard,
+};
+pub const AddScoreCallback = ?*const fn (score: ?*PDScore, errorMessage: ?[*:0]const u8) callconv(.C) void;
+pub const PersonalBestCallback = ?*const fn (score: ?*PDScore, errorMessage: ?[*:0]const u8) callconv(.C) void;
+pub const BoardsListCallback = ?*const fn (boards: ?*PDBoardsList, errorMessage: ?[*:0]const u8) callconv(.C) void;
+pub const ScoresCallback = ?*const fn (scores: ?*PDScoresList, errorMessage: ?[*:0]const u8) callconv(.C) void;
+
+pub const PlaydateScoreboards = extern struct {
+    addScore: *const fn (boardId: ?[*:0]const u8, value: u32, callback: AddScoreCallback) callconv(.C) c_int,
+    getPersonalBest: *const fn (boardId: ?[*:0]const u8, callback: PersonalBestCallback) callconv(.C) c_int,
+    freeScore: *const fn (score: ?*PDScore) callconv(.C) void,
+
+    getScoreboards: *const fn (callback: BoardsListCallback) callconv(.C) c_int,
+    freeBoardsList: *const fn (boards: ?*PDBoardsList) callconv(.C) void,
+
+    getScores: *const fn (boardId: ?[*:0]const u8, callback: ScoresCallback) callconv(.C) c_int,
+    freeScoresList: *const fn (scores: ?*PDScoresList) callconv(.C) void,
+};
+
+///////Network///////////
+pub const HTTPConnection = opaque {};
+pub const TCPConnection = opaque {};
+
+pub const PDNetErr = enum(c_int) {
+    NET_OK = 0,
+    NET_NO_DEVICE = -1,
+    NET_BUSY = -2,
+    NET_WRITE_ERROR = -3,
+    NET_WRITE_BUSY = -4,
+    NET_WRITE_TIMEOUT = -5,
+    NET_READ_ERROR = -6,
+    NET_READ_BUSY = -7,
+    NET_READ_TIMEOUT = -8,
+    NET_READ_OVERFLOW = -9,
+    NET_FRAME_ERROR = -10,
+    NET_BAD_RESPONSE = -11,
+    NET_ERROR_RESPONSE = -12,
+    NET_RESET_TIMEOUT = -13,
+    NET_BUFFER_TOO_SMALL = -14,
+    NET_UNEXPECTED_RESPONSE = -15,
+    NET_NOT_CONNECTED_TO_AP = -16,
+    NET_NOT_IMPLEMENTED = -17,
+    NET_CONNECTION_CLOSED = -18,
+};
+
+pub const WifiStatus = enum(c_int) {
+    WifiNotConnected = 0, //< Not connected to an AP
+    WifiConnected, //< Device is connected to an AP
+    WifiNotAvailable, //< A connection has been attempted and no configured AP was available
+};
+
+pub const HTTPConnectionCallback = ?*const fn (connection: ?*HTTPConnection) callconv(.C) void;
+pub const HTTPHeaderCallback = ?*const fn (conn: ?*HTTPConnection, key: ?[*:0]const u8, value: ?[*:0]const u8) callconv(.C) void;
+
+pub const PlaydateHTTP = extern struct {
+    requestAccess: *const fn (server: ?[*:0]const u8, port: c_int, usessl: bool, purpose: ?[*:0]const u8, requestCallback: AccessRequestCallback, userdata: ?*anyopaque) callconv(.C) AccessReply,
+
+    newConnection: *const fn (server: ?[*:0]const u8, port: c_int, usessl: bool) callconv(.C) ?*HTTPConnection,
+    retain: *const fn (http: ?*HTTPConnection) callconv(.C) ?*HTTPConnection,
+    release: *const fn (http: ?*HTTPConnection) callconv(.C) void,
+
+    setConnectTimeout: *const fn (connection: ?*HTTPConnection, ms: c_int) callconv(.C) void,
+    setKeepAlive: *const fn (connection: ?*HTTPConnection, keepalive: bool) callconv(.C) void,
+    setByteRange: *const fn (connection: ?*HTTPConnection, start: c_int, end: c_int) callconv(.C) void,
+    setUserdata: *const fn (connection: ?*HTTPConnection, userdata: ?*anyopaque) callconv(.C) void,
+    getUserdata: *const fn (connection: ?*HTTPConnection) callconv(.C) ?*anyopaque,
+
+    get: *const fn (connection: ?*HTTPConnection, path: ?[*:0]const u8, headers: ?[*:0]const u8, headerlen: usize) callconv(.C) PDNetErr,
+    post: *const fn (connection: ?*HTTPConnection, path: ?[*:0]const u8, headers: ?[*:0]const u8, headerlen: usize, body: ?[*:0]const u8, bodylen: usize) callconv(.C) PDNetErr,
+    query: *const fn (connection: ?*HTTPConnection, method: ?[*:0]const u8, path: ?[*:0]const u8, headers: ?[*:0]const u8, headerlen: usize, body: ?[*:0]const u8, bodylen: usize) callconv(.C) PDNetErr,
+    getError: *const fn (connection: ?*HTTPConnection) callconv(.C) PDNetErr,
+    getProgress: *const fn (connection: ?*HTTPConnection, read: ?*c_int, total: ?*c_int) callconv(.C) void,
+    getResponseStatus: *const fn (connection: ?*HTTPConnection) callconv(.C) c_int,
+    getBytesAvailable: *const fn (connection: ?*HTTPConnection) callconv(.C) usize,
+    setReadTimeout: *const fn (connection: ?*HTTPConnection, ms: c_int) callconv(.C) void,
+    setReadBufferSize: *const fn (connection: ?*HTTPConnection, bytes: c_int) callconv(.C) void,
+    read: *const fn (connection: ?*HTTPConnection, buf: [*c]u8, buflen: c_uint) callconv(.C) c_int,
+    close: *const fn (connection: ?*HTTPConnection) callconv(.C) void,
+
+    setHeaderReceivedCallback: *const fn (connection: ?*HTTPConnection, headercb: HTTPHeaderCallback) callconv(.C) void,
+    setHeadersReadCallback: *const fn (connection: ?*HTTPConnection, callback: HTTPConnectionCallback) callconv(.C) void,
+    setResponseCallback: *const fn (connection: ?*HTTPConnection, callback: HTTPConnectionCallback) callconv(.C) void,
+    setRequestCompleteCallback: *const fn (connection: ?*HTTPConnection, callback: HTTPConnectionCallback) callconv(.C) void,
+    setConnectionClosedCallback: *const fn (connection: ?*HTTPConnection, callback: HTTPConnectionCallback) callconv(.C) void,
+};
+
+pub const TCPConnectionCallback = ?*const fn (connection: ?*TCPConnection, err: PDNetErr) callconv(.C) void;
+pub const TCPOpenCallback = ?*const fn (connection: ?*TCPConnection, err: PDNetErr, ud: ?*anyopaque) callconv(.C) void;
+
+pub const PlaydateTCP = extern struct {
+    requestAccess: *const fn (server: ?[*:0]const u8, port: c_int, usessl: bool, purpose: ?[*:0]const u8, requestCallback: AccessRequestCallback, userdata: ?*anyopaque) callconv(.C) AccessReply,
+
+    newConnection: *const fn (server: ?[*:0]const u8, port: c_int, usessl: bool) callconv(.C) ?*TCPConnection,
+    retain: *const fn (tcp: ?*TCPConnection) callconv(.C) ?*TCPConnection,
+    release: *const fn (tcp: ?*TCPConnection) callconv(.C) void,
+    getError: *const fn (connection: ?*TCPConnection) callconv(.C) PDNetErr,
+
+    setConnectTimeout: *const fn (connection: ?*TCPConnection, ms: c_int) callconv(.C) void,
+    setUserdata: *const fn (connection: ?*TCPConnection, userdata: ?*anyopaque) callconv(.C) void,
+    getUserdata: *const fn (connection: ?*TCPConnection) callconv(.C) ?*anyopaque,
+
+    open: *const fn (connection: ?*TCPConnection, cb: TCPOpenCallback, ud: ?*anyopaque) callconv(.C) PDNetErr,
+    close: *const fn (connection: ?*TCPConnection) callconv(.C) PDNetErr,
+
+    setConnectionClosedCallback: *const fn (connection: ?*TCPConnection, callback: TCPConnectionCallback) callconv(.C) void,
+
+    setReadTimeout: *const fn (connection: ?*TCPConnection, ms: c_int) callconv(.C) void,
+    setReadBufferSize: *const fn (connection: ?*TCPConnection, bytes: c_int) callconv(.C) void,
+    getBytesAvailable: *const fn (connection: ?*TCPConnection) callconv(.C) usize,
+
+    read: *const fn (connection: ?*TCPConnection, buffer: [*c]u8, length: usize) callconv(.C) c_int, // returns # of bytes read, or PDNetErr on error
+    write: *const fn (connection: ?*TCPConnection, buffer: [*c]const u8, length: usize) callconv(.C) c_int, // returns # of bytes read, or PDNetErr on error
+};
+
+pub const PlaydateNetwork = extern struct {
+    playdate_http: *const PlaydateHTTP,
+    playdate_tcp: *const PlaydateTCP,
+
+    getStatus: *const fn () callconv(.C) WifiStatus,
+    setEnabled: *const fn (flag: bool, callback: ?*const fn (err: PDNetErr) callconv(.C) void) callconv(.C) void,
+
+    reserved: [3]usize,
+};