8 files changed, 132 insertions, 117 deletions

diff --git a/build.zig b/build.zig
index 328679c..f8d9536 100644
--- a/build.zig
+++ b/build.zig
@@ -110,10 +110,15 @@ fn computeTestTargets(isNative: bool, ci: ?bool) ?[]const TestTarget {
 
 // This creates a SQLite static library from the SQLite dependency code.
 fn makeSQLiteLib(b: *std.Build, dep: *std.Build.Dependency, c_flags: []const []const u8, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, sqlite_c: enum { with, without }) *std.Build.Step.Compile {
-    const lib = b.addStaticLibrary(.{
-        .name = "sqlite",
+    const mod = b.addModule("lib-sqlite", .{
         .target = target,
         .optimize = optimize,
+        .link_libc = true,
+    });
+    const lib = b.addLibrary(.{
+        .name = "sqlite",
+        .linkage = .dynamic,
+        .root_module = mod,
     });
 
     lib.addIncludePath(dep.path("."));
@@ -128,7 +133,6 @@ fn makeSQLiteLib(b: *std.Build, dep: *std.Build.Dependency, c_flags: []const []c
         .file = b.path("c/workaround.c"),
         .flags = c_flags,
     });
-    lib.linkLibC();
 
     return lib;
 }
@@ -225,13 +229,17 @@ pub fn build(b: *std.Build) !void {
 
         const test_sqlite_lib = makeSQLiteLib(b, sqlite_dep, c_flags, cross_target, optimize, .with);
 
-        const tests = b.addTest(.{
-            .name = test_name,
+        const mod = b.addModule(test_name, .{
             .target = cross_target,
             .optimize = optimize,
             .root_source_file = b.path("sqlite.zig"),
             .single_threaded = test_target.single_threaded,
         });
+
+        const tests = b.addTest(.{
+            .name = test_name,
+            .root_module = mod,
+        });
         tests.addIncludePath(b.path("c"));
         tests.addIncludePath(sqlite_dep.path("."));
         tests.linkLibrary(test_sqlite_lib);
@@ -282,13 +290,17 @@ fn addPreprocessStep(b: *std.Build, sqlite_dep: *std.Build.Dependency) void {
 }
 
 fn addZigcrypto(b: *std.Build, sqlite_mod: *std.Build.Module, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) *std.Build.Step.InstallArtifact {
-    const exe = b.addSharedLibrary(.{
-        .name = "zigcrypto",
+    const mod = b.addModule("zigcryto", .{
         .root_source_file = b.path("examples/zigcrypto.zig"),
-        .version = null,
         .target = getTarget(target),
         .optimize = optimize,
     });
+    const exe = b.addLibrary(.{
+        .name = "zigcrypto",
+        .root_module = mod,
+        .version = null,
+        .linkage = .dynamic,
+    });
     exe.root_module.addImport("sqlite", sqlite_mod);
 
     const install_artifact = b.addInstallArtifact(exe, .{});
@@ -298,12 +310,15 @@ fn addZigcrypto(b: *std.Build, sqlite_mod: *std.Build.Module, target: std.Build.
 }
 
 fn addZigcryptoTestRun(b: *std.Build, sqlite_mod: *std.Build.Module, target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode) *std.Build.Step.Run {
-    const zigcrypto_test = b.addExecutable(.{
-        .name = "zigcrypto-test",
+    const mod = b.addModule("zigcryto-test", .{
         .root_source_file = b.path("examples/zigcrypto_test.zig"),
         .target = getTarget(target),
         .optimize = optimize,
     });
+    const zigcrypto_test = b.addExecutable(.{
+        .name = "zigcrypto-test",
+        .root_module = mod,
+    });
     zigcrypto_test.root_module.addImport("sqlite", sqlite_mod);
 
     const install = b.addInstallArtifact(zigcrypto_test, .{});
diff --git a/build/Preprocessor.zig b/build/Preprocessor.zig
index a069523..f3d0dc6 100644
--- a/build/Preprocessor.zig
+++ b/build/Preprocessor.zig
@@ -27,10 +27,10 @@ const mem = std.mem;
 fn readOriginalData(allocator: mem.Allocator, path: []const u8) ![]const u8 {
     var file = try std.fs.cwd().openFile(path, .{});
     defer file.close();
+    var buf: [1024]u8 = undefined;
+    var reader = file.reader(&buf);
 
-    var reader = file.reader();
-
-    const data = reader.readAllAlloc(allocator, 1024 * 1024);
+    const data = reader.interface.readAlloc(allocator, 1024 * 1024);
     return data;
 }
 
@@ -127,13 +127,13 @@ const Processor = struct {
             switch (range) {
                 .delete => |dr| {
                     const to_write = self.data[pos..dr.start];
-                    try writer.writeAll(to_write);
+                    try writer.interface.writeAll(to_write);
                     pos = dr.end;
                 },
                 .replace => |rr| {
                     const to_write = self.data[pos..rr.start];
-                    try writer.writeAll(to_write);
-                    try writer.writeAll(rr.replacement);
+                    try writer.interface.writeAll(to_write);
+                    try writer.interface.writeAll(rr.replacement);
                     pos = rr.end;
                 },
             }
@@ -148,7 +148,7 @@ const Processor = struct {
         // Finally append the remaining data in the buffer (the last range will probably not be the end of the file)
         if (pos < self.data.len) {
             const remaining_data = self.data[pos..];
-            try writer.writeAll(remaining_data);
+            try writer.interface.writeAll(remaining_data);
         }
     }
 };
@@ -196,7 +196,9 @@ pub fn sqlite3(allocator: mem.Allocator, input_path: []const u8, output_path: []
     defer output_file.close();
 
     try output_file.writeAll("/* sqlite3.h edited by the zig-sqlite build script */\n");
-    try processor.dump(output_file.writer());
+    var buf: [1024]u8 = undefined;
+    var out_writer = output_file.writer(&buf);
+    try processor.dump(&out_writer);
 }
 
 pub fn sqlite3ext(allocator: mem.Allocator, input_path: []const u8, output_path: []const u8) !void {
@@ -232,5 +234,7 @@ pub fn sqlite3ext(allocator: mem.Allocator, input_path: []const u8, output_path:
     defer output_file.close();
 
     try output_file.writeAll("/* sqlite3ext.h edited by the zig-sqlite build script */\n");
-    try processor.dump(output_file.writer());
+    var buf: [1024]u8 = undefined;
+    var out_writer = output_file.writer(&buf);
+    try processor.dump(&out_writer);
 }
diff --git a/c/loadable_extension.zig b/c/loadable_extension.zig
index fdfe15e..dfce56c 100644
--- a/c/loadable_extension.zig
+++ b/c/loadable_extension.zig
@@ -1,10 +1,8 @@
-const c = @cImport({
+pub const c = @cImport({
     @cInclude("loadable-ext-sqlite3ext.h");
     @cInclude("workaround.h");
 });
 
-pub usingnamespace c;
-
 pub var sqlite3_api: [*c]c.sqlite3_api_routines = null;
 
 pub const sqlite3_transfer_bindings = @compileError("sqlite3_transfer_bindings is deprecated");
@@ -23,16 +21,16 @@ pub const sqlite3_uri_vsnprintf = @compileError("sqlite3_uri_vsnprintf can't be
 pub const sqlite3_str_appendf = @compileError("sqlite3_str_appendf can't be implemented in Zig");
 pub const sqlite3_str_vappendf = @compileError("sqlite3_str_vappendf can't be implemented in Zig");
 
-pub export fn sqlite3_aggregate_context(p: ?*c.sqlite3_context, nBytes: c_int) callconv(.C) ?*anyopaque {
+pub export fn sqlite3_aggregate_context(p: ?*c.sqlite3_context, nBytes: c_int) callconv(.c) ?*anyopaque {
     return sqlite3_api.*.aggregate_context.?(p, nBytes);
 }
-pub export fn sqlite3_bind_blob(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_blob(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.bind_blob.?(pStmt, i, zData, nData, xDel);
 }
-pub export fn sqlite3_bind_double(pStmt: ?*c.sqlite3_stmt, i: c_int, rValue: f64) callconv(.C) c_int {
+pub export fn sqlite3_bind_double(pStmt: ?*c.sqlite3_stmt, i: c_int, rValue: f64) callconv(.c) c_int {
     return sqlite3_api.*.bind_double.?(pStmt, i, rValue);
 }
-pub export fn sqlite3_bind_int(pStmt: ?*c.sqlite3_stmt, i: c_int, iValue: c_int) callconv(.C) c_int {
+pub export fn sqlite3_bind_int(pStmt: ?*c.sqlite3_stmt, i: c_int, iValue: c_int) callconv(.c) c_int {
     return sqlite3_api.*.bind_int.?(pStmt, i, iValue);
 }
 pub export fn sqlite3_bind_int64(pStmt: ?*c.sqlite3_stmt, i: c_int, iValue: c.sqlite3_int64) c_int {
@@ -50,16 +48,16 @@ pub export fn sqlite3_bind_parameter_index(pStmt: ?*c.sqlite3_stmt, zName: [*c]c
 pub export fn sqlite3_bind_parameter_name(pStmt: ?*c.sqlite3_stmt, i: c_int) [*c]const u8 {
     return sqlite3_api.*.bind_parameter_name.?(pStmt, i);
 }
-pub export fn sqlite3_bind_text(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_text(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.bind_text.?(pStmt, i, zData, nData, xDel);
 }
-pub export fn sqlite3_bind_text16(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_text16(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.bind_text16.?(pStmt, i, zData, nData, xDel);
 }
 pub export fn sqlite3_bind_value(pStmt: ?*c.sqlite3_stmt, i: c_int, pValue: ?*const c.sqlite3_value) c_int {
     return sqlite3_api.*.bind_value.?(pStmt, i, pValue);
 }
-pub export fn sqlite3_busy_handler(db: ?*c.sqlite3, xBusy: ?*const fn (?*anyopaque, c_int) callconv(.C) c_int, pArg: ?*anyopaque) c_int {
+pub export fn sqlite3_busy_handler(db: ?*c.sqlite3, xBusy: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int, pArg: ?*anyopaque) c_int {
     return sqlite3_api.*.busy_handler.?(db, xBusy, pArg);
 }
 pub export fn sqlite3_busy_timeout(db: ?*c.sqlite3, ms: c_int) c_int {
@@ -71,10 +69,10 @@ pub export fn sqlite3_changes(db: ?*c.sqlite3) c_int {
 pub export fn sqlite3_close(db: ?*c.sqlite3) c_int {
     return sqlite3_api.*.close.?(db);
 }
-pub export fn sqlite3_collation_needed(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, [*c]const u8) callconv(.C) void) c_int {
+pub export fn sqlite3_collation_needed(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, [*c]const u8) callconv(.c) void) c_int {
     return sqlite3_api.*.collation_needed.?(db, pCollNeededArg, xCollNeeded);
 }
-pub export fn sqlite3_collation_needed16(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded16: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, ?*const anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_collation_needed16(db: ?*c.sqlite3, pCollNeededArg: ?*anyopaque, xCollNeeded16: ?*const fn (?*anyopaque, ?*c.sqlite3, c_int, ?*const anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.collation_needed16.?(db, pCollNeededArg, xCollNeeded16);
 }
 pub export fn sqlite3_column_blob(pStmt: ?*c.sqlite3_stmt, iCol: c_int) ?*const anyopaque {
@@ -140,7 +138,7 @@ pub export fn sqlite3_column_type(pStmt: ?*c.sqlite3_stmt, iCol: c_int) c_int {
 pub export fn sqlite3_column_value(pStmt: ?*c.sqlite3_stmt, iCol: c_int) ?*c.sqlite3_value {
     return sqlite3_api.*.column_value.?(pStmt, iCol);
 }
-pub export fn sqlite3_commit_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_commit_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.c) c_int, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.commit_hook.?(db, xCallback, pArg);
 }
 pub export fn sqlite3_complete(sql: [*c]const u8) c_int {
@@ -149,22 +147,22 @@ pub export fn sqlite3_complete(sql: [*c]const u8) c_int {
 pub export fn sqlite3_complete16(sql: ?*const anyopaque) c_int {
     return sqlite3_api.*.complete16.?(sql);
 }
-pub export fn sqlite3_create_collation(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int {
+pub export fn sqlite3_create_collation(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.c) c_int) c_int {
     return sqlite3_api.*.create_collation.?(db, zName, eTextRep, pArg, xCompare);
 }
-pub export fn sqlite3_create_collation16(db: ?*c.sqlite3, zName: ?*const anyopaque, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int) c_int {
+pub export fn sqlite3_create_collation16(db: ?*c.sqlite3, zName: ?*const anyopaque, eTextRep: c_int, pArg: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.c) c_int) c_int {
     return sqlite3_api.*.create_collation16.?(db, zName, eTextRep, pArg, xCompare);
 }
-pub export fn sqlite3_create_function(db: ?*c.sqlite3, zFunctionName: [*c]const u8, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void) c_int {
+pub export fn sqlite3_create_function(db: ?*c.sqlite3, zFunctionName: [*c]const u8, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.c) void) c_int {
     return sqlite3_api.*.create_function.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal);
 }
-pub export fn sqlite3_create_function16(db: ?*c.sqlite3, zFunctionName: ?*const anyopaque, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void) c_int {
+pub export fn sqlite3_create_function16(db: ?*c.sqlite3, zFunctionName: ?*const anyopaque, nArg: c_int, eTextRep: c_int, pApp: ?*anyopaque, xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void, xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void, xFinal: ?*const fn (?*c.sqlite3_context) callconv(.c) void) c_int {
     return sqlite3_api.*.create_function16.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal);
 }
 pub export fn sqlite3_create_module(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque) c_int {
     return sqlite3_api.*.create_module.?(db, zName, pModule, pAux);
 }
-pub export fn sqlite3_create_module_v2(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque, xDestroy: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_create_module_v2(db: ?*c.sqlite3, zName: [*c]const u8, pModule: [*c]const c.sqlite3_module, pAux: ?*anyopaque, xDestroy: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.create_module_v2.?(db, zName, pModule, pAux, xDestroy);
 }
 pub export fn sqlite3_data_count(pStmt: ?*c.sqlite3_stmt) c_int {
@@ -189,7 +187,7 @@ pub export fn sqlite3_errmsg(db: ?*c.sqlite3) [*c]const u8 {
 pub export fn sqlite3_errmsg16(db: ?*c.sqlite3) ?*const anyopaque {
     return sqlite3_api.*.errmsg16.?(db);
 }
-pub export fn sqlite3_exec(db: ?*c.sqlite3, zSql: [*c]const u8, xCallback: ?*const fn (?*anyopaque, c_int, [*c][*c]u8, [*c][*c]u8) callconv(.C) c_int, pArg: ?*anyopaque, pzErrMsg: [*c][*c]u8) c_int {
+pub export fn sqlite3_exec(db: ?*c.sqlite3, zSql: [*c]const u8, xCallback: ?*const fn (?*anyopaque, c_int, [*c][*c]u8, [*c][*c]u8) callconv(.c) c_int, pArg: ?*anyopaque, pzErrMsg: [*c][*c]u8) c_int {
     return sqlite3_api.*.exec.?(db, zSql, xCallback, pArg, pzErrMsg);
 }
 pub export fn sqlite3_finalize(pStmt: ?*c.sqlite3_stmt) c_int {
@@ -216,7 +214,7 @@ pub export fn sqlite3_interrupt(db: ?*c.sqlite3) void {
 pub export fn sqlite3_last_insert_rowid(db: ?*c.sqlite3) c.sqlite3_int64 {
     return sqlite3_api.*.last_insert_rowid.?(db);
 }
-pub export fn sqlite3_libversion() callconv(.C) [*c]const u8 {
+pub export fn sqlite3_libversion() callconv(.c) [*c]const u8 {
     return sqlite3_api.*.libversion.?();
 }
 pub export fn sqlite3_libversion_number() c_int {
@@ -243,10 +241,10 @@ pub export fn sqlite3_prepare_v2(db: ?*c.sqlite3, zSql: [*c]const u8, nByte: c_i
 pub export fn sqlite3_prepare16_v2(db: ?*c.sqlite3, zSql: ?*const anyopaque, nByte: c_int, ppStmt: [*c]?*c.sqlite3_stmt, pzTail: [*c]?*const anyopaque) c_int {
     return sqlite3_api.*.prepare16_v2.?(db, zSql, nByte, ppStmt, pzTail);
 }
-pub export fn sqlite3_profile(db: ?*c.sqlite3, xProfile: ?*const fn (?*anyopaque, [*c]const u8, c.sqlite3_uint64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_profile(db: ?*c.sqlite3, xProfile: ?*const fn (?*anyopaque, [*c]const u8, c.sqlite3_uint64) callconv(.c) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.profile.?(db, xProfile, pArg);
 }
-pub export fn sqlite3_progress_handler(db: ?*c.sqlite3, nOps: c_int, xProgress: ?*const fn (?*anyopaque) callconv(.C) c_int, pArg: ?*anyopaque) void {
+pub export fn sqlite3_progress_handler(db: ?*c.sqlite3, nOps: c_int, xProgress: ?*const fn (?*anyopaque) callconv(.c) c_int, pArg: ?*anyopaque) void {
     return sqlite3_api.*.progress_handler.?(db, nOps, xProgress, pArg);
 }
 pub export fn sqlite3_realloc(pOld: ?*anyopaque, n: c_int) ?*anyopaque {
@@ -255,7 +253,7 @@ pub export fn sqlite3_realloc(pOld: ?*anyopaque, n: c_int) ?*anyopaque {
 pub export fn sqlite3_reset(pStmt: ?*c.sqlite3_stmt) c_int {
     return sqlite3_api.*.reset.?(pStmt);
 }
-pub export fn sqlite3_result_blob(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_blob(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_blob.?(pCtx, z, n, xDel);
 }
 
@@ -278,28 +276,28 @@ pub export fn sqlite3_result_int64(pCtx: ?*c.sqlite3_context, iVal: c.sqlite3_in
 pub export fn sqlite3_result_null(pCtx: ?*c.sqlite3_context) void {
     return sqlite3_api.*.result_null.?(pCtx);
 }
-pub export fn sqlite3_result_text(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_text.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text16(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text16(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_text16.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text16be(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text16be(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_text16be.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text16le(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_text16le(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_text16le.?(pCtx, z, n, xDel);
 }
 pub export fn sqlite3_result_value(pCtx: ?*c.sqlite3_context, pValue: ?*c.sqlite3_value) void {
     return sqlite3_api.*.result_value.?(pCtx, pValue);
 }
-pub export fn sqlite3_rollback_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_rollback_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque) callconv(.c) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.rollback_hook.?(db, xCallback, pArg);
 }
-pub export fn sqlite3_set_authorizer(db: ?*c.sqlite3, xAuth: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, [*c]const u8, [*c]const u8) callconv(.C) c_int, pArg: ?*anyopaque) c_int {
+pub export fn sqlite3_set_authorizer(db: ?*c.sqlite3, xAuth: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, [*c]const u8, [*c]const u8) callconv(.c) c_int, pArg: ?*anyopaque) c_int {
     return sqlite3_api.*.set_authorizer.?(db, xAuth, pArg);
 }
-pub export fn sqlite3_set_auxdata(pCtx: ?*c.sqlite3_context, iArg: c_int, pAux: ?*anyopaque, xDelete: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_set_auxdata(pCtx: ?*c.sqlite3_context, iArg: c_int, pAux: ?*anyopaque, xDelete: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.set_auxdata.?(pCtx, iArg, pAux, xDelete);
 }
 pub export fn sqlite3_step(pStmt: ?*c.sqlite3_stmt) c_int {
@@ -314,10 +312,10 @@ pub export fn sqlite3_thread_cleanup() void {
 pub export fn sqlite3_total_changes(db: ?*c.sqlite3) c_int {
     return sqlite3_api.*.total_changes.?(db);
 }
-pub export fn sqlite3_trace(db: ?*c.sqlite3, xTrace: ?*const fn (?*anyopaque, [*c]const u8) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_trace(db: ?*c.sqlite3, xTrace: ?*const fn (?*anyopaque, [*c]const u8) callconv(.c) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.trace.?(db, xTrace, pArg);
 }
-pub export fn sqlite3_update_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, c.sqlite3_int64) callconv(.C) void, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_update_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, c_int, [*c]const u8, [*c]const u8, c.sqlite3_int64) callconv(.c) void, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.update_hook.?(db, xCallback, pArg);
 }
 pub export fn sqlite3_user_data(pCtx: ?*c.sqlite3_context) ?*anyopaque {
@@ -383,7 +381,7 @@ pub export fn sqlite3_blob_read(pBlob: ?*c.sqlite3_blob, z: ?*anyopaque, n: c_in
 pub export fn sqlite3_blob_write(pBlob: ?*c.sqlite3_blob, z: ?*const anyopaque, n: c_int, iOffset: c_int) c_int {
     return sqlite3_api.*.blob_write.?(pBlob, z, n, iOffset);
 }
-pub export fn sqlite3_create_collation_v2(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pCtx: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.C) c_int, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_create_collation_v2(db: ?*c.sqlite3, zName: [*c]const u8, eTextRep: c_int, pCtx: ?*anyopaque, xCompare: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, c_int, ?*const anyopaque) callconv(.c) c_int, xDel: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.create_collation_v2.?(db, zName, eTextRep, pCtx, xCompare, xDel);
 }
 pub export fn sqlite3_file_control(db: ?*c.sqlite3, zDbName: [*c]const u8, op: c_int, pArg: ?*anyopaque) c_int {
@@ -494,10 +492,10 @@ pub export fn sqlite3_create_function_v2(
     nArg: c_int,
     eTextRep: c_int,
     pApp: ?*anyopaque,
-    xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void,
-    xDestroy: ?*const fn (?*anyopaque) callconv(.C) void,
+    xFunc: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void,
+    xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void,
+    xFinal: ?*const fn (?*c.sqlite3_context) callconv(.c) void,
+    xDestroy: ?*const fn (?*anyopaque) callconv(.c) void,
 ) c_int {
     return sqlite3_api.*.create_function_v2.?(db, zFunctionName, nArg, eTextRep, pApp, xFunc, xStep, xFinal, xDestroy);
 }
@@ -522,7 +520,7 @@ pub export fn sqlite3_stmt_status(pStmt: ?*c.sqlite3_stmt, op: c_int, resetFlag:
 pub export fn sqlite3_strnicmp(zLeft: [*c]const u8, zRight: [*c]const u8, N: c_int) c_int {
     return sqlite3_api.*.strnicmp.?(zLeft, zRight, N);
 }
-pub export fn sqlite3_unlock_notify(pBlocked: ?*c.sqlite3, xNotify: ?*const fn ([*c]?*anyopaque, c_int) callconv(.C) void, pNotifyArg: ?*anyopaque) c_int {
+pub export fn sqlite3_unlock_notify(pBlocked: ?*c.sqlite3, xNotify: ?*const fn ([*c]?*anyopaque, c_int) callconv(.c) void, pNotifyArg: ?*anyopaque) c_int {
     return sqlite3_api.*.unlock_notify.?(pBlocked, xNotify, pNotifyArg);
 }
 pub export fn sqlite3_wal_autocheckpoint(db: ?*c.sqlite3, N: c_int) c_int {
@@ -531,7 +529,7 @@ pub export fn sqlite3_wal_autocheckpoint(db: ?*c.sqlite3, N: c_int) c_int {
 pub export fn sqlite3_wal_checkpoint(db: ?*c.sqlite3, zDb: [*c]const u8) c_int {
     return sqlite3_api.*.wal_checkpoint.?(db, zDb);
 }
-pub export fn sqlite3_wal_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, ?*c.sqlite3, [*c]const u8, c_int) callconv(.C) c_int, pArg: ?*anyopaque) ?*anyopaque {
+pub export fn sqlite3_wal_hook(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, ?*c.sqlite3, [*c]const u8, c_int) callconv(.c) c_int, pArg: ?*anyopaque) ?*anyopaque {
     return sqlite3_api.*.wal_hook.?(db, xCallback, pArg);
 }
 pub export fn sqlite3_blob_reopen(pBlob: ?*c.sqlite3_blob, iRow: c.sqlite3_int64) c_int {
@@ -576,16 +574,16 @@ pub export fn sqlite3_uri_parameter(zFilename: [*c]const u8, zParam: [*c]const u
 pub export fn sqlite3_wal_checkpoint_v2(db: ?*c.sqlite3, zDb: [*c]const u8, eMode: c_int, pnLog: [*c]c_int, pnCkpt: [*c]c_int) c_int {
     return sqlite3_api.*.wal_checkpoint_v2.?(db, zDb, eMode, pnLog, pnCkpt);
 }
-pub export fn sqlite3_auto_extension(xEntryPoint: ?*const fn () callconv(.C) void) c_int {
+pub export fn sqlite3_auto_extension(xEntryPoint: ?*const fn () callconv(.c) void) c_int {
     return sqlite3_api.*.auto_extension.?(xEntryPoint);
 }
-pub export fn sqlite3_bind_blob64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_blob64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: ?*const anyopaque, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.bind_blob64.?(pStmt, i, zData, nData, xDel);
 }
-pub export fn sqlite3_bind_text64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void, encoding: u8) c_int {
+pub export fn sqlite3_bind_text64(pStmt: ?*c.sqlite3_stmt, i: c_int, zData: [*c]const u8, nData: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.c) void, encoding: u8) c_int {
     return sqlite3_api.*.bind_text64.?(pStmt, i, zData, nData, xDel, encoding);
 }
-pub export fn sqlite3_cancel_auto_extension(xEntryPoint: ?*const fn () callconv(.C) void) c_int {
+pub export fn sqlite3_cancel_auto_extension(xEntryPoint: ?*const fn () callconv(.c) void) c_int {
     return sqlite3_api.*.cancel_auto_extension.?(xEntryPoint);
 }
 pub export fn sqlite3_load_extension(db: ?*c.sqlite3, zFile: [*c]const u8, zProc: [*c]const u8, pzErrMsg: [*c][*c]u8) c_int {
@@ -603,10 +601,10 @@ pub export fn sqlite3_realloc64(pOld: ?*anyopaque, n: c.sqlite3_uint64) ?*anyopa
 pub export fn sqlite3_reset_auto_extension() void {
     return sqlite3_api.*.reset_auto_extension.?();
 }
-pub export fn sqlite3_result_blob64(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_blob64(pCtx: ?*c.sqlite3_context, z: ?*const anyopaque, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_blob64.?(pCtx, z, n, xDel);
 }
-pub export fn sqlite3_result_text64(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.C) void, encoding: u8) void {
+pub export fn sqlite3_result_text64(pCtx: ?*c.sqlite3_context, z: [*c]const u8, n: c.sqlite3_uint64, xDel: ?*const fn (?*anyopaque) callconv(.c) void, encoding: u8) void {
     return sqlite3_api.*.result_text64.?(pCtx, z, n, xDel, encoding);
 }
 pub export fn sqlite3_strglob(zGlob: [*c]const u8, zStr: [*c]const u8) c_int {
@@ -642,7 +640,7 @@ pub export fn sqlite3_db_cacheflush(db: ?*c.sqlite3) c_int {
 pub export fn sqlite3_system_errno(db: ?*c.sqlite3) c_int {
     return sqlite3_api.*.system_errno.?(db);
 }
-pub export fn sqlite3_trace_v2(db: ?*c.sqlite3, uMask: c_uint, xCallback: ?*const fn (c_uint, ?*anyopaque, ?*anyopaque, ?*anyopaque) callconv(.C) c_int, pCtx: ?*anyopaque) c_int {
+pub export fn sqlite3_trace_v2(db: ?*c.sqlite3, uMask: c_uint, xCallback: ?*const fn (c_uint, ?*anyopaque, ?*anyopaque, ?*anyopaque) callconv(.c) c_int, pCtx: ?*anyopaque) c_int {
     return sqlite3_api.*.trace_v2.?(db, uMask, xCallback, pCtx);
 }
 pub export fn sqlite3_expanded_sql(pStmt: ?*c.sqlite3_stmt) [*c]u8 {
@@ -657,10 +655,10 @@ pub export fn sqlite3_prepare_v3(db: ?*c.sqlite3, zSql: [*c]const u8, nByte: c_i
 pub export fn sqlite3_prepare16_v3(db: ?*c.sqlite3, zSql: ?*const anyopaque, nByte: c_int, prepFlags: c_uint, ppStmt: [*c]?*c.sqlite3_stmt, pzTail: [*c]?*const anyopaque) c_int {
     return sqlite3_api.*.prepare16_v3.?(db, zSql, nByte, prepFlags, ppStmt, pzTail);
 }
-pub export fn sqlite3_bind_pointer(pStmt: ?*c.sqlite3_stmt, i: c_int, pPtr: ?*anyopaque, zPTtype: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_bind_pointer(pStmt: ?*c.sqlite3_stmt, i: c_int, pPtr: ?*anyopaque, zPTtype: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.bind_pointer.?(pStmt, i, pPtr, zPTtype, xDestructor);
 }
-pub export fn sqlite3_result_pointer(pCtx: ?*c.sqlite3_context, pPtr: ?*anyopaque, zPType: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) void {
+pub export fn sqlite3_result_pointer(pCtx: ?*c.sqlite3_context, pPtr: ?*anyopaque, zPType: [*c]const u8, xDestructor: ?*const fn (?*anyopaque) callconv(.c) void) void {
     return sqlite3_api.*.result_pointer.?(pCtx, pPtr, zPType, xDestructor);
 }
 pub export fn sqlite3_value_pointer(pVal: ?*c.sqlite3_value, zPType: [*c]const u8) ?*anyopaque {
@@ -717,11 +715,11 @@ pub export fn sqlite3_create_window_function(
     nArg: c_int,
     eTextRep: c_int,
     pArg: ?*anyopaque,
-    xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xFinal: ?*const fn (?*c.sqlite3_context) callconv(.C) void,
-    xValue: ?*const fn (?*c.sqlite3_context) callconv(.C) void,
-    xInverse: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.C) void,
-    xDestroy: ?*const fn (?*anyopaque) callconv(.C) void,
+    xStep: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void,
+    xFinal: ?*const fn (?*c.sqlite3_context) callconv(.c) void,
+    xValue: ?*const fn (?*c.sqlite3_context) callconv(.c) void,
+    xInverse: ?*const fn (?*c.sqlite3_context, c_int, [*c]?*c.sqlite3_value) callconv(.c) void,
+    xDestroy: ?*const fn (?*anyopaque) callconv(.c) void,
 ) c_int {
     return sqlite3_api.*.create_window_function.?(
         db,
@@ -778,7 +776,7 @@ pub export fn sqlite3_changes64(db: ?*c.sqlite3) c.sqlite3_int64 {
 pub export fn sqlite3_total_changes64(db: ?*c.sqlite3) c.sqlite3_int64 {
     return sqlite3_api.*.total_changes64.?(db);
 }
-pub export fn sqlite3_autovacuum_pages(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, [*c]const u8, c_uint, c_uint, c_uint) callconv(.C) c_uint, pArg: ?*anyopaque, xDestructor: ?*const fn (?*anyopaque) callconv(.C) void) c_int {
+pub export fn sqlite3_autovacuum_pages(db: ?*c.sqlite3, xCallback: ?*const fn (?*anyopaque, [*c]const u8, c_uint, c_uint, c_uint) callconv(.c) c_uint, pArg: ?*anyopaque, xDestructor: ?*const fn (?*anyopaque) callconv(.c) void) c_int {
     return sqlite3_api.*.autovacuum_pages.?(db, xCallback, pArg, xDestructor);
 }
 pub export fn sqlite3_error_offset(db: ?*c.sqlite3) c_int {
diff --git a/errors.zig b/errors.zig
index 59293c4..1b170f6 100644
--- a/errors.zig
+++ b/errors.zig
@@ -276,10 +276,7 @@ pub const DetailedError = struct {
     near: i32,
     message: []const u8,
 
-    pub fn format(self: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
-        _ = fmt;
-        _ = options;
-
+    pub fn format(self: @This(), writer: anytype) !void {
         _ = try writer.print("{{code: {}, near: {d}, message: {s}}}", .{ self.code, self.near, self.message });
     }
 };
diff --git a/examples/zigcrypto.zig b/examples/zigcrypto.zig
index 05c44a5..9489df1 100644
--- a/examples/zigcrypto.zig
+++ b/examples/zigcrypto.zig
@@ -39,7 +39,7 @@ fn createAllFunctions(db: *sqlite.Db) !void {
     );
 }
 
-pub export fn sqlite3_zigcrypto_init(raw_db: *c.sqlite3, err_msg: [*c][*c]u8, api: *c.sqlite3_api_routines) callconv(.C) c_int {
+pub export fn sqlite3_zigcrypto_init(raw_db: *c.sqlite3, err_msg: [*c][*c]u8, api: *c.sqlite3_api_routines) callconv(.c) c_int {
     _ = err_msg;
 
     c.sqlite3_api = api;
diff --git a/examples/zigcrypto_test.zig b/examples/zigcrypto_test.zig
index 9340f99..5922d8d 100644
--- a/examples/zigcrypto_test.zig
+++ b/examples/zigcrypto_test.zig
@@ -41,14 +41,14 @@ pub fn main() anyerror!void {
     var diags = sqlite.Diagnostics{};
 
     const blake3_digest = db.oneAlloc([]const u8, allocator, "SELECT hex(blake3('foobar'))", .{ .diags = &diags }, .{}) catch |err| {
-        debug.print("unable to get blake3 hash, err: {!}, diags: {s}\n", .{ err, diags });
+        debug.print("unable to get blake3 hash, err: {}, diags: {f}\n", .{ err, diags });
         return err;
     };
     debug.assert(blake3_digest != null);
     debug.assert(mem.eql(u8, "AA51DCD43D5C6C5203EE16906FD6B35DB298B9B2E1DE3FCE81811D4806B76B7D", blake3_digest.?));
 
     const sha3_digest = db.oneAlloc([]const u8, allocator, "SELECT hex(sha3_512('foobar'))", .{ .diags = &diags }, .{}) catch |err| {
-        debug.print("unable to get sha3 hash, err: {!}, diags: {s}\n", .{ err, diags });
+        debug.print("unable to get sha3 hash, err: {}, diags: {f}\n", .{ err, diags });
         return err;
     };
     debug.assert(sha3_digest != null);
diff --git a/sqlite.zig b/sqlite.zig
index 1b6ea36..7b2cd99 100644
--- a/sqlite.zig
+++ b/sqlite.zig
@@ -132,7 +132,7 @@ pub const Blob = struct {
         }
     }
 
-    pub const Reader = io.Reader(*Self, errors.Error, read);
+    pub const Reader = io.GenericReader(*Self, errors.Error, read);
 
     /// reader returns a io.Reader.
     pub fn reader(self: *Self) Reader {
@@ -164,7 +164,7 @@ pub const Blob = struct {
         return tmp_buffer.len;
     }
 
-    pub const Writer = io.Writer(*Self, Error, write);
+    pub const Writer = io.GenericWriter(*Self, Error, write);
 
     /// writer returns a io.Writer.
     pub fn writer(self: *Self) Writer {
@@ -261,14 +261,14 @@ pub const Diagnostics = struct {
     message: []const u8 = "",
     err: ?DetailedError = null,
 
-    pub fn format(self: @This(), comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+    pub fn format(self: @This(), writer: anytype) !void {
         if (self.err) |err| {
             if (self.message.len > 0) {
-                _ = try writer.print("{{message: {s}, detailed error: {s}}}", .{ self.message, err });
+                _ = try writer.print("{{message: {s}, detailed error: {f}}}", .{ self.message, err });
                 return;
             }
 
-            _ = try err.format(fmt, options, writer);
+            _ = try err.format(writer);
             return;
         }
 
@@ -704,7 +704,7 @@ pub const Db = struct {
             user_ctx,
             null, // xFunc
             struct {
-                fn xStep(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) void {
+                fn xStep(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.c) void {
                     debug.assert(argc == real_args_len);
 
                     const sqlite_args = argv[0..real_args_len];
@@ -728,7 +728,7 @@ pub const Db = struct {
                 }
             }.xStep,
             struct {
-                fn xFinal(ctx: ?*c.sqlite3_context) callconv(.C) void {
+                fn xFinal(ctx: ?*c.sqlite3_context) callconv(.c) void {
                     var args: std.meta.ArgsTuple(@TypeOf(finalize_func)) = undefined;
 
                     // Pass the function context
@@ -780,7 +780,7 @@ pub const Db = struct {
             flags,
             null,
             struct {
-                fn xFunc(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) void {
+                fn xFunc(ctx: ?*c.sqlite3_context, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.c) void {
                     debug.assert(argc == fn_info.params.len);
 
                     const sqlite_args = argv[0..fn_info.params.len];
@@ -955,7 +955,7 @@ pub const Savepoint = struct {
 
         // From DynamiStatement
         EmptyQuery,
-    } || std.fmt.AllocPrintError || Error;
+    } || std.mem.Allocator.Error || Error;
 
     fn init(db: *Db, name: []const u8) InitError!Self {
         if (name.len < 1) return error.SavepointNameTooShort;
@@ -993,7 +993,7 @@ pub const Savepoint = struct {
     pub fn commit(self: *Self) void {
         self.commit_stmt.exec(.{}, .{}) catch |err| {
             const detailed_error = self.db.getDetailedError();
-            logger.err("unable to release savepoint, error: {}, message: {s}", .{ err, detailed_error });
+            logger.err("unable to release savepoint, error: {}, message: {f}", .{ err, detailed_error });
         };
         self.committed = true;
     }
@@ -1008,7 +1008,7 @@ pub const Savepoint = struct {
 
         self.rollback_stmt.exec(.{}, .{}) catch |err| {
             const detailed_error = self.db.getDetailedError();
-            std.debug.panic("unable to rollback transaction, error: {}, message: {s}\n", .{ err, detailed_error });
+            std.debug.panic("unable to rollback transaction, error: {}, message: {f}\n", .{ err, detailed_error });
         };
     }
 };
@@ -1589,7 +1589,7 @@ pub const DynamicStatement = struct {
         const result = c.sqlite3_finalize(self.stmt);
         if (result != c.SQLITE_OK) {
             const detailed_error = getLastDetailedErrorFromDb(self.db);
-            logger.err("unable to finalize prepared statement, result: {}, detailed error: {}", .{ result, detailed_error });
+            logger.err("unable to finalize prepared statement, result: {}, detailed error: {f}", .{ result, detailed_error });
         }
     }
 
@@ -1598,12 +1598,12 @@ pub const DynamicStatement = struct {
         const result = c.sqlite3_clear_bindings(self.stmt);
         if (result != c.SQLITE_OK) {
             const detailed_error = getLastDetailedErrorFromDb(self.db);
-            logger.err("unable to clear prepared statement bindings, result: {}, detailed error: {}", .{ result, detailed_error });
+            logger.err("unable to clear prepared statement bindings, result: {}, detailed error: {f}", .{ result, detailed_error });
         }
         const result2 = c.sqlite3_reset(self.stmt);
         if (result2 != c.SQLITE_OK) {
             const detailed_error = getLastDetailedErrorFromDb(self.db);
-            logger.err("unable to reset prepared statement, result: {}, detailed error: {}", .{ result2, detailed_error });
+            logger.err("unable to reset prepared statement, result: {}, detailed error: {f}", .{ result2, detailed_error });
         }
     }
 
@@ -3223,7 +3223,7 @@ test "sqlite: diagnostics format" {
 
     inline for (testCases) |tc| {
         var buf: [1024]u8 = undefined;
-        const str = try std.fmt.bufPrint(&buf, "my diagnostics: {s}", .{tc.input});
+        const str = try std.fmt.bufPrint(&buf, "my diagnostics: {f}", .{tc.input});
 
         try testing.expectEqualStrings(tc.exp, str);
     }
@@ -3390,7 +3390,8 @@ const MyData = struct {
     const BaseType = []const u8;
 
     pub fn bindField(self: MyData, allocator: mem.Allocator) !BaseType {
-        return try std.fmt.allocPrint(allocator, "{}", .{std.fmt.fmtSliceHexLower(&self.data)});
+        const num = std.mem.bytesAsValue(u128, &self.data);
+        return try std.fmt.allocPrint(allocator, "{s}", .{std.fmt.hex(num.*)});
     }
 
     pub fn readField(alloc: mem.Allocator, value: BaseType) !MyData {
@@ -3797,7 +3798,7 @@ test "sqlite: create aggregate function with no aggregate context" {
         .{ .diags = &diags },
         .{},
     ) catch |err| {
-        debug.print("err: {}\n", .{diags});
+        debug.print("err: {f}\n", .{diags});
         return err;
     };
 
@@ -3858,7 +3859,7 @@ test "sqlite: create aggregate function with an aggregate context" {
         .{ .diags = &diags },
         .{},
     ) catch |err| {
-        debug.print("err: {}\n", .{diags});
+        debug.print("err: {f}\n", .{diags});
         return err;
     };
 
diff --git a/vtab.zig b/vtab.zig
index 53e46c1..539fcc4 100644
--- a/vtab.zig
+++ b/vtab.zig
@@ -50,7 +50,7 @@ pub const VTabDiagnostics = struct {
     error_message: []const u8 = "unknown error",
 
     pub fn setErrorMessage(self: *Self, comptime format_string: []const u8, values: anytype) void {
-        self.error_message = fmt.allocPrint(self.allocator, format_string, values) catch |err| switch (err) {
+        self.error_message = fmt.allocPrintSentinel(self.allocator, format_string, values, 0) catch |err| switch (err) {
             error.OutOfMemory => "can't set diagnostic message, out of memory",
         };
     }
@@ -717,7 +717,7 @@ pub fn VirtualTable(
             return try State.init(module_context, table);
         }
 
-        fn xCreate(db: ?*c.sqlite3, module_context_ptr: ?*anyopaque, argc: c_int, argv: [*c]const [*c]const u8, vtab: [*c][*c]c.sqlite3_vtab, err_str: [*c][*c]const u8) callconv(.C) c_int {
+        fn xCreate(db: ?*c.sqlite3, module_context_ptr: ?*anyopaque, argc: c_int, argv: [*c]const [*c]const u8, vtab: [*c][*c]c.sqlite3_vtab, err_str: [*c][*c]const u8) callconv(.c) c_int {
             _ = db;
             _ = module_context_ptr;
             _ = argc;
@@ -730,7 +730,7 @@ pub fn VirtualTable(
             return c.SQLITE_ERROR;
         }
 
-        fn xConnect(db: ?*c.sqlite3, module_context_ptr: ?*anyopaque, argc: c_int, argv: [*c]const [*c]const u8, vtab: [*c][*c]c.sqlite3_vtab, err_str: [*c][*c]u8) callconv(.C) c_int {
+        fn xConnect(db: ?*c.sqlite3, module_context_ptr: ?*anyopaque, argc: c_int, argv: [*c]const [*c]const u8, vtab: [*c][*c]c.sqlite3_vtab, err_str: [*c][*c]u8) callconv(.c) c_int {
             const module_context = getModuleContext(module_context_ptr);
 
             var arena = heap.ArenaAllocator.init(module_context.allocator);
@@ -761,7 +761,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xBestIndex(vtab: [*c]c.sqlite3_vtab, index_info_ptr: [*c]c.sqlite3_index_info) callconv(.C) c_int {
+        fn xBestIndex(vtab: [*c]c.sqlite3_vtab, index_info_ptr: [*c]c.sqlite3_index_info) callconv(.c) c_int {
             const index_info: *c.sqlite3_index_info = index_info_ptr orelse unreachable;
 
             //
@@ -775,20 +775,20 @@ pub fn VirtualTable(
             // Create an index builder and let the user build the index.
 
             var builder = BestIndexBuilder.init(arena.allocator(), index_info) catch |err| {
-                logger.err("unable to create best index builder, err: {!}", .{err});
+                logger.err("unable to create best index builder, err: {}", .{err});
                 return c.SQLITE_ERROR;
             };
 
             var diags = VTabDiagnostics{ .allocator = arena.allocator() };
             state.table.buildBestIndex(&diags, &builder) catch |err| {
-                logger.err("unable to build best index, err: {!}", .{err});
+                logger.err("unable to build best index, err: {}", .{err});
                 return c.SQLITE_ERROR;
             };
 
             return c.SQLITE_OK;
         }
 
-        fn xDisconnect(vtab: [*c]c.sqlite3_vtab) callconv(.C) c_int {
+        fn xDisconnect(vtab: [*c]c.sqlite3_vtab) callconv(.c) c_int {
             const nullable_state: ?*State = @fieldParentPtr("vtab", vtab);
             const state = nullable_state orelse unreachable;
 
@@ -797,7 +797,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xDestroy(vtab: [*c]c.sqlite3_vtab) callconv(.C) c_int {
+        fn xDestroy(vtab: [*c]c.sqlite3_vtab) callconv(.c) c_int {
             _ = vtab;
 
             debug.print("xDestroy\n", .{});
@@ -805,12 +805,12 @@ pub fn VirtualTable(
             return c.SQLITE_ERROR;
         }
 
-        fn xOpen(vtab: [*c]c.sqlite3_vtab, vtab_cursor: [*c][*c]c.sqlite3_vtab_cursor) callconv(.C) c_int {
+        fn xOpen(vtab: [*c]c.sqlite3_vtab, vtab_cursor: [*c][*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
             const nullable_state: ?*State = @fieldParentPtr("vtab", vtab);
             const state = nullable_state orelse unreachable;
 
             const cursor_state = CursorState.init(state.module_context, state.table) catch |err| {
-                logger.err("unable to create cursor state, err: {!}", .{err});
+                logger.err("unable to create cursor state, err: {}", .{err});
                 return c.SQLITE_ERROR;
             };
             vtab_cursor.* = @ptrCast(cursor_state);
@@ -818,7 +818,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xClose(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.C) c_int {
+        fn xClose(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
             const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
             const cursor_state = nullable_cursor_state orelse unreachable;
 
@@ -827,7 +827,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xEof(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.C) c_int {
+        fn xEof(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
             const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
@@ -865,7 +865,7 @@ pub fn VirtualTable(
             return res;
         }
 
-        fn xFilter(vtab_cursor: [*c]c.sqlite3_vtab_cursor, idx_num: c_int, idx_str: [*c]const u8, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.C) c_int {
+        fn xFilter(vtab_cursor: [*c]c.sqlite3_vtab_cursor, idx_num: c_int, idx_str: [*c]const u8, argc: c_int, argv: [*c]?*c.sqlite3_value) callconv(.c) c_int {
             const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
@@ -878,7 +878,7 @@ pub fn VirtualTable(
             const id = IndexIdentifier.fromC(idx_num, idx_str);
 
             const args = filterArgsFromCPointer(arena.allocator(), argc, argv) catch |err| {
-                logger.err("unable to create filter args, err: {!}", .{err});
+                logger.err("unable to create filter args, err: {}", .{err});
                 return c.SQLITE_ERROR;
             };
 
@@ -891,7 +891,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xNext(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.C) c_int {
+        fn xNext(vtab_cursor: [*c]c.sqlite3_vtab_cursor) callconv(.c) c_int {
             const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
@@ -910,7 +910,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xColumn(vtab_cursor: [*c]c.sqlite3_vtab_cursor, ctx: ?*c.sqlite3_context, n: c_int) callconv(.C) c_int {
+        fn xColumn(vtab_cursor: [*c]c.sqlite3_vtab_cursor, ctx: ?*c.sqlite3_context, n: c_int) callconv(.c) c_int {
             const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
@@ -954,7 +954,7 @@ pub fn VirtualTable(
             return c.SQLITE_OK;
         }
 
-        fn xRowid(vtab_cursor: [*c]c.sqlite3_vtab_cursor, row_id_ptr: [*c]c.sqlite3_int64) callconv(.C) c_int {
+        fn xRowid(vtab_cursor: [*c]c.sqlite3_vtab_cursor, row_id_ptr: [*c]c.sqlite3_int64) callconv(.c) c_int {
             const nullable_cursor_state: ?*CursorState = @fieldParentPtr("vtab_cursor", vtab_cursor);
             const cursor_state = nullable_cursor_state orelse unreachable;
             const cursor = cursor_state.cursor;
@@ -1011,7 +1011,7 @@ const TestVirtualTable = struct {
                             n = fmt.parseInt(usize, kv.value, 10) catch |err| {
                                 switch (err) {
                                     error.InvalidCharacter => diags.setErrorMessage("not a number: {s}", .{kv.value}),
-                                    else => diags.setErrorMessage("got error while parsing value {s}: {!}", .{ kv.value, err }),
+                                    else => diags.setErrorMessage("got error while parsing value {s}: {}", .{ kv.value, err }),
                                 }
                                 return err;
                             };
@@ -1297,7 +1297,7 @@ test "parse module arguments" {
 
     const args = try allocator.alloc([*c]const u8, 20);
     for (args, 0..) |*arg, i| {
-        const tmp = try fmt.allocPrintZ(allocator, "arg={d}", .{i});
+        const tmp = try fmt.allocPrintSentinel(allocator, "arg={d}", .{i}, 0);
         arg.* = @ptrCast(tmp);
     }