lots of broken stuff

src/App.zig

@@ -5,6 +5,7 @@ const App = @This();
 
 const std = @import("std");
 const builtin = @import("builtin");
+const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const apprt = @import("apprt.zig");
 const Window = @import("Window.zig");
@@ -273,8 +274,7 @@ pub const Wasm = if (!builtin.target.isWasm()) struct {} else struct {
     const alloc = wasm.alloc;
 
     // export fn app_new(config: *Config) ?*App {
-    //     return app_new_(config) catch |err| {
-    //         log.err("error initializing app err={}", .{err});
+    //     return app_new_(config) catch |err| { log.err("error initializing app err={}", .{err});
     //         return null;
     //     };
     // }
@@ -295,3 +295,15 @@ pub const Wasm = if (!builtin.target.isWasm()) struct {} else struct {
     //     }
     // }
 };
+
+pub const CAPI = struct {
+    const ProcessState = @import("main.zig").ProcessState;
+    var state: ?ProcessState = null;
+
+    export fn ghostty_init() c_int {
+        assert(state == null);
+        state = undefined;
+        ProcessState.init(&state.?);
+        return 0;
+    }
+};

src/main.zig

@@ -16,58 +16,88 @@ const App = @import("App.zig");
 const cli_args = @import("cli_args.zig");
 const Config = @import("config.zig").Config;
 
-pub fn main() !void {
-    // Output some debug information right away
-    std.log.info("dependency harfbuzz={s}", .{harfbuzz.versionString()});
-    if (options.fontconfig) {
-        std.log.info("dependency fontconfig={d}", .{fontconfig.version()});
-    }
-    std.log.info("renderer={}", .{renderer.Renderer});
-    std.log.info("libxev backend={}", .{xev.backend});
-
-    // First things first, we fix our file descriptors
-    internal_os.fixMaxFiles();
-
-    // We need to make sure the process locale is set properly. Locale
-    // affects a lot of behaviors in a shell.
-    internal_os.ensureLocale();
-
+/// ProcessState represents the global process state. There should only
+/// be one of these at any given moment. This is extracted into a dedicated
+/// struct because it is reused by main and the static C lib.
+///
+/// ProcessState.init should be one of the first things ever called
+/// when using Ghostty. Ghostty calls this for you so this is more of a note
+/// for maintainers.
+pub const ProcessState = struct {
     const GPA = std.heap.GeneralPurposeAllocator(.{});
-    var gpa: ?GPA = gpa: {
-        // Use the libc allocator if it is available beacuse it is WAY
-        // faster than GPA. We only do this in release modes so that we
-        // can get easy memory leak detection in debug modes.
-        if (builtin.link_libc) {
-            if (switch (builtin.mode) {
-                .ReleaseSafe, .ReleaseFast => true,
 
-                // We also use it if we can detect we're running under
-                // Valgrind since Valgrind only instruments the C allocator
-                else => std.valgrind.runningOnValgrind() > 0,
-            }) break :gpa null;
+    gpa: ?GPA,
+    alloc: std.mem.Allocator,
+
+    pub fn init(self: *ProcessState) void {
+        // Output some debug information right away
+        std.log.info("dependency harfbuzz={s}", .{harfbuzz.versionString()});
+        if (options.fontconfig) {
+            std.log.info("dependency fontconfig={d}", .{fontconfig.version()});
         }
+        std.log.info("renderer={}", .{renderer.Renderer});
+        std.log.info("libxev backend={}", .{xev.backend});
 
-        break :gpa GPA{};
-    };
-    defer if (gpa) |*value| {
-        // We want to ensure that we deinit the GPA because this is
-        // the point at which it will output if there were safety violations.
-        _ = value.deinit();
-    };
+        // First things first, we fix our file descriptors
+        internal_os.fixMaxFiles();
 
-    const alloc = alloc: {
-        const base = if (gpa) |*value|
-            value.allocator()
-        else if (builtin.link_libc)
-            std.heap.c_allocator
-        else
-            unreachable;
+        // We need to make sure the process locale is set properly. Locale
+        // affects a lot of behaviors in a shell.
+        internal_os.ensureLocale();
 
-        // If we're tracing, wrap the allocator
-        if (!tracy.enabled) break :alloc base;
-        var tracy_alloc = tracy.allocator(base, null);
-        break :alloc tracy_alloc.allocator();
-    };
+        // Initialize ourself to nothing so we don't have any extra state.
+        self.* = .{
+            .gpa = null,
+            .alloc = undefined,
+        };
+        errdefer self.deinit();
+
+        self.gpa = gpa: {
+            // Use the libc allocator if it is available beacuse it is WAY
+            // faster than GPA. We only do this in release modes so that we
+            // can get easy memory leak detection in debug modes.
+            if (builtin.link_libc) {
+                if (switch (builtin.mode) {
+                    .ReleaseSafe, .ReleaseFast => true,
+
+                    // We also use it if we can detect we're running under
+                    // Valgrind since Valgrind only instruments the C allocator
+                    else => std.valgrind.runningOnValgrind() > 0,
+                }) break :gpa null;
+            }
+
+            break :gpa GPA{};
+        };
+
+        self.alloc = alloc: {
+            const base = if (self.gpa) |*value|
+                value.allocator()
+            else if (builtin.link_libc)
+                std.heap.c_allocator
+            else
+                unreachable;
+
+            // If we're tracing, wrap the allocator
+            if (!tracy.enabled) break :alloc base;
+            var tracy_alloc = tracy.allocator(base, null);
+            break :alloc tracy_alloc.allocator();
+        };
+    }
+
+    pub fn deinit(self: *ProcessState) void {
+        if (self.gpa) |*value| {
+            // We want to ensure that we deinit the GPA because this is
+            // the point at which it will output if there were safety violations.
+            _ = value.deinit();
+        }
+    }
+};
+
+pub fn main() !void {
+    var state: ProcessState = undefined;
+    ProcessState.init(&state);
+    defer state.deinit();
+    const alloc = state.alloc;
 
     // Try reading our config
     var config = try Config.default(alloc);

src/main_c.zig

@@ -4,8 +4,8 @@
 // support).
 const std = @import("std");
 const builtin = @import("builtin");
+const main = @import("main.zig");
 
-// We're just testing right now.
-export fn ghostty_hello() u64 {
-    return 42;
-}
+pub usingnamespace @import("App.zig").CAPI;
+
+pub const std_options = main.std_options;