mirror of
https://github.com/ghostty-org/ghostty.git
synced 2025-07-14 07:46:12 +03:00
fb9c52ecf4
This deletes the GLFW apprt from the Ghostty codebase.
The GLFW apprt was the original apprt used by Ghostty (well, before
Ghostty even had the concept of an "apprt" -- it was all just a single
application then). It let me iterate on the core terminal features,
rendering, etc. without bothering about the UI. It was a good way to get
started. But it has long since outlived its usefulness.
We've had a stable GTK apprt for Linux (and Windows via WSL) and a
native macOS app via libghostty for awhile now. The GLFW apprt only
remained within the tree for a few reasons:
1. Primarily, it provided a faster feedback loop on macOS because
building the macOS app historically required us to hop out of the
zig build system and into Xcode, which is slow and cumbersome.
2. It was a convenient way to narrow whether a bug was in the
core Ghostty codebase or in the apprt itself. If a bug was in both
the glfw and macOS app then it was likely in the core.
3. It provided us a way on macOS to test OpenGL.
All of these reasons are no longer valid. Respectively:
1. Our Zig build scripts now execute the `xcodebuild` CLI directly and
can open the resulting app, stream logs, etc. This is the same
experience we have on Linux. (Xcode has always been a dependency of
building on macOS in general, so this is not cumbersome.)
2. We have a healthy group of maintainers, many of which have access
to both macOS and Linux, so we can quickly narrow down bugs
regardless of the apprt.
3. Our OpenGL renderer hasn't been compatible with macOS for some time
now, so this is no longer a useful feature.
At this point, the GLFW apprt is just a burden. It adds complexity
across the board, and some people try to run Ghostty with it in the real
world and get confused when it doesn't work (it's always been lacking in
features and buggy compared to the other apprts).
So, it's time to say goodbye. Its bittersweet because it is a big part
of Ghostty's history, but we've grown up now and it's time to move on.
Thank you, goodbye.
(NOTE: If you are a user of the GLFW apprt, then please fork the project
prior to this commit or start a new project based on it. We've warned
against using it for a very, very long time now.)
79 lines
2.7 KiB
Zig
79 lines
2.7 KiB
Zig
//! "apprt" is the "application runtime" package. This abstracts the
|
|
//! application runtime and lifecycle management such as creating windows,
|
|
//! getting user input (mouse/keyboard), etc.
|
|
//!
|
|
//! This enables compile-time interfaces to be built to swap out the underlying
|
|
//! application runtime. For example: pure macOS Cocoa, GTK+, browser, etc.
|
|
//!
|
|
//! The goal is to have different implementations share as much of the core
|
|
//! logic as possible, and to only reach out to platform-specific implementation
|
|
//! code when absolutely necessary.
|
|
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const build_config = @import("build_config.zig");
|
|
|
|
const structs = @import("apprt/structs.zig");
|
|
|
|
pub const action = @import("apprt/action.zig");
|
|
pub const gtk = @import("apprt/gtk.zig");
|
|
pub const none = @import("apprt/none.zig");
|
|
pub const browser = @import("apprt/browser.zig");
|
|
pub const embedded = @import("apprt/embedded.zig");
|
|
pub const surface = @import("apprt/surface.zig");
|
|
|
|
pub const Action = action.Action;
|
|
pub const Target = action.Target;
|
|
|
|
pub const ContentScale = structs.ContentScale;
|
|
pub const Clipboard = structs.Clipboard;
|
|
pub const ClipboardRequest = structs.ClipboardRequest;
|
|
pub const ClipboardRequestType = structs.ClipboardRequestType;
|
|
pub const ColorScheme = structs.ColorScheme;
|
|
pub const CursorPos = structs.CursorPos;
|
|
pub const IMEPos = structs.IMEPos;
|
|
pub const Selection = structs.Selection;
|
|
pub const SurfaceSize = structs.SurfaceSize;
|
|
|
|
/// 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 (build_config.artifact) {
|
|
.exe => switch (build_config.app_runtime) {
|
|
.none => none,
|
|
.gtk => gtk,
|
|
},
|
|
.lib => embedded,
|
|
.wasm_module => browser,
|
|
};
|
|
|
|
pub const App = runtime.App;
|
|
pub const Surface = runtime.Surface;
|
|
|
|
/// Runtime is the runtime to use for Ghostty. All runtimes do not provide
|
|
/// equivalent feature sets.
|
|
pub const Runtime = enum {
|
|
/// Will not produce an executable at all when `zig build` is called.
|
|
/// This is only useful if you're only interested in the lib only (macOS).
|
|
none,
|
|
|
|
/// GTK-backed. Rich windowed application. GTK is dynamically linked.
|
|
gtk,
|
|
|
|
pub fn default(target: std.Target) Runtime {
|
|
// The Linux default is GTK because it is full featured.
|
|
if (target.os.tag == .linux) return .gtk;
|
|
|
|
// Otherwise, we do NONE so we don't create an exe and we
|
|
// create libghostty.
|
|
return .none;
|
|
}
|
|
};
|
|
|
|
test {
|
|
_ = Runtime;
|
|
_ = runtime;
|
|
_ = action;
|
|
_ = structs;
|
|
}
|