OpenConsole for VS Code

A terminal in the panel of VS Code that shows Arabic and Hebrew correctly: connected letters, words in the right order, diacritics, and mixed Arabic + English lines.

VS Code's own terminal (xterm.js) draws every character on its own, from left to right, so Arabic letters are not connected and phrases read backwards. This extension adds a tab OpenConsole next to Terminal in the panel. It runs a real shell (PowerShell by default) in a Windows pseudo console and draws the rows that contain right-to-left text with the same layout that the OpenConsole console window uses (the project this extension belongs to).

العربية

Install

Windows 10 (1809) or later, VS Code 1.90 or later.

From the Marketplace (easiest): open the Extensions view in VS Code (Ctrl+Shift+X), search for OpenConsole and install it, or run code --install-extension openconsole.openconsole. Then reload the window.

With the installer: download OpenConsole-x64.zip from the Releases page of the OpenConsole project, extract it, and double-click Install.cmd (it installs the OpenConsole console and, when it finds VS Code, this extension) or Install-VSCode.cmd (only this extension). Then reload the VS Code windows that are open.

With the .vsix file alone (openconsole-<version>.vsix, from the Releases page, or build it: below):

1. Install it:

   code --install-extension openconsole-<version>.vsix
   

   or, in VS Code: Extensions view, ... menu, Install from VSIX...

2. Reload the window (Developer: Reload Window).

3. Open the panel (Ctrl+J) and choose the OpenConsole tab, or run OpenConsole: Focus Terminal from the Command Palette.

To remove it: Install-VSCode.cmd -Uninstall, or code --uninstall-extension openconsole.openconsole. (Version 0.1.0 was called openconsole.openconsole-terminal; the installer removes it.)

Why an extension, and not just a setting

VS Code draws its terminal itself (xterm.js), so a console program such as OpenConsole cannot draw inside it. The closest setting is terminal.integrated.gpuAcceleration = off (the DOM renderer): letters inside a word join, but the words stay in left-to-right order (the first word of "السلام عليكم" ends up on the left), and programs that reorder right-to-left text themselves, such as Claude Code, come out wrong. (Checked with the xterm.js that ships with VS Code 1.139.) The extension handles both.

If you would rather have the real console window than a tab, a terminal profile can open it from the + list of the terminal; see the README of the OpenConsole project ("The console window from VS Code").

What you get

• Connected Arabic letters and the right order. A phrase such as "السلام عليكم" starts on the right, letters join, numbers keep their own order, and box drawing characters end a run, so tables and text user interfaces are not swapped.
• The cursor follows the text. While you type Arabic, the cursor stays at the end where the next letter appears.
• Programs that reorder the text themselves, such as Claude Code, are detected automatically (claude.exe runs under the shell) and drawn correctly. The list is a setting. While you type Arabic at the end of the text box of Claude Code, the cursor is drawn at the left end of the word, where the next letter appears, and the word stays joined (Claude Code itself parks the cursor of the terminal on the first letter of the word, which cut that letter off).
• Text boxes that do not move. In the words mode every Arabic or Hebrew word is joined and mirrored on its own, and the words keep the order you typed them in. Nothing before the word you are typing moves, and a long text that wraps reads from top to bottom, instead of being reordered as one stretch that grows at its right end and is cut where the row wraps. The mode is for coding agents that redraw their text box on every key. It is chosen by itself while a program from openconsole.wordsBidiApps (opencode.exe) runs in the terminal. pi is a Node.js program and cannot be told by its name here, so for pi set openconsole.bidiMode to words. (The OpenConsole console window, not this tab, finds pi by itself.) The price: the words of an Arabic sentence follow each other from left to right; digits always stay left to right.
• Screenshots with Ctrl+V. Take a screenshot and press Ctrl+V: the image is saved as a PNG file in %TEMP%\OpenConsole and its path is pasted, as when you drag a file into a console. Programs that read images by path, such as Claude Code, pick it up. The terminal draws a small [Image #1] over the long path, so the line stays readable. The text is still there: the program receives the real path, and copying the line gives it back. The label counts as one character: Backspace right behind it removes the whole path at once (and Delete right in front of it), not letter by letter; after any other character Backspace is a normal Backspace.
• Icons. Set openconsole.iconFont to a Nerd Font to draw the icons of tools such as starship, lazygit or pi.
• Copy and paste. Ctrl+C copies when text is selected (otherwise it is sent to the program), Ctrl+Shift+C always copies, Ctrl+V, Ctrl+Shift+V and Shift+Insert paste. They work on an Arabic keyboard layout too, and pasting an item from the clipboard history of Windows (Win+V) works as well (Windows sends that paste as a Ctrl+V without a scan code).
• Right mouse button pastes. Click the right button in the terminal and what you copied last is pasted, as in the console window and in Windows Terminal, instead of the menu of VS Code (openconsole.rightClickPaste, turn it off to get the menu). A program that uses the mouse (pi, opencode, vim) gets the right button itself: hold Shift to paste then. A screenshot in the clipboard is pasted as a file path, as with Ctrl+V, when the page is allowed to read it; if not, use Ctrl+V.
• Links. An address (http:// or https://) in the output is underlined when you point at it, with the hint "Follow link (Ctrl + click)". Ctrl + click opens it in your browser (VS Code asks first for sites it does not know). It also works for an address that wraps onto the next row, and in programs that use the mouse, such as pi, opencode or vim: there the Ctrl + click is kept from the program when it is on an address, and every other click still goes to it. Only http and https are opened.
• File paths. A path in the output (src/app.ts:12:5, C:\proj\lib\a.js:7, .\x\y.cs(10,3)) is underlined when you point at it, with the hint "Open file (Ctrl + click)". Ctrl + click opens the file in the editor at that line and column. A relative path is looked for in the folder where that shell started, then in the folders of the workspace; a file that does not exist is only reported. A path on a network share (\\server\share) is never opened, because Windows would send your credentials to that server. A name without a folder counts only when it has a line (index.js:10), so "node.js" in a sentence is not a link.
• Find in the terminal. Ctrl+F opens a small search box at the top right of the terminal (the text of the rows, including the scrollback): Enter / Shift+Enter or F3 go to the next / previous match, the buttons switch case, whole word and regular expression, the box shows "3 of 12", Esc closes it. Also OpenConsole: Find in Terminal.
• What every terminal is doing. When there is more than one terminal, each row of the list shows a small mark: a green dot (a program runs), a turning ring (an agent works), an empty ring (it waits for you), an amber pulse (it needs you: a question, a permission), a check (done), a cross (failed), a grey square (the shell ended), with the time next to it. The agent (Claude Code, Codex, opencode, Gemini, Aider, pi) is told from the programs under the shell or from the title it sets. The state comes, in this order, from what the program reports itself (the sequences OSC 7501;state=working|blocked|done|error, OSC 9;4 progress and OSC 133), from the bottom rows of the screen ("esc to interrupt", a numbered permission question, [y/n]), and from how long the output has been quiet. OpenConsole: Explain the State of This Terminal shows which of them decided and the rows that were read. A terminal that you are looking at is never reported.
• Notifications. When a terminal you are not looking at needs you, calls you with the bell, fails, ends, or an agent / program that worked at least openconsole.attention.minWorkingSeconds (15) is done, a message tells you, with a Show button that opens that terminal. The same thing about the same terminal is told again after 30 seconds at the earliest. The status bar shows $(bell) 2 (with a warning colour when something is blocked): click it for the list, or use OpenConsole: Go to the Next Terminal That Needs You. openconsole.attention.notify is all, important (questions, bell, failures) or off; openconsole.agentRules adds your own rules for what a program's screen means.
• Names and colours. Double click a row to rename that terminal (an empty name gives the name of its kind back; the name is also used in the notifications), or right click a row for Rename, a colour for its icon, Split and Kill. Also OpenConsole: Rename Terminal... and Change Terminal Colour....
• Icons for what runs. With more than one terminal, each row of the list wears the icon of what runs in it: the agent (Claude Code, Gemini, opencode, Copilot), else the program under the shell (Node.js, npm, Yarn, pnpm, Bun, Deno, Python, Git, Docker, Go, Rust, Java, C#, PHP, Ruby, Vim), else its kind of shell (PowerShell, Git Bash, Command Prompt and WSL), and it changes by itself when the program changes. A terminal that you gave a colour keeps the plain icon in that colour. The pictures are the icons of Material Icon Theme by Material Extensions (MIT licence, kept in media/vendor/LICENSES.txt).
• Run several scripts at once. OpenConsole: Run package.json Scripts in Parallel... lists the scripts of the package.json files of the workspace (the root and one level of workspaces: npm, Yarn, pnpm, bun; the manager is told from the lockfile or packageManager). Tick the ones you want: each runs in its own terminal, named <package>: <script>, in the folder of its package, at most openconsole.scripts.maxParallel (4) at a time; the next one starts when a running one ends (0 starts them all at once, for servers that never end). A script name that is not one plain word (spaces, ;, &&, quotes) is never typed into a shell.
• Saved groups of terminals. Put .openconsole/groups.json in the workspace ({ "groups": [ { "name": "dev", "terminals": [ { "name": "api", "cwd": "packages/api", "command": "npm run dev", "color": "green" } ] } ] }; OpenConsole: Edit Saved Groups makes the file) and Start a Saved Group of Terminals... opens one terminal per entry with its folder, name, colour and command. The commands are text of the repository, so they are shown in a question before they run (you can approve a group; a changed command asks again), a cwd may not leave the workspace, and a command may not contain control characters.
• One work tree per agent. New Terminal in a Fresh Git Worktree... makes a new branch oc/<name> in its own folder next to the repository (git worktree), and opens a terminal there, typing openconsole.worktree.startCommand (for example claude). Several agents can then work on the same project at the same time without touching each other's files. Remove an Agent Worktree... removes one again (it warns when it has changes that are not committed). Close the terminals that are in the folder first: Windows cannot delete a folder that a program is in.
• Log messages in the editor. Select a variable (or put the cursor on it) and press Ctrl+Alt+L then L: a line such as console.log("▶ › Cart › add › item:", item) is inserted after the statement that gives the variable its value (before an if or return, at the top of the body for a parameter), indented like its neighbours, with the class and function it is in. In Python it is print(...) (logging.* for the info, debug and warn kinds, with import logging added when it is missing). Other keys, after Ctrl+Alt+L: I info, D debug, T table, W warn, E error, M your own function, then C comment all, U uncomment all, X delete all, R correct all (the file name and line numbers of the messages that moved). The last four act on the log messages of OpenConsole in the active file only (a message counts when it holds both the prefix and the delimiter), and each is one undo step. Several cursors work at once. The finder is heuristic (a tokenizer and a statement scanner, not a parser): when it cannot tell, it puts the line after the statement, and in odd places (a field of a class without a constructor) it says no instead of writing a wrong line. The openconsole.log.* settings change the prefix, the delimiter, the quote, the function, the file name and line number, semicolons and blank lines. The idea comes from the extension Turbo Console Log (by Chakroun Anas); this one is written independently, without its code.
• Your terminals in a browser. OpenConsole: Share Terminals on the Web... (or the broadcast button in the toolbar of the view, which opens the sharing menu once it is on; off until you ask) lets you open the same terminals, not copies, in a browser on a phone or another computer. You choose which terminals; a small server starts on this computer only (127.0.0.1) and you get a link that works once, for ten minutes, with its secret after the # (which a browser never sends to a server). Open it in the browser: VS Code asks you to Allow viewing, Allow typing or Deny that browser, so a link that leaks is worth nothing without your click. The browser then shows the terminals at the size of your panel, with a bar of keys for a phone (Esc, Tab, Ctrl, arrows...), and Arabic is drawn as in VS Code. The status bar shows $(broadcast) Web while anything is shared (click it: new link, browsers that are paired, stop). To reach it from outside this computer you run a tunnel yourself (for example cloudflared tunnel --url http://127.0.0.1:<port>, or Tailscale Serve) and put its address in openconsole.web.publicUrl: only that host is then accepted. There is no relay server and no account. Security: random 256-bit secrets, only hashes are kept, no cookies, exact Host and Origin checks, at most openconsole.web.maxClients browsers, a limit on tries, strict WebSocket parsing, the terminals' own answers to terminal queries are never typed back, and a browser that can only view can never type. Sharing ends with Stop Sharing on the Web or when VS Code closes. Remember that a browser that may type can do whatever you can do in that terminal.
• Motion. The buttons that the page draws move smoothly: the two buttons of a row spring in, one after the other, when the row is pointed at; they grow when pointed at and sink when pressed; the line of Split Terminal divides in two and the lid of the bin lifts (and the bin turns red, as it ends a terminal); a new terminal slides into the list; the entries of the menu next to + come in one after the other. openconsole.motionSpeed sets how long it takes (1 normal, 2 twice as long, 0.5 half, 0 none). With "reduce motion" on in Windows, none of it moves. (The buttons of the toolbar of the view, the + and the others, are drawn by VS Code itself and cannot be animated by an extension.)
• It follows the colours and the font of VS Code.
• Several terminals. The + in the toolbar adds another terminal to the panel, each with its own shell. As in the built-in terminal, a list appears on the right as soon as there is more than one: click a name to switch. The row that is pointed at or has the focus shows two buttons: Split Terminal (the icon with two panes) and the trash, which kills that terminal (the last one starts again instead). The line between the terminal and the list can be dragged to the left or to the right to change the width of the list (it lights up when it is pointed at; a double click gives the usual width back, the arrow keys move it when it has the focus, and the width is kept). Restart and Clear in the toolbar act on the terminal that is shown in the panel, even when you used a terminal in an editor tab last. Clear starts the terminal again: a new shell and an empty screen, so whatever ran in it ends (turn this off with openconsole.clearRestartsTerminal for a Clear that only empties the screen and keeps the shell; that one also clears the pseudo console, so the lines do not come back when the panel is resized, and it needs the conpty.dll that VS Code ships, see openconsole.useVSCodeConpty). Text follows the width. Drag the line between the terminal and the list, or resize the panel: what is on the screen, and the long line that you are typing, wrap again at the new width, both when the terminal gets narrower and when it gets wider.
• Terminals of a chosen kind. The arrow next to the + opens a dropdown menu, as the arrow next to the + of the built-in terminal does (it is drawn at the top right of the terminal, in the colours of VS Code's menus: an extension cannot open a menu from the toolbar with entries that are only known at run time, and the profiles are): a new terminal with a profile (PowerShell, PowerShell 7, Command Prompt, Git Bash, every WSL distribution, and the profiles with a path in terminal.integrated.profiles.windows), New Terminal in Editor, Select Default Profile (the shell that + starts), Split Terminal and Configure Terminal Settings. The list shows the name of the kind.
• Split Terminal. The split button of a row (or Split Terminal in that menu, or in the Command Palette) opens a new terminal at the right side of the one that has the focus, of the same kind, and both are shown side by side with a line between them. In the list the terminals of such a group hang together under one another. Click in a terminal to give it the focus. A terminal that is killed leaves the others the whole width. Splits are side by side only (no split one above the other).
• OpenConsole: New Terminal in Editor (Command Palette, or the ... menu of the view) opens a terminal in an editor tab.
• A suggestion of what you are going to type. While you type at a prompt, the rest of the newest command of your history that starts with what you typed is shown in grey after the cursor. The Right Arrow (or End) types it; any other key ignores it. The history is the one of PowerShell (its ConsoleHost_history.txt) plus the commands you enter in these terminals. It is left out while another program runs in the terminal, on the alternate screen (vim, less), when there is text after the cursor, and when it would go on in an Arabic or Hebrew word that you typed (such a word is laid out from the right, so the grey text would be on the wrong side). Turn it off with openconsole.suggestions. Privacy: the commands you enter here (at most 300) and the folders of their prompts (at most 40) are kept in the state of this extension inside VS Code, on your computer only; with openconsole.suggestions off nothing is read or kept. OpenConsole: Forget the Remembered Commands and Folders deletes them (the history file of PowerShell is never changed).
• The "..." menu of the view, as in the built-in terminal: Scroll to Previous Command and Scroll to Next Command (Ctrl+Up Arrow and Ctrl+Down Arrow in the terminal; they go to the commands that you entered in this terminal), Clear Terminal, Run Active File (types the path of the file of the editor), Run Selected Text (types the selection, or the line of the cursor), Go to Recent Directory... (Ctrl+G in the terminal) and Run Recent Command... (Ctrl+Alt+R). The menu does not print the keys next to the items, but they work inside the terminal. The same items are in the Command Palette as OpenConsole: .... Start Dictation of the built-in terminal is not here: it needs the speech extension of VS Code, which only serves its own terminal.

Rows without right-to-left text are drawn by xterm.js exactly as in the terminal of VS Code.

Settings

The cursor style, the blinking, the scrollback and the line height are taken from terminal.integrated.*.

How it works

• bin/conpty-bridge.exe (source in native/) starts the shell in a Windows pseudo console and exchanges the input, the output, the size and the list of running programs with the extension through a small binary protocol on its standard streams.
• The page in the webview is xterm.js (DOM renderer) plus two files: media/arabic-layout.js decides, with the Unicode Bidirectional Algorithm (bidi-js), which columns form right-to-left runs and where each run is drawn (mirrored inside the columns it occupies), and media/row-patcher.js rebuilds only the rows with right-to-left text: each run is one box that the browser shapes as a whole (this joins the letters) and fits into its columns.
• The design is the one of the renderer of the OpenConsole console window (src/renderer/atlas in this repository).

Limits

• Windows only (x64). The shell needs a pseudo console, so Windows 10 version 1809 or later.
• This is not the built-in terminal: no shell integration, quick fixes or task terminals, and splits are side by side only. Some keys go to VS Code instead of the shell when they are not handled by the terminal.
• With an Arabic keyboard layout active, PSReadLine (the command line editor of PowerShell) types the Arabic letter of the key for shortcuts such as Ctrl+L, Ctrl+A or Ctrl+E, instead of running them. We saw this with the shortcut arriving correctly at the pseudo console, so it is how PSReadLine reads it, and it is not specific to this extension. Switch to the English layout for these shortcuts. Pasting (Ctrl+V, also from the clipboard history of Windows, Win+V) and copying a selection with Ctrl+C work in any layout.
• Selecting part of an Arabic run with the mouse highlights columns that do not line up with the letters (copying gives the right text).
• The DOM renderer is slower than the GPU renderer when a program writes very fast.
• Tested with VS Code 1.139 on Windows 11 with PowerShell 5.1, and with a stand-in for Claude Code. Hebrew uses the same code as Arabic.

Build it yourself

You need Node.js and, for the helper program, the Visual Studio C++ build tools (as for the console window).

cd vscode-extension
npm install
npm run build          # copies xterm.js and bidi-js into media/vendor
npm run build:native   # builds bin/conpty-bridge.exe
npm test               # layout, session and helper tests
npm run package        # writes openconsole-<version>.vsix

To try it without installing, open this folder in VS Code and press F5 (Extension Development Host).

test/e2e has scripts that start a separate VS Code with the extension and take screenshots of it through the debugging port (run.ps1, send.ps1, cdp.js); they were used to check the extension.

License

MIT, see the file LICENSE. xterm.js and bidi-js are MIT licensed as well (texts in media/vendor/LICENSES.txt).

Who made this

I'm yousef0688, and I work at Software House for System Development (Arabic: دار البرمجيات لتطوير الأنظمة), a Jordanian software company based in Amman. The source code, and the console window that this extension belongs to, are at github.com/yousef0688/OpenConsole-Arabic-Terminal.

code --install-extension openconsole.openconsole