Windows Terminal Tips, Tricks, and Productivity Hacks: Optimize your command-line usage and development processes with pro-level techniques

Okay, let's unpack this. Have you ever felt like your command line experience on Windows was well, a little behind the times, definitely like you were jumping through hoops just to copy text or you know, manage multiple tasks.

Uh huh, the old ways were limiting.

Today we're delving deep into something that changes all of that, the new Windows Terminal. Our mission for you, our listener, is to unlock a supercharged command line experience, making you a true power user.

Yeah.

We're drawing our insights from Wilfuqua's excellent book Windows Terminal Tips, Tricks and Productivity Hacks, and we've distilled some powerful insights that we think will genuinely transform your command line workflow.

What's truly fascinating here is how Microsoft has completely rethought this integral tool from the ground up.

Right, it feels totally different.

For years, the Windows command line experience felt like it lagged behind what was available on say Unix based system.

Yeah, malcos Linux they always seem to head exactly.

This exploration will not only reveal the incredible advancements, but also show you how to tailor them precisely to your workflow. It's about more than just a new window it's about efficiency, clarity, and truly making your command line work for you.

So let's start at the beginning. Then, before Windows Terminal, we had con host dot exe. Why did we even need a new terminal? What was so I guess limiting about the old way?

Well, the core issue with con host dot ex was its primary mission backward compatibility.

Oh okay.

It was designed to run basically every old command line application Windows had ever.

Seen, which sounds good in theory, right.

But it became a massive roadblock for innovation. Simple everyday tasks that users expected, like easily selecting and copying text were surprisingly difficult.

Oh I remember that pain multiple clicks exactly.

It felt clunky, and that commitment to never breaking older apps meant the user experience was kind of stuck in the past compared to modern terminals on mac os or Linux. And this is where a key distinction clarifies everything. Understanding the difference between a terminal and a shell.

Okay, yeah, break that down.

A terminal like Windows terminal is what you see. It's the display engine responsible for rendering text, drawing the interface, accepting your keyboard.

And mouse input, got it the window itself pretty much.

It then passes that input to the shell. The shell, on the other hand, is the actual command line program like PowerShell, CMD or Bash that interprets and executes your commands.

So PowerShell isn't the terminal, correct.

Windows Terminal is a brand new, modern terminal that hosts all your existing shells. So all your PowerShell knowledge, your get knowledge still completely valid and now honestly much more powerful within this new host.

That distinction makes perfect sense. So con host was trapped by its past, sacrificing user experience for backward compatibility. But when Microsoft finally decided to build a new what was the absolute first thing they prioritize in terms of user experience? What makes this new Windows terminal so much better? Right out of the box.

They really prioritized a modern, fast, and flexible foundation. It's built on modern Windows technologies, things like UWP, EXML islands.

Okay, techy stuff.

Yeah, but what it means for you is it leverages your system's full power, including GPU acceleration.

AH, using the graphics card.

Exactly for rendering text and effects. It results in a remarkably smooth, fast, and visually rich experience that was simply impossible with the old command prompts. But the immediate aha moment for many users I think comes from its organizational power. How so it brings built in tab support. Finally, Yes, you can finally manage multiple shells PowerShell, WSL, CMDSS, eighth sessions all within a single window. No more dozens of separate windows clutter in your taskbar.

Oh that alone is worth the price of admission, which is.

Freehu Exactly, a quick trol plus shift plus T opens a new tab, trol plus shift plus W closes one simple.

The tab support is a huge game changer for reducing clutter. I can't tell you how many times I've hunted for a specific command window. But you mentioned something even more powerful, pains.

Exactly beyond tabs, you also get terminal pains.

Okay, what does that mean?

Imagine a single tab becoming your entile development cockpit. You could be running a live build process in one pain, debugging in another, and maybe interacting with get in a third, all visible at once, all simultaneously visible and interactive. It's about eliminating that constant context switching, you know, freeing up

Oh nice.

Yeah, the shortcuts are alt plus shift plus minus for horizontal, alt plus shift plus equals for vertical. We can put those exact commands in the show notes.

Good idea, Okay, tabs pains what else? Visually?

Visually, there's also a significant upgrade. It introduced Cascadia code the font YEP, a programming font designed specifically for this. It supports optional programming, so characters like render as a cleaner single E glyph.

Oh that's pretty neat makes code look cleaner.

It does. And it supports power line glyphs, which are special characters that enhance the visual style of custom command line comps.

Like those fancy status bars I see people have.

Exactly turning a drab text line into an informative and frankly esthetically pleasing status bar with things like get status current directory stuff like that.

Okay, I'm sold on the features, But what about control customization? Ah?

For those who love control, The customization is incredibly flexible, uses the settings dot json file.

Jason, Okay, yeah.

With a documented structure This isn't just some random text file. It means editors like visual Studio Code give you first class editing with autocomplete and documentation built right in.

That makes editing way easier than guessing totally.

And the key insight here is that your configurations are easily version controlled. Put it in get and share across different machines, so you get a truly consistent personal environment everywhere.

And it's open source, right and critically, yes.

It's completely open source. You can see all the development happening on Microsoft's GitHub repository.

So you can see where it's going, maybe even contribute.

Absolutely, the team is incredibly active encouraging community contributions and maintaining transparent development, which fuels rapid innovation. It's a really vibrant project.

That transparency and community involvement are huge. So with all these fantastic capabilities, how do you actually get this powerhouse up and running efficiently?

The easiest and most recommended way directly from the Microsoft Store. Just search for it, YEP, search Windows terminal click get. That's it. This also ensures that stays automatically.

Updated, which is nice, okay, easy enough.

Once installed, you launch it like any other app. From the start menu, but for more efficiency, it ships with the command WT dot.

Ex ah WT.

Right, you can simply type wt in the run dialogue or even the Windows Explorer address bar, hit enter and boom it launches.

Andy.

You can even add command line flags like wtdshf to launch directly into full screen mode.

Okay, full screen Terminal, I like it.

Yeah, lots of little tricks like that.

Here's where it gets really interesting for customizing your digital workspace. I think, with all these powerful features, how do we make Windows Terminal truly ours? It all starts with that settings dot json file.

Right, Absolutely, that settings adjacent file is truly the cornerstone of configurability.

Cornerstone Okay.

As we discussed, it offers incredible power for deep customization, makes it easy to version control your settings with git or something, and allows for seamless sharing.

How do you open it quickly?

You can quickly open it by pressing tree, troll plus shift plus aid directly from within Windows Terminal.

Creed, roll plus shift plus comma, got it?

And Yeah. Using Visual Studio code for editing provides a superior experience, whether it's built in autocomplete and documentation really helps avoid typos. The file itself is logically structured, which is helpful. You'll find global settings that apply to the entire terminal overall behavior exactly. Then profile settings for individual shells, so PowerShell can look different from your Wslobuntu shell for.

Instance, ah Per shell settings nice YEP.

Also color scheme settings for its appearance, and keyboard shortcut settings for all your custom hot keys.

So for someone just diving into settings dot json, what are some global settings that can immediately enhance their workflow? Any quick wins?

Definitely a few make a big difference right away.

Copy on select, copy on select What's that?

When set to true, it automatically copies any text you highlight with your mouse straight to the clipboard, no need to write, click or press quockol plus.

C oh copy on select. Yes, I can't tell you how many times I've fumbled with compleplus c in the old con host only to find I'd selected the wrong thing or missed it. It's a small thing, but yeah, it's a huge quality of life upgrade. Seriously, it absolutely is.

Then there's start on user login din'd it start up YEP, which can lunch the terminal automatically when you log into Windows great if it's your daily driver.

Makes sense.

Default profile lets you choose which shell opens by default when you hit the new tab button, or just launch the terminal so.

I can make it powersholl Core instead of old cmd exactly.

You can also set tab visibility to hide the tab strip if you only have one tab open. Gives you a bit more screen real estate.

Oh I like that minimal.

And theme of course to switch between light dark, or just follow your systems theme automatically.

Okay, those are great practical tweaks. Beyond behavior, how can we make it visually stunning and you know, truly reflective of our personal style?

Yeah, esthetics matter. That's where color schemes come in. Windows Terminal includes popular built in schemes like Solarized and Tango. Pretty good starting.

Points, so you can add more.

Oh yeah, the community has created a wealth of options. You can explore websites like Windows Terminal Themes dot dev. Just copy paste the.

Jason ah easy to find new ones.

Or for full control, you can define your own color schemes right in the JSON, mapping standard A and SI color names like bright black or cyan to specific rgb X values.

Total control. Nice.

You can also personalize it deeply with background images. Put your logo, your cat, whatever you want behind the.

Text background images in a terminal okay.

And adjust the translucency of the window using usacrylic and acrylic capacity. Is it that slightly see through modern.

Look acrylic like the Windows fluent design thing?

Exactly? Yeah, and a neat visual trick here. Once a crylic is enabled, you can temporarily adjust the translucency on the fly. Hold crill it plus alt plus shift and scroll your mouse wheel.

Oh, temporary adjustment, that's cool, Yeah.

Just for that session. For more experimental visual effect, you can even play around with pixel shaders, but that's getting pretty advanced.

Okay, maybe I'll stick with background images for now. And for the keyboard wizards among us, the folks who live by shortcuts, what kind of raw power can we unlock with custom shortcuts?

Right the action section in Settings dot Jason. This used to be called key bindings, now it's actions. This is where you define custom keyboard.

Shortcuts, so mapping keys to actions.

Pretty much, each shortcut maps a command which can be a simple string for built in actions or a more complex object for actions with parameters, to a keys property so critical plus shift plus something does this action well.

Kind of actions all.

Sorts, closing tabs, splitting pains, changing font size. But one of the most powerful is send input.

Send input like typing for me exactly.

This allows you to send arbitrary keyboard input directly to the active terminal shell, essentially automating typing.

Give me an example. How's that useful?

Okay, say you constantly navigate to your main project's directory. You could bind maybe c trel plus al plus P to instantly type CD projects followed by an enter key.

Whoa so one key combo jumps me to my fold well.

Warp speed directory navigation. It's about automating those repetitive finger movements. You can even send ANSI escape sequences for things like arrow keys.

Okay, send input sounds incredibly powerful for automation.

What else, There's the WT eight action. This is fantastic for launching pre configured tab and pain.

Layouts, wait launching layouts of the shortcut.

Yeah. Imagine launching an entire project workspace, maybe your code editor like vim in one pain, a live build process like dot netwatch run, and another, all with a single custom command you've defined in your setting start Jason.

That's huge. One shortcut sets up my whole dev environment in terminal exactly.

And this wtgidxc blindary we mentioned earlier. You can use it from outside the terminal too, crease start menu shortcuts or batch files that launch these highly customized complex layouts instantly. We can put some example syntax in the show notes because it gets a bit involved.

Please do that sounds amazing. So okay, we've seen how to make Windows Terminal look and behave exactly how we want. It's truly ours, right But for many of us, the command line isn't just a Windows thing anymore. We live in a multious world, rightly, What about those Linux command line tools we love right here on Windows. Many people

WSL two is a genuine game changer, largely because it finally provides a fast, fully compatible Linux environment directly.

On Windows, faster than WSL one, much.

Faster for filesystem operations, yeah yeah, and more compatible. It solves so many dependency headaches, especially for developers using popular web frameworks or tools designed for Linux.

How does it work? Is it like a VM sort of?

Unlike its predecessor, WSL two runs a real Linux kernel on a lightweight hyper V virtualization.

Layer a real kernel, which.

Results in vastly improved performance and compatibility. It truly feels like Rhyando Lenox natively just inside Windows. And what's truly revolutionary, I think, is the seamless bidirectional access between Windows and Linux. Bidirectional meaning you can easily access your Linux distributions files from Windows. Just navigate to a UNC path like inf open two in File Explorer. Your Linux home directory is right.

There, oh, directly in file Explore. No special tools, nope.

And conversely, your Windows drives like your c drive are automatically mounted directly under m NTC within your Linux environment, so you can c D m n TC users your name, and access Windows files from your Linux shell.

Okay, that's seamless, files are easy. What about running things even better?

You can run Linux programs directly from Windows PowerShell or CMD using WSL dot ex Linux command like wsls ls L runs the Linux ls command. Okay, and maybe even more surprisingly you can run Windows programs from your Linux shell.

Wait, run dot ex files from Bash or z sh yep.

Imagine you're in your WSL terminal. You type notepad dot exc my linux canfig dot txt, It opens that Linux file and Windows notepad no way. Or type explorer dot ex that's explore dot xe space dot and it launches Windows file Explorer right in your current Linux directory.

Mind blown. That level of integration is incredible. Okay, but it's not just about running Linux. It's about making those shells, both Linux and powershells sing with customization and power tools exactly.

Let's start with PowerShell. For PowerShell users. Oh my posh is a fantastic tool. You've probably seen screenshots.

Those really cool looking prompts.

That's the one. It transforms basic prompts into informative, stylish ones. It can show critical details like your current Git branch status, shortened paths so they don't wrap air indicators if the last command failed. All enhanced by using a font like Cascade codepl that has the necessary gliss.

So it makes your prompt work harder for you.

Basically, precisely, and beyond external tools like that, you can actually define your own custom prompt functions right in your PowerShell profile.

Script writing your own prompt.

Yeah. This lets you inject things like ANSI, escape sequences for custom colors, or maybe even add emojis directly into your prout for a unique Flare.

Rocket ship emoji when in my project's folder.

Why not if that works for you. Psrid line is another essential PowerShell module. It's usually included now, but it greatly enhances command line editing.

How does it enhance it?

Its history search is incredibly powerful. Just type part of a command you ran before, say G, then press the up arrow and it intelligently filters your command history. Makes finding that get status command from yesterday way faster.

That's better than just scrolling up endlessly.

Way better. Oh. It also offers command predictions, which appear as feint tech suggestions in your prompt. Guessing what you might type next base on your history. Just hit the right arrow to accept really speeds up your input.

Predictive text for the command line.

Kind of yeah. And for those who love the classic Unix tools, you can bring genu cordals like ales grabs, food oc to PowerShell. They often get installed as part of GIT for Windows.

So I can use l's in PowerShell.

You can't. There's also the z utility, which is amazing. It provides warp speed directory navigation met It learns which directories you a visit frequently or a freesency frequency plus recency. Then you can just type Z and it might jump you straight to see users, your documents, projects if that's where you go. Often jump to common directories with just a few key strokes.

Okay, z sounds essential. Now moving over to WSL two. Maybe using zsh instead of Bash.

Yeah. Zsh is a fantastic, highly configurable alternative to Bash. It's actually the default shell on macOS now and oh my zish builds on this with a massive community ecosystem of themes and plugins.

Z plus oh my zish is the combo.

It's a very popular and powerful combo. Yeah for rerunning commands, and zsh HL plus r provides an interactive history search that's incredibly efficient, similar to PS redlines. Zsh also offers powerful history substitutions, which are brilliant shortcuts. Look what things like zeer, which treat is the last argument of the previous command repeats your entire previous command.

Ah, I've heard of that useful.

For incredibly useful. When you forget to type pseudo first run a command, it fails with permission denied. You just type pseudo and hit enter. Done.

Okay, Pseudo is going in my muscle memory.

It's a life saver. Yeah. You can also set up custom aliases and functions in zsh, just like in PowerShell, to automate repetitive.

Tasks like shortcuts for long commands.

Exactly or recreating powershells I alias invoke item to open files with their default Windows application using PowerShell dot ex, or to find a complex work function that maybe changes directory, opens vs code and fetches GIT updates, all with a single work command.

Automating workflows nice for.

Quick directory navigation, and z auto seeds is an option where you can just type the directory name to CD into it if it exists. Using hyphen instantly toggles you between your last two directories.

Oh jump back and forth, handy.

Very and finally oh my. Switech plugins add even more power. There's zz plug in, bringing that freqency based directory jumping we talked about to.

Z okay z everywhere.

There's zush Auto Suggestions, which gives you those faint text suggestions as you type, like PS redline and syntax highlighting gives you vision feedback coloring commands green if they look valid, red if not before you hit enter.

Wow, that prevents typos too, exactly.

These collectively make your Linux terminal experience within Windows Terminal much smarter and faster.

Now, let's talk about taking all this customizability and power and integrating it with the tools developers use every single day. Get, GitHub, remote systems, even the cloud, all from Windows Terminal. This feels like where you become a true command line powerhouse.

Absolutely, this is where it all comes together for Get and GitHub. A modern setup often involves using SSH authentication.

Instead of HTTPS passwords or tokens.

Yeah, because sshkeys provide a more streamlined workflow that's consistent across Windows, WSL two and even macOS. If you use that too, no more password prompts.

Okay, how do you set that up on Windows?

It means installing the built in open ssh client on Windows ten eleven. It's usually there or easy to add via optional features. Then you can figure the slish agent service to run automatically. The agent handles the keys, hold your decrypted private key in memory securely, so you don't have to re enter your passphrase constantly. You'll generate modern public private key pairs EED two five nine time is recommended.

Now share the public key, keep the private key secret.

Exactly, upload the public key to services like get up, get lab, et cetera. Keep the private key safe. Test with keysst get at getub dot com. Forget on Linux WSL two, managing SSH keys gets interesting. You have options copy your Windows keys into WSL, or maybe share them via a symbolic link from MNPC and set permissions correctly. Then use a tool like keychain to manage your lucheche agent sessions within WSL to itself a.

Bit fiddly, but doable for seamless SSH everywhere.

It is and some seemingly small Get usage tips can actually dramatically reduce friction and cognitive load day to.

Day, Like what Little Things Matter, Get check.

Out dash switches you to the previous branch.

You're on, oh instead of remembering the name exactly.

It's a mental release, keeps you in the flow. Get config globalhelp dot Com. Autocorrect twenty tells get to wait two seconds twenty tens of a second, and automatically fix simple command typos like get stats because get status as.

Time correcting mistakes.

Love it and get push origin head lets you push your current branch to its remote counterpart without typing the branch name again.

Hand you when working on feature branches.

Together, these little things create a much more frictionless Git experience. You can also define powerful get aliases in your dot Git canfig like get s, for get.

Status, short and common commands, or.

Even create command aliases that run shell commands, like a quick get checkpoint alias that stages all changes and commits them with a generic message.

Quick save point yep, and don't forget.

Tools like tig. It's a fantastic text mode curses based Git browser for inspecting commits, branches, blame statues right in your terminal. Very powerful.

Okay, TIG, I'll check that out. What about interacting with GitHub itself.

That's where the get hub cligh comes in.

Brilliant The disk command yeah, or g off log in.

You can do things like GA repo create, which creates the repo locally and on GitHub dot com in one step.

Oh nice.

You can ghpr list to see poll requests, ghpr checkout pr id to instantly check out the code for a specific pull request. It really simplifies those common GitHub interactions. Now connecting to remote systems beyond get hosts, maybe actual servers.

Yeah, ssshing into servers, you'll.

Typically choose between win RM, which is more common in corporate Windows environments, or SSH, which is much more flexible and works for both Windows servers and Linux servers.

Ssh seems more universal generally.

Yeah. To set up an SSH server on Windows itself, you install it via optional features. You can even change the default shell. Users get from CMD to PowerShell core via a registry.

Key, so I can SSH into Windows and get.

PowerShell you can, and public key authentication is key here too, using an authorized keys file, just like on Linux. For secure passwordless access.

Okay, Standard SSH practice.

SEP Secure copy part call which comes with SSH is your friend for copying files between your local machine and remote servers or vice versa at cplocalfile dot txt, user at server dot remote path CLASSICCP. And to make managing lots of connections easier, use your touch canfig file.

The SSH canfig file.

Yeah, centralize all your connection details there. To find a host nickname like host home, it's that the host name, the user, maybe even a remote command to run automatically on connection. Then you just type spoosh home.

Much easier than remembering ips and usernames.

Definitely. Finally, you can integrate these SSH connections directly into Windows Terminal, add custom profiles to your settings dot Jason file that just runs swish home or swoosh work server. Then that connection is just a click away in the new tab dropdown menu, or bind it to.

A shortcut seamless SSH access from the terminal menu. Love it, okay? Last, Big Area cloud Management Azure AWSGCP. Can we manage those from Windows Terminal too?

Absolutely, It's a huge use case for Microsoft Azure. The integration is obviously fair tight. Azure cloud Shell often shows up as an autocreative profile right and Windows Terminals.

Drop down cloudsll profile. What is that?

It connects you to a terminal environment, essentially a Linux container running an Azure It comes preloaded with all the Azure Cli tools as age, terraform, quebec, dole, lots of def tools. Your files can persist in linked Azure storage, so.

Are ready to go Azure environments.

Exactly and inside that or even locally. If you install the Azure Cli. The as interactive command is amazing. It drops you to a special shell with smart autocompletion for commands and parameters, inline documentation, and even.

Examples interactive mode for as.

Plus it helps you learn Jan's path. That's a powerful query language for filtering and reshaping the Jason output you get back from cloud APIs. As interactive lets you easily test james path queries.

Filter that huge JSON blob down to what I need. Okay, what about Google Cloud?

For Google Cloud, you'll typically use WSL two to run the g Cloud STK. It works best in a Linux environment. You run g Cloud in it.

To link your accounts standard setup.

Then you can use g cloud Beta cloudshell shosh authorized session to launch a connection to your Google cloudshell VM similar concept to azures and g Cloud Beta Interactive gives you a similar interactive shell with autocompletion and docks for g Cloud commands.

So interactive shells are common AWS.

For Amazon Web Services AWS, again, WSL two is often your best bet. For the standard AWSCLI, there's a tool called osshell ohshell Yeah. It's a Python based command line shell specifically for AWS. It provides autocompletion, command history, and also supports jme's path filtering via the core flag. It even lets you run local Shell commands using dot cmd.

Nice any PowerShell options for AWS?

Yes, alternatively, there are the AWS tools for PowerShell. These are native PowerShell modules that provide cmdal that's mapping directly to the AWSAPI. So if you prefer a PowerShell centric workflow from editing AWS, that's a great option too.

Okay, tons of power there for cloud management right from the terminal. So what does this all mean for you, our listener? From transforming a basic, clunky command prompt into this multi tab, pain filled powerhouse.

Yeah, it's a huge leap.

To seamlessly running Linux apps side by side with Windows tools, automating get workflows, managing complex cloud infrastructure. We've seen how Windows Terminal isn't just a window anymore. It's really your central hub for productivity. It's about being informed, being efficient, and truly mastering your digital workspace, all from the command line.

And this raises an important question. I think, now that you've seen the sheer breadth of what's possible that tabs, the pains, the shells, the customization, the integrations, what other tools or workflows could you imagine integrating into your customized Windows Terminal experience? How could you make your daily work even more fluid with.

This good question to ponder, Keep exploring, keep customizing, and keep uncovering those deep insights. We hope this journey has given you a solid headstart on becoming a Windows terminal pro. Next time,