Operon

AI-powered IDE for bioinformatics — built by biologists, for biologists.

Operon is a cross-platform desktop application that brings together an AI coding assistant (Claude), integrated terminal, code editor, file browser, and remote-server access into a single tool designed for computational biologists. Whether you're running RNA-seq pipelines on an HPC cluster from your Windows laptop, analyzing single-cell data on a Linux workstation, or writing scripts on a Mac, Operon gives you a professional development environment with AI that understands your domain.

Download • Documentation • Release notes

Why Operon?

Most IDEs are built for software engineers. Operon is built for you — the biologist who writes Python scripts to process sequencing data, runs pipelines on a shared HPC cluster, and needs to search PubMed while debugging a Scanpy workflow. We built Operon because we needed it ourselves.

System Requirements

Note: Developer dependencies (Claude Code, build toolchains where needed) are installed automatically by the setup wizard on first launch.

Linux support matrix

Operon's webview links against webkit2gtk-4.1 (Tauri 2's required WebKit ABI), which is only shipped by newer distributions. The runtime floor is therefore both:

• glibc 2.35+ — Ubuntu 22.04+
• webkit2gtk-4.1 — Ubuntu 22.04+ / Debian 12+ / Fedora 38+

This floor applies to all Linux artifacts, including the AppImage. The AppImage does not bundle WebKit — bundleMediaFramework only bundles the GStreamer media stack, so the host must still provide webkit2gtk-4.1.

Installation

Download (Recommended)

The latest signed installers for every platform are on the GitHub Releases page. A pre-built macOS DMG with notarization is also mirrored at swaruplab.bio.uci.edu/operon.

Build from Source

# 1. Clone the repository
git clone https://github.com/swaruplab/operon.git
cd operon

# 2. Install frontend dependencies
npm install

# 3. Run in development mode (hot-reload)
npm run tauri dev

# 4. Build a production installer for your OS
npm run tauri build
# macOS  → src-tauri/target/release/bundle/{dmg,macos}/
# Win    → src-tauri/target/release/bundle/{msi,nsis}/
# Linux  → src-tauri/target/release/bundle/{deb,appimage,rpm}/

Getting Started

Setup Wizard

On first launch, Operon walks you through installing all dependencies automatically:

Authentication & AI Providers

Operon supports three provider backends, picked from Settings → Auth → Provider:

Using Operon

Workspace Overview

The workspace has 5 main areas:

File Explorer

• Tree view with lazy directory loading
• Create, rename, delete files and folders
• Go-to-folder path bar (Cmd/Ctrl+G)
• Symlink-aware (local and remote)

Code Editor

• Monaco Editor — same engine as VS Code
• 30+ languages with syntax highlighting
• Custom operon-dark and operon-light themes
• Side-by-side diff viewer with accept/reject
• Image and PDF viewer with zoom & download

Integrated Terminal

• Full terminal emulator powered by xterm.js
• Multiple tabs with independent sessions
• Auto-copy on selection
• WebGL rendering for performance
• Preserves your shell aliases and conda environments
• On Windows, Claude Code runs through bundled Git Bash so HPC-style Bash scripts work unchanged

AI Chat — Four Modes

Analysis Protocols

Operon ships with 665 built-in protocols organized into ~30 bio-first categories:

When you select a protocol, its instructions are injected into Claude's context. Claude then follows domain-specific best practices for that analysis type.

Create your own protocols:

• AI-Generated — describe what you need in plain English and Claude writes the full protocol
• Manual — write Markdown in the built-in editor
• Stored in ~/.operon/protocols/ — shareable and version-controllable

PubMed Integration

Toggle PubMed search in Ask mode. Claude searches NCBI's PubMed database, retrieves relevant papers, and incorporates findings with proper citations. No API key required — powered by NCBI E-utilities.

Light & Dark Theme

Toggle between light and dark themes from the top bar at any time. The switch propagates everywhere — UI chrome, Monaco editor, xterm terminal palette (WebGL atlas refresh included), and the native macOS title bar.

Remote Server & HPC

SSH Connections

Connect to remote servers and HPC clusters directly from Operon:

• Password and SSH key authentication
• Duo/MFA support for university clusters
• SSH connection multiplexing (fast, fewer auth prompts)
• Browse remote files, edit code, run commands
• Set up SSH keys directly from the app

Running AI on Remote Clusters

Operon can install Claude Code on your remote server and run AI sessions directly on HPC infrastructure:

• Agent mode works over SSH — executes commands, writes scripts, submits SLURM/PBS jobs on the remote machine
• Data never leaves the server — only terminal I/O travels over SSH
• Runs inside tmux sessions that persist across app restarts
• Output files written to shared filesystem (not node-local /tmp)

This is the killer feature for computational biologists: run Claude directly on your university's HPC cluster with access to your data, your conda environments, and your SLURM queue.

Git Integration

Built-in Git panel in the sidebar:

• View changed files with staged/unstaged diffs
• Stage, unstage, commit with messages
• Push, pull, fetch from remote
• Create and publish new repositories
• Full GitHub workflow without leaving the app

Keyboard Shortcuts

Modifier shorthand: Cmd on macOS, Ctrl on Windows/Linux.

Settings & Customization

Access via Cmd/Ctrl+, or the gear icon in the top bar.

Building for Distribution

The same npm run build:<target> scripts used in development produce signed artifacts when the appropriate signing credentials are present.

macOS — signed & notarized DMGs

cp build-signed.example.sh build-signed.sh
# Edit build-signed.sh with your Apple Developer credentials
bash build-signed.sh

Three macOS templates are provided:

Windows & Linux

The GitHub Actions Release workflow builds signed Windows installers (MSI + NSIS) and Linux bundles (.deb, .rpm, .AppImage) automatically on every v* tag push. Locally:

npm run build:win      # Windows: .msi + .exe
npm run build:linux    # Linux: .deb + .rpm + .AppImage

Project Architecture

operon/
├── src/                    # React/TypeScript frontend
│   ├── components/         # UI components
│   │   ├── chat/           # AI chat panel with streaming, tool display
│   │   ├── editor/         # Monaco editor, diff viewer, file viewer
│   │   ├── terminal/       # xterm.js terminal with tab management
│   │   ├── sidebar/        # File explorer, SSH, Git, Protocols, Help
│   │   ├── layout/         # AppShell, TopBar, ActivityBar, StatusBar
│   │   ├── settings/       # Settings panel
│   │   └── setup/          # First-time setup wizard
│   ├── context/            # React context (project state, editor tabs, theme)
│   ├── hooks/              # Custom hooks (keyboard shortcuts)
│   ├── lib/                # Typed IPC wrappers (claude, files, terminal, ssh, portkey)
│   └── types/              # TypeScript type definitions
├── src-tauri/              # Rust backend (Tauri 2)
│   ├── src/
│   │   ├── main.rs         # Entry point
│   │   ├── lib.rs          # Tauri builder, state managers, command registration
│   │   └── commands/       # IPC command handlers (terminal, files, claude, ssh, settings, portkey, proxy)
│   ├── binaries/           # Bundled sidecars (anthropic-proxy translation layer)
│   └── icons/              # App icons (icns, png, ico)
├── protocols/              # 665 bundled bioinformatics protocols (Markdown)
├── presets/                # Hot-fetchable Portkey gateway presets
├── docs/                   # Documentation website + images
└── build-*.example.sh      # macOS signed-build script templates (no credentials)

Tech Stack

Contributing

We welcome contributions from the bioinformatics community!

Branch model:

• cross-platform — active development and the default branch (PRs go here)
• Release tags (v0.7.x) are cut directly from cross-platform and trigger the multi-OS Release workflow

1. Fork the repository
2. Create a feature branch off cross-platform (git checkout -b feature/my-feature cross-platform)
3. Make your changes
4. Run the dev server to test (npm run tauri dev)
5. Commit and push
6. Open a Pull Request targeting cross-platform

Help & Support

License

MIT License — see LICENSE for details.