Stop Looking Away From Camera! Textream Fixes Your Eye Contact

Your audience can tell. That split-second glance down at your notes. The awkward pause while you find your place. The telltale eye movement that screams "I'm reading, not talking to you." For streamers, presenters, and podcasters, broken eye contact is the silent credibility killer nobody talks about—until now.

What if your script could follow your voice instead of you chasing it? What if you could maintain laser-focused eye contact with your camera while your words flow naturally, highlighted in real-time as you speak them? Enter Textream, the free open-source macOS teleprompter that's making expensive hardware prompters obsolete overnight.

Built by Fatih Kadir Akın with the original concept from Semih Kışlar, Textream isn't just another auto-scrolling text box. It's an intelligent presentation companion that leverages on-device speech recognition to create a teleprompter experience that feels genuinely magical. No cloud processing. No subscription fees. No bulky equipment cluttering your desk. Just you, your Mac, and seamless, invisible script guidance that keeps your audience locked in.

Ready to discover why top streamers and presenters are quietly switching to this Dynamic Island-powered tool? Let's dive deep into what makes Textream the most cleverly designed teleprompter you've never heard of—until today.

What is Textream?

Textream is a free, open-source macOS application that transforms how content creators deliver scripted material. At its core, it's a teleprompter—but calling it that undersells what this tool actually accomplishes. Unlike traditional teleprompters that demand expensive mirror rigs, dedicated hardware, or clunky web-based solutions, Textream lives natively on your Mac and integrates directly into macOS 15 Sequoia's visual language.

The application emerged from a simple observation: modern MacBooks have a notch. That controversial camera cutout? Textream turns it into a feature. By anchoring a Dynamic Island-style overlay directly below your MacBook's notch, the app creates a teleprompter experience that sits above all your applications, always visible to you, completely invisible to your audience.

But the real innovation isn't cosmetic—it's cognitive. Texteam offers three distinct guidance modes that adapt to different presentation styles and technical constraints. The default Word Tracking mode uses Apple's on-device speech recognition framework to highlight each word as you speak it, creating a bi-directional flow where the app follows you, not vice versa. Classic mode provides traditional constant-speed scrolling for situations where microphone access isn't practical. And Voice-Activated mode offers the best of both worlds: scrolling while you speak, pausing when you're silent, enabling natural pacing without manual intervention.

The project is MIT licensed, actively maintained on GitHub, and represents a growing movement toward privacy-respecting, locally-processed creative tools. With zero network dependencies for core functionality, Textream ensures your presentation scripts never leave your machine—a critical consideration for creators handling sensitive material or working in security-conscious environments.

Key Features That Set Textream Apart

Textream's feature set reveals thoughtful attention to real-world presentation workflows. Here's what makes it technically impressive:

Three Guidance Modes with Distinct Technical Approaches

The Word Tracking mode deserves special attention. By leveraging Apple's neural engine locally, it achieves sub-100ms latency between spoken and highlighted words without cloud roundtrips. This matters enormously for maintaining natural speech rhythm—cloud-based alternatives often introduce perceptible delays that disrupt presenter flow.

Dynamic Island Integration

Textream's Pinned to Notch mode exploits macOS window management APIs to create an overlay that genuinely sits above all application layers, including fullscreen video and presentation software. The implementation uses NSWindow.Level manipulation with collectionBehavior flags for .canJoinAllSpaces and .fullScreenAuxiliary, ensuring visibility across Mission Control spaces and fullscreen app transitions.

Multi-Display Architecture

The External Display & Sidecar support isn't merely mirroring—it's a dedicated rendering pipeline. The ExternalDisplayController manages separate CALayer hierarchies for teleprompter output and mirror-flipped rigs, with configurable transform matrices for horizontal, vertical, or 180° rotation. This enables professional broadcast setups where talent sees normal text while camera-mounted mirror rigs receive appropriately flipped output.

Network-Based Remote Systems

Textream implements dual server architecture: a lightweight HTTP/WebSocket server for remote viewing (default port 7373) and a separate director control server (default port 7575). Both use SwiftNIO-based networking with Codable JSON message frames, enabling real-time synchronization without external dependencies.

Privacy-First Design

Every processing pipeline—speech recognition, audio level analysis, script storage—operates on-device. No analytics, no accounts, no telemetry. For creators in corporate, medical, or legal contexts, this architectural decision eliminates compliance friction entirely.

Real-World Use Cases Where Textream Dominates

Live Streaming with Sponsor Segments

Streamers face a unique challenge: reading promotional copy while maintaining authentic engagement with chat. Textream's Voice-Activated mode lets streamers glance at sponsor messaging without the mechanical "reading voice" that kills authenticity. The overlay sits above OBS, Streamlabs, or native streaming tools—visible to the streamer, invisible to the broadcast. When the segment ends, automatic dismissal means no fumbling to close windows mid-stream.

Remote Interview Hosting

Video interviewers must balance question visibility with genuine eye contact. Traditional solutions—dual monitors with notes, physical teleprompter rigs—create setup friction for remote recordings. Textream's Follow Cursor floating window places questions near your webcam's visual center, while Follow Mouse notch mode automatically relocates when you switch between displays during screen shares.

Conference Keynotes and Demos

Presenters at technical conferences often juggle live coding, slide decks, and narrative flow. Textream's Fullscreen mode on a Sidecar iPad creates a dedicated prompter display while your Mac runs the actual presentation. The Tap to jump feature lets you skip ahead when demos run long or audiences ask questions that rearrange your planned flow.

Podcast Recording with Show Notes

Podcasters working solo need hands-free operation. Voice-Activated scrolling eliminates the need to reach for mouse or keyboard mid-episode. The Live waveform provides visual confirmation that microphone pickup remains consistent, catching hardware issues before they ruin recordings. Multi-page support with automatic advance means complex episode structures flow without manual intervention.

Remote Production Direction

The Director Mode transforms Textream into a collaborative tool. A producer can adjust scripts in real-time during live productions, pushing updates to talent without interrupting flow. The read-locked highlighting ensures directors can't accidentally modify already-delivered content—a subtle but crucial safety mechanism for live environments.

Step-by-Step Installation & Setup Guide

Getting Textream running takes under two minutes. Here's the complete process:

Method 1: Homebrew Installation (Recommended)

# Add the custom tap and install in one command
brew install f/textream/textream

Homebrew handles dependencies, updates, and path configuration automatically. This is the maintenance-minimal approach.

Method 2: Manual DMG Download

# Download from GitHub Releases (or use browser)
curl -L https://github.com/f/textream/releases/latest/download/Textream.dmg -o ~/Downloads/Textream.dmg

# Mount and install (macOS handles this via Finder typically)
open ~/Downloads/Textream.dmg
# Drag Textream.app to /Applications

First Launch Security Bypass

Since Textream isn't notarized through the Mac App Store, macOS Gatekeeper will initially block execution. Resolve this with:

# Remove quarantine extended attributes
xattr -cr /Applications/Textream.app

Then right-click Textream.app → Open to establish the initial security exception. Subsequent launches work normally via double-click or Spotlight.

System Requirements Verification

# Confirm macOS version (must be 15.0+)
sw_vers -productVersion

# Verify architecture (Apple Silicon or Intel supported)
uname -m  # Returns arm64 or x86_64

Microphone Permission Setup

Word Tracking and Voice-Activated modes require microphone access. On first use, macOS prompts automatically. Verify or reset permissions via:

System Settings → Privacy & Security → Microphone → Textream

Optional: Sidecar iPad Configuration

For fullscreen teleprompter on iPad:

1. Connect iPad via cable or ensure same Wi-Fi network
2. System Settings → Displays → Mirror or extend to → Select your iPad
3. In Textream: Settings → External Display → Choose Sidecar device

Building from Source (Developers)

# Clone repository
git clone https://github.com/f/textream.git

# Navigate to project directory
cd textream/Textream

# Open in Xcode (requires 16.0+)
open Textream.xcodeproj

# Build and run with ⌘R

The project structure reveals clean separation of concerns:

Textream/
├── Textream.xcodeproj
├── Info.plist
└── Textream/
    ├── TextreamApp.swift              # App entry point, deep link handling
    ├── ContentView.swift              # Main text editor UI + About view
    ├── TextreamService.swift          # Service layer, URL scheme handling
    ├── SpeechRecognizer.swift         # On-device speech recognition engine
    ├── NotchOverlayController.swift   # Dynamic Island + floating overlay
    ├── ExternalDisplayController.swift # Sidecar / external display output
    ├── NotchSettings.swift            # User preferences and presets
    ├── SettingsView.swift             # Tabbed settings UI
    ├── MarqueeTextView.swift          # Word flow layout and highlighting
    ├── BrowserServer.swift            # Remote connection HTTP + WebSocket server
    ├── DirectorServer.swift           # Director mode HTTP + WebSocket server
    ├── PresentationNotesExtractor.swift # PPTX presenter notes extraction
    ├── UpdateChecker.swift            # GitHub release update checker
    └── Assets.xcassets/               # App icon and colors

REAL Code Examples from the Repository

Let's examine actual implementation patterns from Textream's codebase and documentation.

Example 1: URL Scheme Deep Linking

Textream registers a custom URL scheme for external application integration:

// From TextreamApp.swift - handles textream:// protocol
func application(_ application: NSApplication, open urls: [URL]) {
    for url in urls {
        guard url.scheme == "textream" else { continue }
        
        // Parse textream://read?text=Hello%20world
        if url.host == "read", 
           let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
           let textItem = components.queryItems?.first(where: { $0.name == "text" }),
           let encodedText = textItem.value {
            
            // Decode percent-encoded string and load into editor
            let text = encodedText.removingPercentEncoding ?? encodedText
            textreamService.loadScript(text: text)
            textreamService.startPresentation()
        }
    }
}

This enables automation workflows: Apple Shortcuts, Alfred workflows, or shell scripts can launch Textream with pre-populated content. The textreamService singleton coordinates between URL handling and presentation state, ensuring thread-safe state transitions.

Example 2: Director Mode WebSocket Command Protocol

The Director Mode exposes a clean JSON protocol for external control. Here's the setText command implementation:

{
  "type": "setText",
  "text": "Welcome everyone to today's live stream..."
}

This replaces current text, initiates word tracking, and opens the overlay—equivalent to pressing Go in the web UI. The server-side parsing uses Swift Codable with strict type validation:

// Conceptual implementation based on DirectorServer.swift patterns
struct DirectorCommand: Decodable {
    enum CommandType: String, Decodable {
        case setText, updateText, stop
    }
    let type: CommandType
    let text: String?           // Required for setText, optional for updateText
    let readCharCount: Int?     // Required for updateText boundary preservation
}

// Server validates and routes to appropriate handler
func handleCommand(_ data: Data) throws {
    let command = try JSONDecoder().decode(DirectorCommand.self, from: data)
    
    switch command.type {
    case .setText:
        guard let text = command.text else { throw ValidationError.missingText }
        teleprompter.load(text: text)
        teleprompter.startTracking()
        
    case .updateText:
        guard let text = command.text, let readCount = command.readCharCount else {
            throw ValidationError.missingParameters
        }
        // Preserve read boundary: only modify unread portion
        teleprompter.updateUnread(text: text, preservingReadCount: readCount)
        
    case .stop:
        teleprompter.stopAndDismiss()
    }
}

The readCharCount parameter for updateText is particularly elegant—it enables live script editing during active presentations without disrupting already-delivered content. The server maintains character-level state synchronization between director and presenter.

Example 3: Minimal Python Director Client

The repository includes a complete reference implementation for custom director clients:

import asyncio
import json
import websockets

async def director():
    # Connect to Textream's WebSocket server
    # Replace with your Mac's actual IP address
    async with websockets.connect("ws://192.168.1.42:7576") as ws:
        
        # Send initial script - triggers overlay and word tracking
        await ws.send(json.dumps({
            "type": "setText",
            "text": "Hello everyone, welcome to the show."
        }))

        # Consume state broadcasts (~10 Hz from server)
        async for msg in ws:
            state = json.loads(msg)
            
            # Calculate progress percentage safely
            pct = 0
            if state["totalCharCount"] > 0:
                pct = state["highlightedCharCount"] / state["totalCharCount"] * 100
            
            # Real-time monitoring output
            print(f"Progress: {pct:.0f}%  Done: {state['isDone']}")
            
            # Access additional state for custom dashboards
            # state["isListening"] - mic active status
            # state["audioLevels"] - array for waveform visualization
            # state["lastSpokenText"] - recent recognition result
            
            # Clean shutdown when reading completes
            if state["isDone"]:
                break

        # Explicit stop command dismisses overlay
        await ws.send(json.dumps({"type": "stop"}))

# Run the async event loop
asyncio.run(director())

This demonstrates the protocol's simplicity—any language with WebSocket support can implement director functionality. The ~10 Hz state broadcast rate provides smooth visualization without overwhelming network capacity.

Example 4: State Frame Structure

The server-to-client state frames contain rich information for custom UI construction:

{
  "words": ["Welcome", "everyone", "to", "today's", "live", "stream"],
  "highlightedCharCount": 24,
  "totalCharCount": 120,
  "isActive": true,
  "isDone": false,
  "isListening": true,
  "fontColor": "#F5F5F7",
  "lastSpokenText": "Welcome everyone to today's",
  "audioLevels": [0.12, 0.34, 0.08, 0.56, 0.23, 0.41, 0.19, 0.33]
}

The audioLevels array enables custom waveform visualizations in director dashboards. The words array with highlightedCharCount allows precise read-boundary rendering without text duplication between client and server.

Advanced Usage & Best Practices

Optimize Speech Recognition Accuracy

Word Tracking performance depends on environmental factors. Use a dedicated USB microphone positioned 6-12 inches from your mouth. The built-in MacBook microphone works but picks up keyboard noise and room reverberation. Enable Live waveform to verify consistent audio levels before going live.

Configure Scroll Speed for Your Speaking Rate

Measure your natural speaking rate: record one minute of unscripted speech, count words, divide by sixty. Most adults range 130-150 WPM. Textream's 0.5–8 words/s (30–480 WPM) accommodates everything from deliberate technical explanations to rapid-fire auctioneer patter.

Leverage Multi-Page for Complex Structures

Break scripts into logical segments using page breaks. In Follow Cursor mode, automatic advance with 3-second countdown provides natural transitions. This prevents the cognitive overload of seeing entire scripts simultaneously.

Mirror Mode for Professional Rigs

When using camera-mounted teleprompter hardware, Mirror → Horizontal flips text appropriately. Verify rig orientation—some inexpensive rigs require Both (180° rotation) depending on mirror placement geometry.

Director Mode Security Considerations

Both remote servers bind to all interfaces (0.0.0.0) by default. On untrusted networks, restrict via macOS Firewall or bind to localhost only. The protocol has no authentication—appropriate for controlled production environments, problematic for public Wi-Fi.

Comparison with Alternatives

When to choose Textream: You want zero-cost, privacy-guaranteed operation with native macOS integration and don't need cross-platform support.

When to consider alternatives: You require Windows/iOS native apps, prefer cloud-based voice tracking with potentially higher accuracy, or need enterprise support contracts.

Frequently Asked Questions

Does Textream work on macOS versions before Sequoia?

No. Textream requires macOS 15 Sequoia or later due to dependencies on newer Speech framework APIs and Dynamic Island-related window management features. The notch overlay specifically requires display geometry APIs introduced in this version.

Can I use Textream with Zoom, Teams, or other video conferencing apps?

Absolutely. The overlay sits above all application layers including fullscreen video. Enable Hide from screen share to prevent the teleprompter from appearing in your shared screen if you share full desktop rather than single application windows.

Is my presentation data sent to any servers?

Never for core functionality. All speech recognition processes on Apple's Neural Engine locally. The optional Remote and Director modes create local network servers only—no traffic leaves your Wi-Fi network unless you explicitly configure otherwise.

How accurate is the word tracking for non-English languages?

Textream leverages Apple's on-device speech recognition which supports dozens of languages with quality varying by language. European languages generally perform excellently; less common languages may have reduced accuracy. Test your specific language before critical presentations.

Can I import scripts from Google Slides or Keynote?

Directly, no—but export to PowerPoint format first, then use Textream's .pptx presenter notes import. The PresentationNotesExtractor parses the Open XML structure to extract notes pages. For frequent use, consider automating this with Apple Shortcuts.

What's the difference between Remote Connection and Director Mode?

Remote Connection (port 7373) provides read-only teleprompter mirroring to phones/tablets. Director Mode (port 7575) enables active script control and editing from another device. They serve different production roles and can operate simultaneously.

How do I report bugs or contribute features?

Textream is MIT licensed and welcomes contributions. Open issues and pull requests on the GitHub repository. The codebase uses standard Swift patterns with SwiftUI for interface components, making it accessible to iOS/macOS developers.

Conclusion

Textream represents something increasingly rare in creative software: a tool that solves exactly one problem with architectural elegance, then stops. No feature bloat, no subscription extraction, no venture-backed growth hacking. Just a free, open-source macOS teleprompter that leverages your hardware's capabilities rather than fighting them.

The Dynamic Island integration isn't gimmickry—it's genuinely the most natural teleprompter placement ever designed for modern MacBooks. The voice-activated scrolling eliminates the mechanical awkwardness that teleprompters traditionally impose. And the privacy-first, on-device processing means you can use it for sensitive corporate presentations without compliance review.

For streamers tired of sponsor-segment stumbles, interviewers seeking genuine eye contact, presenters wanting confidence without memorization, and podcasters needing hands-free operation, Textream delivers professional results with amateur simplicity.

Stop looking away from your camera. Your audience notices.

Download Textream free from GitHub or install instantly with brew install f/textream/textream. Star the repository, contribute improvements, or simply enjoy never losing your place again.

Built with precision by Fatih Kadir Akın. Original concept by Semih Kışlar. MIT licensed. Community driven.