Commands

This page lists every command of the RTCode.io playground, grouped by the menu or family it belongs to. For each command it gives the label you find in the command palette, its keys on Windows and Linux and on macOS, its menu path, and what changes its effect: modifier keys, preconditions and script forms. Keyboard shortcuts lists the keys alone. The tables describe the playground as of October 2026.

On Apple platforms the playground shows and uses the macOS keys automatically, with ⌘ as Ctrl and ⌥ as Alt.

Running a command

There are four ways to run a command. Every one of them honors the command's precondition: a command that does not apply right now, such as Unshare while nothing is shared, has no key, no palette entry and no context-menu item until it does.

The command palette. Press F1, or choose Playground ▸ Input ▸ Commands. The palette lists every command that is available at the moment by its label.
The menus. The four toolbar menus are File (Alt+F / ⌥+F), Playground (Alt+J / ⌥+J), Open (Alt+K / ⌥+K) and User (Alt+U / ⌃+⌥+U). The File menu is also called the Code menu in the palette. See The playground interface.
The editor context menu. Right-click in the input. RTCode adds its commands in groups: number nudges, evaluation, import, HTML helpers, encode and decode, selections, sync toggles and output windows.
The keys. Menu items and tooltips show the key of a command, in the macOS form on Apple platforms.

A few commands are keys only, with no palette entry: F4, F5 and F6 work from anywhere in the playground, and the Network item of the Edge menu has no key.

Sync commands

The Sync section of the File menu controls how the input and the output follow each other. See Live sync and reloads. The logo button shows the state as an arrow: → for Live input → output, ← for Live output → input, ↔ for both and × for neither.

Command	Windows and Linux	macOS	Menu	Notes
Toggle Input → Output Sync `sync.xi`	`Alt`+`I`	`⌃`+`⌥`+`I` in the editor; `⌥`+`I` elsewhere	File ▸ Sync ▸ Input → Output ▸ Live ▸ Sync	A checkbox, on by default. Turning it on pushes the input to the output once. Script form: `io.sync = true \| false`.
Toggle Input ← Output Sync `sync.xo`	`Alt`+`O`	`⌥`+`O`	File ▸ Sync ▸ Input ← Output ▸ Live ▸ Sync	A checkbox, on by default. Works only while the input is not in focus. Turning it on pulls the output once. Script form: `oi.sync`.
Sync once, input → output	`F4`	`F4`	File ▸ Sync ▸ Input → Output ▸ Once ▸ Sync	An incremental push, also when Live is off. It works with any modifier, from the editor, the output and the console.
Load	`F5`	`F5`	File ▸ Sync ▸ Input → Output ▸ Once ▸ Load	A complete reload of the output that does not keep its state. It never reloads the playground page, and `Ctrl`+`F5` and `Shift`+`F5` do the same. The Load item of the Edge menu is a different command: Code: Revert Changes.
Sync once, output → input	`F6`; `Ctrl`+`Alt`+`O` when the output does not have focus	`F6`; `⌃`+`⌥`+`O` or `⌘`+`⌥`+`O` when the output does not have focus	File ▸ Sync ▸ Input ← Output ▸ Once ▸ Sync	Pulls the output into the input on demand, also while Live Output → Input is off.
Toggle Shadow Source Materialization `sync.srs`	`F7`	`F7`	Palette, context menu	The key works anywhere in the playground, and in the editor it is kept from toggling the browser's caret browsing. Shows the toast Shadow source materialization enabled or disabled.
Toggle Locate `sync.locate`	`F8`	`F8`	Palette, context menu	Shows Locate enabled or Locate disabled. In the editor the key replaces Monaco's own F8. See Locating source.

Code commands

These commands create code, measure it and set its title and routes. The Code and Edge sections of the File menu are hidden in an embedded playground.

Command	Windows and Linux	macOS	Menu	Notes
Create: New Code… `code.new`	`Ctrl`+`Alt`+`N`	`⌃`+`⌘`+`⌥`+`N` in the editor; `⌘`+`⌥`+`N` elsewhere	File ▸ Code ▸ New; context menu	Opens the template chooser over the playground. The link `https://rtcode.io/x/#act=code.new` opens the playground with the chooser. See The playground interface.
Code: Size… `code.size`	`Alt`+`Shift`+`S`	`⌥`+`⇧`+`S`	File ▸ Code ▸ Size	Opens the Local measurement. Shift+click or Shift+Enter on the menu item opens the deployed route instead. Never disabled, even without routes. Script form: `edge.size.open()`. See Measuring code size.
Code: Size (Deployed)… `code.size.deployed`	—	—	Palette	Opens the Deployed measurement of the first route.
Code: Versions… `code.versions`	`Alt`+`V`	`⌥`+`V`	File ▸ Code ▸ Versions	Opens the version viewer of the first route in a window of its own. The menu item shows only when you are signed in and is disabled without routes. See Versions and Smart Undo.
Code: Versions (All Routes)… `code.versions.all`	`Alt`+`Shift`+`V`	`⌥`+`⇧`+`V`	Palette	One viewer window per route. The menu item always opens the first route only.
Set Title… `sync.st`	`Alt`+`T`	`⌥`+`T`	The title button in the toolbar	Opens the Code dialog on Title, or on Routes when the playground has no title. In an embedded playground it opens the File menu instead.
Set Routes… `edge.rs`	`Alt`+`R`	`⌥`+`R` in the editor only; `⌘`+`R` reloads	File ▸ Edge ▸ Route / Routes; the route chip under the title	Opens the Code dialog on the first route. The Route item of the menu shows `Alt`+`T` as its hint on Windows and Linux, and `⌥`+`R` on macOS.
Import URL… `code.import.url`	`Ctrl`+`Alt`+`V`	`⌘`+`⌥`+`V`; also `⌃`+`⌥`+`V` outside the editor	Context menu	Prompts for a URL, prefilled from the clipboard, and replaces the whole input as one undoable edit. CodePen pen URLs are imported. The link `https://rtcode.io/x/#act=code.import.url` opens the playground with the prompt. See The playground interface.
Code: Revert Changes `code.revert`	`Ctrl`+`I` `R`	`⌘`+`I` `R`	File ▸ Edge ▸ Load	Asks Revert all changes since the last deployment?, then opens the deployed source, the first route followed by `?`, in this tab. Disabled without routes.
Code: Revert Changes in New Window… `code.revert.new`	`Ctrl`+`I` `W`	`⌘`+`I` `W`	Palette	The same without a confirmation, in a new window.

Edge commands

The Edge section of the File menu deploys, opens and deletes. With no routes, Edge ▸ Open, Edge ▸ Load, Edge ▸ Delete, Code ▸ Versions and Open ▸ Edge ▸ Route are disabled, and Code ▸ Size stays enabled. With more than one route, the All routes hints appear. The Route item reads Route only when exactly one route is set.

Command	Windows and Linux	macOS	Menu	Notes
Edge: Deploy `edge.put`	`Ctrl`+`S`	`⌘`+`S`	File ▸ Edge ▸ Deploy	Deploys to every route. Any Ctrl (⌘ or ⌃ on macOS) with S and no Alt deploys, also `Ctrl`+`Shift`+`S`. Alt+click or Alt+Enter on the menu item deploys with a message. Script form: `await edge.save.limit()`. See Deploying to RTEdge.net.
Edge: Deploy with Message… `edge.save.message`	`Ctrl`+`Alt`+`S`	`⌘`+`⌥`+`S`	File ▸ Edge ▸ Deploy, with Alt held	Prompts Commit message, optional. Cancel aborts the deploy, and an empty message deploys without one. Script form: `await edge.save.limit({ message })`.
Edge: Open… `edge.open`	`Ctrl`+`E`	`⌘`+`E`	File ▸ Edge ▸ Open; Open ▸ Edge ▸ Route; a middle-click on the title button	Opens the first route in a new tab. With no routes it shows No routes to open. Script form: `edge.open()`.
Edge: Open All Routes… `edge.open.all`	`Ctrl`+`Shift`+`E`	`⌘`+`⇧`+`E`	Open ▸ Edge ▸ Routes; Shift and middle-click on the title button	Opens every route. Script form: `edge.open({ all: true })`.
Edge: Delete… `edge.del`	`Shift`+`Delete`	`⇧`+`⌦` (forward delete)	File ▸ Edge ▸ Delete	Needs sign-in and routes. Asks to confirm, then deletes every route. `Ctrl`+`Shift`+`Delete`, or Shift+Enter on the menu item, skips the confirmation. See Behavior of Delete.
Edge: Recent Deployments… `edge.recent`	`Alt`+`.`	`⌥`+`.`	User ▸ Routes	Opens or closes the Routes drawer of your recent deployments. Signed out, it shows Sign in to view recent.
Network	—	—	File ▸ Edge ▸ Network	Opens the network map at rtedge.net in a window named `_rtedge_net`. No palette entry.

Agent commands

The Agent section of the File menu and the Agent commands of the palette exist only in a browser with FileSystemObserver, in practice desktop Chrome or Edge, and only in a top-level playground. See Agent 📂 Share™ and Browser support.

Command	Windows and Linux	macOS	Menu	Notes
✨ Agent: 📂 Share `f.c.share`	`Alt`+`A` while not sharing	`⌥`+`A` while not sharing	File ▸ Agent ▸ Share	Shares the playground with a work folder named after the first route. The first time it asks for the root folder. Click or Enter on the menu item with a modifier: Shift empties the work folder first, Ctrl (⌃ on macOS) also starts output capture, Alt adds a random suffix of five characters to the folder name, Space toggles Auto-Share.
✨ Agent: 📂 Share + 🔴 Output… `f.c.share.output`	`Ctrl`+`Alt`+`A` while not sharing	`⌘`+`⌥`+`A` while not sharing	Palette	Shares and starts output-only capture.
✨ Agent: 📂 Share… `f.c.ys`	—	—	Palette	Opens the File menu on the Share item, where the modifiers apply.
✨ Agent: 🗂️ Unshare `f.c.yu`	—	—	File ▸ Agent ▸ Unshare	The menu item shows only while sharing. Ctrl (⌃ on macOS) deletes the work folder, Shift empties it, Space toggles Auto-Share. The palette command opens the File menu on Unshare.
Toggle, Enable, Disable ✨ Agent: 📂 Auto-Share `f.Aa, f.A, f.a`	—	—	Palette; Space on Share or Unshare	Shares routed playgrounds automatically when a root is linked. The setting is kept for the browser profile.
✨ Agent: 📂 Shаre ← Folder: Enable, Disable `f.K, f.k`	—	—	Palette	On until you reload. The next Share loads `📄.html`, declared exports, workers and pins from the folder instead of the editor. See Share ← Folder.
✨ Agent: File Sync: Toggle `f.sync`	—	—	Palette	File Sync is on by default. Toggling shows a toast and restarts File Sync when a folder is shared. See File Sync.
✨ Agent: 🗂️ Unlink Root `f.h.un`	—	—	Palette	Available while a root is stored. Forgets it, so the next Share asks for a folder again.
✨ Agent: 📂 Explore… `f.fs.v`	—	—	File ▸ Agent ▸ Explore	Opens the Agent Folder explorer. The menu item shows only while sharing.
✨ Agent: 📍 Pins and Pins Stop `f.pins, f.pins.stop`	`Ctrl`+`P`	`⌘`+`P`	File ▸ Agent ▸ Pins	Starts a pinning session, sharing first when needed, or closes the pins interface. The menu item shows only while sharing. See Pins.
✨ Agent: 📍 Pins + 🔴 Output… `f.c.share.output.pins`	`Ctrl`+`Alt`+`P`	`⌘`+`⌥`+`P`	Palette	Available while no output capture is active. Shares if needed, starts output capture and starts picking.
✨ Agent: 📍 Pins Pause/Resume `f.pins.p_r`	`Ctrl`+`Alt`+`Shift`+`P`	`⌘`+`⌥`+`⇧`+`P`	Palette	Pauses or resumes picking while sharing with the pins interface open. Without it, the same keys swap the panels.
💾 Save: 📄.html `f.s`	`Alt`+`B` in the editor, while sharing	`⌥`+`B` in the editor, while sharing	Palette	Writes the editor to `📄.html`, refreshes `📄.sel` and requests a screenshot.
💾 Load: 📄.html `f.l`	`Alt`+`L` in the editor, while sharing	`⌥`+`L` in the editor, while sharing	Palette	Loads `📄.html` into the editor.
💾 Save: 📸.png `f.u.i`	`Alt`+`Shift`+`I` in the editor, while sharing and capturing	`⌥`+`⇧`+`I` in the editor, while sharing and capturing	Palette	Refreshes `📸.png` in the folder.

Tip: The two Share ← Folder labels spell Share with a Cyrillic а, so typing share in the palette does not find them. Type folder or enable instead.

Capture commands

The Capture section needs getDisplayMedia() and is hidden in an embedded playground. See Screen capture.

Command	Windows and Linux	macOS	Menu	Notes
🔴 🖥️ Capture: Window… `sc.a`	—	—	File ▸ Capture ▸ Window	Where the browser can crop captures, first asks what to share: Window, Playground, Input or Output. The choice is remembered.
🔴 🖥️ Capture (output) `sc.a.output`	`Ctrl`+`Alt`+`Shift`+`C`	`⌘`+`⌥`+`⇧`+`C`; also `⌃`+`⌥`+`⇧`+`C` outside the editor	Palette	Starts output-only capture without the chooser. Disabled while any capture is running.
🔴 🪟 Capture: Picture-in-Picture and Exit `sc.pip, sc.pip.z`	—	—	File ▸ Capture ▸ PiP, PiP Exit	Shows or leaves a picture-in-picture preview of the capture.
🔴 🖼️ Image… `sc.i`	—	—	File ▸ Capture ▸ Image	Saves a still of the capture as `📸.png`, as a download by default. Shift saves it to the shared folder, Ctrl (⌃ on macOS) copies it to the clipboard, Alt skips the download. The palette command opens the File menu on Image.
🔴 🎞️ Video: Start, Save, Pause, Resume `sc.v.a, sc.v.z, sc.v.p, sc.v.r`	—	—	File ▸ Capture ▸ Video, Save, Pause, Resume	Each shows only in the state where it applies. Save downloads `📸.mp4`.
🔴 ⏹️ Capture: Stop `sc.z`	—	—	File ▸ Capture ▸ Stop	Stops the capture.

Output commands

These commands change how the output looks, where it runs and how to leave a runaway page. Remote Output and Freeze are experimental and may change.

Command	Windows and Linux	macOS	Menu	Notes
Output: Settings `o.settings`	—	—	Playground ▸ Output ▸ Settings; the split popover	Opens the modeless Output settings dialog. See Output settings.
Output: Metrics `o.metrics`	—	—	Palette	A closable toast with the layout, aspect, size, zoom and color scheme of the output, refreshed every 300 ms.
Output: Zoom `o.zoom`	`Ctrl`+`Alt`+`=` in the editor	`⌘`+`⌥`+`=` in the editor	Palette; the split popover	Prompts for a zoom factor, minimum 0.1. Outside the editor, `Ctrl`+`Alt`+`=` opens the delta-expression prompt instead. Script form: `oz`.
Zoom out, zoom in	`Ctrl`+`Alt`+`-` and `Ctrl`+`Alt`+`+`; `Alt`+`-`, `Alt`+`Numpad −` and `Alt`+`Numpad +`	`⌃`+`⌥`+`-` and `⌃`+`⌥`+`+`	The split popover	Steps of 0.1, snapped to multiples of 0.1. The plus key needs Shift on US layouts. The split popover flashes the new value, and the Playground button shows a ×N badge while the zoom is not 1.
Output: Color Scheme `o.colorScheme`	`Ctrl`+`Alt`+`C` in the editor; also `Alt`+`C` and `Alt`+`Shift`+`C` elsewhere	`⌘`+`⌥`+`C` in the editor; also `⌥`+`C` and `⌃`+`⌥`+`C` elsewhere	The split popover	Cycles System, Dark, Light. Inside the editor on Windows and Linux, `Alt`+`C` belongs to the find widget. In Safari the split popover row links to a WebKit bug instead; the keys and the dialog still work.
Scroll every output	`Ctrl`+`Alt`+`Home`, `Ctrl`+`Alt`+`End`, `Ctrl`+`Alt`+`PageUp`, `Ctrl`+`Alt`+`PageDown`, `Ctrl`+`Alt`+`←`, `Ctrl`+`Alt`+`→`, `Ctrl`+`Alt`+`[`, `Ctrl`+`Alt`+`]`	The same with `⌃` and `⌥`	The split popover	Scrolls all connected outputs without leaving the editor: to the top or bottom, by a page minus one line, or by 135 px. Shift makes Home, End, PageUp, PageDown and the brackets scroll horizontally. Pressed in the output, the same keys move the cursor of the input instead.
New Output Window (popup)… `sync.x1`	`Alt`+`Shift`+`B`	`⌥`+`⇧`+`B`	Open ▸ Output ▸ Popup	The menu item shows `Alt`+`B`, but the key is `Alt`+`Shift`+`B`. Hidden on touch-only devices. See Output windows.
New Output Window (tab)… `sync.x0`	`Ctrl`+`Alt`+`B`	`⌘`+`⌥`+`B`; also `⌃`+`⌥`+`B`	Open ▸ Output ▸ Tab	Opens the output in a tab of its own.
New Remote Output… Experimental `sync.xz`	`Alt`+`Q`	`⌥`+`Q`	Open ▸ Output ▸ Remote	Asks to confirm, then shows an `rt.ht` link with a QR code. A work in progress.
View Remote Outputs… Experimental `sync.xa`	`Alt`+`Y`	`⌥`+`Y`	The cast button of the toolbar	Lists the remote sessions. Click a session, and confirm, to end it.
Freeze All Windows Experimental `code.rf`	`Ctrl`+`Alt`+`F`	`⌘`+`⌥`+`F`; also `⌃`+`⌥`+`F` outside the editor	Palette	Moves this playground, and every other playground tab of the browser profile, to the Freeze page. Does nothing in a frozen page.
Freeze This Window Experimental `code.rd`	`Ctrl`+`Alt`+`D`	`⌘`+`⌥`+`D`	Palette	Freezes only this tab.

Playground commands

These commands move around the playground: its menus, the layout and the split, focus, fullscreen and the console.

Command	Windows and Linux	macOS	Menu	Notes
Show Code Menu `show.sm`	`Alt`+`F`	`⌥`+`F`	The logo button	Toggles the File menu. Closing it restores the previous focus.
Show Share Menu `show.lm`	`Alt`+`J`	`⌥`+`J`	The layout button	Toggles the Playground menu. The palette uses the older name.
Show Open Menu `show.om`	`Alt`+`K`	`⌥`+`K`	The ↗ button	Toggles the Open menu.
Show User Menu `show.um`	`Alt`+`U`	`⌃`+`⌥`+`U` in the editor; `⌥`+`U` or `⌃`+`⌥`+`U` elsewhere	The avatar	Toggles the User menu. Enter or Space on the focused avatar opens it too.
Toggle Panels `sync.ap`	`Alt`+`P`	`⌥`+`P`	Playground ▸ Swap ▸ Panels	Swaps input and output and mirrors the split position.
Toggle Layout `sync.al`	`Alt`+`/`	`⌥`+`/`	Playground ▸ Swap ▸ Layout	Switches between side by side and stacked.
Split position	`Alt`+`1` to `Alt`+`9`, `Alt`+`0`, `Alt`+`[`, `Alt`+`]`, `Alt`+`'`	The same with `⌥` in place of `Alt`	The split popover	Alt+1 to Alt+9 set 10% to 90%, and the digit of the current position mirrors it to 100 − n. Alt+0 sets 100%, or 0% when the split is above 90%. The brackets move by 1%, with Shift by 10%. Alt+' mirrors the split. Numpad digits are refused. In the macOS editor, Option and a key types a character, so it has actions for the digits and the brackets, which step by 1% only.
Focus the divider; lock the split	`Ctrl`+`'`; `Ctrl`+`Alt`+`'`	`⌘`+`'` or `⌃`+`'`; `⌘`+`⌥`+`'` or `⌃`+`⌥`+`'`	The split divider	The first focuses the divider, and then its keys need no modifier. Press it again to return to the input. The second locks or unlocks the split, and a locked divider turns red on hover.
Focus the console divider	`Ctrl`+`;`	`⌘`+`;` or `⌃`+`;`	The console panel	Needs the console to be open. Press `;` on the divider to return to the input. `Ctrl`+`Alt`+`;` toggles the console, like `Alt`+`;`.
Focus the input, focus the output	`Ctrl`+`I`; `Ctrl`+`O`	`⌘`+`I` or `⌃`+`I`; `⌘`+`O` or `⌃`+`O`	The split popover	Ctrl+I remembers the focused element of the output and focuses the input. Ctrl+O focuses the output and restores that element. In the editor, Ctrl+I starts the chords of the Input commands.
Fullscreen Input, Fullscreen, Fullscreen Output `code.if, code.xf, code.of`	`Ctrl`+`F10`, `Ctrl`+`F11`, `Ctrl`+`F12`	`⌘`+`F10`, `⌘`+`F11`, `⌘`+`F12` in the editor; `⌃` elsewhere	Playground ▸ Fullscreen ▸ Input, Window, Output	Each toggles. They exist only where the Fullscreen API is available, so not on iPhone, and in an embedded playground only when the embedding frame allows fullscreen.
Developer Tools → Console `vcon.df`	`F12`; `Alt`+`;`	`F12`; `⌥`+`;`	The 📜 button	Toggles the console panel. Outside the editor, F12 works only while no element is fullscreen. See Console and network.
Developer Tools → Network `vcon.nw`	`F9`	`F9`	A right-click on the 📜 button	Toggles the network panel.
Commands	`F1`	`F1`	Playground ▸ Input ▸ Commands	Focuses the input and opens the command palette.
Reload	`Ctrl`+`R`	`⌘`+`R`	Playground ▸ Reload, in an embedded playground	Flushes the URL state and reloads the playground, so the session survives. Any Ctrl (⌘ or ⌃ on macOS) with R works, also `Ctrl`+`Shift`+`R`.
Focus the notifications	`Alt`+`N`	`⌥`+`N`	The toast stack hint	Focuses the first control of the toast stack. Esc hides the focused toast and moves on.
About	`Alt`+`Shift`+`/` (`Alt`+`?`)	`⌥`+`⇧`+`/`	Playground ▸ About	Shows the trademark and copyright notice, the version lines and your browser.
Tour	—	—	Playground ▸ Tour	A short tour of the shortcut tooltips.
Reset	—	—	Playground ▸ Reset	Opens the Clear Caches page at `cc.rt.ht` in a new tab. Its buttons open the `/clear` page of each output domain.
Feedback	—	—	Playground ▸ Feedback	Opens the feedback repository on GitHub.
Toggle Word Wrap `sync.tw`	`Alt`+`Z`	`⌥`+`Z`	Palette	Toggles word wrap in the input.
Toggle Double-Click Selects Block; Toggle Find Closes on Result `editor.dcb, editor.fcr`	—	—	Palette	Two editor preferences. Both are saved in the playground URL.
macOS-only editor actions `ms0 to ms9, ms-, ms+, edge.recent, mfc, mfo`	—	`⌥`+`0` to `⌥`+`9`, `⌥`+`[`, `⌥`+`]`, `⌥`+`.`, `⌥`+`;`, `⌃`+`O`	Palette	Option and a key types a character in the editor on a Mac, so these actions exist there only: Set Position to 10% to 90%, Toggle Split Position 0%/100%, Decrease and Increase Split Position, Edge: Recent Deployments…, Focus Console Split, which toggles the console, and Focus Output.

Input commands

The Input section of the Playground menu and the editor's context menu. Chords such as Ctrl+I R are two steps: press the first keys, then press the last key on its own. Number nudging, selections, evaluation and snippets have their own tables below.

Command	Windows and Linux	macOS	Menu	Notes
Find, Replace	`Ctrl`+`F`; `Ctrl`+`H`	`⌘`+`F`	Playground ▸ Input ▸ Code ▸ Find, Replace	Opens the find widget. The Replace item shows no key on macOS.
Input: Copy (Selection) to Clipboard `i2c`	`Ctrl`+`C`	`⌘`+`C`	Playground ▸ Input ▸ Code ▸ Copy	Copies the selections, or the whole input when nothing is selected, with every `copy:redact` element redacted. The editor's own copy and cut redact the same way.
Clear, Paste	`Ctrl`+`V` pastes	`⌘`+`V` pastes	Playground ▸ Input ▸ Code ▸ Clear, Paste	Clear empties the input as one undoable step. Paste inserts the clipboard at the primary selection. Both push to the output only while Live input → output is on.
Undo, Redo	`Ctrl`+`Z`; `Ctrl`+`Y` or `Ctrl`+`Shift`+`Z`	`⌘`+`Z`; `⌘`+`Y` or `⌘`+`⇧`+`Z`	Playground ▸ Input ▸ Code ▸ Edit ▸ Undo, Redo	Smart Undo: editor undo first, then, when the editor has nothing left to undo and the playground has routes, the deployment history. See Versions and Smart Undo.
Select ▸ None	`Esc`	`Esc`	Playground ▸ Input ▸ Select ▸ None	Collapses every selection to its start.
Select ▸ Line: Expand, Start, End, Before, After	`Ctrl`+`L` expands	`⌘`+`L` expands	Playground ▸ Input ▸ Select ▸ Line	Before extends each selection to column 1 of the previous line, and After to the end of the next line.
Select ▸ Highlights	`Ctrl`+`F2`	`⌘`+`F2`	Playground ▸ Input ▸ Select ▸ Highlights	Selects every highlighted occurrence.
Select ▸ All	`Ctrl`+`A`	`⌘`+`A`	Playground ▸ Input ▸ Select ▸ All	Selects the whole input. Outside editable targets `Ctrl`+`A` is blocked, so the page UI is never selected as a whole.
HTML: Select Enclosing Element.innerHTML, .outerHTML and Tags `html.se.i, html.se.o, html.se.t`	`Ctrl`+`Shift`+`I`, `Ctrl`+`Shift`+`O`, `Ctrl`+`Shift`+`U`	`⌘`+`⇧`+`I`, `⌘`+`⇧`+`O`, `⌘`+`⇧`+`U`	Playground ▸ Input ▸ Select ▸ HTML ▸ Inner, Outer, Tags; context menu	Selects, for every cursor, the inner content, the whole element or its two tags. Repeating Outer on an exact element selection climbs to the parent.
Select ▸ History: Undo, Redo	`Ctrl`+`U` undoes	`⌘`+`U` undoes	Playground ▸ Input ▸ Select ▸ History	Undoes or redoes the last cursor movement.
Count Unique Lines `count-lines`	`Ctrl`+`L` `C`	`⌘`+`L` `C`	Context menu	Replaces the input with each distinct line and its count, most frequent first, as one undo step. If the chord does not work, use the palette or the context menu.
Input: Compare/Diff as Original with Clipboard…; the Selection as Original and as Modified `diff.clipboard, diff.i_o, diff.i_m`	`Ctrl`+`K` `C`; `Ctrl`+`I` `O`; `Ctrl`+`I` `M`	`⌘`+`K` `C`; `⌘`+`I` `O`; `⌘`+`I` `M`	Palette	Opens `diff.rt.ht` with your text and the clipboard. The selection forms use the whole input when every selection is empty.
Input: Fetch [i:], Input: Empty [i:] `src.fetch, src.empty`	`Ctrl`+`I` `F`; `Ctrl`+`I` `E`	`⌘`+`I` `F`; `⌘`+`I` `E`	Palette	Within the selections, or the whole input, fetches the content of every element with an `i:` URL into it, or empties it again.
Paste URL Content… `sync.pcou`	—	—	Context menu	Prompts for a URL, fetches it like Import URL and inserts the text at the cursor. The title does not change.
Paste with Positions… `sync.ps`	—	—	Context menu	Pastes the clipboard where `\|` makes a cursor and `\|>…<\|` makes a selection. See Editing superpowers.
Open URL… `open.url`	—	—	Palette	Prompts for a URL and opens it in a new tab.
Clear: Worker Import Cache `pini.cc`	`Ctrl`+`Shift`+`C`	`⌘`+`⇧`+`C`	Palette	Forgets the cached worker imports, so the next build fetches them again. It does not reload; press `F5`.
Clear: Service Worker `inside.clear`	`Ctrl`+`Shift`+`W`	`⌘`+`⇧`+`W`	Palette	Clears the import cache and the service worker, session state and KV data of the current output domain. Browsers reserve `Ctrl`+`Shift`+`W` in a normal tab, so use the palette. See Troubleshooting.
HTML: Element Stats… `analyze.html.stats`	`Alt`+`H` `S`	`⌥`+`H` `S`	Context menu	Shows a table of the elements of the selections, or of the whole input, with the length of their outer and inner HTML.
Selection: Get HTML `sync.gh`	`Alt`+`H` `H`	`⌥`+`H` `H`	Context menu	With a selection, serializes it again through the playground's serializer, which normalizes the markup. No sync.
Unicode: Insert Variation Selector-15 (text) and -16 (emoji), for HTML, CSS, JS and URL `html.0e, html.0f, css.0e, css.0f, js.0e, js.0f, url.0e, url.0f`	—	—	Palette	Inserts `︎` or `️` (HTML), `\FE0E` or `\FE0F` (CSS), `\uFE0E` or `\uFE0F` (JS), `%EF%B8%8E` or `%EF%B8%8F` (URL) at every cursor.

Note: Ctrl/⌘+click on text in the input selects the authored inner HTML of the clicked element, or its outer HTML when it has no inner content. Clicking inside an exact selection climbs to the enclosing element.

Nudging numbers and evaluating expressions

See Editing superpowers for how nudging and evaluation work. A nudge changes every selection that is a number; the others stay unchanged.

Command	Windows and Linux	macOS	Menu	Notes
Increment, Decrement Selected Numbers `sync.Increment Selected Numbers, sync.Decrement Selected Numbers`	`↑`, `↓`	`↑`, `↓`	The toolbar delta controls	Changes every selected number by 1. With a number selected the arrow keys stop moving the cursor.
… by 10 `sync.Increment Selected Numbers by 10, … Decrement …`	`Shift`+`↑`, `Shift`+`↓`	`⇧`+`↑`, `⇧`+`↓`	—	Steps of 10.
… by 100 `sync.Increment Selected Numbers by 100, … Decrement …`	`Ctrl`+`↑`, `Ctrl`+`↓`	`⌘`+`↑`, `⌘`+`↓`	—	Steps of 100.
… by .1 `sync.Increment Selected Numbers by .1, … Decrement …`	`Alt`+`↑`, `Alt`+`↓`	`⌥`+`↑`, `⌥`+`↓`	—	Steps of 0.1, with the result rounded to one decimal.
… by .01 `sync.Increment Selected Numbers by .01, … Decrement …`	`Alt`+`Shift`+`↑`, `Alt`+`Shift`+`↓`	`⌥`+`⇧`+`↑`, `⌥`+`⇧`+`↓`	—	Steps of 0.01, with the result rounded to two decimals.
Toggle Selected Booleans `sync.Toggle Selected Booleans`	`↑`, `↓`	`↑`, `↓`	—	Flips every selected `true` or `false`. The result is lower case. With numbers and booleans selected, the arrows change only the numbers.
Eval Expression on In-/decrement… (Number) `sync.dx`	`Alt`+`=` with a selection	`⌥`+`=` with a selection	The `=` button of the toolbar; context menu	Prompts for the delta expression, prefilled with the current one. An empty answer restores `(x + d)`. Script form: `dx`.
Eval Expression on Selections… (Number) `sync.een`	`Alt`+`E` `	`⌘`+`E` `	Context menu	Needs a selection. Applies an expression once to the numbers of the selections; `x` is the number and `i` the index. See the note on macOS below.
Eval Expression on Selections… (String) `sync.ees`	`Alt`+`E` `S`	`⌘`+`E` `S`	Context menu	Needs a selection. Applies a string expression to the text of each selection. A selection that throws shows its index and message and stays unchanged.
Eval Selections `sync.es`	`Alt`+`E` `E`	`⌃`+`⌘`+`E` `E`	Context menu	Needs a selection. Evaluates the text of each selection as JavaScript and replaces it with the result, formatted as a number. Errors leave the selection unchanged.

Note: On macOS, ⌘+E also opens the first route, and that command is registered after the two expression chords, so ⌘+E ` and ⌘+E S open the route instead. Use the context menu or the palette there.

Selection commands

The chords starting with Alt+S need at least one non-empty selection, and those starting with Alt+M reorder the selected texts among the selections. Without the selection they need, Alt+S inserts a New Style snippet and Alt+M a New Script Module snippet. Sorting and rotating are one undo step each and push to the output. See Editing superpowers.

Command	Windows and Linux	macOS	Menu	Notes
Selections: Reverse Directions `sel.rev`	`Alt`+`S` `R`	`⌥`+`S` `R`	Palette, context menu	Flips the direction of every selection.
Selections: Unify Directions `sel.uni`	`Alt`+`S` `U`	`⌥`+`S` `U`	Palette, context menu	Gives every selection the direction of the last one.
Selections: Split to Cursors `sel.r2c`	`Alt`+`S` `V`	`⌥`+`S` `V`	Palette, context menu	Turns each non-empty selection into cursors at its start and end.
Selections: Invert `sel.inv`	`Alt`+`S` `I`	`⌥`+`S` `I`	Palette, context menu	Selects every unselected span, then runs Unselect Line Breaks.
Selections: Invert in Line `sel.inl`	`Alt`+`S` `L`	`⌥`+`S` `L`	Palette, context menu	Selects the unselected parts of each touched line.
Selections: Fill… `sel.fill`	`Alt`+`S` `F`	`⌥`+`S` `F`	Palette, context menu	Asks for a text, one space by default, and repeats it to the length of each selection. An empty answer cancels.
Selections: Replace… `sel.replace`	`Alt`+`S` `X`	`⌥`+`S` `X`	Palette, context menu	Asks for a literal string and replaces every selection with it, also inserting at cursors. The prompt is prefilled when all selections are equal.
Selections: Enclose with HTML Element… `sel.wraphtml`	`Alt`+`S` `H`	`⌥`+`S` `H`	Palette, context menu	Asks for an element name such as `span`, or opening-tag content such as `a href=//example.com`, and wraps each selection. Void elements such as `img` are refused.
Selections: Split at Fixed Width… `sel.split`	`Alt`+`S` `P`	`⌥`+`S` `P`	Palette, context menu	Asks for `width,separator`, `2,-` by default, and joins chunks of that width with the separator.
Selections: Delete Lines Without `sel.delns`	`Alt`+`S` `D`	`⌥`+`S` `D`	Palette, context menu	Deletes every line that no selection or cursor touches, as one undo step.
Selections: Unselect Line Breaks `sel.unnl`	`Alt`+`S` `N`	`⌥`+`S` `N`	Palette, context menu	Splits multi-line selections per line, without the line breaks, and removes cursors.
Selections: Remove Cursors `sel.rmcur`	`Alt`+`S` `C`	`⌥`+`S` `C`	Palette, context menu	Removes the empty selections.
Selections: Extend to Whole Lines `sel.whole`	`Alt`+`H` `L`	`⌥`+`H` `L`	Palette, context menu	Extends each selection to whole lines, then merges selections that share a line. Needs no selection.
Selections (multiple): Rotate → `sel.rof`	`Alt`+`M` `→`	`⌥`+`M` `→`	Palette, context menu	Moves the last text to the first selection. Needs one selected text and other cursors, so it can move text into empty cursors.
Selections (multiple): Rotate ← `sel.rob`	`Alt`+`M` `←`	`⌥`+`M` `←`	Palette, context menu	Moves the first text to the last selection.
Selections (multiple): Shuffle `sel.shf`	`Alt`+`M` `↑`	`⌥`+`M` `↑`	Palette, context menu	Puts the texts in random order. Needs more than one selected text.
Selections (multiple): Sort as string `sel.sas`	`Alt`+`M` `S`	`⌥`+`M` `S`	Palette, context menu	Sorts the texts with `localeCompare`.
Selections (multiple): Sort as number `sel.san`	`Alt`+`M` `N`	`⌥`+`M` `N`	Palette, context menu	Sorts the texts by `Number(text)`.
Selections (multiple): Reverse `sel.rvm`	`Alt`+`M` `↓` or `Alt`+`M` `R`	`⌥`+`M` `↓` or `⌥`+`M` `R`	Palette, context menu	Reverses the order of the texts.
Toggle Selection Move `selection.toggleMove`	`Ctrl`+`M`	`⌘`+`M`	Palette	Turns Selection Move on or off, with a toast that lists the keys. Browsers may take `⌘`+`M` on macOS to minimize the window.
Move Selection Up, Down, Left, Right `selection.moveUp, selection.moveDown, selection.moveLeft, selection.moveRight`	`Alt`+`↑`, `Alt`+`↓`, `Alt`+`←`, `Alt`+`→` while Selection Move is on	`⌥`+`↑`, `⌥`+`↓`, `⌥`+`←`, `⌥`+`→` while Selection Move is on	Palette	Moves the selections themselves, not the text: up and down by a line, with wrap-around, and left and right by a column across line ends.

Encode and decode commands

Each command maps every selection and pushes to the output. A selection that throws shows its index and the message and stays unchanged. They need a selection, and in the context menu they sit in the js group. The key is Alt+Shift with a letter, then E to encode or D to decode.

Command	Windows and Linux	macOS	Menu	Notes
Encode, Decode URI Component `sync.euc, sync.duc`	`Alt`+`Shift`+`U` `E`, `Alt`+`Shift`+`U` `D`	`⌥`+`⇧`+`U` `E`, `⌥`+`⇧`+`U` `D`	Palette, context menu	`encodeURIComponent`, `decodeURIComponent`.
Encode, Decode Base64 `sync.eb64, sync.db64`	`Alt`+`Shift`+`B` `E`, `Alt`+`Shift`+`B` `D`	`⌥`+`⇧`+`B` `E`, `⌥`+`⇧`+`B` `D`	Palette, context menu	UTF-8 bytes to standard Base64 and back. With a selection, `Alt`+`Shift`+`B` opens a popup output instead of starting the chord, so use the palette or the context menu.
Encode, Decode Hex `sync.ehex, sync.dhex`	`Alt`+`Shift`+`H` `E`, `Alt`+`Shift`+`H` `D`	`⌥`+`⇧`+`H` `E`, `⌥`+`⇧`+`H` `D`	Palette, context menu	UTF-8 bytes to lower-case hex pairs and back. The same chord belongs to HTML Entities, which wins, so use the palette or the context menu.
Encode, Decode HTML Entities `sync.ehtml, sync.dhtml`	`Alt`+`Shift`+`H` `E`, `Alt`+`Shift`+`H` `D`	`⌥`+`⇧`+`H` `E`, `⌥`+`⇧`+`H` `D`	Palette, context menu	Escapes `<`, `>`, `&`, `"` and `'` as `<`, `>`, `&`, `"` and `'`; decodes any entity.
Encode, Decode JSON `sync.ejson, sync.djson`	`Alt`+`Shift`+`J` `E`, `Alt`+`Shift`+`J` `D`	`⌥`+`⇧`+`J` `E`, `⌥`+`⇧`+`J` `D`	Palette, context menu	Encode parses and pretty-prints with two spaces. Decode parses and minifies.
Encode, Decode URL `sync.eurl, sync.durl`	`Alt`+`Shift`+`L` `E`, `Alt`+`Shift`+`L` `D`	`⌥`+`⇧`+`L` `E`, `⌥`+`⇧`+`L` `D`	Palette, context menu	`encodeURI`, `decodeURI`.
Encode, Decode Punycode `sync.epny, sync.dpny`	`Alt`+`Shift`+`P` `E`, `Alt`+`Shift`+`P` `D`	`⌥`+`⇧`+`P` `E`, `⌥`+`⇧`+`P` `D`	Palette, context menu	Encode converts a hostname with `new URL`, and leaves the text unchanged on error. Decode converts it back, loading the converter on first use.

Snippets

Snippet commands insert at every cursor. In the inserted text, | marks where the cursor lands and |>…<| what ends up selected. See Editing superpowers.

Command	Windows and Linux	macOS	Menu	Notes
New Style `sync.ns`	`Alt`+`S`	`⌥`+`S`	Palette, context menu	Inserts `<style>\|</style>`. With a selection, `Alt`+`S` starts a chord instead.
New Script `sync.nx`	`Alt`+`X`	`⌥`+`X`	Palette, context menu	Inserts `<script>\|</script>`.
New Script Module `sync.nm`	`Alt`+`M`	`⌥`+`M`	Palette, context menu	Inserts `<script type=module>\|</script>`. With several selections, `Alt`+`M` starts a chord instead.
New Markdown (MD) `sync.md`	—	—	Palette, context menu	Inserts a `zero-md` module script and a `<zero-md>` element with an inline Markdown script, with `## Welcome` selected.
New Script Worker (simple) `sync.nw`	`Alt`+`G`	`⌥`+`G`	Palette, context menu	Needs a single empty cursor. Inserts a full-page style, `<iframe src=:></iframe>` and a `<script type=worker edge>` whose `fetch` returns the pathname.
New Script Worker `sync.nwf`	—	—	Palette, context menu	Needs a single empty cursor. Inserts a longer example: a module that calls `:hello`, an edge worker that signs the request URL, and a separate `copy:redact` worker for its secret. Review it before you deploy.

Notes

Item modifiers

Click an item, or press Enter on it, with a modifier held.

Item	Shift	Ctrl (⌃ on macOS)	Alt	Space
File ▸ Code ▸ Size	Opens the deployed route	—	—	—
File ▸ Edge ▸ Deploy	—	—	Adds a commit message	—
File ▸ Edge ▸ Delete	Skips the confirmation (Enter only)	—	—	—
File ▸ Agent ▸ Share	Empties the work folder	Also captures the output	Adds a random folder suffix	Toggles Auto-Share
File ▸ Agent ▸ Unshare	Empties the work folder	Deletes the work folder	—	Toggles Auto-Share
File ▸ Capture ▸ Image	Saves to the shared folder	Copies to the clipboard	Skips the download	—
The title button, middle-click	Opens all routes	—	—	—

Some items keep their menu open after you activate them: the Live toggles, the Sync, Load and F6 items, Delete, PiP, Image, the video items, Swap, Clear, Copy and Paste, and the Select items.

Behavior of Delete

Edge: Delete… deletes the deployments of every route in the Code dialog, and it needs you to be signed in. Shift+Delete starts it from any focused element, including text fields and prompts, and in the editor it replaces Monaco's own Shift+Delete, which cuts. Ctrl+Shift+Delete skips the confirmation.

Warning: Because Shift+Delete works from text fields, press it only when you mean to delete. A deleted deployment keeps its version history, but its URL then answers 404. See Deploying to RTEdge.net.

Commands that depend on state

A command appears only while its precondition holds. Number nudges need a number in the selection, evaluation and encode commands need a selection, the single-cursor snippets need one empty cursor, the Agent commands need FileSystemObserver and a top-level playground, and Capture needs getDisplayMedia(). Some keys also depend on where the focus is, or on whether a share or capture is running. Keyboard shortcuts lists them.

Running a command from code Experimental

From io.eval.js or the developer console of the playground tab, run a command by its id in the playground window. The call returns a promise of the command's own result, and does nothing when the precondition is false. The ids are in the tables above.

await i.m.getAction('o.colorScheme').run({ set: 'dark' })   // 'dark'; { set: null } restores System
await i.m.getAction('o.zoom').run({ set: 1.5 })             // the same as oz = 1.5
await i.m.getAction('edge.open.all')?.run()                  // Ctrl/⌘+Shift+E

A few commands take an argument object. o.zoom takes { set: number }, o.colorScheme takes { set: 'dark' | 'light' | null } and open.url takes [url]. Ids with an underscore, a space or a hyphen, such as diff.i_o, count-lines and the nudge ids, need getAction().

Note: Running commands from code is not part of a stable interface. Commands, ids and arguments may change.

Keys that are taken

Where two commands share a key, the playground runs the one registered last whose condition holds. That is why Alt+Shift+B opens a popup output even with a selection, why Alt+Shift+H reaches HTML Entities rather than Hex, and why the ⌘+E expression chords open the route on macOS. Keyboard shortcuts lists the conflicts and the keys that browsers or keyboard layouts may take first.