Convert Figma logo to code with AI

ghostty-org logoghostty

👻 Ghostty is a fast, feature-rich, and cross-platform terminal emulator that uses platform-native UI and GPU acceleration.

48,311
2,096
48,311
202
View on GitHub

Top Related Projects

alacritty's avatar

alacritty

62,439

A cross-platform, OpenGL terminal emulator.

wezterm's avatar

wezterm

24,169

A GPU-accelerated cross-platform terminal emulator and multiplexer written by @wez and implemented in Rust

kovidgoyal's avatar

kitty

31,271

If you live in the terminal, kitty is made for you! Cross-platform, fast, feature-rich, GPU based.

vercel's avatar

hyper

44,700

A terminal built on web technologies

gnachman's avatar

iTerm2

16,980

iTerm2 is a terminal emulator for Mac OS X that does amazing things.

microsoft's avatar

terminal

101,819

The new Windows Terminal and the original Windows console host, all in the same place!

Quick Overview

Ghostty is a fast, feature-rich, and cross-platform terminal emulator. It aims to provide a modern terminal experience with a focus on performance, customization, and user-friendly features. Ghostty is designed to be a compelling alternative to traditional terminal emulators.

Pros

  • High performance and low latency, providing a smooth user experience
  • Cross-platform support (macOS, Linux, and Windows)
  • Extensive customization options, including themes and key bindings
  • Built-in features like ligature support, image viewing, and tabs

Cons

  • Relatively new project, which may lead to potential stability issues
  • Limited documentation compared to more established terminal emulators
  • Smaller community and ecosystem compared to alternatives like iTerm2 or Alacritty
  • May require some configuration to achieve desired functionality

Getting Started

To get started with Ghostty, follow these steps:

  1. Download the latest release for your operating system from the Ghostty releases page.
  2. Install the application following the instructions for your OS.
  3. Launch Ghostty from your applications menu or command line.
  4. (Optional) Create a configuration file at ~/.config/ghostty/config to customize your experience:
# Example configuration
font-family = "JetBrains Mono"
font-size = 14
theme = "Dracula"
  1. Explore the Ghostty documentation for more advanced configuration options and features.

Competitor Comparisons

alacritty logo

alacritty

62,439

A cross-platform, OpenGL terminal emulator.

Pros of Alacritty

  • More mature project with a larger community and longer development history
  • Cross-platform support (Linux, macOS, Windows, BSD)
  • Extensive documentation and configuration options

Cons of Alacritty

  • Written in Rust, which may have a steeper learning curve for contributors
  • Lacks some advanced features like tabs or split panes out-of-the-box

Code Comparison

Ghostty configuration example:

font-family = "JetBrains Mono"
font-size = 14
cursor-style = "beam"

Alacritty configuration example:

font:
  normal:
    family: JetBrains Mono
  size: 14.0
cursor:
  style: Beam

Both projects aim to provide fast, GPU-accelerated terminal emulators. Ghostty is a newer project written in C++, focusing on performance and minimalism. It offers some unique features like built-in multiplexing and a custom UI toolkit.

Alacritty, being more established, has a larger user base and more extensive documentation. It's known for its speed and cross-platform compatibility. However, it may require additional tools or configurations for features like tabs or splits.

The configuration syntax differs between the two, with Ghostty using TOML and Alacritty using YAML. This may impact user preference and ease of configuration.

wezterm logo

wezterm

24,169

A GPU-accelerated cross-platform terminal emulator and multiplexer written by @wez and implemented in Rust

Pros of WezTerm

  • Cross-platform support (Windows, macOS, Linux)
  • Extensive configuration options via Lua scripting
  • Rich feature set including multiplexing, ligatures, and GPU acceleration

Cons of WezTerm

  • Larger resource footprint
  • Steeper learning curve due to Lua configuration
  • Potentially overwhelming number of options for new users

Code Comparison

WezTerm configuration (Lua):

return {
  font = wezterm.font("JetBrains Mono"),
  color_scheme = "Dracula",
  default_prog = {"zsh"},
  window_background_opacity = 0.9,
}

Ghostty configuration (TOML):

font-family = "JetBrains Mono"
theme = "dracula"
shell = "zsh"
background-opacity = 0.9

Key Differences

  • WezTerm offers more flexibility with Lua scripting, while Ghostty uses a simpler TOML configuration.
  • WezTerm has broader platform support, whereas Ghostty focuses on Unix-like systems.
  • Ghostty aims for simplicity and performance, while WezTerm provides a more feature-rich experience.

Conclusion

WezTerm is a highly customizable, cross-platform terminal emulator with a wide range of features. Ghostty, on the other hand, prioritizes simplicity and performance, making it potentially more appealing for users who prefer a streamlined experience on Unix-like systems. The choice between the two depends on individual needs and preferences regarding customization, performance, and platform requirements.

kovidgoyal logo

kitty

31,271

If you live in the terminal, kitty is made for you! Cross-platform, fast, feature-rich, GPU based.

Pros of Kitty

  • More mature and feature-rich project with extensive documentation
  • Cross-platform support (Linux, macOS, and experimental Windows)
  • Large and active community with frequent updates

Cons of Kitty

  • Written in Python and C, which may impact performance
  • Configuration can be complex for new users
  • Larger resource footprint compared to some lightweight alternatives

Code Comparison

Kitty configuration example:

font_family      Fira Code
font_size        12.0
cursor_shape     beam
scrollback_lines 10000

Ghostty configuration example:

font-family = "Fira Code"
font-size = 12
cursor-style = "beam"
scrollback-lines = 10000

While both terminals offer similar functionality, Ghostty uses TOML for configuration, which some users may find more intuitive. Kitty's configuration is more verbose but offers greater flexibility.

Ghostty is a newer project written in Rust, potentially offering better performance and memory usage. However, it currently lacks the extensive feature set and cross-platform support of Kitty. Ghostty's development is ongoing, and it may become a strong competitor as it matures.

vercel logo

hyper

44,700

A terminal built on web technologies

Pros of Hyper

  • Cross-platform support (macOS, Windows, Linux)
  • Extensible through plugins and themes
  • Built with web technologies, making it familiar for web developers

Cons of Hyper

  • Performance can be slower compared to native terminals
  • Higher resource usage due to Electron framework
  • Some users report stability issues and crashes

Code Comparison

Ghostty (configuration example):

font-family = "JetBrains Mono"
font-size = 14
cursor-style = "beam"

Hyper (configuration example):

module.exports = {
  config: {
    fontSize: 14,
    fontFamily: 'JetBrains Mono',
    cursorShape: 'BEAM'
  }
};

Both projects allow for easy customization, but Ghostty uses TOML for configuration, while Hyper uses JavaScript. Ghostty's configuration tends to be more concise, while Hyper's offers more flexibility through JavaScript.

Ghostty is a newer, performance-focused terminal emulator written in Rust, aiming for speed and efficiency. Hyper, on the other hand, is a more established project built on web technologies, offering cross-platform support and extensive customization options at the cost of performance.

gnachman logo

iTerm2

16,980

iTerm2 is a terminal emulator for Mac OS X that does amazing things.

Pros of iTerm2

  • Mature and feature-rich terminal emulator with a large user base
  • Extensive customization options, including themes, profiles, and keyboard shortcuts
  • Robust integration with macOS, including native fullscreen support and Applescript automation

Cons of iTerm2

  • Limited to macOS, not available on other platforms
  • Can be resource-intensive, especially with multiple sessions or advanced features enabled
  • Slower development cycle compared to newer terminal emulators

Code Comparison

iTerm2 (Objective-C):

- (void)setTransparency:(float)transparency {
    _transparency = transparency;
    [self updateTransparency];
    [self setNeedsDisplay:YES];
}

Ghostty (Rust):

pub fn set_opacity(&mut self, opacity: f32) {
    self.opacity = opacity;
    self.update_opacity();
    self.request_redraw();
}

While both projects implement similar functionality, iTerm2 uses Objective-C, which is specific to macOS, while Ghostty uses Rust, allowing for cross-platform development. The Ghostty implementation is more concise and uses modern language features.

iTerm2 is a well-established terminal emulator with a rich feature set, but it's limited to macOS. Ghostty, being newer and written in Rust, offers the potential for cross-platform support and improved performance, but may lack some of the advanced features and integrations found in iTerm2.

microsoft logo

terminal

101,819

The new Windows Terminal and the original Windows console host, all in the same place!

Pros of Terminal

  • More mature and feature-rich project with extensive documentation
  • Cross-platform support (Windows, macOS, Linux)
  • Large community and active development from Microsoft

Cons of Terminal

  • Heavier resource usage compared to lightweight alternatives
  • Primarily focused on Windows, with less emphasis on other platforms
  • Steeper learning curve for customization and advanced features

Code Comparison

Terminal (C++):

void TerminalPage::_HandleScrollEvent(const winrt::Windows::UI::Xaml::Input::PointerRoutedEventArgs& e)
{
    const auto delta = e.GetCurrentPoint(_root).Properties().MouseWheelDelta();
    _DoScroll(delta);
}

Ghostty (Rust):

pub fn handle_scroll(&mut self, delta: i32) {
    let new_scroll = self.scroll.saturating_add_signed(delta);
    self.scroll = new_scroll.clamp(0, self.max_scroll);
    self.redraw();
}

Both code snippets handle scrolling events, but Terminal's implementation is more complex due to its integration with Windows UI frameworks, while Ghostty's approach is more straightforward and platform-agnostic.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Logo
Ghostty

Fast, native, feature-rich terminal emulator pushing modern features.
A native GUI or embeddable library via libghostty.
About · Download · Documentation · Contributing · Developing

About

Ghostty is a terminal emulator that differentiates itself by being fast, feature-rich, and native. While there are many excellent terminal emulators available, they all force you to choose between speed, features, or native UIs. Ghostty provides all three.

libghostty is a cross-platform, zero-dependency C and Zig library for building terminal emulators or utilizing terminal functionality (such as style parsing). Anyone can use libghostty to build a terminal emulator or embed a terminal into their own applications. See Ghostling for a minimal complete project example or the examples directory for smaller examples of using libghostty in C and Zig.

For more details, see About Ghostty.

Download

See the download page on the Ghostty website.

Documentation

See the documentation on the Ghostty website.

Contributing and Developing

If you have any ideas, issues, etc. regarding Ghostty, or would like to contribute to Ghostty through pull requests, please check out our "Contributing to Ghostty" document. Those who would like to get involved with Ghostty's development as well should also read the "Developing Ghostty" document for more technical details.

Roadmap and Status

Ghostty is stable and in use by millions of people and machines daily.

The high-level ambitious plan for the project, in order:

#StepStatus
1Standards-compliant terminal emulation✅
2Competitive performance✅
3Rich windowing features -- multi-window, tabbing, panes✅
4Native Platform Experiences✅
5Cross-platform libghostty for Embeddable Terminals✅
6Ghostty-only Terminal Control Sequences❌

Additional details for each step in the big roadmap below:

Standards-Compliant Terminal Emulation

Ghostty implements all of the regularly used control sequences and can run every mainstream terminal program without issue. For legacy sequences, we've done a comprehensive xterm audit comparing Ghostty's behavior to xterm and building a set of conformance test cases.

In addition to legacy sequences (what you'd call real "terminal" emulation), Ghostty also supports more modern sequences than almost any other terminal emulator. These features include things like the Kitty graphics protocol, Kitty image protocol, clipboard sequences, synchronized rendering, light/dark mode notifications, and many, many more.

We believe Ghostty is one of the most compliant and feature-rich terminal emulators available.

Terminal behavior is partially a de jure standard (i.e. ECMA-48) but mostly a de facto standard as defined by popular terminal emulators worldwide. Ghostty takes the approach that our behavior is defined by (1) standards, if available, (2) xterm, if the feature exists, (3) other popular terminals, in that order. This defines what the Ghostty project views as a "standard."

Competitive Performance

Ghostty is generally in the same performance category as the other highest performing terminal emulators.

"The same performance category" means that Ghostty is much faster than traditional or "slow" terminals and is within an unnoticeable margin of the well-known "fast" terminals. For example, Ghostty and Alacritty are usually within a few percentage points of each other on various benchmarks, but are both something like 100x faster than Terminal.app and iTerm. However, Ghostty is much more feature rich than Alacritty and has a much more native app experience.

This performance is achieved through high-level architectural decisions and low-level optimizations. At a high-level, Ghostty has a multi-threaded architecture with a dedicated read thread, write thread, and render thread per terminal. Our renderer uses OpenGL on Linux and Metal on macOS. Our read thread has a heavily optimized terminal parser that leverages CPU-specific SIMD instructions. Etc.

Rich Windowing Features

The Mac and Linux (build with GTK) apps support multi-window, tabbing, and splits with additional features such as tab renaming, coloring, etc. These features allow for a higher degree of organization and customization than single-window terminals.

Native Platform Experiences

Ghostty is a cross-platform terminal emulator but we don't aim for a least-common-denominator experience. There is a large, shared core written in Zig but we do a lot of platform-native things:

  • The macOS app is a true SwiftUI-based application with all the things you would expect such as real windowing, menu bars, a settings GUI, etc.
  • macOS uses a true Metal renderer with CoreText for font discovery.
  • macOS supports AppleScript, Apple Shortcuts (AppIntents), etc.
  • The Linux app is built with GTK.
  • The Linux app integrates deeply with systemd if available for things like always-on, new windows in a single instance, cgroup isolation, etc.

Our goal with Ghostty is for users of whatever platform they run Ghostty on to think that Ghostty was built for their platform first and maybe even exclusively. We want Ghostty to feel like a native app on every platform, for the best definition of "native" on each platform.

Cross-platform libghostty for Embeddable Terminals

In addition to being a standalone terminal emulator, Ghostty is a C-compatible library for embedding a fast, feature-rich terminal emulator in any 3rd party project. This library is called libghostty.

Due to the scope of this project, we're breaking libghostty down into separate actually libraries, starting with libghostty-vt. The goal of this project is to focus on parsing terminal sequences and maintaining terminal state. This is covered in more detail in this blog post.

libghostty-vt is already available and usable today for Zig and C and is compatible for macOS, Linux, Windows, and WebAssembly. The functionality is extremely stable (since its been proven in Ghostty GUI for a long time), but the API signatures are still in flux.

libghostty is already heavily in use. See examples for small examples of using libghostty in C and Zig or the Ghostling project for a complete example. See awesome-libghostty for a list of projects and resources related to libghostty.

We haven't tagged libghostty with a version yet and we're still working on a better docs experience, but our Doxygen website is a good resource for the C API.

Ghostty-only Terminal Control Sequences

We want and believe that terminal applications can and should be able to do so much more. We've worked hard to support a wide variety of modern sequences created by other terminal emulators towards this end, but we also want to fill the gaps by creating our own sequences.

We've been hesitant to do this up until now because we don't want to create more fragmentation in the terminal ecosystem by creating sequences that only work in Ghostty. But, we do want to balance that with the desire to push the terminal forward with stagnant standards and the slow pace of change in the terminal ecosystem.

We haven't done any of this yet.

Crash Reports

Ghostty has a built-in crash reporter that will generate and save crash reports to disk. The crash reports are saved to the $XDG_STATE_HOME/ghostty/crash directory. If $XDG_STATE_HOME is not set, the default is ~/.local/state. Crash reports are not automatically sent anywhere off your machine.

Crash reports are only generated the next time Ghostty is started after a crash. If Ghostty crashes and you want to generate a crash report, you must restart Ghostty at least once. You should see a message in the log that a crash report was generated.

[!NOTE]

Use the ghostty +crash-report CLI command to get a list of available crash reports. A future version of Ghostty will make the contents of the crash reports more easily viewable through the CLI and GUI.

Crash reports end in the .ghosttycrash extension. The crash reports are in Sentry envelope format. You can upload these to your own Sentry account to view their contents, but the format is also publicly documented so any other available tools can also be used. The ghostty +crash-report CLI command can be used to list any crash reports. A future version of Ghostty will show you the contents of the crash report directly in the terminal.

To send the crash report to the Ghostty project, you can use the following CLI command using the Sentry CLI:

SENTRY_DSN=https://e914ee84fd895c4fe324afa3e53dac76@o4507352570920960.ingest.us.sentry.io/4507850923638784 sentry-cli send-envelope --raw <path to ghostty crash>

[!WARNING]

The crash report can contain sensitive information. The report doesn't purposely contain sensitive information, but it does contain the full stack memory of each thread at the time of the crash. This information is used to rebuild the stack trace but can also contain sensitive data depending on when the crash occurred.