Rany IDE

1. Abstract & Philosophy

The dominant paradigm in AI-assisted coding tools (GitHub Copilot, Cursor, Continue) is reactive: the developer writes, then asks the AI for help. The AI responds, and waits again. This model treats AI as a sophisticated autocomplete.

Rany IDE rejects this model. It is built on the principle that AI agents should be autonomous collaborators — running continuously in the background, proactively contributing to code quality, test coverage, documentation, and security without the developer needing to prompt them. The developer codes; the agents work.

2. Technical Foundation: Zed Editor

Zed is a multiplayer, GPU-accelerated code editor written entirely in Rust by the creators of Atom and Tree-sitter. It is designed for performance characteristics that no Electron-based editor can match:

• Sub-millisecond input responsiveness: Zed renders using a custom GPU rendering pipeline (GPUI) that processes keystrokes in under 1ms on modern hardware — no main thread blocking, no GC pauses
• Tree-sitter parsing: All syntax highlighting, code navigation, and structural analysis use Tree-sitter's incremental parsing, which updates syntax trees in O(changed_characters) time
• LSP-native: Language Server Protocol support is first-class, enabling semantic completions, go-to-definition, and diagnostics for any language with a language server
• Multiplayer-built-in: Real-time collaborative editing via Zed's CRDTs (Conflict-free Replicated Data Types) is a core feature, not a plugin

Rany IDE builds on all of these properties without modification. The Zed codebase is preserved intact; the autonomous agent system is added as a distinct runtime layer that observes the editor state but does not interfere with its critical path.

3. Autonomous Agent System

The agent system is Rany IDE's primary innovation. Each agent is an independent process that runs with a configurable priority and communicates with the editor via an internal messaging protocol:

Agent Communication Protocol

Agents communicate with the editor coordinator via an internal async message bus. They observe file open/save events, cursor position changes, and diagnostics — but never block the editor's main thread:

// Agent lifecycle (simplified Rust pseudo-code)
struct CodeQualityAgent {
    config: AgentConfig,
    sender: MpscSender<AgentMessage>,
}

impl Agent for CodeQualityAgent {
    async fn run(&mut self, editor: &EditorObserver) {
        loop {
            let event = editor.next_event().await;
            
            if let EditorEvent::FileSaved(path) = event {
                let analysis = self.analyze(&path).await;
                
                for suggestion in analysis.suggestions {
                    self.sender.send(AgentMessage::Suggestion {
                        file: path.clone(),
                        range: suggestion.range,
                        message: suggestion.message,
                        severity: suggestion.severity,
                    }).await?;
                }
            }
        }
    }
}

4. Agent Configuration Model

Each agent is configured independently via a JSON settings block in Rany IDE's configuration file. Two key parameters govern agent behavior:

• approval_mode: "auto_safe" — The agent applies safe suggestions (documentation, style fixes) automatically without prompting the developer
• approval_mode: "always_ask" — The agent proposes all suggestions in a review panel that the developer accepts or rejects explicitly

{
  "agents": {
    "code_quality": {
      "enabled": true,
      "approval_mode": "auto_safe",  // Apply safe refactors automatically
      "priority": 5,                 // 1 (lowest) to 10 (highest) CPU priority
      "trigger": "on_save"           // or "continuous" or "on_idle"
    },
    "testing": {
      "enabled": true,
      "approval_mode": "always_ask", // Always ask before generating tests
      "priority": 4,
      "trigger": "on_save",
      "test_framework": "jest"       // jest | cargo-test | pytest | etc.
    },
    "documentation": {
      "enabled": true,
      "approval_mode": "auto_safe",
      "priority": 3,
      "trigger": "on_idle",          // Runs only when editor is idle for 30s
      "doc_format": "jsdoc"          // jsdoc | rustdoc | pydoc | etc.
    }
  }
}

5. Real-Time Collaboration

Rany IDE inherits Zed's multiplayer collaboration system unchanged. Multiple developers can edit the same file simultaneously with operation-based CRDT conflict resolution — no explicit merging, no overwrite conflicts.

Rany IDE extends this collaboration model to the agent layer: when two developers are collaborating on a session, agent suggestions from any participant's IDE are visible to all collaborators in the shared review panel. This means the Testing Agent's generated test cases are immediately visible to the team — not buried in a single developer's local IDE.

6. Orzatty Design Integration

Rany IDE ships with an Orzatty-branded theme as the default visual experience. The color system uses the Orzatty purple/pink brand palette while maintaining readability standards for extended coding sessions:

7. Build & Distribution

# Build from source (requires Rust 1.75+, Node.js 18+)
git clone https://github.com/orzattyholdings/rany-ide.git
cd rany-ide
cargo build --release

# Output binary: ./target/release/rany-ide
# Run tests:
cargo test --workspace
# Property-based tests:
cargo test --workspace --features proptest

Configuration: Stored at platform-standard locations — ~/Library/Application Support/Rany IDE (macOS), $XDG_DATA_HOME/rany-ide (Linux), %LOCALAPPDATA%\Rany IDE (Windows).

8. Roadmap