comments from phillip

Author: okdistribute

connecting/local-discovery.mdx

@@ -0,0 +1,39 @@
+---
+title: "mDNS"
+---
+
+The mDNS discovery mechanism will automatically broadcast your endpoint's
+presence on the local network, and listen for other endpoints doing the same. When
+another endpoint is discovered, the dialing information is exchanged, and a
+connection can be established directly over the local network without needing a relay.
+
+Devices need to be connected to the same local network for mDNS discovery to
+work. This can be a Wi-Fi network, an Ethernet network, or even a mobile
+hotspot. mDNS is not designed to work over the internet or across different
+networks.
+
+## Usage
+
+Local Discovery is _not_ enabled by default, and must be enabled explicitly.
+You'll need to add the `discovery-local-network` feature flag to your
+`Cargo.toml` to use it.
+
+```toml
+[dependencies]
+# Make sure to use the most recent version here instead of nn. (at the time of writing: 0.32)
+iroh = { version = "0.nn", features = ["address-lookup-mdns"] }
+```
+
+Then configure your endpoint to use local discovery concurrently with the default DNS discovery:
+
+```rust
+use iroh::{Endpoint, presets};
+
+let mdns = iroh::address_lookup::mdns::MdnsAddressLookup::builder();
+let ep = Endpoint::builder()
+    .address_lookup(mdns)
+    .bind(presets::N0)
+    .await?;
+```
+
+For more information on how mDNS discovery works, see the [mDNS documentation](https://docs.rs/iroh/latest/iroh/address_lookup/mdns/index.html).

docs.json

@@ -40,27 +40,27 @@
               "connecting/custom-relays",
               "connecting/dns-discovery",
               "connecting/dht-discovery",
+              "connecting/local-discovery",
               "connecting/gossip",
               "connecting/endpoint-hooks"
             ]
           },
           {
-            "group": "Protocols",
+            "group": "Sending Data",
             "pages": [
               "protocols/kv-crdts",
               "protocols/blobs",
               "protocols/rpc",
               "protocols/automerge",
               "protocols/streaming",
               "examples/chat",
-              "protocols/writing-a-protocol"
+              "protocols/writing-a-protocol",
+              "protocols/using-quic"
             ]
           },
           {
             "group": "Transports",
             "pages": [
-              "transports/quic",
-              "transports/mdns",
               "transports/tor",
               "transports/nym",
               "transports/bluetooth"

protocols/using-quic.md

@@ -2,9 +2,26 @@
 title: "Using QUIC"
 ---
 
-## Why this matters for iroh
+Every endpoint uses QUIC over UDP by default — no configuration required.
 
-iroh is built on top of QUIC, providing connectivity, NAT traversal, and encrypted connections out of the box. While iroh handles the hard parts of networking—holepunching, relay servers, and discovery—**you still need to design how your application exchanges data once connected**.
+iroh's QUIC implementation is built on
+[noq](https://github.com/n0-computer/noq), which includes multipath support and
+QUIC NAT traversal.
+
+All connections are encrypted and authenticated using TLS 1.3. Holepunching,
+relay fallback, and multipath are all handled at the QUIC layer automatically.
+
+## Custom transports
+
+QUIC over UDP is the default, but iroh supports plugging in additional custom
+transports alongside it. 
+
+All transports, even custom transports [Tor](/transports/tor), [Nym](/transports/nym), and
+[Bluetooth](/transports/bluetooth) deliver QUIC datagrams.
+
+## Using QUIC
+
+While iroh handles the hard parts of networking—holepunching, relay servers, and discovery—**you still need to design how your application exchanges data once connected**.
 
 Many developers reach for iroh expecting it to completely abstract away the underlying transport. However, iroh intentionally exposes QUIC's powerful stream API because:
 

protocols/writing-a-protocol.mdx

@@ -164,7 +164,7 @@ This follows the [request-response pattern](/protocols/using-quic#request-and-re
 
 ```rs
 async fn connect_side(addr: EndpointAddr) -> Result<()> {
-    let endpoint = Endpoint::bind(presets::N0).await?;
+    let endpoint = Endpoint::bind(iroh::presets::N0).await?;
 
     // Open a connection to the accepting endpoint
     let conn = endpoint.connect(addr, ALPN).await?;