# Where Is the Networking Code Located in the Warp Repository?

> Find Warp's networking code in app network.rs, websocket crates for transport, and warpui crates for OS network monitoring. Understand Warp's network architecture.

- Repository: [Warp/warp](https://github.com/warpdotdev/warp)
- Tags: internals
- Published: 2026-04-30

---

**Warp's networking stack is distributed across [`app/src/network.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/network.rs) for connectivity state management, `crates/websocket/src/` for WebSocket transport, and `crates/warpui/` for OS-specific network monitoring.**

The Warp terminal relies on a multi-layered networking subsystem to handle cloud synchronization, real-time session sharing, and proxy-aware WebSocket connections. Locating the networking code in the Warp repository requires understanding how the terminal separates reachability state, transport implementation, and platform-specific monitoring. This guide maps the exact file paths, structs, and public APIs that manage connectivity across Linux, macOS, and Windows.

## Core Network Reachability (app/src/network.rs)

The central authority for network state lives in [`app/src/network.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/network.rs), which exports the **NetworkStatus** struct and the **NetworkStatusKind** enum.

```rust
/// Represents whether the client is connected to the network.
#[derive(Clone, Copy, Default, PartialEq, Eq, Debug)]
pub enum NetworkStatusKind {
    #[default] Online,
    Offline,
}

```

This module tracks whether the client is online or offline and provides asynchronous primitives for waiting on connectivity. The `NetworkStatus` struct stores the current `NetworkStatusKind` alongside a `Condition` that resolves when the client regains connectivity.

Key methods include:

- **`reachability_changed`** – Called by OS-specific watchers to update state and emit `NetworkStatusEvent::NetworkStatusChanged`.
- **`wait_until_online`** – Returns a future that resolves immediately if online, or awaits the `Condition` until connectivity returns.

## WebSocket Transport Layer (crates/websocket/src/)

Low-level socket handling resides in the `crates/websocket` crate, which abstracts TCP, TLS, and HTTP proxy logic.

### Public API (lib.rs)

The entry point is `Websocket::connect`, defined in [`crates/websocket/src/lib.rs`](https://github.com/warpdotdev/warp/blob/main/crates/websocket/src/lib.rs). This returns a `WebSocket` implementing the `WebsocketMessage` trait, providing a platform-agnostic interface for the rest of the application.

### Native Implementation (native.rs)

[`crates/websocket/src/native.rs`](https://github.com/warpdotdev/warp/blob/main/crates/websocket/src/native.rs) contains the tokio-based implementation that manages `ClientStream<TcpStream>`. When a proxy is configured, it delegates to `proxy::connect_via_proxy` before wrapping the stream with TLS.

```rust
let tcp_stream = proxy::connect_via_proxy(&proxy_info, request.uri()).await?;
client_async_tls_with_connector_and_config(request, tcp_stream, tls_connector, None)

```

### Proxy Handling (proxy.rs)

HTTP CONNECT tunneling is implemented in [`crates/websocket/src/proxy.rs`](https://github.com/warpdotdev/warp/blob/main/crates/websocket/src/proxy.rs). The `connect_via_proxy` function establishes a TCP connection through corporate or user-configured proxies using standard HTTP CONNECT semantics.

## OS-Level Network Monitoring (crates/warpui/)

Platform-specific connectivity watchers live under `crates/warpui/src/windowing/winit/`.

### Windows Implementation

[`crates/warpui/src/windowing/winit/windows/network.rs`](https://github.com/warpdotdev/warp/blob/main/crates/warpui/src/windowing/winit/windows/network.rs) handles Windows-specific network change notifications and forwards them to the core `NetworkStatus` model.

### Linux Implementation

On Linux, [`crates/warpui/src/windowing/winit/linux/zbus/network_status.rs`](https://github.com/warpdotdev/warp/blob/main/crates/warpui/src/windowing/winit/linux/zbus/network_status.rs) listens to `org.freedesktop.NetworkManager` signals via DBus. When the OS reports connectivity changes, the watcher invokes `reachability_changed` on the shared `NetworkStatus` instance.

## Network Logging and UI Integration (app/src/server/)

Warp exposes network diagnostics directly in the terminal UI through three primary files:

- **[`app/src/server/network_logging.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/server/network_logging.rs)** – Records connection events, proxy failures, and state transitions in an in-memory buffer.
- **[`app/src/server/network_log_view.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/server/network_log_view.rs)** – Renders the buffered events as a scrollable view.
- **[`app/src/pane_group/pane/network_log_pane.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/pane_group/pane/network_log_pane.rs)** – Embeds the view as a dockable pane within the main interface.

This architecture allows users to inspect WebSocket handshake details and proxy routing without leaving the terminal.

## Integration Testing

The repository includes specialized test suites for network reliability:

- **[`crates/websocket/src/proxy_tests.rs`](https://github.com/warpdotdev/warp/blob/main/crates/websocket/src/proxy_tests.rs)** – Spins up mock TCP listeners to validate HTTP CONNECT handshakes and proxy tunnel establishment.
- **[`app/src/terminal/shared_session/viewer/network_test.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/terminal/shared_session/viewer/network_test.rs)** – Exercises the WebSocket client used for session sharing, ensuring cloud connectivity remains stable across updates.

## Practical Examples

### Waiting for Connectivity

Use `NetworkStatus` to pause execution until the client is online:

```rust
use warp::app::network::NetworkStatus;

async fn do_something_when_online(network: &NetworkStatus) {
    // Returns immediately if we are already online.
    // Otherwise it pauses until the next `NetworkStatusKind::Online`.
    network.wait_until_online().await;

    // Safe to perform network-dependent work here.
    println!("We are online – proceeding with request");
}

```

### Establishing a WebSocket Connection

Connect to Warp Cloud using the public API:

```rust
use warp::crates::websocket::{Websocket, Message};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Connect to the Warp Cloud server (or any WS endpoint).
    let ws = Websocket::connect("wss://cloud.warp.dev/socket")
        .await?
        .split();

    // Send a simple text message.
    ws.0.send(Message::text("hello")).await?;

    // Listen for a response.
    if let Some(msg) = ws.1.next().await {
        println!("Received: {:?}", msg);
    }
    Ok(())
}

```

### Monitoring OS-Level Changes (Linux)

Initialize the DBus watcher to forward kernel events:

```rust
use warpui::windowing::winit::linux::zbus::NetworkStatusWatcher;
use warp::app::network::NetworkStatus;

fn start_watcher(network: NetworkStatus) {
    // The watcher runs on a background task and calls `reachability_changed`
    // whenever the kernel reports a change.
    NetworkStatusWatcher::new(move |online| {
        network.reachability_changed(online, &mut ModelContext::new());
    });
}

```

## Summary

- **[`app/src/network.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/network.rs)** houses the canonical `NetworkStatus` model and the `wait_until_online` async primitive.
- **`crates/websocket/src/`** contains the WebSocket transport, proxy handling, and native TLS implementation.
- **`crates/warpui/src/windowing/winit/`** provides platform-specific OS network monitors for Windows, macOS, and Linux.
- **[`app/src/server/network_logging.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/server/network_logging.rs)** and related UI files expose connection diagnostics to users.
- Test coverage lives in [`crates/websocket/src/proxy_tests.rs`](https://github.com/warpdotdev/warp/blob/main/crates/websocket/src/proxy_tests.rs) and session-specific network tests.

## Frequently Asked Questions

### Where is the proxy configuration handled in Warp?

Proxy logic is implemented in [`crates/websocket/src/proxy.rs`](https://github.com/warpdotdev/warp/blob/main/crates/websocket/src/proxy.rs), specifically within the `connect_via_proxy` function. This module handles HTTP CONNECT tunneling using `tokio::net::TcpStream`, allowing Warp to route WebSocket traffic through corporate proxies before TLS negotiation occurs in the native transport layer.

### How does Warp detect when the network goes offline?

Warp uses OS-specific watchers located in `crates/warpui/src/windowing/winit/`. On Linux, the watcher listens to NetworkManager DBus signals via [`linux/zbus/network_status.rs`](https://github.com/warpdotdev/warp/blob/main/linux/zbus/network_status.rs), while Windows uses native APIs in [`windows/network.rs`](https://github.com/warpdotdev/warp/blob/main/windows/network.rs). These watchers call `reachability_changed` on the `NetworkStatus` struct defined in [`app/src/network.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/network.rs), which updates the global connectivity state.

### Can I programmatically wait for network restoration in Warp extensions?

Yes. The `NetworkStatus` struct in [`app/src/network.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/network.rs) exposes the `wait_until_online` method, which returns a future that resolves immediately if the client is online or waits until the next `NetworkStatusKind::Online` event. This is useful for deferring cloud operations until connectivity is confirmed.

### Where are network logs displayed in the Warp UI?

Network logs are rendered through a pipeline starting at [`app/src/server/network_logging.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/server/network_logging.rs) (event recording), processed by [`app/src/server/network_log_view.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/server/network_log_view.rs) (view logic), and displayed in [`app/src/pane_group/pane/network_log_pane.rs`](https://github.com/warpdotdev/warp/blob/main/app/src/pane_group/pane/network_log_pane.rs) (dockable UI pane). This allows users to inspect WebSocket handshakes and connection states directly within the terminal interface.