Dubai’s Prime Minister and Vice President Sheikh Mohammed bin Rashid Al Maktoum said on Sunday that the new terminal would be five times the size of the current Dubai International Airport and handle up to 260 million passengers annually.

Dubai announces $35bn construction of world’s largest airport terminal | Aviation News | Al Jazeera

Former England cricket captain Kevin Pietersen has praised Uttar Pradesh Chief Minister Yogi Adityanath for doing an &quot;incredible job&quot; to renovate the Lucknow Airport.

"World-Class": Kevin Pietersen Stunned By New Airport Terminal In Lucknow

Air India and Air India Express have been assigned for the testing of the new terminal, to determine the smooth travel of passengers. 29 April 2024 By Payoshi Bisht Pune is all set to unveil its new airport terminal in the first week of May, as per the decision of the Airport Authority of India

Pune Airport Set To Likely Open New Terminal in May - PUNE PULSE

Dubai’s ruler Sheikh Mohammed bin Rashid al-Maktoum took to X, formerly Twitter, on Sunday to announce that his government has approved the designs for the new passenger terminals at AI Maktoum International Airport worth $34.85 billion.

Dubai to build world's largest airport with 400 terminal gates and much more! Cost, features, and all you need to know - Airlines/Aviation News | The Financial Express

Once fully operational, the airport will “handle a passenger capacity of 260 million annually”, the government declared in a statement.

Dubai begins work on ‘largest airport terminal’ - World - DAWN.COM

Connecticut-based XPO Inc. wants to create a 180,000-square-foot truck freight development off Kansas Highway 7 in Shawnee.

Trucking company XPO Inc. plans terminal in western Shawnee

Lethal Company uses procedurally generated interiors that are usually a labyrinthian level of twisting corridoors and stairwells that lead to nowhere. Unless you enjoy the confusion-horror element, this Minimap mod can be just the thing to help you get your bearings when reporting back to teammates. The map can be toggled on and off and essentially provides the same information as the computer terminal ...

Best Lethal Company mods: top ten mods to download | Rock Paper ...

Much like every other item in Lethal Company, you can find the Signal Translator ship upgrade in the store. This can be accessed by typing &quot;Store&quot; on the terminal screen on the ship. Unfortunately, this costs a whopping $255 and you won&#x27;t be able to purchase it at the start since you only get ...

Lethal Company: How To Get And Use The Signal Transmitter

Terminal is the leading platform used by companies to build full-time, remote engineering teams faster than any other solution on the market. The company provides tech-enabled hiring, employment and people-management solutions to build and run world-class remote engineering ... Read more

Working at Terminal | Glassdoor

Terminal Logistics is automating the yard, one of the last great frontiers of untapped value in transportation.

Terminal - The last frontier of logistics

Terminal

terminal

For developers and those who frequently use command-line interfaces, navigating the terminal can sometimes feel like a repetitive task. Even though terminal commands are straightforward, they can become tedious, especially if you're not fully comfortable with every command’s syntax. In recent years, several tools have emerged to enhance the command-line experience, and Warp is one of the latest options aiming to streamline these processes with a more user-friendly interface. Warp positions itself as a reimagined terminal, aiming to simplify command entry and improve user feedback. Built with AI-driven features and designed to be visually informative, it offers an experience that differs from standard terminals. While there are plenty of add-ons and plugins that can enhance the terminal, Warp's approach is more comprehensive, focusing on making the terminal environment itself more intuitive. A key feature that Warp brings to the table is the real-time contextual information it provides. For example, if you’re working with Git, a common task is to check the branch you're currently on. Traditionally, this requires you to enter git branch to display the branch name, adding a small but constant task for users who work with multiple branches. In a typical terminal, this branch check requires extra input, as the terminal does not automatically display branch information. Warp, however, includes this information in its UI, showing the branch directly within the main display without needing an additional command. This feature could be useful for developers who need quick context and want to minimize interruptions to their workflow. Warp’s interface includes several other features that might appeal to developers looking for a more modern terminal experience. For instance, Warp’s UI is designed to provide a clearer visual structure, potentially making command outputs easier to read compared to traditional terminal outputs. The interface highlights certain types of information, making it easier to parse logs or debug issues at a glance. This kind of layout can make it easier to identify errors or warnings without scanning through an extensive list of command outputs manually. Additionally, Warp has an AI-driven autocomplete feature, which may help users who occasionally forget command syntax or aren’t fully familiar with all command-line options. This feature aims to provide relevant suggestions as you type, potentially reducing the need to consult external documentation or search online for command references. For developers or users who frequently run into syntax uncertainties, Warp’s autocomplete might prove convenient. That said, Warp may not be a one-size-fits-all solution, and some users might find that they prefer traditional terminal environments or are already satisfied with the plugins and customization available in tools like iTerm2 or Hyper. Warp’s emphasis on visual feedback and autocomplete can be helpful for those who prefer a guided experience, but some seasoned command-line users may feel they don’t benefit as much from these features. Another factor to consider is that Warp’s approach could be more resource-intensive than minimalistic terminals. For users on systems where performance is a priority, or for those working in low-resource environments, this could be a trade-off. While Warp’s features provide a different experience, the system resources required may not suit everyone’s setup. In the end, whether Warp is the right fit depends largely on the individual’s workflow and terminal usage patterns. Those who find traditional terminals to be sufficient may not see a need for Warp’s added interface elements or AI-driven assistance. On the other hand, developers who are interested in a more visually supportive environment and would appreciate having contextual information readily available might find Warp to be a worthwhile addition. Overall, Warp represents a shift towards a more modern, user-friendly terminal experience that could help simplify command-line workflows. For users interested in testing out an alternative to the traditional terminal experience, Warp may be worth exploring to see if it complements their development habits and needs. Below is Warp’s interface, showing the current directory and the current branch I’m on, which is the main branch. I did not need to type git branch  to check the current branch, however, Warp showed me this already. In the image below, I have asked a question on how to make a directory. Look closely and see the response it gave. It all boils down to preference at the end of the day. Some may like the traditional look of terminal while others may like a more intuitive interface. For developers and those who frequently use command-line interfaces, navigating the terminal can sometimes feel like a repetitive task. Even though terminal commands are straightforward, they can become tedious, especially if you're not fully comfortable with every command’s syntax. In recent years, several tools have emerged to enhance the command-line experience, and Warp is one of the latest options aiming to streamline these processes with a more user-friendly interface. Warp positions itself as a reimagined terminal, aiming to simplify command entry and improve user feedback. Built with AI-driven features and designed to be visually informative, it offers an experience that differs from standard terminals. While there are plenty of add-ons and plugins that can enhance the terminal, Warp's approach is more comprehensive, focusing on making the terminal environment itself more intuitive. A key feature that Warp brings to the table is the real-time contextual information it provides. For example, if you’re working with Git, a common task is to check the branch you're currently on. Traditionally, this requires you to enter git branch to display the branch name, adding a small but constant task for users who work with multiple branches. In a typical terminal, this branch check requires extra input, as the terminal does not automatically display branch information. Warp, however, includes this information in its UI, showing the branch directly within the main display without needing an additional command. This feature could be useful for developers who need quick context and want to minimize interruptions to their workflow. git branch Warp’s interface includes several other features that might appeal to developers looking for a more modern terminal experience. For instance, Warp’s UI is designed to provide a clearer visual structure, potentially making command outputs easier to read compared to traditional terminal outputs. The interface highlights certain types of information, making it easier to parse logs or debug issues at a glance. This kind of layout can make it easier to identify errors or warnings without scanning through an extensive list of command outputs manually. Additionally, Warp has an AI-driven autocomplete feature, which may help users who occasionally forget command syntax or aren’t fully familiar with all command-line options. This feature aims to provide relevant suggestions as you type, potentially reducing the need to consult external documentation or search online for command references. For developers or users who frequently run into syntax uncertainties, Warp’s autocomplete might prove convenient. That said, Warp may not be a one-size-fits-all solution, and some users might find that they prefer traditional terminal environments or are already satisfied with the plugins and customization available in tools like iTerm2 or Hyper. Warp’s emphasis on visual feedback and autocomplete can be helpful for those who prefer a guided experience, but some seasoned command-line users may feel they don’t benefit as much from these features. Another factor to consider is that Warp’s approach could be more resource-intensive than minimalistic terminals. For users on systems where performance is a priority, or for those working in low-resource environments, this could be a trade-off. While Warp’s features provide a different experience, the system resources required may not suit everyone’s setup. In the end, whether Warp is the right fit depends largely on the individual’s workflow and terminal usage patterns. Those who find traditional terminals to be sufficient may not see a need for Warp’s added interface elements or AI-driven assistance. On the other hand, developers who are interested in a more visually supportive environment and would appreciate having contextual information readily available might find Warp to be a worthwhile addition. Overall, Warp represents a shift towards a more modern, user-friendly terminal experience that could help simplify command-line workflows. For users interested in testing out an alternative to the traditional terminal experience, Warp may be worth exploring to see if it complements their development habits and needs. Below is Warp’s interface, showing the current directory and the current branch I’m on, which is the main branch. I did not need to type git branch to check the current branch, however, Warp showed me this already. git branch In the image below, I have asked a question on how to make a directory. Look closely and see the response it gave. It all boils down to preference at the end of the day. Some may like the traditional look of terminal while others may like a more intuitive interface.

A Modern Take on the Terminal Experience

The Problem: “cd” & “ls” Suck 👎 Using command to change the directory and to preview files in the current directory may work sometimes, but it’s frustrating to have to use this workflow all the time whenever you want to go somewhere. cd ls The Solution I will give you 3 solutions not just one to make your life easier in terminal and jump easily between files. “Give me six hours to chop down a tree, and I will spend the first four sharpening the axe.” — Abraham Lincoln Let’s Sharpen Our Axe 🪓 You’re gonna need some to follow with me: perquisites Zsh Tmux Zoxide LF Fzf Solution 1: Zoxide zoxide is a smarter cd command This one is pretty cool; here’s what it does: It remembers all directories you visit and organizes them by most frequent. All you need is to type some letters from the name des => Desktop It jumps immediately there (super super cool) Step 1: Install It With Homebrew Brew install zoxide. Step 2: Initialize in ~/.zshrc open your ~/.zshrc file, and add this to initialize it eval "$(zoxide init zsh)" source ~/.zshrc to apply the changes source ~/.zshrc Step 3: Use Zoxide Instead of “cd” First, you need to visit the directories you want to jump to, so can identify it and fuzzy find it. zoxide Type + any letters you remember from the directory. z z desk// cd ~/Desktop Solution 2: LF Manager lf (as in "list files") is a terminal file manager written in Go with a heavy inspiration from ranger file manager Let me tell you a secret; this is my favorite one 🤫 if you’re like me, using Vim navigation keys hjkl After you get used to it, you suddenly want to use them everywhere. does exactly that; it works like columns view in Finder but with Vim. LF But don’t get me wrong; it still works with regular “Arrow” keys as well. Step 1: Install It With Homebrew Brew install lf. Step 2: Change the Directory on Quit “ it’s funny, but for some reason, it didn’t change the directory on quit” It’s like the main point, right !! 🥲 So, let’s fix this with a small function working as a wrapper to lf. It just saves the last directory path in the temp file, then cd to it. Add this function to your ~/.zshrc lf Wrapper function lf { local tmp=$(mktemp) command lf -last-dir-path="$tmp" "$@" cd "$(cat "$tmp")" rm -r "$tmp" } Step 3: Customize Your “lfrc” File It’s the LF config file to customize it; I like to keep it minimal. few UI interface configurations shortcuts to jump to my frequent main directories with a small cheatsheet for favorite LF shortcuts you’re gonna find it at ( if you can’t find it, create it ) ~/.config/lf/lfrc | |/ ) __ _ | | | / | | | () | | | | | | || _/ | ___ ___ _ __ / ( / _ | ' | |/ ` | | | | | ( | | ( | */|| ||| |*|, | | UI Set hidden # show hidden files set icons # show icons for files/directories set relativenumber # show files/directories relative numbers Jump Shortcuts map gh cd ~ # use 'gh' to go home directory map gp cd ~/personal/ # use 'gp' to go personal directory map gw cd ~/work/ # use 'gw' to go work directory map gt cd ~/tools/ # use 'gt' to go tools directory map gd cd ~/Downloads/ # use 'gd' to go downloads directory map gv cd /Volumes/ # use 'gv' to go volumes for (external drives) map gb cd ~/brainExt # use 'gb' to go obsidian BrainExt vault Fav Shortcuts hjkl/gg/G # Vim-like Navigation (move) space/v/u # select/invert/unselect (select) y/d/p/c # yank/delete/paste/clear (change) i/e/l # open with less/default-editor/default-app (open) change your default editor in ~/.zshrc To make sure that when you use shortcut, it always opens with it. e Then verify that your default editor changed: echo $EDITOR export EDITOR=vi # change default editor to vim Step 4: Cool Tmux Keybinding Imagine this scenario: you’re working on a file in Tmux, then do a quick shortcut open in new window to open any file from the same directory 🚀 lf Let’s go do exactly that, in ~/.tmux.conf But first, make sure that zsh is our default shell for the tmux conf Set the Default Shell to zsh set-option -g default-shell /bin/zsh this smart keybinding opens a new window with the name “Files.” ctrl+f The new window starts from the same path as well as your current window. And finally, it opens directly there ( use q to quit ) lf ctrl+f => lf (q) bind -n C-f new-window -n "files" -c "#{pane_current_path}" "zsh -ic 'lf; zsh'" Don’t forget to source ~/.tmux.conf tmux source-file ~/.tmux.conf Solution 3: Tmux-fzf Script For this one, we don’t just use another utility. We build our own tmux manager script to fuzzy find all our project files in specific directories and jump. 🦘 Step 1: Organize Your Project Files in Specific Directories For example ~/personal ~/work ~/tools Step 2: Build “Tmux Manager” Bash Script Create a new file with the name in the tools directory. tmux_manager.sh Change this file into an executable: chmod +x tmux_manager.sh This script lists all projects in those directories to fuzzy find. Finally, open the selected project as (or create it if not found) Tmux Session #!/usr/bin/env bash _ __ ___ _ ___ __| | | | /_\ | | | ' ` _ | | | \ / / | || | | | | | || |> <| | | ,/ use fuzzy finder to get my working directories paths session=$(find ~ ~/personal ~/work/ ~/tools -mindepth 1 -maxdepth 1 -type d | fzf) get last part as a name & replace any (.) with (_) session_name=$(basename "$session" | tr . _) if the session doesn't already exist, create it. if ! tmux has-session -t "$session_name" 2> /dev/null; then # remove err msg to null tmux new-session -s "$session_name" -c "$session" -d fi switch to the session by name tmux switch-client -t "$session_name" Step 3: Create an Alias to Our “Tmux Manager” Script open ~/.zshrc, to add our new Alias Don’t forget to source it 😉 source ~/.zshrc alias tm="~/tools/tmux_manager.sh" Step 4: Cooool tmux keybinding for “Tmux Manager” The same trick we did before with lf. A quick shortcut will run our tmux manager script alias. ctrl+t It will open in a new tmux window; a big list of all projects. Your selected project will open in its own Tmux session. Tell me that this isn’t cool ?! 🙃 bind -n C-t new-window -n "tmux" "zsh -ic 'tm; zsh'" don’t forget to source ~/.tmux.conf tmux source-file ~/.tmux.conf Let’s Be Friends on Twitter 👋 https://twitter.com/belalsamyyy

A Blazing Fast File Management for Terminal ⚡️

is a Python project that aims to provide a simple yet efficient timer for terminal users, particularly targeting the geek community. This project allows users to set timers directly from their command line interface, making it convenient for those who spend a significant amount of time working in the terminal! The main objective of is to offer a minimalistic and distraction-free timer experience. It provides a clean and straightforward interface, ensuring that users can focus solely on tracking time without any unnecessary clutter or distractions. MyTimer MyTimer GitHub Repo Installation Source Code Download or Version 0.9 Latest Source pip install . PyPI Check Python Packaging User Guide pip install mytimer==0.9 Demo Usage ⚠️ You can use or to run this program mytimer python -m mytimer Version mytimer --version Basic ⚠️ Press to exit Ctrl + C mytimer Time Limit mytimer --minute=7 --second=30 mytimer --hour=2 --minute=20 Timer Mode ⚠️ The default mode is count-up mytimer --minute=7 --second=30 --countdown mytimer --minute=7 --second=30 --countup Alarm ⚠️ This mode may not be supported on all systems mytimer --minute=7 --second=30 --alarm Alarm Repeat ⚠️ The default value is 1 mytimer --minute=7 --second=30 --alarm --alarm-repeat=5 Tone ⚠️ The default tone is 1 mytimer --minute=7 --second=30 --alarm --tone=2 Tones List Face mytimer --minute=7 --second=30 --face=3 Faces List Program mytimer --program=black-tea Programs List Message mytimer --minute=7 --second=30 --message="Test message" Show your support Give a ⭐️ if helped you! this project

Introducing MyTimer: A Geeky Timer for Terminal Enthusiasts

Tired of reopening terminal windows every time you come back to a VSCode project? You can pick up right where you left off without having to re-run setup commands and reopen programs by using Tmux sessions. Read on to find out how. Introducing Tmux Tmux (Terminal Multiplexer) is basically a window manager for your terminal. It has two main functionalities: Splitting the terminal into multiple windows and panes. Storing your terminal sessions in a server process, allowing you to reattach to the session even after closing your terminal instance. Tmux is super powerful and has many use cases. For example, you can protecting your remote ssh terminal sessions from being nuked when dealing with a flaky connection. If you’re not already familiar with this tool, I recommend to get started. Ham Vocke’s “Quick and Easy Guide to tmux” Instructions for setting up Tmux in VSCode To start persisting your terminal sessions using Tmux in VSCode: Step 1: Make sure you have Tmux installed If you’re using macOS, you can use Homebrew by running the following command in your terminal: brew install tmux For Ubuntu or WSL users, you can install it by executing: sudo apt-get install tmux If you’re using any other linux distro I’m sure you probably already know what you’re doing Step 2: Add a new terminal profile Open VSCode settings with Cmd+Shift+P (macOS) or Ctrl+Shift+P (Windows/Linux) Search for . This will open the file. Open User Settings (JSON) settings.json Under or , add: terminal.integrated.profiles.osx terminal.integrated.profiles.linux "terminal.integrated.profiles.osx": {
  //...existing profiles...
  "tmux-shell": {
    "path": "tmux",
    "args": ["new-session", "-A", "-s", "vscode:${workspaceFolder}"]
  }
} This runs on terminal startup, connecting to existing sessions named after the workspace folder. This way, if you’ve already created a terminal for this project, you’ll connect back to it automatically! tmux new-session Step 3: Set Tmux as the Default Terminal Profile Finally, to make the newly created Tmux profile the default for your system, add or modify the following line in the file: settings.json "terminal.integrated.defaultProfile.osx": "tmux-shell" Now, every time you open VSCode terminal, Tmux will startup automatically, allowing you to pick up exactly where you left off last time. Conclusion We’ve gone over how to integrate Tmux into VSCode’s integrated terminal. You can now use Tmux’s powerful session and window management easily inside VSCode! Also published . here

Tmux & VSCode — Persist Terminals for Productivity and Profit

As developers, we spend a lot of our time in the terminal. Most of the developers I talked to use several tools in their console... yes, the console, that itchy thing that will only display letters and numbers. This tool is more powerful than you think. And there are very many nice handy tools to use. This post outlines my list of tools that every developer must have or has heard about ;). So let's get started! Utils - Auto-correct miss-typed commands thefuck is one of those utilities you won't be able to live without once you've tried it. Whenever you mis-type a command and get an error, just run and it'll auto-correct it. Use up/down to choose a correction, or just run to just execute the most likely immediately. thefuck fuck fuck --yeah - Community-maintained docs ) tldr (better man is a huge collection of community-maintained man pages. Unlike traditional man pages, they're summarized, contain useful usage examples and nicely colourized for easy reading tldr - Count lines of code ) scc (better cloc gives you a breakdown of number of lines of code written in each language for a specific directory. It also shows some fun stats, like estimated cost to develop and complexity info. It's incredibly fast, very accurate and has support for a wide range of languages scc - Listing Files ) exa (better ls is a modern Rust-based replacement for the command, for listing files. It can display file-type icons, colors, file/folder info and has several output formats - tree, grid or list exa ls - Disk Usage ) duf (better df is great for showing info about mounted disks and checking free space. It produces a clear and colorful output, and includes options for sorting and customizing results. duf - Download Utility ) aria2 (better wget is a lightweight, multi-protocol, resuming download utility for HTTP/HTTPS, FTP, SFTP, BitTorrent and Metalink, with support for controlling via an RPC interface. It's incredibly , and has tons of . There's also - a nice web interface companion. aria2 feature rich options ziahamza/webui-aria2 - Reading Files ) bat (better cat is a clone of with syntax highlighting and git integration. Written in Rust, it's very performant, and has several options for customizing output and theming. There's support for automatic piping and file concatenation bat cat - File Comparisons ) diff-so-fancy (better diff gives you better looking diffs for comparing strings, files, directories and git changes. The change highlighting makes spotting changes much easier, and you can customize the output layout and colors diff-so-fancy - Watch for changes entr lets you run an arbitrary command whenever file changes. You can pass a file, directory, symlink or regex to specify which files it should watch. It's really useful for automatically rebuilding projects, reacting to logs, automated testing, etc. Unlike similar projects, it uses kqueue(2) or inotify(7) to avoid polling, and improve performance entr - Reading + writing metadata exiftool ExifTool is handy utility for reading, writing, stripping and creating meta information for a wide variety of file types. Never accidentally leak your location when sharing a photo again! - Duplicate file finder fdupes is used for identifying and/or deleting duplicate files within specified directories. It's useful for freeing up disk space when you've got two or more identical files jdupes - Fuzzy file finder ) fzf (better find is an extremely powerful, and easy to use fuzzy file finder and filtering tool. It lets you search for a string or pattern across files. fzf also has available for most shells and IDEs, for showing instant results while searching. This by Alexey Samoshkin highlights some of it's use cases. fzf plugins post - Command benchmarking hyperfine makes it easy to accurately benchmark and compare arbitrary commands or scripts. It takes care of warm-up runs, clearing the cache for accurate results and preventing interference from other programs. It can also export results as raw data and generate charts. hyperfine - Process viewer procs (better ps) is an easy to navigate process viewer, it has colored highlighting, makes sorting and searching for processes easy, has tree view and updates in real-time procs - Search within files ) ripgrep (better grep is a line-oriented search tool that recursively searches the current directory for a regex pattern. It can ignore the contents of and skip binary files. It's able to search within compressed archives, or only search specific extension, and understands files using various encoding methods ripgrep .gitignore - Fast, incremental file transfer rsync lets you copy large files locally or to or from remote hosts or external drives. It can be used to keep files across multiple locations synced, and is perfect for creating, updating and restoring backups rsync - Find and replace ) sd (better sed is an easy, fast and intuitive find and replace tool, based on string literals. It can be executed on a file, an entire directory, or any piped text sd - Directory hierarchy ) tre (better tree outputs a tree stye list of files for your current or a specified directory, with colors. When running with the option, it numbers each item, and creates a temporary alias that you can use to quickly jump to that location tre -e CLI Monitoring and Performance Apps - Bandwidth utilization monitor bandwhich Show bandwidth usage, connection information, outgoing hosts and DNS queries in real-time - Container metrics and monitoring ctop Like , but for monitoring resource usage for running (Docker and runC) containers. It shows real-time CPU, memory and network bandwidth as well as the name, status and ID of each container. There's also a built-in log viewer, and options to manage (stop, start, exec, etc) containers top - Resource monitoring ) bpytop (better htop is a fast, interactive, visual resource monitor. It shows top running processes, recent CPU, mem, disk and network history. From the interface you can navigate, sort and search - there's also support for custom color themes bpytop - Resource monitor + web and API glances is another resource monitor, but with a different feature set. It includes a fully responsive web view, a REST API and historical monitoring. It's easily extendable, and can be integrated with other services glances - Interactive ping tool ) gping (better ping can run ping tests on multiple hosts, while showing results in real-time graph. It can also be used to monitor execution time, when used with the flag gping --cmd - Disk usage analyzer and monitor ) dua-cli (better du let's you interactively view used and available disk space for each mounted drive, and makes freeing up storage easy dua-cli - Command line speed test utility speedtest-cli just runs an internet speed test, via speedtest.net - but straight from the terminal :) speedtest-cli - DNS lookup client ) dog (better dig is an easy-to-use DNS lookup client, with support for DoT and DoH, nicely coloured outputs and the option to emit JSON dog CLI Productivity Apps Surf the web, play music, check emails, manage calendars, read the news and more, all without leaving the terminal! - CLI web browser browsh is a fully interactive, real-time, and modern text-based browser rendered to TTYs and browsers. It supports both mouse and keyboard navigation, and is surprisingly feature rich for a purely terminal based application. It also mitigates battery drain issues that plague modern browsers, and with support for MoSH, you can experience faster load times due to reduced bandwidth browsh - Bookmark manager buku is a terminal-based bookmark manager, with tons of configuration, storage and usage options. There's also an optional and , for accessing your bookmarks outside of the terminal buku web UI browser plugin - Music browser / player cmus is terminal music player, controlled with keyboard shortcuts. It has support for a wide range of audio formats and codecs, and allows organising tracks into playlists and applying playback settings cmus - Track crypto prices cointop show current crypto prices, and track the price history of your portfolio. Supports price alerts, historical charts, currency conversion, fuzzy searching, and much more. You can try the demo via the web at , or by running cointop cointop.sh ssh cointop.sh - Search the web from the terminal ddgr is like , but for DuckDuckGo. It's fast, clean and easy, with support for instant answers, search completion, search bangs, and advanced search. It respects your privacy by default, and also has HTTPS proxy support, and works with Tor ddgr googler - Code editor ) micro (better nano is an easy to use, fast and extendable code editor with mouse support. Since it's packaged into a single binary, installation is as simple as micro curl https://getmic.ro | bash - Calendar client khal is a terminal calendar app, which shows upcoming events, month and agenda views. You can sync it with any CalDAV calendar, and add, edit and remove events directly khal - Email client mutt is a classic, a terminal based mail client for sending, reading and managing emails. It supports all mainstream email protocols and mailbox formats, allows for attachments, BCC/CC, threads, mailing lists and delivery status notifications mut - RSS / ATOM news reader newsboat is an RSS feed reader and aggregator, for reading the news, blogs and following updates directly from the terminal newsboat - Todo + task management taskwarrior is a CLI task management/ todo app. It's both simple and unobtrusive, but also incredibly powerful and scalable, with advanced organisation and query features built in. There's also a lot (700+!) of extra for extending it's functionality and integrating with third-party services task plugins - Terminal UI for Reddit tuir is a great one if you want to look like you're working, while actually browsing Reddit! It's got intuitive keybindings, custom themes, and can render images and multi-media content too. There's also for hacker news tuir haxor CLI Dev Suits - HTTP / API testing testing client httpie is a HTTP client, for testing, debugging and using APIs. It supports everything you'd expect - HTTPS, proxies, authentication, custom headers, persistent sessions, JSON parsing. Usage is simple with an expressive syntax and colourized output. Like other HTTP clients (Postman, Hopscotch, Insomnia, etc) HTTPie also includes a web UI httpie - Full Docker management app lazydocker is a Docker management app, that lets you view all containers and images, manage their state, read logs, check resource usage, restart/ rebuild, analyse layers, prune unused containers, images and volumes, and so much more. It saves you from needing remember, type and chain multiple Docker commands. lazydocker - Full Git management app lazygit is a visual git client, on the command line. Easily add, commit and puch files, resolve conflicts, compare diffs, manage logs, and do complex operations like squashes and rewinds. There's keybindings for everything, colors, and it's easily configurable and extenable lazygit CLI External Sercvices - Reverse proxy for sharing localhost ngrok safely* exposes your localhost to the internet behind a unique URL. This lets you share what you're working on with you're remote colleagues, in real-time. Usage is , but it's also got a lot of advanced features for things like authentication, webhooks, firewalls, traffic inspection, custom/ wildcard domains and much more ngrok very simple - Fast file sharing transfer.sh makes uploading and sharing files really easy, directly from the command line. It's free, supports encryption, gives you a unique URL, and can also be self-hosted.I've written a Bash helper function to make usage a bit easier, you can or try it out by running transfer find it here bash <(curl -L -s https://alicia.url.lol/transfer) - Deploy a site in seconds surge is a free static hosting provider, that you can deploy to directly from the terminal in a single command, just run from within your directory! It supports custom domains, auto SSL certs, pushState support, cross-origin resource support - and it's free! surge surge dist - Check the weather wttr.in is a service that displays the weather in a format that's digestible in the command line. Just run or to try it out. There's URL parameters to customise what data is returned, as well as the format wttr.in curl wttr.in curl wttr.in/London CLI Fun - Have an ASCII cow say your message cowsay is a configurable talking cow. It's based off the by Tony Monroe cowsay original - Output text as big ASCII art text figlet outputs text as ASCII art figlet - Make console output raibow colored lolcat makes any text passed to it rainbow coloured lolcat - Show system data and ditstro info neofetch prints distro and system info (so you can flex that you use Arch btw on r/unixporn) neofetch As an example, I'm using , , and to create a custom time-based MOTD shown to the user when they first log in. It greets them by their name, shows server info and time, date, weather and IP. . cowsay figlet lolcat neofetch Here's the source code Conclusion I think there is at least one interesting tool for you and your productivity enlisted in this list. Hope you enjoy! Also published . here

Unleashing the Power of the Terminal: Essential Tools Every Developer Should Know

In this article, the exciting realm of making terminal applications smarter is delved into by integrating ChatGPT, a cutting-edge language model developed by OpenAI. The focus is on exploring how ChatGPT and other LLM models such as WizardCoder, MPT can revolutionize the user experience by enabling natural language interactions, thus opening up new possibilities for enhanced productivity and efficiency. To access the project directly, please click the provided . link Large Language models have revolutionized the field of natural language processing, empowering developers and researchers to build intelligent applications. In this article, we explores how these models bring intelligence to terminal applications. Three different models were used for this purpose. ChatGPT, MPT and WizardCoder. ChatGPT, developed by OpenAI, is a state-of-the-art language model designed for generating human-like text responses. It excels in engaging in interactive and dynamic conversations with users. From providing detailed answers to answering questions, ChatGPT showcases the power of language models in natural language understanding and generation. MPT is a multilingual variant of the popular Transformer model. It has been trained on a vast corpus of text from different languages, enabling it to understand and generate text in multiple languages. MPT enables cross-lingual applications, machine translation, and language understanding tasks, bridging communication gaps across diverse linguistic communities. WizardCoder is an innovative language model specifically designed for code generation and programming assistance. It understands programming languages and can generate code snippets based on user prompts. With WizardCoder, developers can leverage the power of language models to speed up their coding tasks, explore code suggestions, and gain insights into best coding practices. GPTerm This project focuses on the conversion of plain text into shell commands using ChatGPT and open-source language models. While some models yielded satisfactory results, others fell short of expectations. The primary terminal application used in this study is iTerm, although the project is anticipated to be compatible with other terminal applications as well, even though specific tests have not been conducted. The project is divided into two main parts. In the first part, the user can manually enter and execute shell commands within the current plugin without closing it. The second part involves the translation of given plain text into shell commands, which are then presented to the user. If desired, the user has the flexibility to modify or remove certain sections of the generated command without executing it. Both sections function in a similar manner. To differentiate between manual input of shell commands and obtaining shell commands from plain text, a dot (.) must be placed at the beginning of the plain text. This allows the application to determine the user’s intention accurately. The project aims to serve as a convenient tool for users who need quick reminders or clarification regarding shell commands they may have forgotten or become confused about. It also provides suggestions for alternative and more efficient commands than the ones they intend to write. Users can also verify the correctness of their commands, all without the need for extensive internet searches. This project involves conducting experiments with three different models to explore their performance and obtain varying results. The initial focus was on the ChatGPT model, which yielded the most successful and reliable outcomes. Since generating shell commands often involves small-word scripts, the number of tokens remains low, resulting in cost-effectiveness. As a result, ChatGPT is a suitable choice. However, tests were also conducted with other models. In addition to ChatGPT, the WizardCoder and MPT models were also utilized, focusing on CPU performance by employing quantized models. However, it is recommended to conduct tests with the original states of the models, as higher success rates are anticipated in such scenarios. The MPT model correctly interpreting some commands while providing incorrect answers in other cases. It was also observed that there were instances where the response was non-responsive. Given that no customized model based on code exists, this behavior can be considered natural. Based on observations, the WizardCoder model outperforms the MPT model. Although it may appear slightly less advanced compared to ChatGPT, it still offers acceptable results for those interested in utilizing open-source models. It is important to note that while results obtained from ChatGPT are delivered in a highly structured JSON format, other open-source models may occasionally produce noisy responses to questions. Below, you will find the results obtained from open-source models. 1-
{
 "command": "mkdir creator && cp /new/hua/* creator/"
}
```<|im_end|>

2-
~~~json
 {
 "command": "ls -l /storage | grep pdf | sort -r"
 }
 ~~~
3-
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n 
 {"command": "cd storage && touch ny.py" }' In particular, when working with open-source models, occasional instances of noisy results, as depicted above, may arise. To solve this problem, a regular expression (regex) approach has been implemented to effectively remove any noise from such outcomes. In future iterations, the regex pattern will be refined to encompass all possible error cases. However, for the current implementation, the pattern has been tailored to address the most prevalent sources of noise, considering the constraints of time. However, in the current implementation, the pattern has been adjusted to effectively handle the main sources of noise, taking into account the time limitations. Usage To begin with, it is recommended to work within an environment. In this project, the conda environment “py1” (sample conda env name) is utilized for development. Then; pip3 install gpterm-tool You can run the provided above command for installation purposes. Once installed, it can be utilized by using the ‘gpterm’ keyword on iTerm or any other terminal application. Run with ChatGPT model (Highly Recommended) gpterm -k <openai_api_key> Run with MPT model gpterm -m mpt -p <quantized_mpt_model_path> Run with WizardCoder model gpterm -m wizardcoder -p <quantized_wizardcoder_model_path> As the models used have a large number of parameters and are executed on the CPU, the processing speed of the results may be slower. The project was developed on an M1 MacBook Pro, and no tests with GPU implementation have been performed yet. Hence, for professional use, it is recommended to opt for the ChatGPT model. For swift access and usage of this program, you have the option to include an alias in the zshrc file. This allows for convenient and rapid execution of the program. My conda env name is py1. alias gt='conda activate py1 && gpterm -k <openai_api_key>' Following that, the program can be easily launched via the terminal by simply entering the “gp” keyword. You can see the answers given by ChatGPT and WizardCoder models to the same questions below. ChatGPT vs WizardCoder ChatGPT name_ai ---> . go in storage folder and sort only pdf files reversely

>>> cd storage && ls -r *.pdf

name_ai ---> . Create a folder named sample_1 and create a txt file for each number starting from 1 to 10 in it and assign that number as the name

>>> mkdir sample_1 && for i in {1..10}; do touch sample_1/$i.txt; done

name_ai ---> . Create a file named nw_1 with .txt extension and add all the numbers from 1 to 10 in it

>>> touch nw_1.txt; echo {1..10} >> nw_1.txt WizardCoder name_ai ---> . go in storage folder and sort only pdf files reversely

>>> ls -l storage | grep pdf | sort -r

name_ai ---> . Create a folder named sample_1 and create a txt file for each number starting from 1 to 10 in it and assign that number as the name

>>> mkdir sample_1 && cd sample_1 \\ Wrong one here !

name_ai ---> . Create a file named nw_1 with .txt extension and add all the numbers from 1 to 10 in it

>>> touch nw_1.txt && echo '1 2 3 4 5 6 7 8 9 10' >> nw_1.txt ChatGPT provides highly accurate responses. In the WizardCoder model, it successfully generated the correct command in two out of the three requests, although it did produce an incorrect command in one request.As mentioned previously, chatgpt is highly recommended for professional applications. Nevertheless, by retraining the WizardCoder model using the commands that are frequently used, its effectiveness can be enhanced. Project Repo : https://github.com/ademakdogan/GPTerm Github : https://github.com/ademakdogan Linkedin : https://www.linkedin.com/in/adem-akdoğan-948334177/ References Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., & Sutskever, I. (2019). Language models are unsupervised multitask learners. arXiv preprint arXiv:1911.02116. Yin, P., Deng, L., Li, J., & Zettlemoyer, L. (2021). Model Programming Transformer. arXiv preprint arXiv:2105.14947. Brown, T. B., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., & Amodei, D. (2020). Language models are few-shot learners. arXiv preprint arXiv:2005.14165. Luo, Z., Xu, C., Zhao, P., Sun, Q., Geng, X., Hu, W., … & Jiang, D. (2023). WizardCoder: Empowering Code Large Language Models with Evol-Instruct. arXiv preprint arXiv:2306.08568. Gu, J., Li, Z., Zhang, H., Wang, H., Liu, S., Wu, Q., … & Sun, X. (2021). Llama: Language Model Pre-training Without Masking. arXiv preprint arXiv:2102.10219.

GPTerm: Creating Intelligent Terminal Apps with ChatGPT and LLM Models

Let's learn about via these 42 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Terminal /Learn Repo 1. 10+ Things I Love About Linux Linux is growing and evolving even after 30 years since its birth, but the core ideas behind it remain the same, which opens the doors to new horizons. 2. How to Make your Rails App Work with the Mac M1 Chip [SOLVED] Get your rails app running from terminal using the following steps on MacBook M1 Chip. 3. Dashboards, monitoring and alerting — right from your terminal !!! As a backend developer, I always need to monitor something. State machine in the database, records count, message queue lag, custom application metrics, system performance, progress of my deployment scripts. Tons of stuff! 4. You Can Track Stock Market Data From Your Terminal As a developer, I love working with the terminal. The plain, simple, and in my opinion the best way to interact with the computer (also it makes you look geeky) 5. Introducing the Terminal Reader App by HackerNoon This is a web application with the intention of providing a different way of reading. Yes, you will be reading in a terminal-like application. 6. 6 Essential Linux Terminal Commands Everyone Should Know Linux is one of the best-known and most used operating systems in the world. Here are 6 essential commands which can make you better at using Linux systems. 7. How To Create Reusable Bash Scripts Bash is a language that is quite useful for automation no matter what language you write in. Bash can do so many powerful system level tasks. Even if you are on windows these days you are likely to come accross bash inside a cloud VM, Continuous Integration, or even inside of docker. 8. Creating a Terminal Emulator in React How to create a terminal emulator in React and Typescript 9. POSIX: An Untold Story Tapping the keys while sitting in front of black terminal, traversing the huge logs and sipping from a cup of coffee. 10. Git Commands That Every Developer Must Know Git, an open source distributed version control system has been helping developers over a decade now. It is a great tool for tracking source code changes during software development. However, there are a lot of git commands, and this article lists the most important ones that will help your team get work done efficiently. 11. How to Run Multiple Terminal Commands in ONE, Like a Boss Buck is a free, open-source and lightweight CLI tool used by developers to group multiple terminal commands into one. 12. React Ink for CLI: A Gentle Introduction React Ink is a library that brings the power of React to designing Command-Line Interfaces. 13. Using a Script to Send Desktop Notifications from Your Linux Terminal Send visual feedback and reminders from scripts, using notify-send and at commands on Linux.  Also how to get MacOS to do it as well, through some jury-rigging. 14. How to Install and run Swift on a Linux Machine How to install and run Swift on Linux 15. Why You Should Convert Your Images To WebP WebP lets you compress your images as efficiently as possible, reducing the size of your web page while preserving quality. You can convert from the terminal 16. Warp: The Terminal For the Modern Developers Today, I’m proud to officially introduce Warp, a from-first-principles reinvention of the terminal to make it work better for developers and teams. 17. Setting up a Development Workflow in the Windows Terminal For decades, Windows users have been made fun of by the Linux community for the lack of a cool terminal (among other things). Well, it's about time we fight! 18. What is the Difference between Telnet and SSH? Telnet and SSH are network protocols used to manage and access devices remotely. SSH is more secure and preferred because it encrypts data sent over the network 19. Pioneer Challenge: Overview The Terminal hasn't changed much since the 1980s. Every other aspect of your workflow is radically different. Especially in the last decade, we’ve seen companies transform industries with the advent of collaborative software: Figma (collaborative design), Github (collaborate code), G Suite (collaborative Word and Excel) and more. 20. Make Your Rust Code More Rustic By Breaking Some Rules Warp engineer and resident Rust expert @ChuckAPierce  writes about when to break the rules of Rust's infamous borrow checker. 21. Get the Most Out of Your Terminal: A Comprehensive Guide to WezTerm Configuration Alacritty, Kitty, Foot, and WezTerm can be challenging due to the lack of a Getting Started guide and limited examples. I'll walk you through my configuration, 22. 16 Commands For Every Use Case to Set Up React Apps in Seconds ⚡🚀 In this article, I have handpicked 16 commands to set up your React apps in seconds. 23. 9 Fun Command-Line Tools to Make Your Life Easier Command-Line Tools to Make Your Life Easier and More Fun 24. Poor Command-Line Hygiene? Consider Load-bearing the Shell History Can you use your command-line shell history as a second brain? Should you? Here are some ideas to help leverage the humble Ctrl-r key to supercharge your work. 25. How to Set Up an iPad for Machine Learning Development If you have an iPad and want to use it as a development tool, you only need to complete 5 steps before using it. In this guide, you'll learn how to: 26. Keeping SSH Connection Alive for Longer Durations SSH connection gets terminated if the server(or client, in some cases) is idle for a certain period of time. It can be fixed by a simple trick. 27. How to Set Up a World Where Dyeing Your Hair Terminal Green Shows Dedication to Your Job Step 1: Make #02550 your project’s primary color over a beer with a friend for no particular reason. 28. How to Enable Autocomplete (and AI) in your Terminal Here's how I enhance my terminal with autocomplete and Artificial Intelligence 29. Let's Build a Linux Shell [Part I] Since the early days of Unix, the shell has been part of the user's interface with the operating system. The first Unix shell (the Thompson shell) had very limited features, mainly I/O redirection and command pipelines. Later shells expanded on that early shell and added more and more capabilities, which gave us powerful features that include word expansion, history substitution, loops and conditional expressions, among many others. 30. The Problem With Promotion-Obsessed Cultures The problems with promo-culture 31. How To Install Bash On Windows 10 Microsoft recently joined hands with Canonical (the parent company of Ubuntu) to bring the entire userland into Windows, minus the Linux Kernel. So as a result, you, as a developer, get access to the whole range of Ubuntu command-line tools and utilities with bash shell integrated with Windows. Let’s look at how we can install Bash on Windows 10 and take full advantage of the new feature. 32. Real-time Scanning of Other Terminals with Strace Introduction 33. Working With Files In Python Most of us have had that one experience where we had a ton of dis-organized files in our machines. It happens. One minute, you're opening a large zip file, the next thing you know,  the files are everywhere in the directory, mixing with all your important files and randomly placed leaving you with the task of manually sorting what needs to go where. It's a real pain. To ease this process, we're going to delve into file management with python the smart way. 34. A Simple Sequential and Parallel Task List Runner for Terminal Taskz is a library for Node.js, a simple sequential and parallel task list runner for terminal. 35. Building A Linux Shell - Part II [A Step-by-Step Guide] In the first part of this tutorial, we've built a simple Linux shell that prints a prompt string, reads input, then echoes the input back to the screen. This isn't very much impressive now, is it? 36. Basic Commands That Will Help You Get Started With Terminal At first, the command line interface can be overwhelming: it’s an empty screen and a prompt. 37. How I Inspect & Manipulate Files from the Command Line 38. A Linux, Mac and UNIX Tutorial Of The Top 6 Cool Terminal Commands For Beginners In this tutorial, you'll learn the most common and useful commands that you can run in almost any UNIX-like environment, including Linux and Mac OS X. 39. Exploring the New GitHub CLI Github just released it’s own Command-Line Interface (CLI) so developers can now do everyday GitHub tasks from the terminal. Yay! This means no more squiggling around the UI. With this new CLI, you can now view, create, clone, or fork repositories, create, view, and edit gists, you can also work with pull requests and issues right from the terminal. 40. Building a Linux Shell [Part III] This is part III of a tutorial on how to build a Linux shell. You can read the first two parts of this tutorial from these links: part I, part II. 41. Building a Linux Shell [Part IV] This is part IV of a tutorial on how to build a Linux shell. You can read the previous parts of this tutorial from the following links: part I, part II, part III. 42. Building a Linux Shell [Part V] This is part V of a tutorial on how to build a Linux shell. You can read the previous parts of this tutorial from the following links: part I, part II, part III, part IV. Thank you for checking out the 42 most read stories about Terminal on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

42 Stories To Learn About Terminal

GPU terminals are all the rage these days. The competition between players like , , , , and is heating up, and there's still no clear winner. Although they don't have all the fancy features that classic terminals like or have, such as good support for bitmap fonts and ligatures, they can be faster at displaying and refreshing large amounts of information. And even though the average person (not a Counter Strike champion with a 240Hz monitor) is slow at processing all that information, the ability to optimize terminal performance can be a fun way to show off your nerdy side 🤓. Alacritty Kitty Foot Warp WezTerm iTerm2 Terminator I chose to change from to one of the powered alternatives... The question now is, which one should I choose? But first, I'll give an ultra-brief rundown on each one. iTerm2 Alacritty 💨 In my opinion, it's the slowest one, and its stability is questionable. It has a minimalistic style, with a simple UI that doesn't have tabs or panes and lacks font ligatures. Some people have reported that it crashes frequently. Also, the author is well-known for their meticulous attention to detail, which is why new features are added slowly. Despite its shortcomings, it still has 2.5 times more Github stars than our next option. Kitty 🐱 The Terminal offers more customization options and boasts a , with occasional spikes of , while Alacritty has a latency of 50ms. The Terminal has better font rendering and supports ligatures, although they may need to be set up. Unfortunately, Kitty is not available on Windows. latency of 35ms 7ms Foot 🦶 A lesser-known option in the area. Even though it doesn't have GPU support, I still wanted to mention it because it's known for its low resource usage. In my testing, it only used 13-19 MB of RAM. It has fast performance thanks to its clever design that minimizes input latency even without GPU rendering. So, the terminal is both high-performing and resource-efficient. The author and compares them to Alacritty. thoroughly explains the performance trade-offs Warp 🌀 A truly innovative and reinvented version of classic terminals that operates like a code editor, featuring AI command search powered by GPT-3. With a new stdin/stdout interaction workflow and many other exciting features, it's a game-changer for some hipster-like individuals (if you don’t afraid of telemetry). WezTerm 🤠 My favorite one. Although the cowboy emoji might suggest a connection to the Western genre, it has nothing to do with the terminal itself. The name is simply the author's name. Wez If you're looking for a terminal that's the same across Windows, Mac, and Linux, then WezTerm is the one for you. Built using Rust, just like Alacritty, so boasts high performance. It's loaded with many well-documented features and easily customizable using Lua configs, making it a favorite among Vim users. Despite being a relatively new release, its documentation is already top-notch, better than any other terminal. Base Configuration That being said, configuring WezTerm can be challenging due to the lack of a guide and limited examples. When you first install WezTerm, your file will be blank, leaving you in the dark about all the fantastic features the terminal offers. But don't worry! That's where this article comes in. I'll walk you through my configuration, explaining each line in detail and providing a complete example you can use or modify to fit your specific needs. Getting Started ~/.wezterm.lua Let's start by defining some global variables that we'll use later. The module provides access to WezTerm configuration and control in your config file. It's a good practice to put this line at the top of your config file. wezterm local wezterm = require 'wezterm' Now, let's add two more variables. The module manages the multiplexer layer, which is responsible for everything related to panes, tabs, windows, and workspaces, but not the terminal itself. And the module helps us bind keys to actions. Technically, is a specific enum constructor, while is a separate Lua module, but for now, it doesn't matter. wezterm.mux wezterm.action action mux local mux = wezterm.mux
local act = wezterm.action Let's go a bit further. The function triggers a after a specific occurs. As you can see, the event invokes . Simply saying, the function runs immediately after the terminal starts. It's pretty straightforward. wezterm.on callback event gui-startup function(cmd) Next, we create a new window using , which returns objects associated with that window. Although we may not utilize these returned values, it is necessary to capture them anyway. That's just how it works. If you need a more precise understanding, you can find definitions of available functions on the search page of WezTerm's website. mux.spawn_window Also, I like to maximize the window right away. wezterm.on('gui-startup', function()
 local tab, pane, window = mux.spawn_window({})
 window:gui_window():maximize()
end) The next substantial final part begins with a statement. return return {
 default_prog = { '/usr/local/bin/fish', '-l' }
 window_decorations = "RESIZE"
 ...

} Yes, in the WezTerm structure, we need the result of our configuration so that the rest of the configuration will be enclosed in 's brackets. return return With , we set our favorite shell. Mine is fish. The flag means running as if it started as a login shell. By setting to , we achieve a minimalist design by disabling the title bar and enabling the resizable borders. When we open WezTerm, we'll get a maximized window without a title bar, just the way we like it. default_prog -l window_decorations RESIZE Okay, got it. Let's have some fun with WezTerm's panes. You can change the background colors, but to avoid any health issues due to a lack of design skills, the only options available for adjustment are saturation and brightness. This is done by design in WezTerm, so you can easily see which pane you're currently on when you switch between them. inactive_pane_hsb = {
 saturation = 0.8
 brightness = 0.7
} Let's check out the desired outcome. The actual style will depend on the color scheme, so we're going to the next chunk of the configuration, called theme. is a good theme, but you can find to your taste on the official website. Don't need to install something. Just put the theme's name under . Hardcore 746 others color_scheme color_scheme = 'Hardcore'
font = wezterm.font('JetBrainsMono Nerd Font')
font_size = 14
line_height = 1.2 The font is a big deal for hackers. I like 'cause it's top-notch and free. I might like even more, but it's too pricey. JetBrainsMono Nerd Berkeley Mono The size I set to 14 depends on your monitor and personal preference. For me, the font is ideal when it's too small but not relatively small enough. The height follows the same rule, I think. But it's better to leave the height at 1 because the font designer won't be happy if you change it. The font was developed with its original height, and if you mess with it, you might mess up the thing creator intended. Moving next. use_dead_keys = false
scrollback_lines = 5000 You may not know about dead keys. If so, let me introduce you to . These keys can cause some problems in Vim editors and specific shell hotkeys. Secondly, the scrollback lines refer to the number of lines you want to keep in view per tab. I don't remember when I need to keep more than 5000 lines. Wikipedia Next, let's tweak the font size to avoid issues when using tiling window managers like Yabai (which I use). As for the second option, I'm not sure if I need to add something. adjust_window_size_when_changing_font_size = false
hide_tab_bar_if_only_one_tab = true Moving on, let's take control of the appearance of the tab bar. A unique font for tabs can break your eyes from the main font and make your setup look more professional and (maybe) designer-like. window_frame = {
 font = wezterm.font { family = 'Noto Sans', weight = 'Regular' },
} Hotkeys Configuration Now, let's dive into customizing our hotkeys. The command where our key customization start. By doing the following step, we're turning off all the default key assignments, so we'll have to set each binding explicitly. disable_default_key_bindings = true The leader key is a combination of keys that allows users to quickly access various features and commands in a software program using keyboard shortcuts. In VSCode, the default leader key is usually set to on Windows or Linux and on Mac. However, this can be customized to suit individual preferences. The way it works is that you first press the leader key and then press another key to trigger a specific function. This differs from hotkeys, which require you to press multiple keys simultaneously. Ctrl Cmd leader = { key = 'b', mods = 'CMD', timeout_milliseconds = 2000 } Although I set a leader key, I rarely use it because it makes you slower. Classical hotkeys work faster for me, so most of the configuration I will share later is about them. The following chunk is vast. Most of the values are taken from defaults. I’ll say only about the keys I changed. keys = {
  { key = 'l', mods = 'CMD|SHIFT', action = act.ActivateTabRelative(1) }
  { key = 'h', mods = 'CMD|SHIFT', action = act.ActivateTabRelative(-1) }
  { key = 'j', mods = 'CMD', action = act.ActivatePaneDirection 'Down', }
  { key = 'k', mods = 'CMD', action = act.ActivatePaneDirection 'Up', }
  { key = 'Enter', mods = 'CMD', action = act.ActivateCopyMode }
  { key = 'R', mods = 'SHIFT|CTRL', action = act.ReloadConfiguration }
  { key = '+', mods = 'CTRL', action = act.IncreaseFontSize }
  { key = '-', mods = 'CTRL', action = act.DecreaseFontSize }
  { key = '0', mods = 'CTRL', action = act.ResetFontSize }
  { key = 'C', mods = 'SHIFT|CTRL', action = act.CopyTo 'Clipboard' }
  { key = 'N', mods = 'SHIFT|CTRL', action = act.SpawnWindow }
  { key = 'U', mods = 'SHIFT|CTRL', action = act.CharSelect{ copy_on_select = true, copy_to =  'ClipboardAndPrimarySelection' } }
  { key = 'v', mods = 'CMD', action = act.PasteFrom 'Clipboard' }
  { key = 'PageUp', mods = 'CTRL', action = act.ActivateTabRelative(-1) }
  { key = 'PageDown', mods = 'CTRL', action = act.ActivateTabRelative(1) }
  { key = 'LeftArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Left' }
  { key = 'RightArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Right' }
  { key = 'UpArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Up' }
  { key = 'DownArrow', mods = 'SHIFT|CTRL', action = act.ActivatePaneDirection 'Down' }
  { key = 'f', mods = 'CMD', action = act.SplitVertical { domain = 'CurrentPaneDomain' }, }
  { key = 'd', mods = 'CMD', action = act.SplitHorizontal { domain = 'CurrentPaneDomain' }, }
  { key = 'h', mods = 'CMD', action = act.ActivatePaneDirection 'Left', }
  { key = 'l', mods = 'CMD', action = act.ActivatePaneDirection 'Right', }
  { key = 't', mods = 'CMD', action = act.SpawnTab 'CurrentPaneDomain' }
  { key = 'w', mods = 'CMD', action = act.CloseCurrentTab{ confirm = false } }
  { key = 'x', mods = 'CMD', action = act.CloseCurrentPane{ confirm = false } }
  { key = 'b', mods = 'LEADER|CTRL', action = act.SendString '\x02', }
  { key = 'Enter', mods = 'LEADER', action = act.ActivateCopyMode, }
  { key = 'p', mods = 'LEADER', action = act.PastePrimarySelection, }
  { key = 'k', mods = 'CTRL|ALT', action = act.Multiple
    {
      act.ClearScrollback 'ScrollbackAndViewport'
      act.SendKey { key = 'L', mods = 'CTRL' }
    }
  }
  { key = 'r', mods = 'LEADER', action = act.ActivateKeyTable { name = 'resize_pane', one_shot = false, }, }
} Switch Tabs Switching tabs in browsers has always been done with the + and + + hotkeys. That was until I learned Neovim, and I discovered a better way. Instead of using the traditional method, you can press + + to move to the right tab and + + to the left tab. This way of switching tabs is faster because it involves using both hands, making it easier to switch between tabs like a pro. It's a plus if you're a Neovim user and need to switch between tabs in both Neovim and WezTerm while working with your shell. And it becomes even better if you configure your browser (I use Chrome) with the same hotkeys, allowing you to switch tabs smoothly without moving your fingers much on the keyboard. Ctrl Tab Ctrl Shift Tab Ctrl Shift H Ctrl Shift L Spawn Tabs The tried and true method of using + to open a new tab and + to close it works seamlessly with browsers. Your muscle memory will thank you for using this familiar technique. Ctrl Tab Ctrl W Split Panes Quite easy. Similar to , but probably more accessible because you need always two fingers. Just + to split the pane vertically, and + to split horizontally. You can close the pane by + , however shell + work as well. iTerm2 Cmd F Cmd D Ctrl X Ctrl D Copying Text You can use the Enter key if you're lazy, but WezTerm is just as comfortable with a mouse. In that case, double-click (or highlight) the text, and it'll be copied right away without having to press + or anything similar. Ctrl C That's probably it! Just a heads up, you can set up keys for different sections like , , and more. I don't get into details since I mostly use the defaults. I hope this guide helped you take your WezTerm terminal configuration to the next level. copy_mode search_mode

Get the Most Out of Your Terminal: A Comprehensive Guide to WezTerm Configuration

At first, the command line interface can be overwhelming: it’s an empty screen and a prompt. When you type, text appears on the screen. But before you can get any use from it, you need to know what to type. Let’s take a look at the commands that will help get things done when you are just starting with the command line. Working directory Before we start any meaningful work, we first need to know where we are. The commands you run are evaluated in a folder—the working directory. There are a few commands that help you check your current context and move to a more convenient location: —shows the full path of your working directory: pwd —switches the working directory to : cd <folder> <folder> A few more examples with : cd —moves to the parent folder of the current one cd .. —moves back to the preview folder cd - —moves to home directory cd ~ Listing files So, now that we know what folder we are in, let’s now see what we have inside. The command to show a list of files is : ls As you see, both files and directories are shown together, and it’s not entirely clear what is what. I usually run this command with two parameters: —to show files, event the hidden ones -a all —to show the information in long format -l In the output you can see: & —aliases to the folder itself and its parent folder . .. —hidden folder for keeping the files used by a Git repository .git each line starts with or . The first means files; the second means directories. - d Managing files and folders To finish up with the basics, we just need some commands to modify the files and directories. Commands to do it: —creates an empty file touch <file-name> —creates an empty folder mkdir <directory-name> —removes the specified file rm <file-name> —removes the specified folder rm -d <directory-name> Read the friendly manual is a command that shows you a manual for other commands. All the commands we have mentioned so far have plenty of options. You can learn more about them directly from the terminal by using . You run : man man man <command name> Return value is a simple program that returns its arguments to the standard output. You can use it to write a value to a file: echo echo Test > test.txt Display files’ content a tool mean to con enates multiple files. It’s often used to pick the content of only one file, to get it to the standard input of another command with the pipe operator. Example: cat cat cat file-1.txt file-2.txt Count content of the file In the context of CLI, stands for word count. It lets you check the length of the output of other files: wc The output here means that in the specified file we have: 29 lines 116 words 542 characters View part of the file and are utilities to read a few lines from the beginning or end of the files, respectively. By default, both show 10 lines. You can see them in action: head tail Checking the whole file is a command that paginates a file or its input to fit it on the screen. I covered the basic navigation shortcuts in : less my recent article You can use to view the output of any other command—just connect with a pipe: less If you are confused by the terminology, I explain standard input, output, and pipes . here Searching the file content is a great search tool that supports . Its power comes from flexibility: by specifying one of its numerous options, you can tweak its behavior to what you need. By default, it waits for values to come in the standard input—not the most common use case. Therefore, you most likely want to run it as a filter inside a command pipeline. grep regular expressions The typical use as a pipe filter looks like this: In this pipeline: —concatenates all files in the current folder that ends with txt and returns it in a standard output cat *txt —returns only lines that have in them grep 1 1 Reverse search Often, it’s easier to describe what you don’t want to have rather than what you want. With , you can easily use it to filter out some lines by adding the option to it. For example: grep -v Note! You can combine many commands with the pipe operator: cat *txt | grep -v 1 | grep file-
Content of file-2.txt Searching through files Grep allows you to search in files as well—you just need to add (from recursive search in subdirectories): -r In the output, you can see: —path to the file ./file —the matching line Lorem ipsum File names only If you are interested only in files have your matching values, then you can add the option to your command: which -l This option becomes especially useful when you combine it with the next command/ Calling commands based on the output of other commands takes lines from standard input and adds them as parameters for another command. One of the common uses is to find all files that contain some value and run a command on them—for example, delete them: xargs grep -rl Lorem | xargs rm There is no output of the command, but let’s see what files are available before and after running the command: ls
long-file.txt For now, the files are gone, but later in this article we will see a tool that helps us track and restore files. As you can see in the second run of (recursive listing of a directory and each subdirectory): ls -R is gone from the top directory, and file is gone from the nested folder. another-file.txt Scripting files edits is a stream editor. It allows for modifications to the values in the pipe: sed echo 'hello world' | sed 's/world/you/'
hello you In our example, the parameter denote the following: s/world/you/ —means substitute s —regex to match the value to be substituted world —new value to be used instead you Editing files on disk A more practical use case for is to edit files. When can combine it with and , you can start developing pretty neat one-liners that will help you apply big updates to your codebase: sed grep xargs # at Linux
grep -lr file | xargs sed -i -e 's/file/File/g'

# at macOS
grep -lr file | xargs sed -i '' -e 's/file/File/g' In our command: —returns the list of all files that contains . grep -lr file file —turns them into input parameters for . xargs sed or —switches the editor to work directly on the files. sed -i -e sed -i '' -e —substitutes lowercase letter “file” with uppercase “File”. at the end means that the change is meant to be global. It should update every instance that is found in the file—not only the first instance in each line. s/file/File/g /g Track files changes Git is a version control system that is ubiquitous in our industry. If you intend to become a developer, you will need to learn it eventually. I’ve already written , but here we will focus on Git commands that integrate nicely with other CLI tools we have covered here. a lot about Git git grep This is a command inspired by . It lets you search through the files tracked by the repository. When you track your files with Git, you can use instead of . The main advantage is that it automatically ignores files that you set Git to ignore—which is often the case with . grep git grep grep -r node_modules Similar to the original , you can use option to get only the file names: grep -l $ git grep -l File
file-a
file-b
file-c git ls-files A command to list all files tracked by the repository. You can combine it with to find all the files that match some pattern, and then use to do some operation on all of them. grep xargs Text editor is a text editor that is a bit of a nerdy cliché, and my editor of choice. I switched to it after I got tired with an old computer that struggled to run Eclipse and other big integrated development environments (IDEs). vim Vim is fast, flexible, and offers great keyboard shortcuts. Even more: keyboard shortcuts are the only way to use it because it doesn’t support a mouse. The learning curve is a bit steep—at first it can be challenging to even close it. Long term, learning Vim can be a good investment. What makes it especially worthwhile is that the editor commands in Vim are very close to the commands that are used by and search patterns in . What you learn in one of those tools, you can immediately apply in the other tools as well. sed greps Clipboard Utilities Sometimes you would like to get the output of a command line program and just paste it in one of the applications in your graphical interface. All operating systems bring some utility that allows you to do exactly that: —utility that is available on macOS pbcopy —utility that you could install on Ubuntu xclip cat file-1.txt | pbcopy And now I can paste the file’s contents in the browser. Managing terminal sessions is a terminal multiplexer—a program that allows you to run multiple sessions inside one terminal emulator window. It allows you to keep different ‘windows’ for different uses. For example, I usually have: tmux one session for running Git commands, another with vim, where I edit code, and at least one session to run the development server Want to learn more? The command line is a great tool set that is often challenging at the beginning. On this blog, I sometimes try to explore such topics in a beginner-friendly way—to help new developers learn those tools so that they can become more efficient with their work. If you are interested in getting updates about my new CLI-related content, . sign up here Also Published Here

Basic Commands That Will Help You Get Started With Terminal

I get asked on every single video how I have autocomplete on my terminal, and the answer is... ! drum rolls... fig.io Actually, it's much more than a simple autocomplete, even if to be honest it's what I use 90% of the time. If you want to see a showcase of some of the major features, as usual, I recorded a video and you can find it on YouTube! https://youtu.be/HNVB9Dro2S4?embedable=true Still here? If you don’t want to watch the video, feel free to read the article instead! Autocomplete Let’s give a closer look at autocomplete. What you could expect from an autocomplete is to suggest you the next command while typing it. Or for example, getting the list of all the files in the current directory. Fig does much much more! When you start typing a command (for example ) you will see fig suggesting all the possible flags and options you can use, for example or . git checkout --force -b Enough? Not yet! You can also see on the recommendations all the available branches you can pass as arguments to the command! I mean, it's cool on an image, but you should really have a look at the video to see it in action! You will be surprised to notice that as soon as you start typing , you will see in the autocomplete some weird commands, like or . git cma lgo What are those? Well, they are the aliases I defined in my dotfiles, and fig is able to read them and suggest them to me! Artificial Intelligence The coolest feature right after autocomplete is… well, the name is self-explanatory… artificial intelligence. We’re in 2023, AI is everywhere, including our terminals. With fig, you can start typing to get some help. fig ai To begin with, let's start with a simple to get help. fig ai -h English -> Bash translation

Usage: fig ai [INPUT]...

Arguments:
  [INPUT]...

Options:
  -h, --help  Print help It's all there on the first line, it translates English to Bash. Just write in plain english what you want to do and fig will translate it to a bash command for you! Then you can either use it, edit it or ask the ai to generate a new command. Again, I think it doesn't give it justice just written as a blog post, you should really really watch the video or even better try it yourself. Custom scripts In a concept similar to alias, you can define some custom scripts and give them a name. When you type in your terminal, you will get a list of all the scripts you defined. fig run There's also a script store where you can find some scripts other people created and use them directly in your terminal. Plugins Similar to the scripts and the script store, you can find plugins aaaand a plugin store. With plugins, you can even further enhance your terminal experience. Dotfiles Fig helps you manage aliases, variables, paths, and more, all in one place. As you can see in the video I'm not really using this feature, but I think I should. It's one of those nice to have that you can easily live without, but once you discover them you start thinking why you haven't started using them earlier. Open Source Did I already mention that autocomplete is Open Source? You can contribute on GitHub. Plugins are open source too and you can add yours directly on the repo! Actually, feel free to go on the page and have a look at all the repos, there's a lot to discover. withfig Closing And that’s it! It wasn’t a paid sponsorship but I genuinely enjoy using fig’s autocomplete every day and since you asked many times I thought it was cool to make an entire piece of content about it. Do you also use fig and its other features? Let me know in the comments! Thanks for reading this article, I hope you found it interesting! Do you like my content? You might consider subscribing to my YouTube channel! It means a lot to me ❤️ You can find it here: @DevLeonardo

Stories, News & Mentions about TERMINAL

Terminal’s Stories on HackerNoon

Terminal's News & Mentions