mirror of
https://github.com/ghostty-org/ghostty.git
synced 2025-12-31 02:32:13 +00:00
9dc2e5978f
This makes `libghostty-vt` build for freestanding wasm targets (aka a browser) and produce a `ghostty-vt.wasm` file. This exports the same C API that libghostty-vt does. This commit specifically makes the changes necessary for the build to build properly and for us to run the build in CI. We don't yet actually try using it...
627 lines
21 KiB
Zig
627 lines
21 KiB
Zig
/// Build configuration. This is the configuration that is populated
|
|
/// during `zig build` to control the rest of the build process.
|
|
const Config = @This();
|
|
|
|
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
|
|
const ApprtRuntime = @import("../apprt/runtime.zig").Runtime;
|
|
const FontBackend = @import("../font/backend.zig").Backend;
|
|
const RendererBackend = @import("../renderer/backend.zig").Backend;
|
|
const TerminalBuildOptions = @import("../terminal/build_options.zig").Options;
|
|
const XCFrameworkTarget = @import("xcframework.zig").Target;
|
|
const WasmTarget = @import("../os/wasm/target.zig").Target;
|
|
const expandPath = @import("../os/path.zig").expand;
|
|
|
|
const gtk = @import("gtk.zig");
|
|
const GitVersion = @import("GitVersion.zig");
|
|
|
|
/// Standard build configuration options.
|
|
optimize: std.builtin.OptimizeMode,
|
|
target: std.Build.ResolvedTarget,
|
|
xcframework_target: XCFrameworkTarget = .universal,
|
|
wasm_target: WasmTarget,
|
|
|
|
/// Comptime interfaces
|
|
app_runtime: ApprtRuntime = .none,
|
|
renderer: RendererBackend = .opengl,
|
|
font_backend: FontBackend = .freetype,
|
|
|
|
/// Feature flags
|
|
x11: bool = false,
|
|
wayland: bool = false,
|
|
sentry: bool = true,
|
|
simd: bool = true,
|
|
i18n: bool = true,
|
|
wasm_shared: bool = true,
|
|
|
|
/// Ghostty exe properties
|
|
exe_entrypoint: ExeEntrypoint = .ghostty,
|
|
version: std.SemanticVersion = .{ .major = 0, .minor = 0, .patch = 0 },
|
|
|
|
/// Binary properties
|
|
pie: bool = false,
|
|
strip: bool = false,
|
|
patch_rpath: ?[]const u8 = null,
|
|
|
|
/// Artifacts
|
|
flatpak: bool = false,
|
|
snap: bool = false,
|
|
emit_bench: bool = false,
|
|
emit_docs: bool = false,
|
|
emit_exe: bool = false,
|
|
emit_helpgen: bool = false,
|
|
emit_macos_app: bool = false,
|
|
emit_terminfo: bool = false,
|
|
emit_termcap: bool = false,
|
|
emit_test_exe: bool = false,
|
|
emit_themes: bool = false,
|
|
emit_xcframework: bool = false,
|
|
emit_webdata: bool = false,
|
|
emit_unicode_table_gen: bool = false,
|
|
|
|
/// Environmental properties
|
|
env: std.process.EnvMap,
|
|
|
|
pub fn init(b: *std.Build, appVersion: []const u8) !Config {
|
|
// Setup our standard Zig target and optimize options, i.e.
|
|
// `-Doptimize` and `-Dtarget`.
|
|
const optimize = b.standardOptimizeOption(.{});
|
|
const target = target: {
|
|
var result = b.standardTargetOptions(.{});
|
|
|
|
// If we're building for macOS and we're on macOS, we need to
|
|
// use a generic target to workaround compilation issues.
|
|
if (result.result.os.tag == .macos and
|
|
builtin.target.os.tag.isDarwin())
|
|
{
|
|
result = genericMacOSTarget(b, result.query.cpu_arch);
|
|
}
|
|
|
|
// If we have no minimum OS version, we set the default based on
|
|
// our tag. Not all tags have a minimum so this may be null.
|
|
if (result.query.os_version_min == null) {
|
|
result.query.os_version_min = osVersionMin(result.result.os.tag);
|
|
}
|
|
|
|
break :target result;
|
|
};
|
|
|
|
// This is set to true when we're building a system package. For now
|
|
// this is trivially detected using the "system_package_mode" bool
|
|
// but we may want to make this more sophisticated in the future.
|
|
const system_package = b.graph.system_package_mode;
|
|
|
|
// This specifies our target wasm runtime. For now only one semi-usable
|
|
// one exists so this is hardcoded.
|
|
const wasm_target: WasmTarget = .browser;
|
|
|
|
// Determine whether GTK supports X11 and Wayland. This is always safe
|
|
// to run even on non-Linux platforms because any failures result in
|
|
// defaults.
|
|
const gtk_targets = gtk.targets(b);
|
|
|
|
// We use env vars throughout the build so we grab them immediately here.
|
|
var env = try std.process.getEnvMap(b.allocator);
|
|
errdefer env.deinit();
|
|
|
|
var config: Config = .{
|
|
.optimize = optimize,
|
|
.target = target,
|
|
.wasm_target = wasm_target,
|
|
.env = env,
|
|
};
|
|
|
|
//---------------------------------------------------------------
|
|
// Target-specific properties
|
|
config.xcframework_target = b.option(
|
|
XCFrameworkTarget,
|
|
"xcframework-target",
|
|
"The target for the xcframework.",
|
|
) orelse .universal;
|
|
|
|
//---------------------------------------------------------------
|
|
// Comptime Interfaces
|
|
config.font_backend = b.option(
|
|
FontBackend,
|
|
"font-backend",
|
|
"The font backend to use for discovery and rasterization.",
|
|
) orelse FontBackend.default(target.result, wasm_target);
|
|
|
|
config.app_runtime = b.option(
|
|
ApprtRuntime,
|
|
"app-runtime",
|
|
"The app runtime to use. Not all values supported on all platforms.",
|
|
) orelse ApprtRuntime.default(target.result);
|
|
|
|
config.renderer = b.option(
|
|
RendererBackend,
|
|
"renderer",
|
|
"The app runtime to use. Not all values supported on all platforms.",
|
|
) orelse RendererBackend.default(target.result, wasm_target);
|
|
|
|
//---------------------------------------------------------------
|
|
// Feature Flags
|
|
|
|
config.flatpak = b.option(
|
|
bool,
|
|
"flatpak",
|
|
"Build for Flatpak (integrates with Flatpak APIs). Only has an effect targeting Linux.",
|
|
) orelse false;
|
|
|
|
config.snap = b.option(
|
|
bool,
|
|
"snap",
|
|
"Build for Snap (do specific Snap operations). Only has an effect targeting Linux.",
|
|
) orelse false;
|
|
|
|
config.sentry = b.option(
|
|
bool,
|
|
"sentry",
|
|
"Build with Sentry crash reporting. Default for macOS is true, false for any other system.",
|
|
) orelse sentry: {
|
|
switch (target.result.os.tag) {
|
|
.macos, .ios => break :sentry true,
|
|
|
|
// Note its false for linux because the crash reports on Linux
|
|
// don't have much useful information.
|
|
else => break :sentry false,
|
|
}
|
|
};
|
|
|
|
config.simd = b.option(
|
|
bool,
|
|
"simd",
|
|
"Build with SIMD-accelerated code paths. Results in significant performance improvements.",
|
|
) orelse simd: {
|
|
// We can't build our SIMD dependencies for Wasm. Note that we may
|
|
// still use SIMD features in the Wasm-builds.
|
|
if (target.result.cpu.arch.isWasm()) break :simd false;
|
|
|
|
break :simd true;
|
|
};
|
|
|
|
config.wayland = b.option(
|
|
bool,
|
|
"gtk-wayland",
|
|
"Enables linking against Wayland libraries when using the GTK rendering backend.",
|
|
) orelse gtk_targets.wayland;
|
|
|
|
config.x11 = b.option(
|
|
bool,
|
|
"gtk-x11",
|
|
"Enables linking against X11 libraries when using the GTK rendering backend.",
|
|
) orelse gtk_targets.x11;
|
|
|
|
config.i18n = b.option(
|
|
bool,
|
|
"i18n",
|
|
"Enables gettext-based internationalization. Enabled by default only for macOS, and other Unix-like systems like Linux and FreeBSD when using glibc.",
|
|
) orelse switch (target.result.os.tag) {
|
|
.macos, .ios => true,
|
|
.linux, .freebsd => target.result.isGnuLibC(),
|
|
else => false,
|
|
};
|
|
|
|
//---------------------------------------------------------------
|
|
// Ghostty Exe Properties
|
|
|
|
const version_string = b.option(
|
|
[]const u8,
|
|
"version-string",
|
|
"A specific version string to use for the build. " ++
|
|
"If not specified, git will be used. This must be a semantic version.",
|
|
);
|
|
|
|
config.version = if (version_string) |v|
|
|
// If an explicit version is given, we always use it.
|
|
try std.SemanticVersion.parse(v)
|
|
else version: {
|
|
const app_version = try std.SemanticVersion.parse(appVersion);
|
|
// If no explicit version is given, we try to detect it from git.
|
|
const vsn = GitVersion.detect(b) catch |err| switch (err) {
|
|
// If Git isn't available we just make an unknown dev version.
|
|
error.GitNotFound,
|
|
error.GitNotRepository,
|
|
=> break :version .{
|
|
.major = app_version.major,
|
|
.minor = app_version.minor,
|
|
.patch = app_version.patch,
|
|
.pre = "dev",
|
|
.build = "0000000",
|
|
},
|
|
|
|
else => return err,
|
|
};
|
|
if (vsn.tag) |tag| {
|
|
// Tip releases behave just like any other pre-release so we skip.
|
|
if (!std.mem.eql(u8, tag, "tip")) {
|
|
const expected = b.fmt("v{d}.{d}.{d}", .{
|
|
app_version.major,
|
|
app_version.minor,
|
|
app_version.patch,
|
|
});
|
|
|
|
if (!std.mem.eql(u8, tag, expected)) {
|
|
@panic("tagged releases must be in vX.Y.Z format matching build.zig");
|
|
}
|
|
|
|
break :version .{
|
|
.major = app_version.major,
|
|
.minor = app_version.minor,
|
|
.patch = app_version.patch,
|
|
};
|
|
}
|
|
}
|
|
|
|
break :version .{
|
|
.major = app_version.major,
|
|
.minor = app_version.minor,
|
|
.patch = app_version.patch,
|
|
.pre = vsn.branch,
|
|
.build = vsn.short_hash,
|
|
};
|
|
};
|
|
|
|
//---------------------------------------------------------------
|
|
// Binary Properties
|
|
|
|
// On NixOS, the built binary from `zig build` needs to patch the rpath
|
|
// into the built binary for it to be portable across the NixOS system
|
|
// it was built for. We default this to true if we can detect we're in
|
|
// a Nix shell and have LD_LIBRARY_PATH set.
|
|
config.patch_rpath = b.option(
|
|
[]const u8,
|
|
"patch-rpath",
|
|
"Inject the LD_LIBRARY_PATH as the rpath in the built binary. " ++
|
|
"This defaults to LD_LIBRARY_PATH if we're in a Nix shell environment on NixOS.",
|
|
) orelse patch_rpath: {
|
|
// We only do the patching if we're targeting our own CPU and its Linux.
|
|
if (!(target.result.os.tag == .linux) or !target.query.isNativeCpu()) break :patch_rpath null;
|
|
|
|
// If we're in a nix shell we default to doing this.
|
|
// Note: we purposely never deinit envmap because we leak the strings
|
|
if (env.get("IN_NIX_SHELL") == null) break :patch_rpath null;
|
|
break :patch_rpath env.get("LD_LIBRARY_PATH");
|
|
};
|
|
|
|
config.pie = b.option(
|
|
bool,
|
|
"pie",
|
|
"Build a Position Independent Executable. Default true for system packages.",
|
|
) orelse system_package;
|
|
|
|
config.strip = b.option(
|
|
bool,
|
|
"strip",
|
|
"Strip the final executable. Default true for fast and small releases",
|
|
) orelse switch (optimize) {
|
|
.Debug => false,
|
|
.ReleaseSafe => false,
|
|
.ReleaseFast, .ReleaseSmall => true,
|
|
};
|
|
|
|
//---------------------------------------------------------------
|
|
// Artifacts to Emit
|
|
|
|
config.emit_exe = b.option(
|
|
bool,
|
|
"emit-exe",
|
|
"Build and install main executables with 'build'",
|
|
) orelse true;
|
|
|
|
config.emit_test_exe = b.option(
|
|
bool,
|
|
"emit-test-exe",
|
|
"Build and install test executables with 'build'",
|
|
) orelse false;
|
|
|
|
config.emit_unicode_table_gen = b.option(
|
|
bool,
|
|
"emit-unicode-table-gen",
|
|
"Build and install executables that generate unicode tables with 'build'",
|
|
) orelse false;
|
|
|
|
config.emit_bench = b.option(
|
|
bool,
|
|
"emit-bench",
|
|
"Build and install the benchmark executables.",
|
|
) orelse false;
|
|
|
|
config.emit_helpgen = b.option(
|
|
bool,
|
|
"emit-helpgen",
|
|
"Build and install the helpgen executable.",
|
|
) orelse false;
|
|
|
|
config.emit_docs = b.option(
|
|
bool,
|
|
"emit-docs",
|
|
"Build and install auto-generated documentation (requires pandoc)",
|
|
) orelse emit_docs: {
|
|
// If we are emitting any other artifacts then we default to false.
|
|
if (config.emit_bench or
|
|
config.emit_test_exe or
|
|
config.emit_helpgen) break :emit_docs false;
|
|
|
|
// We always emit docs in system package mode.
|
|
if (system_package) break :emit_docs true;
|
|
|
|
// We only default to true if we can find pandoc.
|
|
const path = expandPath(b.allocator, "pandoc") catch
|
|
break :emit_docs false;
|
|
defer if (path) |p| b.allocator.free(p);
|
|
break :emit_docs path != null;
|
|
};
|
|
|
|
config.emit_terminfo = b.option(
|
|
bool,
|
|
"emit-terminfo",
|
|
"Install Ghostty terminfo source file",
|
|
) orelse switch (target.result.os.tag) {
|
|
.windows => true,
|
|
else => switch (optimize) {
|
|
.Debug => true,
|
|
.ReleaseSafe, .ReleaseFast, .ReleaseSmall => false,
|
|
},
|
|
};
|
|
|
|
config.emit_termcap = b.option(
|
|
bool,
|
|
"emit-termcap",
|
|
"Install Ghostty termcap file",
|
|
) orelse switch (optimize) {
|
|
.Debug => true,
|
|
.ReleaseSafe, .ReleaseFast, .ReleaseSmall => false,
|
|
};
|
|
|
|
config.emit_themes = b.option(
|
|
bool,
|
|
"emit-themes",
|
|
"Install bundled iTerm2-Color-Schemes Ghostty themes",
|
|
) orelse true;
|
|
|
|
config.emit_webdata = b.option(
|
|
bool,
|
|
"emit-webdata",
|
|
"Build the website data for the website.",
|
|
) orelse false;
|
|
|
|
config.emit_xcframework = b.option(
|
|
bool,
|
|
"emit-xcframework",
|
|
"Build and install the xcframework for the macOS library.",
|
|
) orelse builtin.target.os.tag.isDarwin() and
|
|
target.result.os.tag == .macos and
|
|
config.app_runtime == .none and
|
|
(!config.emit_bench and
|
|
!config.emit_test_exe and
|
|
!config.emit_helpgen);
|
|
|
|
config.emit_macos_app = b.option(
|
|
bool,
|
|
"emit-macos-app",
|
|
"Build and install the macOS app bundle.",
|
|
) orelse config.emit_xcframework;
|
|
|
|
//---------------------------------------------------------------
|
|
// System Packages
|
|
|
|
// These are all our dependencies that can be used with system
|
|
// packages if they exist. We set them up here so that we can set
|
|
// their defaults early. The first call configures the integration and
|
|
// subsequent calls just return the configured value. This lets them
|
|
// show up properly in `--help`.
|
|
|
|
{
|
|
// These dependencies we want to default false if we're on macOS.
|
|
// On macOS we don't want to use system libraries because we
|
|
// generally want a fat binary. This can be overridden with the
|
|
// `-fsys` flag.
|
|
for (&[_][]const u8{
|
|
"freetype",
|
|
"harfbuzz",
|
|
"fontconfig",
|
|
"libpng",
|
|
"zlib",
|
|
"oniguruma",
|
|
}) |dep| {
|
|
_ = b.systemIntegrationOption(
|
|
dep,
|
|
.{
|
|
// If we're not on darwin we want to use whatever the
|
|
// default is via the system package mode
|
|
.default = if (target.result.os.tag.isDarwin()) false else null,
|
|
},
|
|
);
|
|
}
|
|
|
|
// These default to false because they're rarely available as
|
|
// system packages so we usually want to statically link them.
|
|
for (&[_][]const u8{
|
|
"glslang",
|
|
"spirv-cross",
|
|
"simdutf",
|
|
}) |dep| {
|
|
_ = b.systemIntegrationOption(dep, .{ .default = false });
|
|
}
|
|
|
|
// These are dynamic libraries we default to true, preferring
|
|
// to use system packages over building and installing libs
|
|
// as they require additional ldconfig of library paths or
|
|
// patching the rpath of the program to discover the dynamic library
|
|
// at runtime
|
|
for (&[_][]const u8{"gtk4-layer-shell"}) |dep| {
|
|
_ = b.systemIntegrationOption(dep, .{ .default = true });
|
|
}
|
|
}
|
|
|
|
return config;
|
|
}
|
|
|
|
/// Configure the build options with our values.
|
|
pub fn addOptions(self: *const Config, step: *std.Build.Step.Options) !void {
|
|
// We need to break these down individual because addOption doesn't
|
|
// support all types.
|
|
step.addOption(bool, "flatpak", self.flatpak);
|
|
step.addOption(bool, "snap", self.snap);
|
|
step.addOption(bool, "x11", self.x11);
|
|
step.addOption(bool, "wayland", self.wayland);
|
|
step.addOption(bool, "sentry", self.sentry);
|
|
step.addOption(bool, "simd", self.simd);
|
|
step.addOption(bool, "i18n", self.i18n);
|
|
step.addOption(ApprtRuntime, "app_runtime", self.app_runtime);
|
|
step.addOption(FontBackend, "font_backend", self.font_backend);
|
|
step.addOption(RendererBackend, "renderer", self.renderer);
|
|
step.addOption(ExeEntrypoint, "exe_entrypoint", self.exe_entrypoint);
|
|
step.addOption(WasmTarget, "wasm_target", self.wasm_target);
|
|
step.addOption(bool, "wasm_shared", self.wasm_shared);
|
|
|
|
// Our version. We also add the string version so we don't need
|
|
// to do any allocations at runtime. This has to be long enough to
|
|
// accommodate realistic large branch names for dev versions.
|
|
var buf: [1024]u8 = undefined;
|
|
step.addOption(std.SemanticVersion, "app_version", self.version);
|
|
step.addOption([:0]const u8, "app_version_string", try std.fmt.bufPrintZ(
|
|
&buf,
|
|
"{f}",
|
|
.{self.version},
|
|
));
|
|
step.addOption(
|
|
ReleaseChannel,
|
|
"release_channel",
|
|
channel: {
|
|
const pre = self.version.pre orelse break :channel .stable;
|
|
if (pre.len == 0) break :channel .stable;
|
|
break :channel .tip;
|
|
},
|
|
);
|
|
}
|
|
|
|
/// Returns the build options for the terminal module. This assumes a
|
|
/// Ghostty executable being built. Callers should modify this as needed.
|
|
pub fn terminalOptions(self: *const Config) TerminalBuildOptions {
|
|
return .{
|
|
.artifact = .ghostty,
|
|
.simd = self.simd,
|
|
.oniguruma = true,
|
|
.c_abi = false,
|
|
.slow_runtime_safety = switch (self.optimize) {
|
|
.Debug => true,
|
|
.ReleaseSafe,
|
|
.ReleaseSmall,
|
|
.ReleaseFast,
|
|
=> false,
|
|
},
|
|
};
|
|
}
|
|
|
|
/// Returns a baseline CPU target retaining all the other CPU configs.
|
|
pub fn baselineTarget(self: *const Config) std.Build.ResolvedTarget {
|
|
// Set our cpu model as baseline. There may need to be other modifications
|
|
// we need to make such as resetting CPU features but for now this works.
|
|
var q = self.target.query;
|
|
q.cpu_model = .baseline;
|
|
|
|
// Same logic as build.resolveTargetQuery but we don't need to
|
|
// handle the native case.
|
|
return .{
|
|
.query = q,
|
|
.result = std.zig.system.resolveTargetQuery(q) catch
|
|
@panic("unable to resolve baseline query"),
|
|
};
|
|
}
|
|
|
|
/// Rehydrate our Config from the comptime options. Note that not all
|
|
/// options are available at comptime, so look closely at this implementation
|
|
/// to see what is and isn't available.
|
|
pub fn fromOptions() Config {
|
|
const options = @import("build_options");
|
|
return .{
|
|
// Unused at runtime.
|
|
.optimize = undefined,
|
|
.target = undefined,
|
|
.env = undefined,
|
|
|
|
.version = options.app_version,
|
|
.flatpak = options.flatpak,
|
|
.app_runtime = std.meta.stringToEnum(ApprtRuntime, @tagName(options.app_runtime)).?,
|
|
.font_backend = std.meta.stringToEnum(FontBackend, @tagName(options.font_backend)).?,
|
|
.renderer = std.meta.stringToEnum(RendererBackend, @tagName(options.renderer)).?,
|
|
.snap = options.snap,
|
|
.exe_entrypoint = std.meta.stringToEnum(ExeEntrypoint, @tagName(options.exe_entrypoint)).?,
|
|
.wasm_target = std.meta.stringToEnum(WasmTarget, @tagName(options.wasm_target)).?,
|
|
.wasm_shared = options.wasm_shared,
|
|
.i18n = options.i18n,
|
|
};
|
|
}
|
|
|
|
/// Returns the minimum OS version for the given OS tag. This shouldn't
|
|
/// be used generally, it should only be used for Darwin-based OS currently.
|
|
pub fn osVersionMin(tag: std.Target.Os.Tag) ?std.Target.Query.OsVersion {
|
|
return switch (tag) {
|
|
// We support back to the earliest officially supported version
|
|
// of macOS by Apple. EOL versions are not supported.
|
|
.macos => .{ .semver = .{
|
|
.major = 13,
|
|
.minor = 0,
|
|
.patch = 0,
|
|
} },
|
|
|
|
// iOS 17 picked arbitrarily
|
|
.ios => .{ .semver = .{
|
|
.major = 17,
|
|
.minor = 0,
|
|
.patch = 0,
|
|
} },
|
|
|
|
// This should never happen currently. If we add a new target then
|
|
// we should add a new case here.
|
|
else => null,
|
|
};
|
|
}
|
|
|
|
// Returns a ResolvedTarget for a mac with a `target.result.cpu.model.name` of `generic`.
|
|
// `b.standardTargetOptions()` returns a more specific cpu like `apple_a15`.
|
|
//
|
|
// This is used to workaround compilation issues on macOS.
|
|
// (see for example https://github.com/mitchellh/ghostty/issues/1640).
|
|
pub fn genericMacOSTarget(
|
|
b: *std.Build,
|
|
arch: ?std.Target.Cpu.Arch,
|
|
) std.Build.ResolvedTarget {
|
|
return b.resolveTargetQuery(.{
|
|
.cpu_arch = arch orelse builtin.target.cpu.arch,
|
|
.os_tag = .macos,
|
|
.os_version_min = osVersionMin(.macos),
|
|
});
|
|
}
|
|
|
|
/// The possible entrypoints for the exe artifact. This has no effect on
|
|
/// other artifact types (i.e. lib, wasm_module).
|
|
///
|
|
/// The whole existence of this enum is to workaround the fact that Zig
|
|
/// doesn't allow the main function to be in a file in a subdirctory
|
|
/// from the "root" of the module, and I don't want to pollute our root
|
|
/// directory with a bunch of individual zig files for each entrypoint.
|
|
///
|
|
/// Therefore, main.zig uses this to switch between the different entrypoints.
|
|
pub const ExeEntrypoint = enum {
|
|
ghostty,
|
|
helpgen,
|
|
mdgen_ghostty_1,
|
|
mdgen_ghostty_5,
|
|
webgen_config,
|
|
webgen_actions,
|
|
webgen_commands,
|
|
};
|
|
|
|
/// The release channel for the build.
|
|
pub const ReleaseChannel = enum {
|
|
/// Unstable builds on every commit.
|
|
tip,
|
|
|
|
/// Stable tagged releases.
|
|
stable,
|
|
};
|