Curated Terminal CLI Tools for Backend Developers

Terminal CLI Tools for Backend Developers

Getting comfortable with the CLI (Command Line Interface) can dramatically improve development productivity. Tools like Warp, Homebrew, Oh My Zsh, fzf, zoxide, Powerlevel10k, eza, and bat help create a highly efficient workflow, allowing developers to operate more comfortably and effectively.

Here’s a list of CLI tools I always install when setting up a fresh terminal environment on a new MacBook. These are based on real-world usage, and I plan to keep updating this collection as I discover more helpful utilities.

1. Warp

Warp is a modern terminal application that offers a user-friendly interface and features more akin to an IDE than a traditional shell.

It’s packed with features that help developers work more efficiently. Some highlights include:

• Command auto-completion: Warp offers smart command suggestions out of the box, without requiring any additional plugins. This can save time, especially when typing long or complex commands.
• Code snippets: You can save frequently used command patterns as reusable snippets and insert them quickly when needed—great for repetitive tasks.
• Terminal session sharing: Easily share your session with others for pair debugging or live support.
• Session restoration: Reopen the terminal with your previous session fully restored.
• In-terminal search: Search text within the current session.
• Cloud-synced settings: Sync your preferences and configuration across multiple devices.

Warp is available under both free and paid licenses. The paid plan unlocks AI-powered features, cloud drives, collaboration tools, and enterprise-grade support. If you don’t need those extras, the free version is more than enough for day-to-day development.

Getting started with Warp is straightforward:

1. Visit the official Warp website.
2. Click the Download button to grab the installer for macOS.
3. Open the downloaded Warp.dmg and drag the icon into your Applications folder.

Personally, the feature that finally made me switch from iTerm to Warp was the fixed prompt position. I use a vertical monitor for terminal work, and having the prompt anchored at the top reduces eye movement and strain. It also eliminates the need for repetitive clear commands and makes navigating long terminal sessions much easier. Combined with the block-based structure, Warp helps me visually separate tasks and copy outputs cleanly for team sharing.

iTerm remains a powerful and reliable tool—especially for those deeply accustomed to traditional terminal workflows. But with Warp’s rapid development, responsive feedback loop, and continued enhancements, I expect it to gain even more traction among modern backend developers.

2. Homebrew

Homebrew is a package manager for macOS that makes it easy to install and manage software from the command line. It serves a similar role to tools like apt on Debian/Ubuntu, yum on CentOS/Red Hat, or pacman on Arch Linux—bringing that same simplicity and control to macOS.

Homebrew helps developers work more efficiently by offering:

• Package management: Easily install, update, and uninstall packages on macOS. This is particularly useful for setting up and maintaining a development environment.
• Dependency resolution: Automatically handles dependencies, ensuring all necessary libraries and tools are installed without conflict.
• Taps and formulae: Beyond the core repository, Homebrew supports user-maintained taps and custom formulae for installing a wide range of tools.
• Extensibility: With Homebrew Cask, you can also manage GUI applications—useful for both developers and everyday users.

Homebrew also makes it easy to keep all installed packages up to date and manage your entire toolchain from a central interface. Its robust dependency management is especially valuable when configuring or migrating development environments.

It’s open source and free to use, and getting started takes just a few steps:

1. Open your terminal and run the following command to install Homebrew:

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. After installation, verify it with:

$ brew --version
Homebrew 4.3.12

Personally, Homebrew has made software installation and management on macOS dramatically more convenient. Instead of downloading installers from various websites and managing them manually, I can install everything from the terminal with a single command. It also helps avoid version conflicts and missing dependencies thanks to its built-in resolution logic.

Compared to traditional installation methods, Homebrew is much more intuitive and efficient. Whether I’m installing a new package or updating an existing one, a single brew command gets the job done. The Homebrew community is also very active, so most tools you need are likely already available and well-maintained. It's a reliable foundation for quickly setting up a stable development environment.

For a more in-depth look at Homebrew, check out Enhance macOS Experience With Homebrew.

3. Oh My Zsh

Oh My Zsh is an open-source framework that makes it easy to manage plugins, themes, and configurations for the Zsh shell. While Zsh already offers more flexibility and features than Bash, Oh My Zsh simplifies customization and helps developers create a more productive terminal experience.

Here’s what makes Oh My Zsh so useful:

• Plugin system: With hundreds of plugins available, Oh My Zsh can enhance your workflow by adding Git status prompts, directory navigation helpers, auto-completion, and more.
• Theme system: Oh My Zsh includes a vast collection of themes that let you customize your terminal’s appearance with ease.
• Customizability: Configuration is straightforward via the ~/.zshrc file. You can set environment variables, enable or disable plugins, change themes, and more.

3-1. Installing Oh My Zsh

Most macOS and Linux distributions already come with Zsh installed. If not, you can install it with Homebrew:

$ brew install zsh

Install Oh My Zsh by running the following script:

$ sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

If Zsh isn’t already your default shell, you can set it manually:

$ chsh -s $(which zsh)

After installation, you can edit your .zshrc to configure your environment:

export ZSH="$HOME/.oh-my-zsh"
ZSH_THEME="agnoster"
plugins=(git)

3-2. Customizing Themes in Oh My Zsh

You can customize the look and feel of your terminal by modifying the ZSH_THEME variable in your .zshrc. The default theme is robbyrussell, but there are many others available.

ZSH_THEME="robbyrussell"

Browse available themes here: Oh My Zsh Themes

3-3. Useful Plugins for Oh My Zsh

To enable plugins, list them in the plugins array inside .zshrc. Some popular plugins include:

• git – Shortcuts like gst for git status and gco for git checkout.
• z – Tracks frequently used directories and lets you jump to them quickly.
• autosuggestions – Suggests commands based on history as you type.
• syntax-highlighting – Highlights commands as you write them, making errors easier to catch.
• docker – Adds handy aliases for Docker commands.

Some plugins require manual installation:

# zsh-autosuggestions
$ git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

# zsh-syntax-highlighting
$ git clone https://github.com/zsh-users/zsh-syntax-highlighting ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

Then activate them in your .zshrc:

plugins=(
  git
  autosuggestions
  syntax-highlighting
)

Apply changes by reloading your config:

$ source ~/.zshrc

If you're using a terminal like Warp, many features such as autosuggestions and syntax highlighting may already be built-in. However, Oh My Zsh still offers a powerful way to customize and extend your Zsh experience to match your exact needs.

With a rich ecosystem of plugins and themes, Oh My Zsh transforms Zsh into a powerful, flexible shell for developers. It’s easy to install, easy to configure, and hard to live without once you get used to it.

4. Powerlevel10k

Powerlevel10k is a high-performance Zsh prompt theme known for its blazing speed and extensive customization options. Even when working with large Git repositories, it remains fast and responsive. It displays useful context directly in the prompt—such as Git status, working directory, battery level, time, network status, and more—helping streamline your development workflow.

If you enjoy tweaking your development environment, Powerlevel10k offers a visually clean and fully configurable interface. It’s a great choice for developers who want both aesthetics and functionality in their terminal.

4-1. Installing Powerlevel10k

To install Powerlevel10k on macOS:

1. Use Homebrew to install it:

$ brew install powerlevel10k

2. Add Powerlevel10k to your .zshrc:

$ echo 'source $(brew --prefix)/share/powerlevel10k/powerlevel10k.zsh-theme' >>~/.zshrc

3. Reload your shell or restart the terminal:

$ source ~/.zshrc

Once enabled, Powerlevel10k will launch an interactive configuration wizard the next time you start your terminal. You’ll be guided through a series of visual choices to customize icons, colors, and layout.

4-2. Setting Up Nerd Fonts for Powerlevel10k

To render all icons correctly, Powerlevel10k requires a Nerd Font-enabled monospaced font. You can download one from Nerd Fonts or refer to this guide: Applying Nerd Fonts to Mono Fonts.

If you're running the configuration wizard for the first time, avoid selecting the "Pure" style—it’s a minimal option that hides much of the rich context Powerlevel10k is designed to show.

You can re-run the configuration wizard at any time with:

$ p10k configure

4-3. Customizing Powerlevel10k

To go beyond the defaults, you can edit the Powerlevel10k config file, typically located at ~/.p10k.zsh. Here you can fine-tune prompt behavior, segment order, language versions (Node.js, Java, etc.), icons, colors, and more.

To open the configuration file:

$ open ~/.p10k.zsh

Powerlevel10k transforms your Zsh prompt into a powerful, visually structured interface. It improves clarity and productivity—especially when navigating Git repos—while staying lightning fast. If you’re already using Zsh, this is one upgrade you won’t want to miss.

5. eza

eza is a modern replacement for the classic ls command. It’s a CLI tool for listing files and directories with improved visuals, richer metadata, and support for icons and tree views. Designed with developer experience in mind, eza provides a cleaner and more informative way to browse the file system—especially helpful when dealing with large project structures.

Here’s what makes eza a significant upgrade over ls:

• Color output: Highlights file types with color-coded entries for improved readability.
• Icon support: Works with Nerd Fonts to display icons beside file names—useful for identifying file types at a glance.
• Readable timestamps: Displays modification times in a human-friendly format.
• File size formatting: Shows sizes in KB, MB, or GB rather than raw bytes.
• Flexible sorting: Supports sorting by name, size, time, and more with intuitive options.

Originally a successor to the now-unmaintained exa, eza builds on its predecessor’s features with better performance, more reliable maintenance, and extended functionality. It supports most ls-style options, making it easy to adopt.

5-1. Installing eza

You can install eza using Homebrew:

$ brew install eza

Once installed, you can use eza directly in place of ls. Here are a few common examples:

# Basic listing
$ eza

# Long listing with hidden files and human-readable sizes
$ eza -alh

# Sorted by modification time
$ eza -alht

# Sorted by file size
$ eza -alhS

# With icons (requires Nerd Fonts)
$ eza -alh --icons

5-2. Aliasing ls to eza in Your Shell

To replace ls with eza globally in your terminal:

$ echo "alias ls='eza'" >> ~/.zshrc
$ source ~/.zshrc

You can also add more personalized aliases to make common patterns easier to use:

alias ls="eza"
alias ll="eza -alhF --icons"
alias lt="eza -alhT --icons"
alias lsa="eza -alh --icons"
alias lst="eza -alhT --icons"

5-3. Using eza with Nerd Fonts

If you’re using a font patched with Nerd Fonts, eza can render icons for files and folders directly in the terminal:

$ eza -alh --icons
Permissions Size User       Date Modified Name
.rw-r--r--@ 6.1k catsriding 18 Nov  2023   .DS_Store
.rw-r--r--    22 catsriding 23 Oct  2023   .env
.rw-r--r--  1.7k catsriding  2 Feb 20:21   .eslintrc.json
drwxr-xr-x@    - catsriding 11 Aug 12:18   .git
.rw-r--r--  334k catsriding 28 Apr 01:37   package-lock.json
.rw-r--r--@ 1.4k catsriding  7 Oct  2023   README.md
.rw-r--r--   599 catsriding 10 Aug 11:48   tsconfig.json

eza significantly improves the command-line file browsing experience. It’s especially helpful in Git repositories or when working with deeply nested file structures. Once you try it, it’s hard to go back to plain ls.

6. fzf

fzf is short for "fuzzy finder"—a fast, interactive CLI search tool that helps you locate files, commands, and content without needing exact input. It supports fuzzy matching across command history, file paths, Git branches, processes, environment variables, and more. Designed for speed and extensibility, fzf is a versatile addition to any terminal workflow.

• Interactive filtering: Fast, keyboard-driven search through long lists of items.
• Flexible integration: Works with pipes, custom scripts, and standard Unix tools like find, awk, and ps.
• Customizable: Supports theming, key bindings, and preview windows.
• Cross-source filtering: Apply the same search mechanism across different inputs—from files to processes to environment variables.

6-1. Installing fzf

You can install fzf using Homebrew:

$ brew install fzf

After installation, you can optionally enable additional key bindings and auto-completion features with:

$ /opt/homebrew/opt/fzf/install

6-2. Using fzf

Run fzf directly to browse files and directories in the current folder:

$ fzf

As you type, fzf filters the results in real time. Use arrow keys to select, and press Enter to confirm.

fzf becomes truly powerful when combined with other CLI tools. Here are a few real-world scenarios:

# Navigate into a selected directory
$ cd "$(find . -type d | fzf)"

# Open a selected file with Vim
$ vim $(fzf)

# Checkout a Git branch
$ git checkout $(git branch | fzf)

# Kill a selected running process
$ kill -9 $(ps -ef | fzf | awk '{print $2}')

# Export a selected environment variable
$ export $(printenv | fzf)

# Select a file and list its details
$ ls -l $(fzf)

fzf is a terminal-native productivity booster. Once it's integrated into your shell workflow, it becomes an indispensable tool for navigating and selecting with speed. Whether you're managing files, switching branches, or reviewing logs, fzf makes it feel effortless.

7. zoxide

zoxide is a blazing-fast, smarter alternative to cd. This CLI directory jumper learns which folders you use most and allows you to switch between them with minimal input. Inspired by tools like z and autojump, zoxide brings better performance, cross-shell support, and intuitive usage to terminal navigation.

• Frequency-based learning: Prioritizes directories you've used most recently and frequently.
• Minimal typing: Jump to long paths with short fragments, like z proj → /Users/you/dev/my-project.
• fzf integration: Browse and filter directory history with fzf by running zi.
• Cross-platform: Works on macOS, Linux, and Windows. Compatible with bash, zsh, fish, and others.

7-1. Installing zoxide

To install zoxide with Homebrew:

$ brew install zoxide

Then, activate it in your shell by adding the following to your .zshrc:

eval "$(zoxide init zsh)"

Apply changes:

$ source ~/.zshrc

To make zoxide respond to the familiar cd command instead of z, use:

eval "$(zoxide init --cmd cd zsh)"

This allows you to benefit from zoxide without changing your muscle memory.

7-2. Using zoxide

Once installed, simply move around as usual using cd. zoxide builds up a directory database in the background. Later, you can jump with:

$ z src       # matches ~/workspace/myapp/src
$ z blog api  # fuzzy matches nested paths

For interactive selection, combine with fzf:

$ zi

This presents your directory history in a searchable list.

zoxide is a clear upgrade over traditional directory navigation. Once you get used to it, jumping around your workspace becomes second nature—no more typing full paths or scanning ls output.

8. bat

bat is a modern replacement for cat—a CLI file viewer that adds syntax highlighting, line numbers, themes, and more. It makes reading code and logs in the terminal much more pleasant and useful for developers.

• Syntax highlighting: Automatically highlights source code and config files with over 100 language definitions.
• Line numbers: Shows line numbers by default for easier reference and navigation.
• Theming support: Customize appearance with multiple themes like "OneHalfDark", "Solarized", or "Dracula".
• Visual diffs: Compare multiple files and visually highlight differences with --diff.

bat is compatible with cat in most usage scenarios, but greatly improves readability and user experience.

8-1. Installing bat

Install bat via Homebrew:

$ brew install bat

Once installed, you can use bat just like cat, but with additional enhancements:

# View a file with syntax highlighting and line numbers
$ bat filename.js

8-2. Using bat

Here are some powerful ways to use bat:

# Use a specific theme
$ bat --theme="OneHalfDark" config.yml

# Show the visual diff between two files
$ bat --diff file1.js file2.js

# Output multiple files in one view
$ bat Dockerfile README.md

Common bat options:

• --list-themes: Show all available color themes.
• --style=[full|header|grid|numbers|snip]: Customize output layout.
• --line-range=30:60: Only print selected lines.
• --highlight-line 42: Highlight a specific line.
• --paging=[auto|never|always]: Toggle pagination behavior.
• --wrap=[auto|never|character]: Set line-wrapping rules.
• --plain: Disable highlighting and line numbers (acts more like cat).
• --color=[always|never|auto]: Control color output.

You can also set bat as your default cat using an alias:

echo "alias cat='bat'" >> ~/.zshrc
source ~/.zshrc

bat is especially helpful for inspecting source files, configuration files, or debugging logs right from your terminal—with clarity, context, and visual comfort.

9. jq

jq is a powerful and lightweight CLI JSON processor that makes working with structured data in the terminal both simple and efficient. Whether you're debugging an API response, filtering configuration files, or scripting complex transformations, jq is an indispensable tool for any backend developer.

• Powerful filtering: Extract specific fields from nested objects and arrays with simple syntax.
• Data transformation: Convert and restructure JSON on the fly using functional-style operations.
• Chaining and pipelining: Combine multiple operations into a single pipeline.
• Automation-friendly: Integrates well with shell scripts for automated API parsing or log processing.

9-1. Installing jq

Install jq via Homebrew:

$ brew install jq

9-2. Using jq

# Extract a single field from an object
$ echo '{"name": "Alice", "age": 25}' | jq '.name'
"Alice"

# Filter items in an array
$ echo '[{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]' | jq '.[] | select(.age > 25)'
{
  "name": "Bob",
  "age": 30
}

# Restructure the output format
$ echo '{"name": "Alice", "age": 25, "city": "New York"}' | jq '{fullName: .name, location: .city}'
{
  "fullName": "Alice",
  "location": "New York"
}

# Combine filters and mapping
$ echo '[{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}, {"name": "Charlie", "age": 35}]' \
| jq '.[] | select(.age > 25) | {name, age}'
{
  "name": "Bob",
  "age": 30
}
{
  "name": "Charlie",
  "age": 35
}

jq offers a readable, declarative way to work with complex data structures directly from the terminal. Whether you're debugging API payloads, exploring configuration files, or building automation scripts, it's an essential part of any CLI toolkit.

10. lazygit

lazygit is a terminal Git UI tool that lets you manage Git repositories in a more intuitive and efficient way—without manually typing complex Git commands. It provides a visual interface within the terminal, making it especially useful for developers who manage multiple branches or follow complex Git workflows.

lazygit enhances Git usability by providing visual access to essential features:

• Commit log navigation: View the Git log with ease and navigate through past commits. You can inspect individual commits and compare changes.
• Branch management: Switch between branches, create new ones, and visually compare differences between them. Merging and rebasing are also simplified.
• Staging and unstaging: Quickly stage or unstage modified files, or even specific code chunks, through a streamlined UI.
• Conflict resolution: When merge conflicts occur, lazygit helps you identify and resolve them visually. You can choose resolution strategies per file.
• Push and pull operations: Easily interact with remote repositories—push your changes or pull updates with just a few keystrokes.
• Tag handling: Create, delete, and check out tags, or compare between tags for version inspection.

10-1. Installing lazygit

On macOS, you can install lazygit via Homebrew:

$ brew install lazygit

Once installed, you can launch it directly with:

$ lazygit

This opens a TUI (Terminal User Interface) within your Git repository, allowing you to perform Git actions visually and interactively.

10-2. Using lazygit

Once lazygit is launched, you can navigate and operate using intuitive key bindings:

• q: Quit lazygit
• ↑ / ↓: Move between items
• ← / →: Switch between panels
• a: Create new branch
• c: Commit changes
• C: Amend last commit
• r: Rebase current branch
• m: Merge branches
• f: Pull changes from remote
• F: Force push to remote
• s: Stage selected file
• S: Stage all changes
• u: Unstage selected file
• U: Unstage all files
• d: Delete file
• R: Refresh repository
• p: Push to remote
• h: View commit history
• x: Discard changes
• space: Select file
• enter: View item details

To speed things up, you can create an alias for lazygit:

# Add alias
$ echo "alias lzg='lazygit'" >> ~/.zshrc

# Reload shell configuration
$ source ~/.zshrc

Now you can launch lazygit simply by typing lzg.

lazygit is a powerful yet intuitive tool that makes Git operations easier without leaving the terminal. It streamlines your workflow, reduces the need to memorize Git commands, and is particularly handy for developers who prefer a visual interface within their shell.

11. lazydocker

lazydocker is a terminal-based Docker UI tool that helps you manage Docker containers, images, volumes, and networks in a visual and intuitive way. With a simple interface, lazydocker allows you to handle Docker and Docker Compose workflows without having to memorize complex commands.

lazydocker is especially useful for developers who are not fully comfortable with Docker CLI or those managing multiple containers simultaneously. It allows you to monitor and interact with your Docker environment visually—all within your terminal.

• Container management: View running containers, start/stop/restart them, inspect logs, and execute commands in containers—all via an interactive interface.
• Image management: Browse locally available Docker images, remove unused ones, or trigger new builds.
• Network and volume management: Inspect existing Docker networks and volumes, and remove them when necessary to free up system resources.
• Docker Compose integration: Manage multi-service environments defined via docker-compose.yml with ease—start, stop, and inspect services directly through the UI.
• Resource monitoring: Track CPU and memory usage of each container in real time, helping you diagnose performance issues quickly.

11-1. Installing lazydocker

On macOS, you can install lazydocker using Homebrew:

$ brew install lazydocker

Once installed, launch it using:

$ lazydocker

This opens an interactive UI where you can manage containers, volumes, images, and networks. You can inspect resource status, view logs, run commands, and more—all from one place.

11-2. Using lazydocker

Here are some helpful keyboard shortcuts available in lazydocker:

• ?: Help menu
• d: Remove container
• e: Toggle visibility of stopped containers
• p: Pause container
• s: Stop container
• r: Restart container
• a: Attach to container
• m: View logs
• E: Open shell in container
• c: Run predefined command
• b: View all commands
• w: Open in browser (if a container exposes an HTTP port)
• enter: Focus main panel
• [, ]: Switch between tabs
• /: Filter list
• +, _: Toggle view modes (normal/half/fullscreen)

To make it easier to launch, you can create an alias:

$ echo "alias lzd='lazydocker'" >> ~/.zshrc
$ source ~/.zshrc

You can now launch lazydocker simply by typing lzd.

lazydocker is a great tool for visually managing Docker and Docker Compose environments—no need to memorize all the Docker commands. If you work extensively with containers in your development workflow, lazydocker will make your daily operations faster and more manageable.

12. Helix

Helix is a modern terminal-based text editor that provides a powerful yet approachable editing experience. Designed with Vim users in mind, Helix offers familiar keybindings while also delivering features that appeal to those who may not be Vim experts. Written in Rust, it boasts excellent performance and includes full support for the Language Server Protocol (LSP), enabling capabilities like code completion, diagnostics, and go-to-definition across many languages.

12-1. Installing Helix

On macOS, you can install Helix via Homebrew:

$ brew install helix

12-2. Using Helix

After installation, launch Helix using the hx command. For example, to open and edit main.rs, run:

$ hx main.rs

Helix operates primarily through three modes:

• Normal mode: For navigation and editing
  • h, j, k, l: Move cursor left, down, up, right
  • d: Delete
  • y: Yank (copy)
  • p: Paste
  • u: Undo
  • Ctrl + r: Redo
  • :: Enter command mode
  • gg: Jump to beginning of file
  • G: Jump to end of file
  • w, b: Move by word
• Insert mode: For typing text
  • i: Insert at cursor
  • a: Insert after cursor
  • o: Insert new line below
  • Esc: Exit to normal mode
• Visual mode: For selecting blocks of text
  • v: Character-wise selection
  • V: Line-wise selection
  • Ctrl + v: Block-wise (rectangular) selection
  • y, d: Yank or delete selected text

Helix’s keybindings are mostly inspired by Vim but can be customized via ~/.config/helix/config.toml. For example, to bind Ctrl + s to save a file:

[keys.normal]
"ctrl-s" = ":w"

Helix offers a command mode (invoked with :) for running various editor commands. Suggestions appear as you type, enabling quick discovery and execution. Common commands include:

• :open <filename>: Open or switch to a file
• :write or :w: Save the current file
• :quit or :q: Exit Helix
• :wq: Save and quit
• :find <pattern>: Search within the file
• :split, :vsplit: Horizontal or vertical split views
• :bnext: Switch to the next buffer

12-3. Customizing Helix Themes

Helix supports a wide range of themes. You can change themes and editor behavior by editing config.toml:

theme = "onedark"

[editor]
line-number = "absolute"
mouse = false

[editor.cursor-shape]
insert = "bar"
normal = "block"
select = "underline"

[editor.file-picker]
hidden = false

To use a custom theme, save the theme file to ~/.config/helix/themes, and reference it in config.toml:

theme = "catsriding"

You’ll find full theming guidance in the Helix theme documentation.

Helix is an excellent option if you're looking for a modern, fast terminal editor with powerful Vim-style editing. If you often find yourself needing to look up Vim commands again and again, Helix may offer a friendlier experience while retaining the efficiency of modal editing. ⌨️

13. ngrok

ngrok is a tool that creates a secure public URL for your local server. It’s especially useful when you need to test a locally running application externally or when integrating with third-party APIs that require an HTTPS endpoint. Instead of configuring HTTPS on your local machine, you can use ngrok to generate an HTTPS-accessible URL instantly, without complex network setup.

Key features of ngrok include:

• Expose local servers: ngrok automatically generates a secure, public-facing URL that maps to your running local server. This is ideal for quick previews or sharing with team members.
• HTTPS by default: All URLs provided by ngrok are HTTPS-enabled, ensuring secure connections without local SSL configuration.
• Webhook testing: ngrok makes it easy to test webhooks locally by forwarding external service requests to your development environment in real time.
• Traffic inspection: ngrok includes a local dashboard that displays traffic logs, headers, and payloads—perfect for debugging.
• Support for TCP/UDP: ngrok supports more than just HTTP, allowing tunneling for TCP and UDP protocols as well.

13-1. Installing Ngrok

You can install ngrok with Homebrew on macOS:

$ brew install ngrok/ngrok/ngrok

13-2. Using Ngrok to Expose Local Servers

Once installed, you can expose your local server like this:

$ ngrok http 3000

After running this command, you’ll see output similar to:

ngrok                                                                   (Ctrl+C to quit)

Session Status                online
Account                       your-account-name (Plan: Free)
Version                       3.0.0
Region                        United States (us)
Latency                       78ms
Web Interface                 http://127.0.0.1:4040
Forwarding                    https://84c5df474.ngrok-free.dev -> http://localhost:3000

The Forwarding URL (e.g., https://84c5df474.ngrok-free.dev) is now publicly accessible. You can share this link or use it in external services, such as webhook testing or frontend development previews. ngrok’s built-in web interface (http://127.0.0.1:4040) also allows you to inspect requests and responses in real time.

ngrok is a must-have tool for developers working with locally hosted apps. It simplifies testing and collaboration by eliminating the need for network reconfiguration, firewalls, or cloud deployments.