Comparing Take Command v37 and Windows Terminal
Comparing Take Command and Windows Terminal
Windows Terminal is Microsoft's terminal host for shells and command-line programs. Take Command is a commercial command-line environment: it includes a tabbed terminal interface, the TCC command processor, a batch file IDE and debugger, and other integrated tools. Both can host multiple command-line applications.
This article compares Take Command v37 with Windows Terminal's publicly documented features as of November 2026. Windows Terminal features can also vary by version, operating system, and Stable versus Preview build.
The important distinction: A terminal displays a session and handles input; a shell interprets commands. TCC, PowerShell, CMD, and bash are shells, and all can be hosted by Take Command or Windows Terminal.
Features at a glance
The table compares the more significant built-in capabilities. (Take Command has many smaller features that didn't make the list.)
| Feature | Take Command v37 | Windows Terminal |
|---|---|---|
| Product and licensing | Commercial suite with a terminal, TCC, and related tools. 30-day fully functional trial; check JP Software for current licensing terms. | Free, open-source terminal host; available through the Microsoft Store and other distribution methods. |
| Included shell | Includes TCC, a CMD-compatible command processor with extensive additional commands and scripting features. can also host shells such as PowerShell, CMD, and WSL shells. | Does not supply a separate command language; hosts installed shells such as PowerShell, CMD, WSL shells, and TCC. |
| Tabs and panes | Tabbed sessions, independent horizontally or vertically split terminal panes, and horizontal or vertical groups of document tabs. | Tabbed sessions and horizontally or vertically split panes within tabs. |
| Profiles | Local, SSH, serial, WSL, Docker, and Podman profile types. | Local and WSL |
| SSH | Dedicated SSH connections and profiles using OpenSSH, with options such as a jump host and port forwarding. | No |
| Serial devices | Built-in serial terminal sessions and reusable COM-port profiles. | No |
| WSL and containers | Open an installed WSL distribution or an already-running local Docker or Podman container from a profile. | Installed WSL distributions |
| Shell integration | Recognizes shell markers for features such as prompt navigation, status marks, command folding, and result cards when integration is available. | Supports limited shell-integration features with appropriately configured shells. Exact functionality depends on the shell and Windows Terminal version. |
| Command result cards | Command headers can show status and duration and remain visible while scrolling; folding and output actions are available when shell integration and folding are enabled. | No |
| Scrollback and search | Search, regular-expression match export, annotations, bookmarks, and an optional semantic scrollback overview. | Searchable scrollback and prompt navigation. |
| Recording and replay | Terminal recording and in-app, read-only replay of asciicast recordings. | No |
| Triggers and highlights | Terminal regular-expression triggers and separate output highlight rules can draw attention to matching output. | No |
| Embedded graphics | ReGIS vector graphics, Kitty, iTerm2, and SIXEL images. Can display PNG, JPEG, BMP, GIF, TIFF, and WebP images in a terminal window. | SIXEL images with compatible shell |
| Desktop notifications | Display Windows desktop toast notifications when a shell sends an OSC 9 or OSC 777 notification | Limited |
| File management | Optional embedded Windows File Explorer pane, with drag-and-drop integration. | No |
| Batch scripting and debugging | TCC extends CMD-style scripting; the suite includes an editor and batch debugger with interactive debugging tools. | Script editing and debugging requires external tools. |
| Workspaces and restore | Named workspaces and optional previous-session recovery for eligible profile-backed tabs. Workspaces do not restore terminal output or split-pane sessions. | Optional persisted window layouts can restore windows, tabs, pane layouts, and profiles, but not pane contents. Startup actions can define a layout. |
| Command palette and shortcuts | Command Palette, configurable menus, keyboard shortcuts, and programmable toolbars. | Command Palette and a customizable action and key-binding system, including settings.json configuration. |
| Broadcast input | Supports broadcasting input to selected sessions. | In Preview version |
| QuickText | Shortcuts for text used repeatedly in a session | No |
| Secrets Vault | Stores passwords and passphrases in DPAPI-protected file | No |
| Rendering and appearance | GPU-accelerated Direct2D/DirectWrite terminal rendering; themes, fonts, colors, backgrounds, and transparency options. | GPU-accelerated text rendering; profiles, color schemes, fonts, background images, and transparency options. |
| AI | MCP server included. Supports Claude Code, Codex CLI, Gemini CLI, and Vibe CLI. | No |
| Terminal compatibility | Unicode and UTF-8, broad ANSI virtual terminal support, hyperlinks, and multiple inline graphics protocols (ReGIS, SIXEL, iTerm2, Kitty). | Unicode and UTF-8, a subset of ANSI virtual terminal sequences, hyperlinks, and SIXEL graphics. |
| Accessibility | Terminal tabs and panes expose Windows UI Automation, including text patterns, for tools such as NVDA. | Provides accessibility support; results depend on the screen reader, version, settings, and application running in the terminal. |
The shell and automation toolkit
Windows Terminal gives you a tabbed window environment for command-line programs. It does not provide a command shell. This may be an advantage if you already have a preferred shell and want a simple terminal.
Take Command includes TCC, which is designed for compatibility with familiar CMD commands while extending them with additional commands, options, variables, functions, aliases, and control structures. TCC's IDE and debugger provide an integrated way to edit and troubleshoot batch scripts. For users with substantial CMD-style scripts and automation, those tools can reduce the need to assemble a separate collection of utilities.
Both Windows Terminal and Take Command can run any Windows or WSL shell.
Compatibility is not a guarantee that every script behaves identically. Test existing batch files, especially those that rely on undocumented behavior or a particular external program. A script written for PowerShell or bash remains a PowerShell or bash script regardless of which terminal hosts it.
Organizing local and remote work
Both terminal apps provide tabs and split panes, so you can keep a shell, logs, and a second task visible together. Take Command also has tab groups: horizontal or vertical arrangements of whole document tabs. Those groups are distinct from split terminal panes inside a tab.
Take Command adds named workspaces for profile-backed tabs and can offer to recover a previous session. Its workspace records tab-group arrangements and selected tabs but does not save terminal output or terminal-pane splits. Windows Terminal's optional persisted layout can restore the arrangement and profile of panes in its windows, although the contents of those panes are not restored. Neither is a substitute for application-level state or a durable session on a remote server.
For remote work, Take Command offers dedicated SSH and serial connection profiles alongside local sessions.
Working with output
Take Command's annotations and bookmarks help preserve context in retained scrollback: mark a line, attach a note, or use the semantic overview to locate interesting parts of a long session. Command result cards can show status and duration and provide actions such as copying or saving output. Command cards require compatible shell-integration markers; not every program or connection will produce command boundaries.
Windows Terminal offers searchable scrollback and limited shell-integration features. Its strength is a straightforward terminal interface; if your main workflow is reading output and using your shell's history, those capabilities may be enough. If you want in-terminal annotations, recording, triggers, graphic images, and/or richer command-result workflows, you need Take Command.
For both products, the scrollback buffer is finite. Recording, exporting, or preserving a server-side log is a better choice when output must be retained for later auditing. Treat recordings and copied output as potentially sensitive: they may contain credentials, paths, or private data.
Customization, rendering, and compatibility
Both Take Command and Windows Terminal support color themes, fonts, colors, background images, keyboard-driven workflows, and command palettes. Take Command adds display themes, dockable panes and programmable toolbars.
Both use modern GPU-accelerated rendering. That does not establish a universal performance winner: throughput and perceived responsiveness vary with the shell, font, output pattern, terminal settings, hardware, and display. If rendering speed matters, benchmark your actual workload and configuration rather than relying on an unqualified speed claim.
Terminal compatibility also depends on the application and protocol. Test the specific full-screen, remote, accessibility, and graphics applications you depend on in the version you plan to deploy.
Understanding what you are comparing
The terminal provides the window, renders text, accepts keyboard and mouse input, and manages the visible sessions. The shell reads command lines, expands variables, launches programs, and provides a scripting language. The terminal does not acquire the shell's commands, and a shell does not acquire every feature of its host.
That distinction explains why a single feature checklist can be misleading. A person using Windows Terminal with PowerShell, an editor, and an SSH client has a capable development environment, but much of that capability comes from separately installed components. Take Command combines its terminal with TCC and other utilities, so some of its advantages are advantages of the package rather than of the terminal display alone. Conversely, someone who prefers bash or PowerShell can use those shells in Take Command without adopting TCC as the center of the workflow.
Consider three separate questions: Which interface is most comfortable? Which shell language best fits the work? And how many supporting tools should be integrated rather than chosen independently? The answers need not all point to the same vendor. In particular, running TCC inside Windows Terminal is popular, although it does not turn Windows Terminal into the complete Take Command interface or bring over all its integrated tools.
Interactive command-line work
For a quick task, both products can open a shell and let you type familiar commands. The difference becomes more obvious with full time usage. A Windows Terminal user might open separate tabs for PowerShell, a WSL distribution, and a development server, then use the command palette or key bindings to move among them. This is a reasonable approach for someone who already knows the individual shells and prefers to keep the terminal itself focused on hosting them.
A Take Command user can arrange sessions in tabs and panes as well, but can also make use of TCC's interactive command environment and the suite's menus, toolbars, and optional Explorer pane. For someone who regularly alternates between typed commands and graphical file operations, keeping those activities in one application can reduce window switching. Others may prefer a separate file manager with its own larger window; integration is an option, not an obligation.
Pay attention to the shell when evaluating the experience. Command history, completion, aliases, command syntax, and the behavior of a pipeline can differ depending on whether the session runs TCC, PowerShell, CMD, or a Linux shell. Changing terminal applications alone does not make an unfamiliar shell's syntax familiar. A fair trial uses the same shell in each host first, then separately evaluates what TCC adds when it is the shell under test.
Batch files and scripting
Windows Terminal can host the shell that runs a script, but the terminal is not itself a batch language or a full script debugger. A team using PowerShell can pair the terminal with a PowerShell-aware editor and debugger; a WSL user can choose the tools appropriate for a Linux shell. This modular approach lets an organization standardize on tools it already uses and replace individual components independently.
Take Command's advantage is the combination of TCC's extended command language with an included batch IDE and debugger. That combination is particularly relevant when the work involves maintaining Windows command files, exploring complex command sequences interactively, and investigating why an automation job behaves differently from what its author expected. The integrated debugger offers a powerful yet easy to use alternative to relying on diagnostic messages and repeatedly rerunning a long script.
The trade-off is portability. A script that uses TCC-specific commands, variables, or language features needs a suitable TCC installation in the environment where it executes. (Or a copy of TCC-RT, the free runtime-only version of TCC.) A script intended for a Windows CMD environment should be tested there rather than assumed to work because it succeeded under TCC. Likewise, using Windows Terminal does not make a PowerShell script portable to CMD or make a bash script independent of its Linux tools. Document the required shell, external programs, permissions, and version alongside any automation that other people must run.
For existing automation, start with a small representative set: an interactive task, a scheduled batch job, and a script with dependencies on environment variables or working directories. Compare output and exit behavior in the intended execution environment before migrating critical jobs.
Remote access - SSH and serial connections
For an administrator, the practical question is often not merely whether a terminal can display remote text, but how connections are defined, opened, and revisited. Take Command provides dedicated SSH profiles built around OpenSSH, with connection options documented in its help. A saved profile can make recurring sessions easier to identify and reopen. Windows Terminal can instead launch an installed SSH client in a tab or configured profile, allowing users to keep their existing client configuration and authentication practices.
Those approaches are compatible with many of the same operational habits. Use host-key verification, least-privilege accounts, and approved authentication methods regardless of the window in which SSH runs. A convenient tab title is not proof of a server's identity, and a saved profile is not a substitute for verifying the connection. For long-running work that must survive a network interruption, investigate server-side session management rather than assuming either local terminal will preserve the remote process automatically.
Serial access is a more direct point of difference. Take Command can open a Windows COM port as a terminal session and save serial connection profiles. This is useful when monitoring a device, configuring network equipment, or investigating boot messages, subject to the device's required port settings. The serial session uses terminal facilities such as search and recording, but it does not itself run a shell; shell prompt marks and command folding therefore do not apply to ordinary serial output.
Tabs, panes, and restoring a working layout
Tabs are useful for switching among independent tasks; panes are useful when several sessions need to remain visible at once. For example, a developer might put a build in one pane and a test runner in another, while keeping an unrelated administrative session in a separate tab. Both products offer tabs and split panes, but their layout models and restoration options should be evaluated on their own terms rather than treated as identical.
In Take Command, a terminal split creates independent sessions within a tab. Horizontal and vertical tab groups are different: they arrange groups of whole document tabs, each with its own tab bar. A tab group can therefore contain multiple tabbed sessions without being a split terminal pane. Windows Terminal also supports pane arrangements within tabs, with its own commands and layout behavior. Try resizing, switching focus, and managing a busy layout with your preferred keyboard and mouse before deciding which feels more natural.
Persistence deserves particular care. Take Command's named workspaces record eligible tabs opened directly from saved local, SSH, or serial profiles and their tab-group arrangement. Ad-hoc sessions, replay tabs, and terminal-pane splits are not saved as workspace tabs. The workspace does not preserve output, running processes, passwords, or later changes to a shell's working directory. Previous-session recovery is a separate optional feature and offers to reopen eligible tabs rather than silently relaunching them.
Windows Terminal can optionally persist supported window, tab, and pane layouts, but restored panes do not contain the old terminal contents or resume the old processes. In both products, a restored visual arrangement should be understood as a way to reopen sessions, not as a snapshot of a running machine. If an operation is costly or unsafe to repeat, use a workflow that makes its state explicit rather than depending on layout restoration.
Finding meaning in long output
Terminal search answers the immediate question, "Where is that text?" More advanced tools answer a different question: "What happened here, and why is this section important?" A long build, test run, or deployment can produce thousands of lines; even when the underlying command succeeds, identifying a warning or comparing two steps takes longer than issuing the command itself.
Take Command's result cards add a command-oriented view where supported shell-integration markers are present. A card can show a running or completed status and, when timing information is available, a duration. The header remains visible while you scroll through that command's output. An arbitrary program or serial stream that supplies no suitable command markers does not automatically become a series of cards.
Take Command's annotations and bookmarks serve complementary purposes. An annotation attaches a free-form note to a selected range of retained text without changing the underlying output. A bookmark marks a retained row for later navigation, such as the first error in a build or a particular device message. These are useful during an investigation, but they are not a permanent archive of the session: important evidence should also be saved or recorded before the relevant scrollback is lost.
Windows Terminal provides search and, with compatible shell integration, prompt marks and navigation. A user who already sends output to structured logs or uses a separate log viewer may not need richer terminal annotations. On the other hand, someone who works primarily from transient interactive output may value having more review tools close to the session. Compare the entire path from producing output to finding, retaining, and sharing the relevant result.
Recording, replay, and automated attention
Take Command supports terminal recording in asciicast v3 format and read-only replay. This can be helpful for reviewing an interactive demonstration, reproducing the sequence of events before an error, or sharing a session with a colleague. Replay is not the same as reconnecting to the original shell: it presents a recording rather than restoring the original process. Verify the recording and playback behavior in the beta build before making it part of an important procedure.
For Windows Terminal, comparable session capture requires an external recorder, script, logging mechanism, or application-specific tool. That can be a reasonable choice when a team already has a standard recording format or retention system. In either case, check what the chosen recorder captures, how playback is performed, and whether timestamps or interactive input are included.
Take Command has regular expression triggers that evaluate completed output rows. Depending on the configured action, a match can draw attention to relevant output or initiate an action; separate highlight rules change presentation without performing trigger actions. These tools can make a warning easier to notice in a busy session, but a pattern is not an authoritative monitoring system. Test rules against representative output, including false positives, and use appropriately designed monitoring and alerting for critical operations.
Recordings, exported output, copied results, and trigger actions all have security implications. A session may contain personal information, internal hostnames, tokens, or commands that should not be shared. Review and sanitize artifacts before distribution, restrict access according to your organization's policies, and avoid storing secrets in ordinary profile snippets or reusable command text.
Four scenarios to compare in practice
1. A developer with Windows and Linux tools
Open a local Windows shell, a WSL shell, and a project build in separate sessions. In Windows Terminal, evaluate profile discovery, pane arrangements, shortcuts, and the process for reopening the layout. In Take Command, compare the same sessions and then try its tab groups and terminal panes. Include a realistic full-screen editor and a long compiler output, not just a prompt. The important result is how quickly you can navigate, understand failures, and return to work.
2. An administrator managing several hosts
Set up representative SSH connections using your normal authentication rules. Compare launching connections from Take Command's profiles with launching an SSH client in Windows Terminal. Check how clearly each session identifies its destination and how the workflow behaves after a disconnect.
3. A maintainer of Windows command files
Choose a batch file with several branches and external dependencies. Run it in the shell, then investigate it with your normal editor and debugger. Evaluate the Take Command batch IDE and TCC separately, including whether the project would benefit from TCC-specific features and whether the target machines can run them. If standard CMD compatibility is a requirement, retain a test under CMD as part of the evaluation.
4. A technician reviewing device output
Connect an appropriate device using a known-good serial configuration. Compare Take Command's serial session with your established serial client, and evaluate scrolling, search, recording, and any required device controls. Save a sample capture, replay or inspect it, and confirm that it contains the evidence you need. Windows Terminal may remain useful alongside a separate serial application even if it is not the component that connects to the COM port.
Making a fair evaluation
Use a short checklist instead of assuming that either product wins every category. Start with the same machine, monitor scaling, font, shell, and working directory where possible. Record the exact product versions and whether Windows Terminal is Stable or Preview. Then try the tasks that actually consume your time: navigating output, managing several sessions, debugging a script, opening an SSH connection, and recovering a layout after restarting.
For performance comparisons, distinguish a high-volume output test from ordinary typing, interactive scrolling, and idle resource use. Large differences in font metrics, transparency, scrollback settings, or rendering options can make a comparison misleading. Responsiveness is also more than raw output throughput: a terminal that remains usable while a build is running may be preferable to one that merely finishes a synthetic display test faster.
Finally, consider the cost of the whole workflow. An open-source host can be combined with free tools, but selecting, configuring, documenting, and maintaining those tools takes effort. A commercial suite has a license cost, but its integrated features may reduce that assembly work. The right choice depends on the people, scripts, devices, support requirements, and existing investments involved, not just on the number of checkmarks in a table.
Pros and cons
Take Command: strengths
- Integrated shell and scripting: TCC adds substantial interactive and batch capabilities.
- Built-in development tools: An editor and batch debugger support CMD-style automation workflows.
- Rich session tools: Split panes, SSH and serial profiles, asciicast recording and playback, annotations, bookmarks, notifications, and triggers.
- Graphics support: Terminal windows can display ReGIS vector graphics, iTerm2 images, SIXEL images, and Kitty graphics with your text output.
- Integrated desktop workflow: The File Explorer pane, toolbars, menus, and configurable layout bring GUI and command-line tasks together.
- Workspaces: Save and open a named arrangement of tab windows.
- More context for output: Shell-integrated command cards, command folding, and semantic navigation makes lengthy sessions easier to review.
- AI: Take Command's MCP server is integrated with TCC and supports Claude Code, Codex CLI, Gemini CLI, and Vibe CLI.
- Extensive help: Press F1 to access Take Command's comprehensive help.
Take Command: considerations
- Commercial licensing: The suite is not free/open source (but is available as a 30-day free trial). Review current pricing, and upgrade terms.
- More to learn and configure: The extensive feature set may be unnecessary for someone who only wants a simple terminal host.
- Script portability: TCC-specific commands and syntax require TCC (or the free TCC-RT runtime) where the scripts run.
Windows Terminal: strengths
- Free and open source: Its source code and executable are available publicly.
- Windows integration: Microsoft documents default-terminal configuration on supported Windows versions, alongside Store and other installation options.
Windows Terminal: considerations
- No TCC-equivalent shell included: Enhanced command and scripting capabilities depend on the shell and tools you install. If you need a more capable shell than CMD, you'll need to learn PowerShell or one of the WSL shells like bash.
- External tools required for many workflows: File browsing, batch debugging, SSH, serial clients, and session recording require other applications.
- Limited shell integration features: ANSI virtual terminal sequences are limited. No semantic navigation or command cards.
- Configuration complexity: Advanced custom actions and shared setups may require editing JSON and understanding profiles.
- Feature and version differences: Some capabilities arrive in Preview first; confirm availability in the build you use.
Which should you choose?
Choose Take Command if you want TCC's enhanced command language, integrated batch debugging, connection management, and terminal productivity tools in a single environment.
Choose Windows Terminal if your terminal needs are basic, you want a free, open-source terminal host with a limited feature set, and are comfortable supplying your own shells, editors, debuggers, and connection tools.
Use both if you prefer the Windows Terminal interface for some sessions but also want TCC. Install TCC, create a Windows Terminal profile pointing to it, and use Take Command itself when its integrated tools are valuable.
For the most useful comparison, try each with the same shells and representative workloads: a long build, an SSH session, a multi-pane layout, and the scripts you run every day. Assess ease of use, compatibility, accessibility, licensing, and performance in your own environment.
Sources and further reading
Take Command v37 details above are based on the bundled v37 help, especially What's New in Version 37, and the topics for split panes, workspaces, SSH, serial terminals, command result cards, annotations, bookmarks, and recording. Consult the help included with Take Command for exact behavior.