Code IDE Tour

Every kind of work has its proper surface. In Circuitry you think on the whiteboard, design in the Designer, and run pipelines on the workflow board — and when the work is project code, the right surface is a proper IDE. Nothing less does the job.

So open a project — File → Open Project ⌘⇧O, or New Project ⌘⇧N — and Circuitry becomes exactly that: a full agentic IDE, reshaped around your codebase with a file browser, git version control, real editors for your files, and a coding agent one click away. If you know editors like VS Code, you'll be at home in minutes. And what joins this surface to all the others is the AI chat assistant: the same conversation that edits your code can work on every other aspect of the project — the sketches, the designs, the pipelines — each on the surface it belongs to.

Tap to enlarge

Just one file

Not every job is a whole project. File → Open File ⌘O opens a single file in its proper editor — a markdown note, an image, a spreadsheet, a script — with no project around it. Browse to it, or paste the path straight into the path box at the top of the picker and press ⏎: handy when another tool has just told you a path and you have nothing to drag.

To start a new file, choose Code from the new-document menu, pick the language, and give the file a name. It opens straight away in the right editor: an HTML, Markdown or React file beside its preview, a Python file beside its canvas. No project is needed, and nothing is written to disk yet. The first time you save it, Circuitry asks where to put it: the open project, or a folder on this computer, this device (including iCloud Drive), or your Circuit. In a web browser you can also keep it in This Browser, on any plan, or download a copy. After that, Save writes to that file.

Demos

The Demos folder at the top of Cloud files holds ready-made projects. Opening a code demo saves all of its files (the code, and the pictures, data and music it uses) in a folder named after the demo, and opens it from there, so you can see the files in Files, open them and run them:

• In a web browser: under This Browser in Files, in the Demos folder. This works on every plan, including Free. The files stay in this browser's storage; clearing the site's data in the browser removes them.
• In a web browser with your Circuit connected (Personal and up): the first demo you open asks for a folder on your Circuit, and every demo after that is saved there. While the Circuit is not connected, demos are saved in This Browser and Circuitry tells you so.
• In the desktop app: the first demo you open asks for a folder on this computer (it suggests Documents/Circuitry/Demos), and every demo after that is saved there.
• On iPhone, iPad and Android: in the Demos folder on the device.

To change where demos are saved, open Settings → General → Demos. A demo opens from its saved copy straight away next time, even offline, and is updated when the demo changes. The saved copy stays the demo's own: when you change a demo file and save, Circuitry saves a copy of the whole demo with your change, in a folder of its own, and opens that. Your copy is yours to edit and save as often as you like, and updates to the demo never touch it.

The project workspace

• File browser — the left panel becomes your project tree: browse, open, and manage the project's files; open files are marked so you can see at a glance what's already in your tabs.
• Git version control — a source-control panel tracks your working tree: see changes, stage, commit, and manage branches without leaving the studio.
• Editors for many file types — code with syntax highlighting and intelligent completions, plus viewers and editors for markdown, HTML, images, PDFs, data files, and more. Every file opens as a tab; split the view to work side by side.

Markdown and HTML, with live split previews

Markdown and HTML files get a split view — source on one side, the rendered result on the other:

Tap to enlarge

The HTML split view is wired in both directions:

• Hover the rendered page and the matching code is selected in the editor ( inspect mode — a Chrome-style element picker).
• Hover the code and the related element highlights on the design ( hover select).

You read the page the way you read code, and the code the way you see the page.

The chat agent

Press the chat icon in the app header and Circuitry's dedicated chat agent opens beside your work. It's the same two-way channel every Circuitry editor shares: select anything — code, a file, a design element — and ask the chat to edit, change, or review "this". It knows what's selected and in which file, so you point instead of describing. When it edits your code, the changes land as approve / reject markers in the editor — nothing is silently applied. Here the agent has reworked a project file: every hunk carries its own Accept / Reject buttons, the review bar tallies what's pending with Accept All / Reject All, and the chat's file card shows the same change counts. Note the picker at the top of the chat — this conversation is powered by the Claude Code CLI:

Tap to enlarge

The agent runs on whatever intelligence suits you:

• Cloud frontier models — the latest hosted models.
• Local models — private, on your own machine. See Local AI Models.
• CLI coding agents — drive tools like Claude Code, Gemini CLI, or Codex through the same chat.

And if you'd rather work directly in a coding assistant, switch the chat to CLI mode and talk straight to the tool itself — same pane, no translation layer. Direct CLI mode needs the Circuitry MCP server installed for that assistant — it's how the CLI communicates with Circuitry and your documents. See Coding Agent for the full setup.

A tour of the controls

Keyboard shortcuts below use Cmd — that's Ctrl on Windows and Linux.

Top toolbar

The toolbar stays out of the way until there's something to act on — unsaved changes, a pending AI edit, or a storage connection.

• Accept All / Reject All — when an agent or AI edit is pending, a review bar appears on the left with change stats and these two buttons. The proposed changes are shown as a diff right in the editor; nothing is final until you decide.
• Save — Save writes the buffer back to the local or remote file (⌘S). Disabled when there's nothing to save. A new file that has never been saved asks where to put it first.
• Connection readout — text on the right shows where the file lives when it's opened through a storage connection or the Circuit.

Status bar

Always present along the bottom of the editor.

• Language readout — the detected language driving syntax highlighting.
• Run — runs the file, for a language that can run. While a Python file runs in its preview, the same button is Stop.
• — Debugging, for languages with breakpoints. It is dim until the file has a breakpoint; once lit, Run stops at the breakpoints, and a debug bar (Stop, Continue, Over, Into, Out and the line) is docked above the code. Tap it to turn debugging off and run straight through. See Debugging.
• Unsaved changes — an amber dot while you edit, then a check once your changes are kept on this device, a few seconds after you stop typing. Save writes them to the file itself.
• — npm, on a file inside a Node project that is on a computer: install the project's packages, add one, or open a terminal in the project. See Node Packages (npm). For Python, a !pip install line in the file installs a package: see Installing Python Packages.
• AI inline completion toggle — a small sparkle-plus-Tab-key glyph. When it's on, ghost-text suggestions appear as you type and ⇥ accepts them; click to switch inline AI off or back on. Visible for every language.

Python preview

A Python file can draw 2D and 3D graphics on a preview beside the code. See Pyctures.

• — Preview shows the preview only. Split shows the code and the preview side by side. With both off, the file is plain Python and Run prints to the output panel. A new, empty Python file opens split. On a phone, turns the preview on, and a Code / Preview switcher moves between the two.
• — Frame rate shows the preview's frames per second in its top-right corner while a program runs.

JavaScript preview

A plain JavaScript file that draws (a scene) shows a preview beside the code too, with the same and buttons. The preview follows your typing, Run or starts the scene again, LOG shows what it prints, and records it. See pictures.js.

Markdown and HTML extras

• — Preview toggles between the rendered page and the source.
• Split view — a two-column button places source and live preview side by side, with the two-way hover sync described above.
• — Refresh preview re-renders the HTML preview; an amber dot warns when the source isn't in a renderable state and the preview is stale.
• AUTO / MAN — toggles HTML preview auto-refresh; in manual mode the preview updates only when you press refresh.

In the editor itself

• Ghost text — inline AI drafts the next few lines in faint text; ⇥ accepts, keep typing to ignore. See Inline AI.
• Inline prompt — press ⌘K and describe the change you want at the cursor; the edit comes back as a reviewable diff.
• Breakpoints — JavaScript, TypeScript, and Python files support line breakpoints for debug runs. Lua files do not; use print and read the output panel. (A TypeScript code node on the canvas supports them too — see Code Node. Different surface, same gesture: a file is debugged as itself, a node's code is a step in a workflow.)
• Vim keybindings — optional modal editing across editors and terminals, so you can code and navigate many nodes and files without leaving the home row. Toggled with ⌘⇧V once enabled in Settings → Code Editing. See Vim Mode.

The Edit and Select menus

Most of what you'd reach for in a mature code editor lives here, grouped so the menu stays short:

• Convert Case — UPPERCASE, lowercase, Title Case, camelCase, PascalCase, snake_case, kebab-case.
• Lines — move, duplicate, delete, join, sort ascending or descending, remove duplicates, trim trailing whitespace, transpose characters.
• Format — format the whole document or just the selection, indent and outdent, reindent, convert indentation between spaces and tabs, or detect it from the file.
• Find — find and replace, and two different ways to rename: Change All Occurrences (⌘F2) edits every match of the word under the cursor, while Rename Symbol (F2) understands scope, so it leaves a same-named variable in another function alone.
• Select — expand and shrink the selection, add cursors above and below, put a cursor at the end of every selected line, and add occurrences one at a time (⌘D) or all at once (⌘⇧L).

Filter Through Command (⌘⌥R) sends the selection — or the whole file, if nothing is selected — to a Python or shell command and replaces it with the output. It's the escape hatch for the transform no menu has: deduplicate and sort a list, reformat a block of JSON, renumber something. Python runs without any setup; the Shell option appears once you have a computer of your own connected. One undo puts the file back.

You don't have to remember how the command gets its input. Press Describe it, say what you want in plain English — "sort the lines and drop duplicates", "strip the timestamps off the front" — and it writes the command for you. It sees a sample of the text you selected, so it can match the format that's actually there rather than guessing. Describing it needs a paid plan; the Hobby plan is enough.

Editing code that lives on the canvas

Code and Agent nodes in a workflow carry the same editor. Open a node's code and it docks beside the canvas with its own header:

• Language dropdown — switches the code node's language: JavaScript, TypeScript, Lua, Three.js, Python, then Go, Rust, C, C++ and Zig, plus Shell when a computer of your own is connected. Go, Rust, C, C++ and Zig are compiled — see Code nodes for what that changes.
• — Run this node executes just the linked node.
• — Prompt Wizard (agent nodes) drafts or refines the node's prompt using upstream output.
• — Configure opens the node's settings panel.
• The footer has the same AI inline completion toggle, with a reminder that ⌘K opens inline AI.

Press — Expand editor — for a distraction-free fullscreen surface with its own tools: AI Wizard to generate code from a description, Run for this node, Run All for the whole workflow, Save, Copy code, zoom controls (Cmd −, Cmd 0, Cmd +), and Exit fullscreen (Esc).

Keyboard

Works with the rest of the studio

The IDE is one surface of one studio — your code lives beside the boards that plan it and the agents that build it:

• Circuitry as an Agentic IDE — the why and the workflow
• Full IDE: Code Editor — editor features in depth
• Inline AI — completions and the inline prompt
• Coding Agent — models, CLIs, and setup
• Agent Chat in Split-Screen — pairing chat with a document
• Terminal Tour — the shell beside your code