User Guide

Connect to any serial (UART / RS-232) device through a USB-to-serial adapter or a built-in USB serial interface (like on Arduino or ESP32 DevKit boards).

Connection panel — port selection, baud rate, control lines

Step by step

1. Plug in your device — USB-to-serial adapter, Arduino, ESP32, or any serial device. ComIO.Studio will auto-detect the new port via USB hotplug — it appears in the dropdown automatically.
2. Select the port from the Port dropdown (e.g., /dev/ttyUSB0 on Linux, COM3 on Windows). You can also click the ⟳ (refresh) button to manually refresh the list.
3. Set Baud Rate — choose from the dropdown. Must match your device. Most common: 9600 or 115200.
4. Optionally adjust other settings:
   • Data bits: 5, 6, 7, or 8 (default)
   • Parity: None (default), Odd, or Even
   • Stop bits: 1 (default) or 2
   • Flow control: No FC (default), XON/XOFF, or RTS/CTS
5. Click "Connect".
6. The LED indicator turns green, status shows "On", and the status bar displays your configuration (e.g., 115200 8N1 No FC).
7. Incoming data now appears in the terminal window.

Changing settings while connected

You can change baud rate, data bits, parity, stop bits, and flow control while connected — changes are applied instantly without disconnecting.

Control lines

Two toggle switches let you manually set output lines:

• RTS (Request To Send) — toggle on/off
• DTR (Data Terminal Ready) — toggle on/off

Four read-only indicators show the current state of input lines:

• DSR (Data Set Ready), CTS (Clear To Send), DCD (Data Carrier Detect), RI (Ring Indicator)

The main terminal window shows all incoming (RX) and outgoing (TX) data with color coding — green for RX, blue for TX.

Terminal with toolbar — encoding, timestamps, search, ANSI/VT100

Toolbar controls

• Encoding — display format:
  • ASCII (default) — text with line assembly
  • HEX — raw bytes in hexadecimal
  • ASCII + HEX — both together
• Autoscroll — when ON (default), terminal auto-scrolls to the latest data
• TS RX / TS TX — toggle timestamps for received / transmitted data (both ON by default)
• ANSI — parse ANSI escape codes for colored output (ON by default)
• VT100 — full VT100 terminal emulation with cursor positioning and screen control (OFF by default)
• RX line ending — how to split incoming data into lines: Raw, LF, CR, or CRLF (default)
• Buffer limit — maximum memory: 5 MB, 10 MB (default), 15 MB, or 20 MB
• 🎨 Terminal colors — opens a dialog where you can customize output colors:
  • TX — sent data
  • RX — received data
  • Info — system / programmer messages
  • Timestamp — time prefix
  Each row has a live preview and a ↺ button to reset just that color. Use Reset all to restore defaults.

Search

Type in the Search field to highlight matching lines. Use < and > buttons to jump between matches. A counter (e.g., 3/15) shows your position.

Save & Clear

• "Save" — downloads terminal contents as a text file
• "Clear" — clears the terminal and resets RX/TX statistics

Right-click context menu

• Copy (Ctrl+C) — copy selected text
• Add to Send — paste selected text into the command input field
• Send — immediately send the selected text to the serial port
• Select All (Ctrl+A) — select all terminal content
• Clear Terminal — same as the Clear button

Statistics (sidebar)

• RX: bytes received
• TX: bytes sent
• Time: connection uptime
• Recon.: number of reconnections

The command bar at the bottom of the screen is where you type and send data to the connected device.

Command bar — input, send, loop, format, history, file send

Basic sending

1. Type your command in the input field
2. Choose format: Text (default) or Hex (e.g., FF 01 03 00)
3. Choose TX line ending: None, CR, LF (default), or CRLF — appended to every sent command
4. Click "Send" or press Enter

Command history

Toggle "History" ON to see a dropdown with previously sent commands. You can also press ↑ / ↓ arrow keys to cycle through history. Click "Clear" in the dropdown header to erase all history.

Loop send

For repeated polling or keep-alive commands:

1. Toggle "Loop" ON
2. Set the interval in milliseconds (default: 1000 ms, range: 10–60000)
3. Type your command and click "Send" — the command is sent repeatedly at the set interval
4. The button changes to "Stop" (red) — click it to stop the loop

File send

Send the contents of a file through the serial port:

1. Click "Choose file" and select a file
2. Optionally set delay between chunks (0–1000 ms) for slow devices
3. Click "Send file" — a progress bar shows the transfer status

Macros are one-click command shortcuts. You have 6 macro buttons (M1–M6) in the sidebar.

Macros section — quick-access buttons M1–M6

How to set up macros

1. Click the "Edit" button in the Macros section — a modal window opens with all 6 macros
2. For each macro, fill in:
   • Name — the label shown on the button (e.g., "Reset", "Init")
   • Data — the command to send (e.g., ATZ or FF 01 03)
   • Mode — Text or Hex
   • EOL — line ending: None, CR, LF, or CRLF
3. Click "Save" to save all macros, or "Cancel" to discard changes

Edit Macros — name, data, format, and line ending for each macro

Using macros

Click any macro button (M1–M6) in the sidebar grid — the command is sent immediately. The button shows the custom name you set, or "M1"–"M6" if unnamed. Hovering shows a tooltip with the macro content.

Example: ESP8266 AT commands

M1: Name="AT"      Data="AT"        EOL=CRLF
M2: Name="Version" Data="AT+GMR"    EOL=CRLF
M3: Name="Reset"   Data="AT+RST"    EOL=CRLF
M4: Name="WiFi"    Data="AT+CWLAP"  EOL=CRLF

Triggers watch incoming serial data and automatically send a response when a text pattern is detected.

Triggers section — active toggle and rule count

How to create a trigger

1. Click the "Edit" button in the Triggers section — a modal window opens
2. Click "+ Add" to add a new trigger rule
3. Fill in the fields:
   • Pattern — the text to detect in incoming data (e.g., Password:)
   • → (arrow separator)
   • Response — what to auto-send back (e.g., mypassword)
   • Mode — Text or Hex
   • EOL — line ending: None, CR, LF, or CRLF
4. Click "Save"

Edit Triggers — pattern, response, format, and per-rule toggle

Managing triggers

• Enable/Disable individual trigger — toggle switch next to each rule
• Remove a trigger — click ✕ on the right side of the rule
• "Active" toggle (in the sidebar) — enables or disables ALL triggers at once
• Rule count — shows how many rules are configured (e.g., "3 rules")

Example: Auto-login

Pattern:  "Password:"
Response: "mypassword"    EOL=CRLF

→ When the device sends "Password:", ComIO.Studio
  automatically replies with "mypassword\r\n".

Example: Keep-alive

Pattern:  "PING"
Response: "PONG"    EOL=LF

→ Device sends "PING" → auto-reply "PONG\n".

ComIO.Studio includes a Lua 5.4 scripting engine for automating complex serial communication workflows.

Lua Script section — Run/Stop, status indicator, Edit button

Script editor

1. Click "Edit" in the Lua Script section — a modal editor opens with syntax highlighting
2. Write your Lua code, or select an example from the "📚 Examples..." dropdown
3. "Open" — load a .lua or .txt file from disk
4. "Save" / "Save As" — save your script to disk
5. "Close" — close the editor (code is auto-saved in memory)

Script Editor — syntax highlighting, examples dropdown, file operations

Running scripts

1. Make sure the serial port is connected (the Run button is disabled otherwise)
2. Click "Run" — status changes to "Running"
3. Script output appears in the terminal as 📜 [Script] ...
4. Click "Stop" to terminate a running script

Lua API Reference

-- ═══ Serial Port ═══

serial.send("AT+GMR\r\n")          -- Send text data
serial.send_hex("FF 01 02 03")     -- Send hex bytes
serial.send_raw(binary_string)     -- Send raw binary data
serial.read_all()                  -- Read all buffered data
serial.wait_for("OK", 5000)        -- Wait for pattern (timeout ms)
serial.wait_for_bytes(25, 3000)    -- Wait for N bytes (timeout ms)

-- ═══ Utility ═══

comio.sleep(1000)                  -- Pause execution (milliseconds)
comio.log("message")               -- Print to terminal output
comio.timestamp()                  -- Get current timestamp string
comio.to_hex(data)                 -- Convert binary to hex string
comio.crc16_modbus(data)           -- Calculate Modbus CRC16

Example: AT command test

comio.log("Starting AT command test...")

serial.send("AT\r\n")
local resp = serial.wait_for("OK", 3000)

if resp then
    comio.log("✅ AT responded OK")
else
    comio.log("❌ No response — check connection")
    return
end

serial.send("AT+GMR\r\n")
resp = serial.wait_for("OK", 3000)
comio.log("Firmware: " .. (resp or "unknown"))
comio.log("✅ Test complete!")

Example: Modbus RTU query

-- Read 10 holding registers from device at address 1
local addr = 0x01
local func = 0x03
local start_reg = 0x0000
local num_regs = 0x000A

local frame = string.char(addr, func,
    (start_reg >> 8) & 0xFF, start_reg & 0xFF,
    (num_regs >> 8) & 0xFF, num_regs & 0xFF)

local crc = comio.crc16_modbus(frame)
frame = frame .. string.char(crc & 0xFF, (crc >> 8) & 0xFF)

serial.send_raw(frame)
local resp = serial.wait_for_bytes(25, 3000)
comio.log("Response: " .. comio.to_hex(resp))

Flash firmware directly to microcontrollers through the serial port (UART bootloader). This uses the chip's built-in UART bootloader — you only need a USB-to-serial connection, no external hardware programmers (JTAG/SWD) are needed.

Programmer section — target selection, Flash/Read/Erase/Detect buttons

Supported chip families

• ESP32 (Espressif) — all ESP32 variants
• ESP8266 (Espressif) — ESP-01, NodeMCU, etc.
• STM32 (ST UART Bootloader) — chips with built-in UART bootloader
• AVR (Arduino STK500) — via serial bootloader protocol

Step by step

1. Select your Target chip family from the dropdown.
2. Make sure the correct serial port is selected in the Connection panel.
3. Click "Select Files" — a popup shows firmware segments. Each segment has:
   • Segment name (e.g., "Bootloader", "Firmware")
   • Address — flash memory address (e.g., 0x01000)
   • "Browse" — select a .bin, .hex, or .elf file
4. For ESP32/ESP8266 you can click "+ Add segment" to add more files.
5. Click ⚙ (Settings) to configure target-specific parameters:
   • ESP32/ESP8266: Flash Mode (QIO/DIO/DOUT), Frequency, Size, Compress, Stub loader.
   • STM32: Full erase, Write unprotect, Readout unprotect (mass-erases chip if executed).
   • AVR: Page size, Fuse reading/writing.
   • All targets: Connect Timeout.
6. Put your device in flash/boot mode:
   • ESP8266/ESP32: mostly automatic (RTS/DTR toggling). If your board lacks auto-reset, hold GPIO0 LOW, then reset.
   • STM32: set BOOT0 pin HIGH, then reset.
   • AVR: reset the board (bootloader activates automatically).
7. Choose an action:
   • Detect — reads chip info (MAC, signature).
   • Erase — wipes the flash memory.
   • Read — dumps flash memory to a file on your disk.
   • Flash — writes the selected files to the chip. A circular progress ring shows the status.

Select Files — firmware segments with addresses and file selection

Flash Settings — mode, frequency, size, timeouts, and toggle options

Other buttons

• "Erase" — erase the entire flash memory
• "Detect" — identify the connected chip (name, flash size, MAC address)

Example: ESP8266 AT firmware (1MB flash)

Segment 1: Bootloader    @ 0x00000  → boot_v1.7.bin
Segment 2: Firmware      @ 0x01000  → user1.1024.new.2.bin
Segment 3: Init Data     @ 0xFC000  → esp_init_data_default.bin
Segment 4: Blank (RF)    @ 0x7E000  → blank.bin
Segment 5: Blank (sys)   @ 0xFE000  → blank.bin

ComIO.Studio ships with an embedded llama.cpp runtime — you can run an open-source LLM fully offline, with no API key, no terminal, no Node.js. Everything happens inside the app.

How to enable

1. Open the AI panel in the right side of the app.
2. Click AI Settings → Local Models.
3. Pick a model from the list and click Download (GGUF format, a few hundred MB to several GB depending on the model).
4. Once download finishes, select the model as the active engine and start chatting.

When to use it

• Offline / air-gapped environments — no internet required after the model is downloaded.
• Privacy-sensitive work — prompts and replies never leave your machine.
• Zero recurring cost — no subscription, no per-query billing.

OpenRouter is a single API gateway that gives you access to hundreds of LLMs (Claude, GPT, Gemini, Llama, Mistral, DeepSeek and more) with one API key and one bill. No terminal, no CLI install — just paste a key into the app.

How to set it up

1. Create an account at openrouter.ai and top up some credit (pay-as-you-go).
2. Go to openrouter.ai/keys and generate a new API key (it looks like sk-or-v1-…).
3. In ComIO.Studio, open the AI panel → AI Settings → OpenRouter.
4. Paste the key, pick a model from the dropdown, and save.

When to use it

• You want to compare models easily — switch between Claude, GPT-4, Gemini, etc. from one dropdown without managing multiple API keys.
• You don't want to install a CLI agent like Claude Code or Codex.
• You need cost transparency — OpenRouter shows per-request pricing on their dashboard.

Beyond the built-in local model and OpenRouter, ComIO.Studio's AI panel can also drive an external command-line agent — either Claude Code (Anthropic) or Codex (OpenAI). Both run on Node.js. The whole setup is four steps: open a terminal → install Node.js → install ONE agent → use it in the app.

Pick your operating system below — every command on this page updates accordingly. Each code block has a Copy button in its top-right corner: click it, switch to the terminal, paste, then press Enter.

Pick your OS — applies to all steps below:

Step 1 — Open a terminal

A terminal is the window where you'll paste the commands from steps 2 and 3.

Open it: press Ctrl+Alt+T, or look for Terminal in your application menu.

To paste into it: Ctrl+Shift+V. Plain Ctrl+V usually does not work in a terminal.

About sudo: commands that start with sudo need admin rights. The terminal will ask for your user password — type it and press Enter. Nothing appears as you type — that's intentional, just keep going.

Open it: press Cmd+Space to open Spotlight, type Terminal, press Return. Alternative: Finder → Applications → Utilities → Terminal.

To paste into it: Cmd+V.

About passwords: if a command asks for a password, type your Mac login password and press Return. Nothing appears as you type — that's normal.

Open it:

• Windows 11: right-click the Start button (Windows logo, bottom-left of the screen) → Terminal. If a step below says it needs admin rights, choose Terminal (Administrator) instead and click Yes when Windows asks "Do you want to allow this app to make changes?".
• Windows 10: right-click Start → Windows PowerShell (or Windows PowerShell (Admin) for steps that need admin rights).

To paste into it: Ctrl+V, or right-click inside the terminal window.

Heads-up: after installing anything new (Node.js, claude, codex…) close the terminal window and open a new one. Windows caches the list of available commands per session — the new tool only shows up in a fresh terminal.

Step 2 — Install Node.js

Node.js is the runtime both AI agents are built on — install it once and you're set for both. Use the LTS release (20.x or newer).

Debian / Ubuntu — paste both lines into the terminal and press Enter after each (the sudo line will ask for your user password):

curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs

Verify:

node --version && npm --version

You should see two version numbers (something like v22.x.x and 10.x.x).

Don't use nvm for this. ComIO.Studio is a GUI app — it spawns subprocesses with a minimal environment that doesn't load nvm's shell init, so Node would end up invisible to the app even if it works in your terminal. Install system-wide as shown above.

If you have Homebrew:

brew install node

If not, download the macOS installer (.pkg) from nodejs.org and double-click to install.

Verify:

node --version && npm --version

You should see two version numbers.

Use winget (built into Windows 11). It needs the Terminal (Administrator) variant:

winget install OpenJS.NodeJS.LTS

If you don't have winget, download the .msi installer from nodejs.org and double-click to install.

Now close the terminal window and open a new one (PATH cache, see Step 1).

Verify in the new terminal:

node --version
npm --version

You should see two version numbers.

Step 3 — Install ONE AI agent

Pick one agent below — you don't need both. Each agent has three sub-steps: 3a install, 3b sign in, 3c verify. You can switch (or add the second one later) any time in ComIO.Studio's AI Settings.

Claude Code by Anthropic Codex by OpenAI

Claude Code is Anthropic's command-line agent. In sub-step 3b you'll have two sign-in methods — pick Option A (browser login with your Claude.ai account) for normal use, or Option B (API key) only if you need headless / scripted access. Do NOT do both.

3a — Install Claude Code

curl -fsSL https://claude.ai/install.sh | bash

This installs the binary to ~/.local/bin/claude. Make sure that directory is in your PATH — most distros add it automatically. If claude --version later fails with "command not found", append this to ~/.bashrc (or ~/.zshrc) and reopen the terminal:

export PATH="$HOME/.local/bin:$PATH"

3b — Sign in (pick ONE method)

Option A — sign in with your Claude.ai account (recommended for most users)

If you already use Claude.ai in the browser, this is the easiest path — no API key juggling, billing goes through your existing subscription. Just run:

claude login

A browser tab opens; log in with your Anthropic / Claude.ai account and approve the CLI. Done — you can close the tab.

Option B — use an API key (for scripts, automation, separate billing)

Generate a key at console.anthropic.com/settings/keys (it looks like sk-ant-…). Add it to your shell profile so every new terminal sees it:

echo 'export ANTHROPIC_API_KEY=sk-ant-...' >> ~/.bashrc
source ~/.bashrc

3c — Verify

claude --version

If you see a version number, you're done. ComIO.Studio will pick up claude automatically.

3a — Install Claude Code

curl -fsSL https://claude.ai/install.sh | bash

Same installer as Linux — places the binary in ~/.local/bin/claude. If claude --version later fails, add this to ~/.zshrc and reopen Terminal:

export PATH="$HOME/.local/bin:$PATH"

3b — Sign in (pick ONE method)

Option A — sign in with your Claude.ai account (recommended for most users)

If you already use Claude.ai in the browser, this is the easiest path. Just run:

claude login

A browser tab opens; log in with your Anthropic / Claude.ai account.

Option B — use an API key (for scripts, automation, separate billing)

Generate a key at console.anthropic.com/settings/keys (looks like sk-ant-…). Add to ~/.zshrc:

echo 'export ANTHROPIC_API_KEY=sk-ant-...' >> ~/.zshrc
source ~/.zshrc

3c — Verify

claude --version

If you see a version number, you're done.

3a — Install Claude Code

npm install -g @anthropic-ai/claude-code

This places claude.cmd in %APPDATA%\npm\, which Node.js's installer already added to your PATH. Close and reopen the terminal after this command — Windows caches PATH per session.

Do not use the Linux install.sh on Windows — it lays down a POSIX binary as ~/.local/bin/claude.exe that crashes immediately when ComIO.Studio (a GUI app, no console attached) tries to spawn it.

3b — Sign in (pick ONE method)

Option A — sign in with your Claude.ai account (recommended for most users)

If you already use Claude.ai in the browser, this is the easiest path. In the new terminal run:

claude login

A browser window opens; log in with your Anthropic / Claude.ai account and approve the CLI.

Option B — use an API key (for scripts, automation, separate billing)

Generate a key at console.anthropic.com/settings/keys (looks like sk-ant-…). Save it permanently in your user environment:

setx ANTHROPIC_API_KEY "sk-ant-..."

Important: close the terminal and open a new one so the variable becomes visible.

3c — Verify

claude --version

If you see a version number, you're done.

Codex is OpenAI's command-line agent. In sub-step 3b you'll have two sign-in methods — pick Option A (browser login with your ChatGPT account) for normal use, or Option B (API key) only if you need headless / scripted access. Do NOT do both.

3a — Install Codex

npm install -g @openai/codex

If npm: command not found, finish Step 2 first.

3b — Sign in (pick ONE method)

Option A — sign in with your ChatGPT account (recommended for most users)

If you already have a ChatGPT account, this is the easiest path — billing goes through your existing OpenAI subscription. Just run:

codex login

A browser tab opens; log in with your ChatGPT / OpenAI account and approve the CLI.

Option B — use an API key (for scripts, automation, separate billing)

Generate a key at platform.openai.com/api-keys (looks like sk-…). Add to your shell profile:

echo 'export OPENAI_API_KEY=sk-...' >> ~/.bashrc
source ~/.bashrc

3c — Verify

codex --version

If you see a version number, you're done.

3a — Install Codex

npm install -g @openai/codex

If npm: command not found, finish Step 2 first.

3b — Sign in (pick ONE method)

Option A — sign in with your ChatGPT account (recommended for most users)

The easiest path if you already have a ChatGPT account:

codex login

A browser tab opens; log in with your ChatGPT / OpenAI account.

Option B — use an API key (for scripts, automation, separate billing)

Generate a key at platform.openai.com/api-keys (looks like sk-…). Add to ~/.zshrc:

echo 'export OPENAI_API_KEY=sk-...' >> ~/.zshrc
source ~/.zshrc

3c — Verify

codex --version

If you see a version number, you're done.

3a — Install Codex

npm install -g @openai/codex

If npm: command not found, finish Step 2 first. Close and reopen the terminal after installing.

3b — Sign in (pick ONE method)

Option A — sign in with your ChatGPT account (recommended for most users)

If you already have a ChatGPT account, this is the easiest path. In the new terminal run:

codex login

A browser window opens; log in with your ChatGPT / OpenAI account and approve the CLI.

Option B — use an API key (for scripts, automation, separate billing)

Generate a key at platform.openai.com/api-keys (looks like sk-…). Save it permanently:

setx OPENAI_API_KEY "sk-..."

Important: close the terminal and open a new one so the variable becomes visible.

3c — Verify

codex --version

If you see a version number, you're done.

Step 4 — Use it inside ComIO.Studio

You're done with the terminal. The rest happens inside the app — same on every OS:

1. Open the AI panel (🤖 button in the title bar).
2. Switch to the Settings tab.
3. Pick the Engine — Claude Code or Codex (whichever you installed in Step 3).
4. For Claude Code: choose a model (sonnet for daily work, opus for the hardest tasks, haiku for cheap/fast). Optionally set a max budget in USD per session and a permission mode.
5. For Codex: pick the model and (optionally) reasoning effort.
6. Switch to the Chat tab and send a test message — first run takes a few seconds while the agent boots up.

Troubleshooting

"Send" stays clickable, no response appears. The agent subprocess crashed before producing output. To see why, launch ComIO.Studio from a terminal — its error output (stderr) will print there:

# if installed via .deb / system package
comio-studio

# if you downloaded the AppImage
./ComIO.Studio-x86_64.AppImage

Look in that terminal for lines like Claude Code: process exited with or Codex: process exited with. Most common causes: agent not in PATH, or auth missing.

"claude: command not found" / "codex: command not found" right after install. Open a fresh terminal — your shell caches PATH per session. If still missing, make sure ~/.local/bin (or $(npm prefix -g)/bin) is in PATH; add it to ~/.bashrc if needed.

"Authorization failed" / HTTP 401. Run claude logout && claude login (or codex logout && codex login). For API-key auth, regenerate the key in your account console and re-export the env var.

Agent works in terminal but not from ComIO.Studio (you already have nvm-managed Node). The app spawns subprocesses with a minimal env that doesn't load nvm's shell init, so the agent can't find Node. Install Node.js system-wide alongside nvm — that's what ComIO.Studio sees:

sudo apt install -y nodejs   # Debian/Ubuntu
# or
sudo dnf install -y nodejs   # Fedora/RHEL

Your nvm setup keeps working in the terminal — the system Node is just there for the GUI app to find.

"Send" stays clickable, no response appears. The agent subprocess crashed before producing output. To see why, launch ComIO.Studio from Terminal — its error output (stderr) will print there:

/Applications/ComIO.Studio.app/Contents/MacOS/comio-studio

Tip: in Finder, right-click the app → Show Package Contents → drag the comio-studio file from Contents/MacOS/ into Terminal, then press Return. Look in that terminal for Claude Code: process exited with or Codex: process exited with. Most common causes: agent not in PATH, or auth missing.

"claude: command not found" / "codex: command not found" right after install. Close the Terminal window and open a new one — PATH is cached per session. If still missing, confirm /opt/homebrew/bin (Apple Silicon) or /usr/local/bin (Intel), or $(npm prefix -g)/bin is in PATH.

"Authorization failed" / HTTP 401. Run claude logout && claude login (or codex logout && codex login). For API-key auth, regenerate the key in your account console and re-export the env var in ~/.zshrc.

"claude" cannot be opened because the developer cannot be verified — macOS Gatekeeper. Right-click the binary in Finder → Open, or run in Terminal: xattr -d com.apple.quarantine $(which claude). Same trick works for codex.

"Send" stays clickable, no response appears. The agent subprocess crashed before producing output. To see why, launch ComIO.Studio from a terminal — its error output (stderr) will print there. Open PowerShell (right-click Start → Terminal) and run the path where the installer placed the app, for example:

# MSI installer (system-wide)
& "C:\Program Files\ComIO.Studio\ComIO.Studio.exe"

# NSIS installer (per-user)
& "$env:LOCALAPPDATA\Programs\ComIO.Studio\ComIO.Studio.exe"

Look in the terminal window for Claude Code: process exited with or Codex: process exited with. Most common causes: agent not in PATH, or auth missing.

"claude: command not found" / "codex: command not found" right after install. Close the terminal and open a new one — Windows caches the list of executables per session. If still missing, in PowerShell run echo $env:PATH and confirm %APPDATA%\npm is on the list.

STATUS_BREAKPOINT (exit code 0x80000003 / 2147483651). Update ComIO.Studio to v0.1.16 or newer — earlier builds wiped critical Windows env vars (SystemRoot, USERPROFILE, …) before spawning the agent, which made Node.js crash at HTTPS init.

"Authorization failed" / HTTP 401. Run claude logout then claude login (or codex logout / codex login). For API-key auth, regenerate the key in your account console and re-set with setx ANTHROPIC_API_KEY "..." (or OPENAI_API_KEY), then open a fresh terminal.

The AI panel on the right side is a chat assistant that understands your serial communication context. It sees your port configuration, recent terminal data, and can help with protocol analysis, troubleshooting, and code generation.

Opening the AI panel

Click the 🤖 button in the title bar to show or hide the AI panel.

Tabs

• Chat — main conversation interface
• History — saved chat sessions (↩ to load a previous session, ✕ to delete it)
• Settings — customize the AI behavior:
  • Temperature — controls response creativity (lower = more precise, higher = more creative)
  • AI Assistant Instruction — custom system prompt that tells the AI how to behave, what domain to focus on, etc.

Using the chat

1. Type your question in the input field
2. Press Enter or click "Send"
3. The AI automatically sees your serial port config and recent terminal data as context
4. During generation, the button changes to "Cancel" — click to stop
5. Click + to start a new chat session

What you can ask

• "What protocol is this data?" — paste hex data for protocol identification
• "Why is my device not responding?" — troubleshooting with context
• "Write a Lua script that reads temperature every 5 seconds"
• "Decode this frame: 01 03 04 00 64 00 C8" — byte-level Modbus analysis
• "What baud rate should I use for this chip?"
• "Explain what my device is sending" — AI reads terminal buffer and analyzes

The Logging section in the sidebar captures serial data to a downloadable file — separate from the terminal display.

How to use

1. Toggle "Log" ON — logging starts immediately
2. Choose format:
   • Text — plain text output
   • Hex — raw bytes in hexadecimal
   • Mixed (default) — text with hex for non-printable bytes
3. Toggle "TS" to add timestamps ([HH:MM:SS.mmm]) to each line (ON by default)
4. Click "Download" to save the log as a .txt file
5. Toggle "Log" OFF when done

The log captures both RX and TX data with direction prefixes. Buffer holds up to 100,000 lines.

The title bar contains the application menu and window controls.

File menu

• New session — reset the workspace
• Exit — close the application

Edit menu

• Copy — copy selected terminal text
• Paste — paste into the command input
• Select all — select all terminal content

View menu

• Language — switch UI language
• Theme — change color scheme
• Panels — show/hide sidebar sections: Connection, Statistics, Macros, Triggers, Lua Script, Logging

ComIO menu

• License — view or enter your license key
• Pricing & Plans — subscription options
• About — application version info