Terminal Integration Specialist

Here's the SwiftUI integration pattern:

import SwiftUI
import SwiftTerm

struct TerminalView: UIViewRepresentable {
    let sshSession: SSHSession
    
    func makeUIView(context: Context) -> TerminalView {
        let terminal = TerminalView(frame: .zero)
        terminal.configureTerminal(
            font: .monospacedSystemFont(ofSize: 14, weight: .regular),
            colorScheme: .default
        )
        // Bridge SSH I/O to terminal
        sshSession.onData = { data in
            DispatchQueue.main.async {
                terminal.feed(byteArray: [UInt8](data))
            }
        }
        terminal.onTerminalInput = { data in
            sshSession.write(data)
        }
        return terminal
    }
}

Key patterns:

1. Threading: SSH data arrives on a background thread. Use DispatchQueue.main.async to feed data to terminal (UI thread only).
2. Lifecycle: Start SSH session in makeUIView, close in dismantleUIView. Handle reconnection if the view reappears.
3. Performance: SwiftTerm batches terminal updates internally. Don't call feed() for individual bytes — pass complete data chunks.
4. Accessibility: Set terminal.isAccessibilityElement = true and implement accessibilityValue with current screen content.

Fast output causing janky scrolling is a rendering bottleneck. Here's the fix:

Problem: Each feed() call triggers a render pass. At 10,000 lines/second, that's 10,000 renders — way beyond 60fps.

Solution: Coalesce rendering with a display link:

1. Buffer incoming data instead of feeding immediately
2. Use CADisplayLink to flush the buffer once per frame (60fps)

class TerminalController {
    private var dataBuffer = Data()
    private var displayLink: CADisplayLink?
    
    func startRenderLoop() {
        displayLink = CADisplayLink(target: self, selector: #selector(flushBuffer))
        displayLink?.add(to: .main, forMode: .common)
    }
    
    func appendData(_ data: Data) {
        dataBuffer.append(data)  // Lock-free if single producer
    }
    
    @objc func flushBuffer() {
        guard !dataBuffer.isEmpty else { return }
        let batch = dataBuffer
        dataBuffer = Data()
        terminal.feed(byteArray: [UInt8](batch))
    }
}

Result: Instead of 10,000 renders/second, you get exactly 60 renders/second with all data batched. Scrolling becomes smooth.

Additional optimization: If scrollback buffer exceeds 100,000 lines, trim from the top. Use terminal.scrollbackLines = 100_000 to set the limit.