can specify a wasm target in build

src/App.zig

@@ -266,3 +266,32 @@ pub const Message = union(enum) {
         font_size: ?font.face.DesiredSize = null,
     };
 };
+
+// Wasm API.
+pub const Wasm = if (!builtin.target.isWasm()) struct {} else struct {
+    const wasm = @import("os/wasm.zig");
+    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 null;
+    //     };
+    // }
+    //
+    // fn app_new_(config: *Config) !*App {
+    //     const app = try App.create(alloc, config);
+    //     errdefer app.destroy();
+    //
+    //     const result = try alloc.create(App);
+    //     result.* = app;
+    //     return result;
+    // }
+    //
+    // export fn app_free(ptr: ?*App) void {
+    //     if (ptr) |v| {
+    //         v.destroy();
+    //         alloc.destroy(v);
+    //     }
+    // }
+};

src/DevMode.zig

@@ -3,6 +3,7 @@
 const DevMode = @This();
 
 const std = @import("std");
+const builtin = @import("builtin");
 const imgui = @import("imgui");
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
@@ -14,7 +15,7 @@ const Config = @import("config.zig").Config;
 
 /// If this is false, the rest of the terminal will be compiled without
 /// dev mode support at all.
-pub const enabled = true;
+pub const enabled = !builtin.target.isWasm();
 
 /// The global DevMode instance that can be used app-wide. Assume all functions
 /// are NOT thread-safe unless otherwise noted.

src/apprt.zig

@@ -12,13 +12,16 @@ const builtin = @import("builtin");
 
 pub usingnamespace @import("apprt/structs.zig");
 pub const glfw = @import("apprt/glfw.zig");
+pub const browser = @import("apprt/browser.zig");
 pub const Window = @import("apprt/Window.zig");
 
 /// The implementation to use for the app runtime. This is comptime chosen
 /// so that every build has exactly one application runtime implementation.
 /// Note: it is very rare to use Runtime directly; most usage will use
 /// Window or something.
-pub const runtime = switch (builtin.os.tag) {
+pub const runtime = if (builtin.target.isWasm())
+    browser
+else switch (builtin.os.tag) {
     else => glfw,
 };
 

src/apprt/browser.zig

@@ -0,0 +1,2 @@
+pub const App = struct {};
+pub const Window = struct {};

src/main_wasm.zig

@@ -8,6 +8,7 @@ pub usingnamespace @import("os/wasm/log.zig");
 pub usingnamespace @import("font/main.zig");
 pub usingnamespace @import("terminal/main.zig");
 pub usingnamespace @import("config.zig").Wasm;
+pub usingnamespace @import("App.zig").Wasm;
 
 // Set our log level. We try to get as much logging as possible but in
 // ReleaseSmall mode where we're optimizing for space, we elevate the

src/os/wasm.zig

@@ -2,6 +2,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const options = @import("build_options");
+const Target = @import("wasm/target.zig").Target;
 
 comptime {
     if (!builtin.target.isWasm()) {
@@ -13,6 +14,16 @@ comptime {
 /// in JS will be backed by a SharedArrayBuffer and some behaviors change.
 pub const shared_mem = options.wasm_shared;
 
+/// Our specific target platform.
+pub const target: ?Target = if (!builtin.target.isWasm()) null else target: {
+    const result = @intToEnum(Target, @enumToInt(options.wasm_target));
+    // This maybe isn't necessary but I don't know if enums without a specific
+    // tag type and value are guaranteed to be the same between build.zig
+    // compilation and our own source compilation so I have this just in case.
+    std.debug.assert(std.mem.eql(u8, @tagName(result), @tagName(options.wasm_target)));
+    break :target result;
+};
+
 /// The allocator to use in wasm environments.
 ///
 /// The return values of this should NOT be sent to the host environment

src/os/wasm/target.zig

@@ -0,0 +1,6 @@
+/// The wasm target platform. This is used to toggle certain features
+/// on and off since the standard triple target is often not specific
+/// enough (i.e. we can't tell wasm32-freestanding is for browser or not).
+pub const Target = enum {
+    browser,
+};

src/renderer.zig

@@ -14,13 +14,17 @@ pub usingnamespace @import("renderer/message.zig");
 pub usingnamespace @import("renderer/size.zig");
 pub const Metal = @import("renderer/Metal.zig");
 pub const OpenGL = @import("renderer/OpenGL.zig");
+pub const WebGL = @import("renderer/WebGL.zig");
 pub const Options = @import("renderer/Options.zig");
 pub const Thread = @import("renderer/Thread.zig");
 pub const State = @import("renderer/State.zig");
 
 /// The implementation to use for the renderer. This is comptime chosen
 /// so that every build has exactly one renderer implementation.
-pub const Renderer = switch (builtin.os.tag) {
+const wasm = @import("os/wasm.zig");
+pub const Renderer = if (wasm.target) |target| switch (target) {
+    .browser => WebGL,
+} else switch (builtin.os.tag) {
     .macos => Metal,
     else => OpenGL,
 };

src/renderer/WebGL.zig

@@ -0,0 +1,2 @@
+//! Renderer implementation for WebGL in the browser.
+pub const WebGL = @This();