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

Install:-

To install in MacOS

# update formulae
brew update

# stable
brew install --cask ghostty

# tip
brew install --cask ghostty@tip

Ghostty Docs

Ghostty needs zero configuration. But to customize the use and feel its good to have the config created. Below is my config and its still learning phase

dotfiles/Library/Application Support/com.mitchellh.ghostty/config at main · abhishekamralkar/dotfiles

Actions:-

Ghostty supports below actions

Available actions:

Available actions:

  +version
  +help
  +list-fonts
  +list-keybinds
  +list-themes
  +list-colors
  +list-actions
  +show-config
  +validate-config
  +crash-report
  +show-face

• see all available themes

ghostty +list-themes

• see all keybindings

ghostty +list-keybinds

super + alt   + shift + j               write_scrollback_file:open
super + alt   + shift + w               close_all_windows
super + alt   + i                       inspector:toggle
super + alt   + right                   goto_split:right
super + alt   + down                    goto_split:bottom
super + alt   + left                    goto_split:left
super + alt   + up                      goto_split:top
super + ctrl  + equal                   equalize_splits
super + ctrl  + down                    resize_split:down,10
super + ctrl  + left                    resize_split:left,10
super + ctrl  + up                      resize_split:up,10
super + ctrl  + f                       toggle_fullscreen
super + ctrl  + right                   resize_split:right,10
super + shift + down                    jump_to_prompt:1
super + shift + w                       close_window
super + shift + left_bracket            previous_tab
super + shift + right_bracket           next_tab
super + shift + up                      jump_to_prompt:-1
super + shift + comma                   reload_config
super + shift + enter                   toggle_split_zoom
super + shift + j                       write_scrollback_file:paste
super + shift + d                       new_split:down
ctrl  + shift + left_bracket            previous_tab
ctrl  + shift + period                  move_tab:1
ctrl  + shift + comma                   move_tab:-1
ctrl  + shift + right_bracket           next_tab
ctrl  + shift + tab                     previous_tab
super + page_up                         scroll_page_up
super + physical:four                   goto_tab:4
super + backspace                       esc:
super + w                               close_surface
super + physical:eight                  goto_tab:8
super + down                            jump_to_prompt:1
super + enter                           toggle_fullscreen
super + t                               new_tab
super + c                               copy_to_clipboard
super + physical:one                    goto_tab:1
super + equal                           increase_font_size:1
super + physical:three                  goto_tab:3
super + right                           text:\x05
super + d                               new_split:right
super + plus                            increase_font_size:1
super + q                               quit
super + home                            scroll_to_top
super + left                            text:\x01
super + comma                           open_config
super + minus                           decrease_font_size:1
super + a                               select_all
super + n                               new_window
super + page_down                       scroll_page_down
super + left_bracket                    goto_split:previous
super + physical:nine                   last_tab
super + right_bracket                   goto_split:next
super + end                             scroll_to_bottom
super + zero                            reset_font_size
super + physical:five                   goto_tab:5
super + physical:seven                  goto_tab:7
super + up                              jump_to_prompt:-1
super + k                               clear_screen
super + s                               toggle_quick_terminal
super + physical:two                    goto_tab:2
super + physical:six                    goto_tab:6
super + v                               paste_from_clipboard
alt   + left                            esc:b
alt   + right                           esc:f
ctrl  + v                               new_split:right
ctrl  + h                               new_split:down
ctrl  + tab                             next_tab
ctrl  + z                               close_surface
shift + up                              adjust_selection:up
shift + left                            adjust_selection:left
shift + page_up                         adjust_selection:page_up
shift + end                             adjust_selection:end
shift + right                           adjust_selection:right
shift + page_down                       adjust_selection:page_down
shift + down                            adjust_selection:down
shift + home                            adjust_selection:home

For me migration from iTerm to Ghostty is super easy. I’m looking forward to using Ghostty as my default shell moving forward.

Introduction

Text processing is a common task in programming, whether it’s for analyzing logs, parsing documents, or performing natural language processing. One of the fundamental tasks in text processing is counting how many times each word appears in a given input. In this tutorial, we’ll write a Go program that reads text input, counts the occurrences of each word, and then sorts the words by their frequency.

The Program

Here’s the complete Go program we’ll be discussing:

Step-by-Step Explanation

Let’s break down the code step by step to understand how it works.

1. Setting Up the Scanner

The program begins by setting up a `Scanner` to read input from standard input (os.Stdin). The bufio package provides a convenient way to read input efficiently:

scan := bufio.NewScanner(os.Stdin)

The Scanner is a powerful tool for reading text, as it can be easily configured to split the input into words, lines, or custom tokens.

2. Configuring the Scanner to Split by Words

By default, the `Scanner` reads input line by line. However, since we want to count individual words, we need to configure the scanner to split input by words using bufio.ScanWords:

scan.Split(bufio.ScanWords)

The `bufio.ScanWords` function tells the scanner to treat each word as a separate token, which makes it easy to process each word individually.

3. Counting Word Frequencies

Next, we use a map to keep track of how many times each word appears in the input. Maps in Go are a key-value data structure, making them ideal for this purpose:

words := make(map[string]int)
for scan.Scan() {
 words[scan.Text()]++
}

- scan.Scan(): Advances the scanner to the next word.
- scan.Text(): Retrieves the current word as a string.
- words[scan.Text()]++: Increments the count for the word in the map. If the word isn’t already in the map, it’s added with an initial count of 1.

4. Displaying the Number of Unique Words

Once all the input has been processed, we can determine how many unique words were found by checking the length of the map:

fmt.Println(len(words), “unique words”)

The len(words) function returns the number of keys in the map, which corresponds to the number of unique words.

5. Preparing Data for Sorting

To sort the words by their frequency, we need to move the word-count pairs from the map into a slice of structs. We define a simple data struct to hold each word and its count:

go
type data struct {
 k string
 v int
}
var s []data
for k, v := range words {
 s = append(s, data{k, v})
}

Here, we iterate over the map, appending each word and its count to the slice s.

6. Sorting the Words by Frequency

Go’s sort package allows us to sort slices in a flexible manner. We use sort.Slice to sort our slice of data structs in descending order based on the word count:

sort.Slice(s, func(i, j int) bool {
 return s[i].v > s[j].v
})

This sorting function compares the counts (v) of two elements and orders them so that the words with higher counts come first.

7. Displaying the Sorted Results

Finally, we iterate over the sorted slice and print each word along with its frequency:

for _, s := range s {
 fmt.Println(s.k, "appears", s.v, "times")
}

This loop prints each word followed by the number of times it appeared in the input.

Conclusion

In this tutorial, we’ve walked through a Go program that reads text input, counts the frequency of each unique word, and sorts the words by their frequency. This program is an excellent demonstration of how to use Go’s bufio and sort packages for efficient text processing.