rsloop 0.1.48__tar.gz → 0.1.49__tar.gz

{rsloop-0.1.48 → rsloop-0.1.49}/.github/workflows/tests.yml

@@ -62,54 +62,7 @@ jobs:
         run: python3 scripts/run_rust_tests.py ${{ matrix.test_args }}
 
   vibeio-native:
-    name: embedded runtime (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 15
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    steps:
-      - name: Check out repository
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-
-      - name: Set up Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: "1.98.1"
-          components: clippy, rustfmt
-
-      - name: Cache runtime harness build
-        uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: tools/vibeio-check
-
-      - name: Check embedded runtime formatting
-        run: cargo fmt --manifest-path tools/vibeio-check/Cargo.toml --all -- --check
-
-      - name: Check embedded runtime documentation
-        env:
-          RUSTDOCFLAGS: -D warnings
-        run: cargo doc --manifest-path tools/vibeio-check/Cargo.toml --all-features --no-deps --locked
-
-      - name: Lint embedded runtime on the native target
-        run: cargo clippy --manifest-path tools/vibeio-check/Cargo.toml --all-targets --all-features --locked -- -D warnings
-
-      - name: Check isolated embedded runtime features
-        shell: bash
-        run: |
-          for feature in '' fs process signal pipe stdio splice blocking-default; do
-            cargo clippy --manifest-path tools/vibeio-check/Cargo.toml --all-targets --no-default-features --features "$feature" --locked -- -D warnings
-            cargo test --manifest-path tools/vibeio-check/Cargo.toml --no-default-features --features "$feature" --locked
-          done
-
-      - name: Run default-feature embedded runtime tests
-        run: cargo test --manifest-path tools/vibeio-check/Cargo.toml --locked
-
-      - name: Run all-feature embedded runtime tests
-        run: cargo test --manifest-path tools/vibeio-check/Cargo.toml --all-features --locked
+    uses: ./.github/workflows/vibeio-native.yml
 
   clippy:
     name: clippy (risk-focused)

rsloop-0.1.49/.github/workflows/vibeio-native.yml

@@ -0,0 +1,109 @@
+name: Vibeio native tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      repetitions:
+        description: "All-feature test repetitions per native platform"
+        type: choice
+        default: "3"
+        options: ["1", "3", "10"]
+      isolated_features:
+        description: "Also lint and test each feature independently"
+        type: boolean
+        default: true
+  workflow_call:
+    inputs:
+      repetitions:
+        type: string
+        default: "1"
+      isolated_features:
+        type: boolean
+        default: true
+
+permissions:
+  contents: read
+
+jobs:
+  native:
+    name: vibeio (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    defaults:
+      run:
+        shell: bash
+    env:
+      RUST_BACKTRACE: "1"
+      CARGO_TERM_COLOR: never
+      REPETITIONS: ${{ inputs.repetitions }}
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Set up Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "1.98.1"
+          components: clippy, rustfmt
+
+      - name: Cache runtime harness build
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: tools/vibeio-check
+
+      - name: Record native environment
+        run: |
+          mkdir -p target/vibeio-native-logs
+          case "$REPETITIONS" in
+            1|3|10) ;;
+            *) echo "Unsupported repetition count: $REPETITIONS"; exit 1 ;;
+          esac
+          {
+            git rev-parse HEAD
+            rustc -Vv
+            cargo -V
+            uname -a
+          } 2>&1 | tee target/vibeio-native-logs/environment.log
+
+      - name: Check formatting and documentation
+        env:
+          RUSTDOCFLAGS: -D warnings
+        run: |
+          cargo fmt --manifest-path tools/vibeio-check/Cargo.toml --all -- --check
+          cargo doc --manifest-path tools/vibeio-check/Cargo.toml --all-features --no-deps --locked 2>&1 | tee target/vibeio-native-logs/documentation.log
+
+      - name: Lint native all-feature build
+        run: cargo clippy --manifest-path tools/vibeio-check/Cargo.toml --all-targets --all-features --locked -- -D warnings 2>&1 | tee target/vibeio-native-logs/clippy.log
+
+      - name: Inventory native tests
+        run: cargo test --manifest-path tools/vibeio-check/Cargo.toml --all-features --locked -- --list 2>&1 | tee target/vibeio-native-logs/test-inventory.log
+
+      - name: Run native all-feature tests repeatedly
+        run: |
+          for ((iteration=1; iteration<=REPETITIONS; iteration++)); do
+            cargo test --manifest-path tools/vibeio-check/Cargo.toml --all-features --locked -- --nocapture 2>&1 | tee "target/vibeio-native-logs/all-features-${iteration}.log"
+          done
+
+      - name: Check isolated features
+        if: ${{ inputs.isolated_features }}
+        run: |
+          for feature in '' fs process signal pipe stdio splice blocking-default; do
+            label="${feature:-default}"
+            cargo clippy --manifest-path tools/vibeio-check/Cargo.toml --all-targets --no-default-features --features "$feature" --locked -- -D warnings 2>&1 | tee "target/vibeio-native-logs/clippy-${label}.log"
+            cargo test --manifest-path tools/vibeio-check/Cargo.toml --no-default-features --features "$feature" --locked -- --nocapture 2>&1 | tee "target/vibeio-native-logs/tests-${label}.log"
+          done
+
+      - name: Upload native test evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: vibeio-native-${{ matrix.os }}-${{ github.run_attempt }}
+          path: target/vibeio-native-logs/
+          if-no-files-found: warn
+          retention-days: 14

{rsloop-0.1.48 → rsloop-0.1.49}/Cargo.lock

@@ -935,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "rsloop"
-version = "0.1.48"
+version = "0.1.49"
 dependencies = [
  "async-channel 2.5.0",
  "async-io",

{rsloop-0.1.48 → rsloop-0.1.49}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsloop"
-version = "0.1.48"
+version = "0.1.49"
 edition = "2024"
 description = "An event loop for asyncio written in Rust"
 license = "Apache-2.0"

{rsloop-0.1.48 → rsloop-0.1.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsloop
-Version: 0.1.48
+Version: 0.1.49
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -496,10 +496,32 @@ The repository also includes:
 
 ```bash
 uv run --with maturin maturin develop --release
-uv run --with uvloop python benches/compare_event_loops.py
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/compare_event_loops.py
 ```
 
-An example output from that script on macOS (arm64) with CPython 3.14:
+### Four-loop comparison on Linux
+
+Measured on September 7, 2026 on an Intel Core i9-9900K, Linux
+7.0.0-31-generic (x86_64), and CPython 3.14, with rsloop 0.1.48 built in
+release mode. Each entry is the median of five measured runs after one warmup,
+with each run in a fresh subprocess. Times are milliseconds; lower is better.
+
+| Workload | asyncio | uvloop | zuvloop | rsloop |
+|---|---:|---:|---:|---:|
+| 200,000 callbacks | 109.24 | 51.03 | **36.97** | 45.80 |
+| 50,000 tasks | 148.07 | 88.56 | **77.48** | 87.05 |
+| 5,000 TCP roundtrips | 149.27 | 122.88 | 105.12 | **90.62** |
+
+The TCP workload uses 1,024-byte payloads and rsloop's native fast streams;
+the other loops use stdlib asyncio streams. Use `--no-rsloop-fast-streams`
+to compare all loops through the stdlib streams layer. Zuvloop led callbacks
+and tasks in this run, while rsloop led TCP roundtrips. These are local
+microbenchmarks, not isolated-lab measurements or general application performance
+claims; do not compare them directly with the historical macOS results below.
+
+### Historical macOS comparison
+
+An earlier example output from the script on macOS (arm64) with CPython 3.14:
 
 ```
 callbacks (200,000 ops)
@@ -525,51 +547,51 @@ The production-shaped workload matrix exercises HTTP, WebSocket libraries,
 TLS, mixed message sizes, backpressure, and connection lifecycle behavior:
 
 ```bash
-uv run --with uvloop python benches/workload_matrix.py \
-  --loops rsloop,uvloop \
+uv run --with uvloop --with zuvloop python benches/workload_matrix.py \
+  --loops rsloop,uvloop,zuvloop \
   --sustained \
-  --json-output target/matrix-opt-final.json
+  --scenarios http_keepalive,tls_http,websocket_messages,websocket_tls,websockets_messages,websockets_tls,aiohttp_websocket_messages,aiohttp_websocket_tls,starlette_websocket_messages,starlette_websocket_tls,mixed_streams,bulk_transfer \
+  --json-output target/matrix-zuvloop.json
 ```
 
-Measured on September 6, 2026 with an Intel Core i9-9900K, Linux
-7.0.0-31-generic (x86_64), CPython 3.14.0, rsloop 0.1.47 (release build), and
-uvloop 0.22.1. Each row reports the median of seven measured runs after two
+Measured on September 7, 2026 with an Intel Core i9-9900K, Linux
+7.0.0-31-generic (x86_64), CPython 3.14.7, rsloop 0.1.48 (release build),
+uvloop 0.22.1, and zuvloop 0.0.14. Each row reports the median of seven measured runs after two
 warmups, using 16 concurrent connections and 500 requests per
 connection. Throughput is traffic-only operations per second, except for
 `bulk_transfer`, which reports traffic MiB/s. The p95 columns are the medians
-of each run's p95 latency; the difference is `(rsloop / uvloop - 1) × 100%`.
+of each run's p95 latency. Higher throughput and lower latency are better.
+Each loop/scenario pair runs in its own subprocess, with warmups and measured
+runs sharing that process. Loops run sequentially in the order shown.
 
-WebSocket library versions were websockets 17.0.1, aiohttp 3.14.3, Starlette
+WebSocket library versions were websockets 17.1, aiohttp 3.14.3, Starlette
 1.6.0, and uvicorn 0.52.3. The run used unrestricted CPU affinity, with other
 host services running but no concurrent builds or tests. These measurements
 are from a different host than the macOS microbenchmark example above.
 
-| Scenario | rsloop | uvloop | rsloop difference | rsloop p95 | uvloop p95 |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| HTTP keep-alive | 51,561 | 51,410 | +0.3% | 0.354 ms | 0.351 ms |
-| TLS HTTP | 72,465 | 25,493 | +184.3% | 0.241 ms | 0.668 ms |
-| Raw WebSocket | 5,197 | 5,296 | -1.9% | 5.023 ms | 3.504 ms |
-| Raw WebSocket over TLS | 5,395 | 4,824 | +11.8% | 3.945 ms | 3.870 ms |
-| `websockets` | 22,756 | 24,780 | -8.2% | 0.830 ms | 0.690 ms |
-| `websockets` over TLS | 26,044 | 15,081 | +72.7% | 0.672 ms | 1.109 ms |
-| aiohttp WebSocket | 29,879 | 33,895 | -11.8% | 0.656 ms | 0.511 ms |
-| aiohttp WebSocket over TLS | 32,983 | 19,063 | +73.0% | 0.526 ms | 0.890 ms |
-| Starlette WebSocket | 18,524 | 20,325 | -8.9% | 0.997 ms | 0.832 ms |
-| Starlette WebSocket over TLS | 18,058 | 13,555 | +33.2% | 0.942 ms | 1.257 ms |
-| Mixed streams | 42,797 | 34,642 | +23.5% | 0.484 ms | 0.521 ms |
-| Bulk transfer (MiB/s) | 1,993.5 | 1,223.7 | +62.9% | 14.768 ms | 26.061 ms |
+| Scenario | rsloop | uvloop | zuvloop | rsloop p95 | uvloop p95 | zuvloop p95 |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| HTTP keep-alive | 54,357 | 48,364 | 56,826 | 0.335 ms | 0.366 ms | 0.297 ms |
+| TLS HTTP | 69,047 | 25,267 | 24,076 | 0.287 ms | 0.663 ms | 0.700 ms |
+| Raw WebSocket | 4,834 | 4,858 | 4,932 | 5.244 ms | 3.878 ms | 3.381 ms |
+| Raw WebSocket over TLS | 4,875 | 4,457 | 4,421 | 4.425 ms | 4.020 ms | 3.770 ms |
+| `websockets` | 23,878 | 26,237 | 27,928 | 0.784 ms | 0.640 ms | 0.606 ms |
+| `websockets` over TLS | 26,946 | 14,933 | 13,640 | 0.640 ms | 1.103 ms | 1.319 ms |
+| aiohttp WebSocket | 31,145 | 34,552 | 37,733 | 0.625 ms | 0.498 ms | 0.458 ms |
+| aiohttp WebSocket over TLS | 33,730 | 18,576 | 18,245 | 0.517 ms | 0.905 ms | 0.929 ms |
+| Starlette WebSocket | 18,992 | 20,695 | 21,176 | 0.964 ms | 0.816 ms | 0.873 ms |
+| Starlette WebSocket over TLS | 17,876 | 13,454 | 12,487 | 0.955 ms | 1.243 ms | 1.437 ms |
+| Mixed streams | 41,260 | 35,805 | 37,094 | 0.483 ms | 0.504 ms | 0.476 ms |
+| Bulk transfer (MiB/s) | 2,120.0 | 1,269.6 | 1,287.8 | 14.114 ms | 25.134 ms | 24.801 ms |
 
 The former single-burst idle-activation row has been retired: its traffic
 phase lasted only a few milliseconds and produced unstable throughput rankings.
 Idle activation now has a separate, versioned latency benchmark described below.
-The other measurements above are unchanged. HTTP's 0.3% difference is too small
-to call a win.
-
-Compared with the same sustained workload on the pre-optimization build,
-plain-text `websockets`, aiohttp, and Starlette throughput improved by 10.2%,
-19.4%, and 22.3%, respectively. They still trail uvloop. The historical regression
-gate also flagged HTTP tail latency and legacy idle activation; this is not an
-across-the-board performance win. See the
+In this run, zuvloop had the highest plaintext HTTP and WebSocket throughput,
+while rsloop led TLS throughput, mixed streams, and bulk transfer. Throughput
+and tail latency do not always agree: rsloop's raw WebSocket p95 was higher
+than both alternatives, including over TLS. These results are not an
+across-the-board performance win or a before/after regression measurement. See the
 [benchmark documentation](./benches/README.md) for workload definitions and
 reproduction commands.
 
@@ -582,41 +604,45 @@ so has more to lose when cores are contended.
 ### Idle activation latency
 
 ```bash
-.venv/bin/python benches/workload_matrix.py \
-  --loops rsloop,uvloop --scenarios idle_connections --repeat 8 \
+uv run --with uvloop --with zuvloop python benches/workload_matrix.py \
+  --loops rsloop,uvloop,zuvloop --scenarios idle_connections --repeat 9 \
   --idle-cycles 100 --idle-warmup-cycles 5 --idle-seconds 0.2 \
   --json-output target/idle-v2-paired.json
 ```
 
 Idle v2 reuses 200 established connections across repeated idle/wakeup cycles.
 It measures all replies from one shared activation timestamp, including task
-scheduling delay, and reports first/50%/95%/all-reply latency. Eight fresh-process
-blocks alternate loop order; confidence intervals resample whole paired runs,
+scheduling delay, and reports first/50%/95%/all-reply latency. Nine fresh-process
+blocks rotate loop order so each loop runs first three times; confidence intervals resample whole paired runs,
 not individual connections. Results are classified as improved, regressed, or
 inconclusive using a 5% practical threshold and an approximate 95% confidence
-interval. The command takes about six minutes; use `--idle-cycles 3
+interval. The command takes about ten minutes; use `--idle-cycles 3
 --idle-warmup-cycles 1 --idle-seconds 0.01 --repeat 1` for a smoke test only.
 
 The new measurements cannot be compared with the retired ops/s row. See
 [benchmark methodology and regression handling](./benches/README.md#idle-activation-v2)
 for timing definitions, host controls, raw distributions, and sample requirements.
 
-Validation on the Linux/i9-9900K host above collected 800 measured cycles per
-loop in 16 distinct processes, with unrestricted affinity and no concurrent
+Measured on September 7, 2026 on the Linux/i9-9900K host above with CPython
+3.14.7, rsloop 0.1.48 (release), uvloop 0.22.1, and zuvloop 0.0.14.
+The run collected 900 measured cycles per loop in 27 distinct processes,
+with unrestricted affinity and no concurrent
 builds or test runs. These are medians across runs of each run's median cycle
 milestone, in milliseconds (lower is better):
 
 | Loop | First reply | 50% replied | 95% replied | All replied |
 | --- | ---: | ---: | ---: | ---: |
-| rsloop | 17.510 | 17.893 | 18.169 | 18.299 |
-| uvloop | 18.072 | 18.584 | 19.029 | 19.076 |
-
-The preselected paired comparison is **inconclusive**: the geometric mean
-run-level p95 latency change for rsloop versus uvloop is +9.6%, with a 95%
-bootstrap interval of [-4.8%, +32.2%]. This uses paired run ratios, not the
-ratio of the table's medians. Individual cycle-p95 latencies still form fast
-and slow clusters (rsloop 3.423–28.634 ms; uvloop 3.708–24.329 ms). The new
-benchmark exposes that uncertainty rather than declaring a throughput winner.
+| rsloop | 12.605 | 12.868 | 13.059 | 13.146 |
+| uvloop | 13.564 | 13.927 | 14.219 | 14.247 |
+| zuvloop | 16.331 | 16.772 | 17.146 | 17.206 |
+
+Both paired comparisons against uvloop are **inconclusive**. The geometric mean
+run-level p95 latency change is -13.7% for rsloop, with a 95% bootstrap interval
+of [-27.5%, +3.1%], and -0.4% for zuvloop, with an interval of [-21.5%, +25.6%].
+These use paired run ratios, not the ratio of the table's medians. Individual
+cycle-p95 latencies span 3.444–29.529 ms for rsloop, 3.739–24.965 ms for uvloop,
+and 3.388–29.540 ms for zuvloop. The benchmark exposes that uncertainty rather
+than declaring a latency winner from the median ordering alone.
 
 See [`benches/README.md`](./benches/README.md) for workload details and
 extra flags, and [`examples/README.md`](./examples/README.md) for the FastAPI

{rsloop-0.1.48 → rsloop-0.1.49}/README.md

@@ -464,10 +464,32 @@ The repository also includes:
 
 ```bash
 uv run --with maturin maturin develop --release
-uv run --with uvloop python benches/compare_event_loops.py
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/compare_event_loops.py
 ```
 
-An example output from that script on macOS (arm64) with CPython 3.14:
+### Four-loop comparison on Linux
+
+Measured on September 7, 2026 on an Intel Core i9-9900K, Linux
+7.0.0-31-generic (x86_64), and CPython 3.14, with rsloop 0.1.48 built in
+release mode. Each entry is the median of five measured runs after one warmup,
+with each run in a fresh subprocess. Times are milliseconds; lower is better.
+
+| Workload | asyncio | uvloop | zuvloop | rsloop |
+|---|---:|---:|---:|---:|
+| 200,000 callbacks | 109.24 | 51.03 | **36.97** | 45.80 |
+| 50,000 tasks | 148.07 | 88.56 | **77.48** | 87.05 |
+| 5,000 TCP roundtrips | 149.27 | 122.88 | 105.12 | **90.62** |
+
+The TCP workload uses 1,024-byte payloads and rsloop's native fast streams;
+the other loops use stdlib asyncio streams. Use `--no-rsloop-fast-streams`
+to compare all loops through the stdlib streams layer. Zuvloop led callbacks
+and tasks in this run, while rsloop led TCP roundtrips. These are local
+microbenchmarks, not isolated-lab measurements or general application performance
+claims; do not compare them directly with the historical macOS results below.
+
+### Historical macOS comparison
+
+An earlier example output from the script on macOS (arm64) with CPython 3.14:
 
 ```
 callbacks (200,000 ops)
@@ -493,51 +515,51 @@ The production-shaped workload matrix exercises HTTP, WebSocket libraries,
 TLS, mixed message sizes, backpressure, and connection lifecycle behavior:
 
 ```bash
-uv run --with uvloop python benches/workload_matrix.py \
-  --loops rsloop,uvloop \
+uv run --with uvloop --with zuvloop python benches/workload_matrix.py \
+  --loops rsloop,uvloop,zuvloop \
   --sustained \
-  --json-output target/matrix-opt-final.json
+  --scenarios http_keepalive,tls_http,websocket_messages,websocket_tls,websockets_messages,websockets_tls,aiohttp_websocket_messages,aiohttp_websocket_tls,starlette_websocket_messages,starlette_websocket_tls,mixed_streams,bulk_transfer \
+  --json-output target/matrix-zuvloop.json
 ```
 
-Measured on September 6, 2026 with an Intel Core i9-9900K, Linux
-7.0.0-31-generic (x86_64), CPython 3.14.0, rsloop 0.1.47 (release build), and
-uvloop 0.22.1. Each row reports the median of seven measured runs after two
+Measured on September 7, 2026 with an Intel Core i9-9900K, Linux
+7.0.0-31-generic (x86_64), CPython 3.14.7, rsloop 0.1.48 (release build),
+uvloop 0.22.1, and zuvloop 0.0.14. Each row reports the median of seven measured runs after two
 warmups, using 16 concurrent connections and 500 requests per
 connection. Throughput is traffic-only operations per second, except for
 `bulk_transfer`, which reports traffic MiB/s. The p95 columns are the medians
-of each run's p95 latency; the difference is `(rsloop / uvloop - 1) × 100%`.
+of each run's p95 latency. Higher throughput and lower latency are better.
+Each loop/scenario pair runs in its own subprocess, with warmups and measured
+runs sharing that process. Loops run sequentially in the order shown.
 
-WebSocket library versions were websockets 17.0.1, aiohttp 3.14.3, Starlette
+WebSocket library versions were websockets 17.1, aiohttp 3.14.3, Starlette
 1.6.0, and uvicorn 0.52.3. The run used unrestricted CPU affinity, with other
 host services running but no concurrent builds or tests. These measurements
 are from a different host than the macOS microbenchmark example above.
 
-| Scenario | rsloop | uvloop | rsloop difference | rsloop p95 | uvloop p95 |
-| --- | ---: | ---: | ---: | ---: | ---: |
-| HTTP keep-alive | 51,561 | 51,410 | +0.3% | 0.354 ms | 0.351 ms |
-| TLS HTTP | 72,465 | 25,493 | +184.3% | 0.241 ms | 0.668 ms |
-| Raw WebSocket | 5,197 | 5,296 | -1.9% | 5.023 ms | 3.504 ms |
-| Raw WebSocket over TLS | 5,395 | 4,824 | +11.8% | 3.945 ms | 3.870 ms |
-| `websockets` | 22,756 | 24,780 | -8.2% | 0.830 ms | 0.690 ms |
-| `websockets` over TLS | 26,044 | 15,081 | +72.7% | 0.672 ms | 1.109 ms |
-| aiohttp WebSocket | 29,879 | 33,895 | -11.8% | 0.656 ms | 0.511 ms |
-| aiohttp WebSocket over TLS | 32,983 | 19,063 | +73.0% | 0.526 ms | 0.890 ms |
-| Starlette WebSocket | 18,524 | 20,325 | -8.9% | 0.997 ms | 0.832 ms |
-| Starlette WebSocket over TLS | 18,058 | 13,555 | +33.2% | 0.942 ms | 1.257 ms |
-| Mixed streams | 42,797 | 34,642 | +23.5% | 0.484 ms | 0.521 ms |
-| Bulk transfer (MiB/s) | 1,993.5 | 1,223.7 | +62.9% | 14.768 ms | 26.061 ms |
+| Scenario | rsloop | uvloop | zuvloop | rsloop p95 | uvloop p95 | zuvloop p95 |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| HTTP keep-alive | 54,357 | 48,364 | 56,826 | 0.335 ms | 0.366 ms | 0.297 ms |
+| TLS HTTP | 69,047 | 25,267 | 24,076 | 0.287 ms | 0.663 ms | 0.700 ms |
+| Raw WebSocket | 4,834 | 4,858 | 4,932 | 5.244 ms | 3.878 ms | 3.381 ms |
+| Raw WebSocket over TLS | 4,875 | 4,457 | 4,421 | 4.425 ms | 4.020 ms | 3.770 ms |
+| `websockets` | 23,878 | 26,237 | 27,928 | 0.784 ms | 0.640 ms | 0.606 ms |
+| `websockets` over TLS | 26,946 | 14,933 | 13,640 | 0.640 ms | 1.103 ms | 1.319 ms |
+| aiohttp WebSocket | 31,145 | 34,552 | 37,733 | 0.625 ms | 0.498 ms | 0.458 ms |
+| aiohttp WebSocket over TLS | 33,730 | 18,576 | 18,245 | 0.517 ms | 0.905 ms | 0.929 ms |
+| Starlette WebSocket | 18,992 | 20,695 | 21,176 | 0.964 ms | 0.816 ms | 0.873 ms |
+| Starlette WebSocket over TLS | 17,876 | 13,454 | 12,487 | 0.955 ms | 1.243 ms | 1.437 ms |
+| Mixed streams | 41,260 | 35,805 | 37,094 | 0.483 ms | 0.504 ms | 0.476 ms |
+| Bulk transfer (MiB/s) | 2,120.0 | 1,269.6 | 1,287.8 | 14.114 ms | 25.134 ms | 24.801 ms |
 
 The former single-burst idle-activation row has been retired: its traffic
 phase lasted only a few milliseconds and produced unstable throughput rankings.
 Idle activation now has a separate, versioned latency benchmark described below.
-The other measurements above are unchanged. HTTP's 0.3% difference is too small
-to call a win.
-
-Compared with the same sustained workload on the pre-optimization build,
-plain-text `websockets`, aiohttp, and Starlette throughput improved by 10.2%,
-19.4%, and 22.3%, respectively. They still trail uvloop. The historical regression
-gate also flagged HTTP tail latency and legacy idle activation; this is not an
-across-the-board performance win. See the
+In this run, zuvloop had the highest plaintext HTTP and WebSocket throughput,
+while rsloop led TLS throughput, mixed streams, and bulk transfer. Throughput
+and tail latency do not always agree: rsloop's raw WebSocket p95 was higher
+than both alternatives, including over TLS. These results are not an
+across-the-board performance win or a before/after regression measurement. See the
 [benchmark documentation](./benches/README.md) for workload definitions and
 reproduction commands.
 
@@ -550,41 +572,45 @@ so has more to lose when cores are contended.
 ### Idle activation latency
 
 ```bash
-.venv/bin/python benches/workload_matrix.py \
-  --loops rsloop,uvloop --scenarios idle_connections --repeat 8 \
+uv run --with uvloop --with zuvloop python benches/workload_matrix.py \
+  --loops rsloop,uvloop,zuvloop --scenarios idle_connections --repeat 9 \
   --idle-cycles 100 --idle-warmup-cycles 5 --idle-seconds 0.2 \
   --json-output target/idle-v2-paired.json
 ```
 
 Idle v2 reuses 200 established connections across repeated idle/wakeup cycles.
 It measures all replies from one shared activation timestamp, including task
-scheduling delay, and reports first/50%/95%/all-reply latency. Eight fresh-process
-blocks alternate loop order; confidence intervals resample whole paired runs,
+scheduling delay, and reports first/50%/95%/all-reply latency. Nine fresh-process
+blocks rotate loop order so each loop runs first three times; confidence intervals resample whole paired runs,
 not individual connections. Results are classified as improved, regressed, or
 inconclusive using a 5% practical threshold and an approximate 95% confidence
-interval. The command takes about six minutes; use `--idle-cycles 3
+interval. The command takes about ten minutes; use `--idle-cycles 3
 --idle-warmup-cycles 1 --idle-seconds 0.01 --repeat 1` for a smoke test only.
 
 The new measurements cannot be compared with the retired ops/s row. See
 [benchmark methodology and regression handling](./benches/README.md#idle-activation-v2)
 for timing definitions, host controls, raw distributions, and sample requirements.
 
-Validation on the Linux/i9-9900K host above collected 800 measured cycles per
-loop in 16 distinct processes, with unrestricted affinity and no concurrent
+Measured on September 7, 2026 on the Linux/i9-9900K host above with CPython
+3.14.7, rsloop 0.1.48 (release), uvloop 0.22.1, and zuvloop 0.0.14.
+The run collected 900 measured cycles per loop in 27 distinct processes,
+with unrestricted affinity and no concurrent
 builds or test runs. These are medians across runs of each run's median cycle
 milestone, in milliseconds (lower is better):
 
 | Loop | First reply | 50% replied | 95% replied | All replied |
 | --- | ---: | ---: | ---: | ---: |
-| rsloop | 17.510 | 17.893 | 18.169 | 18.299 |
-| uvloop | 18.072 | 18.584 | 19.029 | 19.076 |
-
-The preselected paired comparison is **inconclusive**: the geometric mean
-run-level p95 latency change for rsloop versus uvloop is +9.6%, with a 95%
-bootstrap interval of [-4.8%, +32.2%]. This uses paired run ratios, not the
-ratio of the table's medians. Individual cycle-p95 latencies still form fast
-and slow clusters (rsloop 3.423–28.634 ms; uvloop 3.708–24.329 ms). The new
-benchmark exposes that uncertainty rather than declaring a throughput winner.
+| rsloop | 12.605 | 12.868 | 13.059 | 13.146 |
+| uvloop | 13.564 | 13.927 | 14.219 | 14.247 |
+| zuvloop | 16.331 | 16.772 | 17.146 | 17.206 |
+
+Both paired comparisons against uvloop are **inconclusive**. The geometric mean
+run-level p95 latency change is -13.7% for rsloop, with a 95% bootstrap interval
+of [-27.5%, +3.1%], and -0.4% for zuvloop, with an interval of [-21.5%, +25.6%].
+These use paired run ratios, not the ratio of the table's medians. Individual
+cycle-p95 latencies span 3.444–29.529 ms for rsloop, 3.739–24.965 ms for uvloop,
+and 3.388–29.540 ms for zuvloop. The benchmark exposes that uncertainty rather
+than declaring a latency winner from the median ordering alone.
 
 See [`benches/README.md`](./benches/README.md) for workload details and
 extra flags, and [`examples/README.md`](./examples/README.md) for the FastAPI

{rsloop-0.1.48 → rsloop-0.1.49}/benches/README.md

@@ -8,14 +8,15 @@ before/after results and limitations; these are not Python event-loop comparison
 This benchmark compares:
 
 - stdlib `asyncio`
-- `uvloop`
+- `uvloop` (`winloop` on Windows)
+- `zuvloop` on Python 3.14+
 - the Rust prototype in `rsloop`
 
 Run it from the repository root so Python resolves the editable Rust package cleanly:
 
 ```bash
 uv run --with maturin maturin develop --release
-uv run --with uvloop python benches/compare_event_loops.py
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/compare_event_loops.py
 ```
 
 Benchmark runner: [`benches/compare_event_loops.py`](./compare_event_loops.py)
@@ -28,7 +29,7 @@ Useful quick run:
 
 ```bash
 uv run --with maturin maturin develop --release
-uv run --with uvloop python benches/compare_event_loops.py \
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/compare_event_loops.py \
   --warmups 0 \
   --repeat 3 \
   --callbacks 50000 \
@@ -42,7 +43,7 @@ measured runs, add a label directory:
 
 ```bash
 uv run --with maturin maturin develop --release --features profiler
-uv run --with uvloop python benches/compare_event_loops.py \
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/compare_event_loops.py \
   --loops rsloop \
   --workloads callbacks,tasks,tcp_streams \
   --profile-rsloop-dir benches/profiles
@@ -68,10 +69,10 @@ Current workloads:
 - `tcp_streams`: local `asyncio.start_server()` / `asyncio.open_connection()` echo round trips
 
 By default, `tcp_streams` uses `rsloop`'s native fast streams. If you want all
-three loops to go through the stdlib `asyncio` streams layer instead, pass:
+selected loops to go through the stdlib `asyncio` streams layer instead, pass:
 
 ```bash
-uv run --with uvloop python benches/compare_event_loops.py --no-rsloop-fast-streams
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/compare_event_loops.py --no-rsloop-fast-streams
 ```
 
 ## Representative workload matrix
@@ -107,18 +108,22 @@ Build rsloop in release mode and run the standard matrix with:
 
 ```bash
 uv run --with maturin maturin develop --release
-uv run --with uvloop python benches/workload_matrix.py  # Unix
-uv run --with winloop python benches/workload_matrix.py # Windows
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/workload_matrix.py  # Unix
+uv run --with winloop --with 'zuvloop; python_version >= "3.14"' python benches/workload_matrix.py # Windows
 ```
 
 The default comparison is `asyncio,uvloop,rsloop` on Unix. Because uvloop is
 not available on Windows, the default there is `asyncio,winloop,rsloop`.
-Unavailable optional loops are reported and skipped.
+On Python 3.14+, zuvloop is added before rsloop in both defaults. Older Python
+versions retain the three-loop defaults. Select a subset with `--loops`, for
+example `--loops uvloop,zuvloop,rsloop` on Unix with Python 3.14+.
+Unavailable optional loops are reported and skipped; workload failures are not
+silently replaced by another loop. zuvloop is a benchmark-only dependency.
 
 For a quick smoke run:
 
 ```bash
-uv run --with uvloop python benches/workload_matrix.py \
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/workload_matrix.py \
   --warmups 0 \
   --repeat 1 \
   --concurrency 4 \
@@ -152,7 +157,7 @@ pass before each rsloop scenario:
 
 ```bash
 uv run --with maturin maturin develop --release --features profiler
-uv run --with uvloop python benches/workload_matrix.py \
+uv run --with uvloop --with 'zuvloop; python_version >= "3.14"' python benches/workload_matrix.py \
   --loops rsloop \
   --profile-rsloop-dir benches/profiles \
   --allow-profiler-build