Convert Figma logo to code with AI

microsoft logoterminal

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

94,862
8,215
94,862
1,537
View on GitHub

Top Related Projects

alacritty's avatar

alacritty

55,502

A cross-platform, OpenGL terminal emulator.

gnome-terminator's avatar

terminator

2,074

multiple GNOME terminals in one window

kovidgoyal's avatar

kitty

23,729

Cross-platform, fast, feature-rich, GPU based terminal

wez's avatar

wezterm

16,583

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

vercel's avatar

hyper

43,192

A terminal built on web technologies

Quick Overview

The Microsoft Terminal is a modern, powerful, and customizable terminal application for Windows. It provides a unified experience for users to access various command-line tools, including PowerShell, Command Prompt, and Windows Subsystem for Linux (WSL), all within a single window.

Pros

  • Customizable: The Terminal offers a wide range of customization options, allowing users to personalize the appearance, behavior, and keyboard shortcuts to suit their preferences.
  • Integrated Shells: The Terminal supports multiple command-line interfaces, including PowerShell, Command Prompt, and WSL, making it a versatile tool for developers and power users.
  • Performance: The Terminal is designed to be fast and responsive, providing a smooth and efficient user experience.
  • Cross-Platform Compatibility: The Terminal is compatible with various Windows versions, ensuring a consistent experience across different systems.

Cons

  • Learning Curve: The Terminal's extensive customization options and integration with multiple shells may present a steeper learning curve for some users, especially those new to the command-line environment.
  • Compatibility Issues: While the Terminal is designed to work with a wide range of Windows versions, there may be occasional compatibility issues or bugs that require troubleshooting.
  • Limited Third-Party Integration: The Terminal's focus on providing a unified experience may limit its integration with some third-party tools or applications that users may rely on.
  • Resource Consumption: The Terminal's advanced features and functionality may result in higher resource consumption, which could be a concern for users with older or less powerful hardware.

Getting Started

To get started with the Microsoft Terminal, follow these steps:

  1. Download the latest version of the Microsoft Terminal from the official GitHub repository: https://github.com/microsoft/terminal.
  2. Install the Terminal by running the provided installer.
  3. Launch the Terminal and explore the various settings and customization options available in the settings menu.
  4. Familiarize yourself with the different command-line interfaces (PowerShell, Command Prompt, WSL) and switch between them as needed.
  5. Customize the Terminal's appearance, behavior, and keyboard shortcuts to suit your preferences.
  6. Explore the Terminal's advanced features, such as tabs, panes, and profiles, to enhance your productivity.
  7. Stay up-to-date with the latest Terminal updates and features by regularly checking the GitHub repository or the official Microsoft documentation.

Competitor Comparisons

alacritty logo

alacritty

55,502

A cross-platform, OpenGL terminal emulator.

Pros of Alacritty

  • Cross-platform support (Linux, macOS, Windows)
  • GPU-accelerated rendering for improved performance
  • Minimal, customizable configuration via YAML file

Cons of Alacritty

  • Limited built-in features compared to Terminal
  • Steeper learning curve for configuration
  • Less integration with Windows-specific features

Code Comparison

Alacritty configuration (YAML):

window:
  dimensions:
    columns: 80
    lines: 24
  padding:
    x: 2
    y: 2

Terminal configuration (JSON):

{
  "profiles": {
    "defaults": {
      "colorScheme": "Campbell",
      "fontFace": "Cascadia Code",
      "fontSize": 12
    }
  }
}

Key Differences

  • Alacritty focuses on performance and minimalism, while Terminal offers a more feature-rich experience
  • Terminal provides better integration with Windows ecosystem and PowerShell
  • Alacritty's configuration is YAML-based, whereas Terminal uses JSON
  • Terminal offers a GUI for customization, while Alacritty relies on text-based configuration
  • Alacritty has a smaller footprint and faster startup time compared to Terminal

Both projects aim to provide modern terminal experiences, but with different priorities and target audiences. Alacritty is ideal for users seeking performance and cross-platform consistency, while Terminal caters to Windows users looking for a more integrated and feature-rich solution.

gnome-terminator logo

terminator

2,074

multiple GNOME terminals in one window

Pros of Terminator

  • Cross-platform compatibility (Linux, BSD, macOS)
  • Highly customizable layout with split-pane functionality
  • Supports plugins for extended functionality

Cons of Terminator

  • Less modern UI compared to Terminal
  • Slower development pace and fewer recent updates
  • Limited integration with Windows-specific features

Code Comparison

Terminal (PowerShell):

$PSVersionTable.PSVersion
Get-Process | Where-Object { $_.CPU -gt 10 } | Sort-Object CPU -Descending

Terminator (Bash):

echo $BASH_VERSION
ps aux | awk '$3 > 10.0' | sort -k3 -r

Key Differences

  • Terminal focuses on Windows integration and modern UI
  • Terminator emphasizes multi-pane layouts and cross-platform use
  • Terminal has more active development and frequent updates
  • Terminator offers greater customization options for Linux users

User Base

  • Terminal: Primarily Windows users, developers, and IT professionals
  • Terminator: Linux and Unix users, system administrators, and developers working in multi-window environments

Performance

  • Terminal: Generally faster and more responsive on Windows systems
  • Terminator: Efficient on Linux, but may have performance issues on other platforms

Integration

  • Terminal: Deep integration with Windows and PowerShell
  • Terminator: Better integration with Linux desktop environments, especially GNOME
kovidgoyal logo

kitty

23,729

Cross-platform, fast, feature-rich, GPU based terminal

Pros of Kitty

  • Cross-platform support (Linux, macOS, BSD)
  • GPU-accelerated rendering for improved performance
  • Extensive customization options and scripting capabilities

Cons of Kitty

  • Steeper learning curve for configuration
  • Less integrated with Windows ecosystem
  • Smaller user base and community compared to Terminal

Code Comparison

Terminal (PowerShell):

$PSVersionTable.PSVersion
Get-Process | Where-Object { $_.CPU -gt 10 } | Sort-Object CPU -Descending

Kitty (Bash):

echo $BASH_VERSION
ps aux | awk '$3 > 10' | sort -k3 -rn

Summary

Kitty offers cross-platform support and GPU acceleration, making it a powerful choice for Linux and macOS users. It provides extensive customization options but may have a steeper learning curve. Terminal, on the other hand, is deeply integrated with the Windows ecosystem and has a larger user base. Both terminals support scripting, but their syntax and capabilities differ based on the underlying shell and operating system.

wez logo

wezterm

16,583

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

Pros of WezTerm

  • Cross-platform support (Windows, macOS, Linux)
  • GPU-accelerated rendering for improved performance
  • Extensive configuration options via Lua scripting

Cons of WezTerm

  • Smaller community and less documentation compared to Terminal
  • Steeper learning curve for advanced customization
  • Less integration with Windows-specific features

Code Comparison

WezTerm configuration (Lua):

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

Terminal configuration (JSON):

{
  "profiles": {
    "defaults": {
      "fontFace": "Cascadia Code",
      "colorScheme": "One Half Dark"
    }
  }
}

Key Differences

  • WezTerm uses Lua for configuration, while Terminal uses JSON
  • WezTerm offers more granular control over appearance and behavior
  • Terminal provides better integration with Windows and PowerShell

Community and Development

  • Terminal has a larger user base and more frequent updates
  • WezTerm has a smaller but dedicated community
  • Both projects are open-source and actively maintained

Performance

  • WezTerm generally offers better performance due to GPU acceleration
  • Terminal has improved performance in recent updates, narrowing the gap

Customization

  • WezTerm provides more extensive customization options through Lua scripting
  • Terminal offers a user-friendly settings UI for basic customization
vercel logo

hyper

43,192

A terminal built on web technologies

Pros of Hyper

  • Cross-platform compatibility (Windows, macOS, Linux)
  • Extensible through plugins and themes
  • Built with web technologies, making it easier for web developers to customize

Cons of Hyper

  • Generally slower performance compared to native terminals
  • Higher memory usage
  • Limited built-in features without plugins

Code Comparison

Terminal (PowerShell):

$PSVersionTable.PSVersion
Get-ChildItem -Path C:\ -Recurse

Hyper (JavaScript):

const { exec } = require('child_process');
exec('powershell -Command "$PSVersionTable.PSVersion"', (err, stdout, stderr) => {
  console.log(stdout);
});

Key Differences

  • Terminal is a native Windows application, while Hyper is Electron-based
  • Terminal offers better integration with Windows features
  • Hyper provides a more modern, customizable interface
  • Terminal has better performance for intensive tasks
  • Hyper allows for easier cross-platform development

Use Cases

Terminal is better suited for:

  • Windows power users and administrators
  • Performance-critical scenarios
  • Deep integration with Windows systems

Hyper is ideal for:

  • Web developers who prefer familiar technologies
  • Users who prioritize customization and cross-platform consistency
  • Those who frequently switch between operating systems

Convert Figma logo designs to code with AI

Visual Copilot

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

Try Visual Copilot

README

terminal-logos

Terminal Build Status

Welcome to the Windows Terminal, Console and Command-Line repo

This repository contains the source code for:

Related repositories include:

Installing and running Windows Terminal

[!NOTE] Windows Terminal requires Windows 10 2004 (build 19041) or later

Microsoft Store [Recommended]

Install the Windows Terminal from the Microsoft Store. This allows you to always be on the latest version when we release new builds with automatic upgrades.

This is our preferred method.

Other install methods

Via GitHub

For users who are unable to install Windows Terminal from the Microsoft Store, released builds can be manually downloaded from this repository's Releases page.

Download the Microsoft.WindowsTerminal_<versionNumber>.msixbundle file from the Assets section. To install the app, you can simply double-click on the .msixbundle file, and the app installer should automatically run. If that fails for any reason, you can try the following command at a PowerShell prompt:

# NOTE: If you are using PowerShell 7+, please run
# Import-Module Appx -UseWindowsPowerShell
# before using Add-AppxPackage.

Add-AppxPackage Microsoft.WindowsTerminal_<versionNumber>.msixbundle

[!NOTE] If you install Terminal manually:

  • You may need to install the VC++ v14 Desktop Framework Package. This should only be necessary on older builds of Windows 10 and only if you get an error about missing framework packages.
  • Terminal will not auto-update when new builds are released so you will need to regularly install the latest Terminal release to receive all the latest fixes and improvements!

Via Windows Package Manager CLI (aka winget)

winget users can download and install the latest Terminal release by installing the Microsoft.WindowsTerminal package:

winget install --id Microsoft.WindowsTerminal -e

[!NOTE] Dependency support is available in WinGet version 1.6.2631 or later. To install the Terminal stable release 1.18 or later, please make sure you have the updated version of the WinGet client.

Via Chocolatey (unofficial)

Chocolatey users can download and install the latest Terminal release by installing the microsoft-windows-terminal package:

choco install microsoft-windows-terminal

To upgrade Windows Terminal using Chocolatey, run the following:

choco upgrade microsoft-windows-terminal

If you have any issues when installing/upgrading the package please go to the Windows Terminal package page and follow the Chocolatey triage process

Via Scoop (unofficial)

Scoop users can download and install the latest Terminal release by installing the windows-terminal package:

scoop bucket add extras
scoop install windows-terminal

To update Windows Terminal using Scoop, run the following:

scoop update windows-terminal

If you have any issues when installing/updating the package, please search for or report the same on the issues page of Scoop Extras bucket repository.

Installing Windows Terminal Canary

Windows Terminal Canary is a nightly build of Windows Terminal. This build has the latest code from our main branch, giving you an opportunity to try features before they make it to Windows Terminal Preview.

Windows Terminal Canary is our least stable offering, so you may discover bugs before we have had a chance to find them.

Windows Terminal Canary is available as an App Installer distribution and a Portable ZIP distribution.

The App Installer distribution supports automatic updates. Due to platform limitations, this installer only works on Windows 11.

The Portable ZIP distribution is a portable application. It will not automatically update and will not automatically check for updates. This portable ZIP distribution works on Windows 10 (19041+) and Windows 11.

DistributionArchitectureLink
App Installerx64, arm64, x86download
Portable ZIPx64download
Portable ZIPARM64download
Portable ZIPx86download

Learn more about the types of Windows Terminal distributions.

Windows Terminal Roadmap

The plan for the Windows Terminal is described here and will be updated as the project proceeds.

Terminal & Console Overview

Please take a few minutes to review the overview below before diving into the code:

Windows Terminal

Windows Terminal is a new, modern, feature-rich, productive terminal application for command-line users. It includes many of the features most frequently requested by the Windows command-line community including support for tabs, rich text, globalization, configurability, theming & styling, and more.

The Terminal will also need to meet our goals and measures to ensure it remains fast and efficient, and doesn't consume vast amounts of memory or power.

The Windows Console Host

The Windows Console host, conhost.exe, is Windows' original command-line user experience. It also hosts Windows' command-line infrastructure and the Windows Console API server, input engine, rendering engine, user preferences, etc. The console host code in this repository is the actual source from which the conhost.exe in Windows itself is built.

Since taking ownership of the Windows command-line in 2014, the team added several new features to the Console, including background transparency, line-based selection, support for ANSI / Virtual Terminal sequences, 24-bit color, a Pseudoconsole ("ConPTY"), and more.

However, because Windows Console's primary goal is to maintain backward compatibility, we have been unable to add many of the features the community (and the team) have been wanting for the last several years including tabs, unicode text, and emoji.

These limitations led us to create the new Windows Terminal.

You can read more about the evolution of the command-line in general, and the Windows command-line specifically in this accompanying series of blog posts on the Command-Line team's blog.

Shared Components

While overhauling Windows Console, we modernized its codebase considerably, cleanly separating logical entities into modules and classes, introduced some key extensibility points, replaced several old, home-grown collections and containers with safer, more efficient STL containers, and made the code simpler and safer by using Microsoft's Windows Implementation Libraries - WIL.

This overhaul resulted in several of Console's key components being available for re-use in any terminal implementation on Windows. These components include a new DirectWrite-based text layout and rendering engine, a text buffer capable of storing both UTF-16 and UTF-8, a VT parser/emitter, and more.

Creating the new Windows Terminal

When we started planning the new Windows Terminal application, we explored and evaluated several approaches and technology stacks. We ultimately decided that our goals would be best met by continuing our investment in our C++ codebase, which would allow us to reuse several of the aforementioned modernized components in both the existing Console and the new Terminal. Further, we realized that this would allow us to build much of the Terminal's core itself as a reusable UI control that others can incorporate into their own applications.

The result of this work is contained within this repo and delivered as the Windows Terminal application you can download from the Microsoft Store, or directly from this repo's releases.

Resources

For more information about Windows Terminal, you may find some of these resources useful and interesting:

FAQ

I built and ran the new Terminal, but it looks just like the old console

Cause: You're launching the incorrect solution in Visual Studio.

Solution: Make sure you're building & deploying the CascadiaPackage project in Visual Studio.

[!NOTE] OpenConsole.exe is just a locally-built conhost.exe, the classic Windows Console that hosts Windows' command-line infrastructure. OpenConsole is used by Windows Terminal to connect to and communicate with command-line applications (via ConPty).

Documentation

All project documentation is located at aka.ms/terminal-docs. If you would like to contribute to the documentation, please submit a pull request on the Windows Terminal Documentation repo.

Contributing

We are excited to work alongside you, our amazing community, to build and enhance Windows Terminal!

BEFORE you start work on a feature/fix, please read & follow our Contributor's Guide to help avoid any wasted or duplicate effort.

Communicating with the Team

The easiest way to communicate with the team is via GitHub issues.

Please file new issues, feature requests and suggestions, but DO search for similar open/closed preexisting issues before creating a new issue.

If you would like to ask a question that you feel doesn't warrant an issue (yet), please reach out to us via Twitter:

Developer Guidance

Prerequisites

Building the Code

This repository uses git submodules for some of its dependencies. To make sure submodules are restored or updated, be sure to run the following prior to building:

git submodule update --init --recursive

OpenConsole.sln may be built from within Visual Studio or from the command-line using a set of convenience scripts & tools in the /tools directory:

Building in PowerShell

Import-Module .\tools\OpenConsole.psm1
Set-MsBuildDevEnvironment
Invoke-OpenConsoleBuild

Building in Cmd

.\tools\razzle.cmd
bcz

Running & Debugging

To debug the Windows Terminal in VS, right click on CascadiaPackage (in the Solution Explorer) and go to properties. In the Debug menu, change "Application process" and "Background task process" to "Native Only".

You should then be able to build & debug the Terminal project by hitting F5. Make sure to select either the "x64" or the "x86" platform - the Terminal doesn't build for "Any Cpu" (because the Terminal is a C++ application, not a C# one).

👉 You will not be able to launch the Terminal directly by running the WindowsTerminal.exe. For more details on why, see #926, #4043

Coding Guidance

Please review these brief docs below about our coding practices.

👉 If you find something missing from these docs, feel free to contribute to any of our documentation files anywhere in the repository (or write some new ones!)

This is a work in progress as we learn what we'll need to provide people in order to be effective contributors to our project.

Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.