zuvloop 0.0.1__tar.gz

zuvloop-0.0.1/.gitignore

@@ -0,0 +1,24 @@
+.zig-cache/
+zig-out/
+__pycache__/
+*.py[cod]
+*.so
+.venv/
+.coverage
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+dist/
+build/
+tests/certs/
+
+# Rendered documentation
+site/
+
+# CodSpeed run data
+.codspeed/
+
+# Compiled extension, built in place
+zuvloop/*.so
+zig-out/
+.conformance/

zuvloop-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marcelo Trylesinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zuvloop-0.0.1/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: zuvloop
+Version: 0.0.1
+Summary: A libuv event loop for asyncio, written in Zig.
+Project-URL: Source, https://github.com/Kludex/zuvloop
+Author-email: Marcelo Trylesinski <marcelotryle@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+License-File: vendor/libuv/LICENSE
+License-File: vendor/libuv/LICENSE-docs
+License-File: vendor/libuv/LICENSE-extra
+Keywords: asyncio,event-loop,libuv,uvloop,zig
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Zig
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: opentelemetry-api>=1.23
+Description-Content-Type: text/markdown
+
+# zuvloop
+
+<p align="center">
+  <em>A fast, drop-in asyncio event loop, powered by libuv and written in Zig ⚡</em>
+</p>
+
+---
+
+**Documentation**: <a href="https://zuvloop.marcelotryle.com" target="_blank">https://zuvloop.marcelotryle.com</a>
+
+**Source Code**: <a href="https://github.com/Kludex/zuvloop" target="_blank">https://github.com/Kludex/zuvloop</a>
+
+---
+
+zuvloop is a replacement for the built-in `asyncio` event loop.
+
+Your code stays the same. The loop underneath gets faster. 🚀
+
+The key features are:
+
+- **Fast**: Scheduling, timers, sockets, and DNS run in native code, driven by [libuv](https://libuv.org) — the same engine behind Node.js. Up to **6x faster than asyncio** and faster than [uvloop](https://github.com/MagicStack/uvloop) on every benchmark below.
+- **Drop-in**: One line to switch. Everything is standard `asyncio` — same `Task` objects, same protocols, same APIs.
+- **Fully typed**: Ships type hints for everything and passes **strict mypy**. Your editor will love it. ✨
+- **Observable**: Built-in [OpenTelemetry](https://opentelemetry.io) instrumentation — slow-callback spans, unhandled-exception spans, loop metrics. Zero cost until you turn it on.
+- **Modern**: Built for Python 3.14, including the new asyncio introspection tools (`python -m asyncio ps`, call graphs, and friends).
+
+## Performance
+
+<p align="center">
+  <img src="docs/assets/performance.png" alt="zuvloop vs uvloop vs asyncio benchmarks">
+</p>
+
+Throughput relative to stock asyncio (higher is better), measured with the suite in
+`benchmarks/` on an M3 Max, macOS 26, CPython 3.14. The labels show the absolute numbers.
+
+| Benchmark | asyncio | uvloop | zuvloop |
+| --- | ---: | ---: | ---: |
+| `call_soon` | 2.69M/s | 4.69M/s | **5.91M/s** |
+| `call_soon` with arguments | 2.43M/s | 3.87M/s | **6.47M/s** |
+| timer schedule + cancel | 1.58M/s | 2.62M/s | **9.55M/s** |
+| bulk stream | 8.4 GiB/s | 8.5 GiB/s | **10.2 GiB/s** |
+| echo round trips, 1 KiB | 39.0k/s | 56.8k/s | **58.5k/s** |
+| uvicorn, plaintext | 55.3k req/s | 71.9k req/s | **75.9k req/s** |
+| uvicorn, 10 KiB body | 52.6k req/s | 68.7k req/s | **73.6k req/s** |
+| aiohttp server | 49.0k req/s | 59.8k req/s | **60.6k req/s** |
+| aiohttp client | 13.2k req/s | 16.2k req/s | **16.9k req/s** |
+| `getaddrinfo`, numeric host | 28.5k/s | 1.57M/s | **1.90M/s** |
+
+Curious how? The [architecture docs](https://zuvloop.marcelotryle.com) explain the design:
+argument storage inside handles (no tuple per callback), a native timer heap behind a single
+`uv_timer_t`, per-turn vectored write batching, zero-copy reads, and a `getaddrinfo` fast path
+for address literals.
+
+## Requirements
+
+- Python 3.14+
+- Linux or macOS
+
+## Installation
+
+```console
+$ pip install zuvloop
+```
+
+To build from source you also need [Zig](https://ziglang.org/download/) 0.16.
+
+## Example
+
+Write normal asyncio code, run it with zuvloop:
+
+```python
+import asyncio
+
+import zuvloop
+
+
+async def main() -> None:
+    reader, writer = await asyncio.open_connection("example.com", 80)
+    writer.write(b"GET / HTTP/1.0\r\nHost: example.com\r\n\r\n")
+    await writer.drain()
+    print(await reader.read(64))
+    writer.close()
+    await writer.wait_closed()
+
+
+zuvloop.run(main())
+```
+
+Prefer to keep `asyncio.run()`? Hand it the loop factory:
+
+```python
+asyncio.run(main(), loop_factory=zuvloop.new_event_loop)
+```
+
+That's it. That's the migration. 🎉
+
+## Observability
+
+zuvloop emits plain OpenTelemetry. The only runtime dependency is `opentelemetry-api` — not the
+SDK, nothing vendor-specific. Until your application installs a provider, the instruments are
+no-ops and cost nothing.
+
+Anything that speaks OpenTelemetry can collect it. For example, with
+<a href="https://logfire.pydantic.dev" target="_blank">Logfire</a>:
+
+```python
+import logfire
+import zuvloop
+
+logfire.configure()  # installs the OTel providers
+
+
+async def main() -> None: ...
+
+
+zuvloop.run(main())
+```
+
+That's all — there is no zuvloop-specific setup. Spans and counters are emitted
+as events happen, and the loop gauges are sampled automatically while the loop
+runs (only when a real provider is installed, so an uninstrumented program never
+pays for sampling).
+
+You get:
+
+- **`zuvloop.slow_callback`** spans — with real start/end timestamps measured by `uv_hrtime()`
+  in native code, and the awaiting call graph attached (via `asyncio.format_call_graph()`),
+  so you see *why* a callback was running, not just its repr.
+- **`zuvloop.unhandled_exception`** spans — with the exception recorded.
+- Counters, a callback-duration histogram, and live loop gauges (`loop_count`, `events`,
+  `idle_time_ns`, `ready`, `timers`, `watchers`, ...).
+
+And because zuvloop schedules real `asyncio.Task` objects, the Python 3.14 introspection tools
+work unchanged:
+
+```console
+$ python -m asyncio ps <pid>
+$ python -m asyncio pstree <pid>
+```
+
+## Compatibility
+
+zuvloop is checked against CPython's own conformance suite and against the test suites of the
+projects that exercise an event loop hardest — run unmodified, with the loop swapped underneath:
+
+| Suite | Result |
+| --- | --- |
+| CPython `test_asyncio` | 88 passed, 4 skipped, none failing |
+| uvicorn | 1257 passed, no failures |
+| aiohttp | 4473 passed, 36 failed — 33 of which also fail on stock asyncio |
+
+`scripts/conformance.py` runs CPython's `EventLoopTestsMixin`, `SubprocessTestsMixin` and
+`BaseSockTestsMixin` against zuvloop, downloading the source of whichever interpreter is running
+so the suite always matches it. Each test runs in its own process, so a hang is reported rather
+than stopping the run. Three of the four skips are white-box tests of CPython's own internals -
+two patch `asyncio.base_events.socket`, one counts calls to `BaseEventLoop._run_once` - which no
+loop outside the standard library can satisfy.
+
+Of aiohttp's three remaining failures, two are `blockbuster` reporting a blocking `os.stat` that
+the standard library makes on the same path, and the third is the `loop.time()` difference below.
+
+(For reference: uvloop cannot complete the aiohttp suite — it fails fifteen tests and then hangs.)
+
+There is one intentional difference: **patching `loop.time()` does not move the scheduler**.
+zuvloop keeps its timer heap in native code and reads the clock directly, so monkeypatching
+`time()` — a trick some test suites use to fast-forward timeouts — changes what `loop.time()`
+returns and nothing else. A loop that needs a controllable clock should schedule against one
+explicitly.
+
+Also not implemented: `sendfile()` and `sock_sendfile()` raise `NotImplementedError`. Handles
+returned by `call_soon` and `call_later` implement the `asyncio.Handle` and
+`asyncio.TimerHandle` interfaces but are not instances of those classes; `call_soon_threadsafe`
+does return a real `asyncio.Handle`, because 3.14 requires cancelling one from another thread to
+block until a callback that has already started finishes.
+
+## Development
+
+```console
+$ uv venv --python 3.14
+$ uv pip install -e . --group dev
+$ uv run pytest
+$ uv run mypy
+$ uv run ruff check
+$ uv run --group bench python benchmarks/run.py
+```
+
+The extension is rebuilt by `hatch_build.py` on every install. To rebuild in place:
+
+```console
+$ python scripts/build.py
+```
+
+`vendor/libuv` is an unmodified upstream release tarball; see `vendor/README.md`. Update it with
+`./vendor/update-libuv.sh <version>`.
+
+## License
+
+This project is licensed under the terms of the MIT license.

zuvloop-0.0.1/README.md

@@ -0,0 +1,198 @@
+# zuvloop
+
+<p align="center">
+  <em>A fast, drop-in asyncio event loop, powered by libuv and written in Zig ⚡</em>
+</p>
+
+---
+
+**Documentation**: <a href="https://zuvloop.marcelotryle.com" target="_blank">https://zuvloop.marcelotryle.com</a>
+
+**Source Code**: <a href="https://github.com/Kludex/zuvloop" target="_blank">https://github.com/Kludex/zuvloop</a>
+
+---
+
+zuvloop is a replacement for the built-in `asyncio` event loop.
+
+Your code stays the same. The loop underneath gets faster. 🚀
+
+The key features are:
+
+- **Fast**: Scheduling, timers, sockets, and DNS run in native code, driven by [libuv](https://libuv.org) — the same engine behind Node.js. Up to **6x faster than asyncio** and faster than [uvloop](https://github.com/MagicStack/uvloop) on every benchmark below.
+- **Drop-in**: One line to switch. Everything is standard `asyncio` — same `Task` objects, same protocols, same APIs.
+- **Fully typed**: Ships type hints for everything and passes **strict mypy**. Your editor will love it. ✨
+- **Observable**: Built-in [OpenTelemetry](https://opentelemetry.io) instrumentation — slow-callback spans, unhandled-exception spans, loop metrics. Zero cost until you turn it on.
+- **Modern**: Built for Python 3.14, including the new asyncio introspection tools (`python -m asyncio ps`, call graphs, and friends).
+
+## Performance
+
+<p align="center">
+  <img src="docs/assets/performance.png" alt="zuvloop vs uvloop vs asyncio benchmarks">
+</p>
+
+Throughput relative to stock asyncio (higher is better), measured with the suite in
+`benchmarks/` on an M3 Max, macOS 26, CPython 3.14. The labels show the absolute numbers.
+
+| Benchmark | asyncio | uvloop | zuvloop |
+| --- | ---: | ---: | ---: |
+| `call_soon` | 2.69M/s | 4.69M/s | **5.91M/s** |
+| `call_soon` with arguments | 2.43M/s | 3.87M/s | **6.47M/s** |
+| timer schedule + cancel | 1.58M/s | 2.62M/s | **9.55M/s** |
+| bulk stream | 8.4 GiB/s | 8.5 GiB/s | **10.2 GiB/s** |
+| echo round trips, 1 KiB | 39.0k/s | 56.8k/s | **58.5k/s** |
+| uvicorn, plaintext | 55.3k req/s | 71.9k req/s | **75.9k req/s** |
+| uvicorn, 10 KiB body | 52.6k req/s | 68.7k req/s | **73.6k req/s** |
+| aiohttp server | 49.0k req/s | 59.8k req/s | **60.6k req/s** |
+| aiohttp client | 13.2k req/s | 16.2k req/s | **16.9k req/s** |
+| `getaddrinfo`, numeric host | 28.5k/s | 1.57M/s | **1.90M/s** |
+
+Curious how? The [architecture docs](https://zuvloop.marcelotryle.com) explain the design:
+argument storage inside handles (no tuple per callback), a native timer heap behind a single
+`uv_timer_t`, per-turn vectored write batching, zero-copy reads, and a `getaddrinfo` fast path
+for address literals.
+
+## Requirements
+
+- Python 3.14+
+- Linux or macOS
+
+## Installation
+
+```console
+$ pip install zuvloop
+```
+
+To build from source you also need [Zig](https://ziglang.org/download/) 0.16.
+
+## Example
+
+Write normal asyncio code, run it with zuvloop:
+
+```python
+import asyncio
+
+import zuvloop
+
+
+async def main() -> None:
+    reader, writer = await asyncio.open_connection("example.com", 80)
+    writer.write(b"GET / HTTP/1.0\r\nHost: example.com\r\n\r\n")
+    await writer.drain()
+    print(await reader.read(64))
+    writer.close()
+    await writer.wait_closed()
+
+
+zuvloop.run(main())
+```
+
+Prefer to keep `asyncio.run()`? Hand it the loop factory:
+
+```python
+asyncio.run(main(), loop_factory=zuvloop.new_event_loop)
+```
+
+That's it. That's the migration. 🎉
+
+## Observability
+
+zuvloop emits plain OpenTelemetry. The only runtime dependency is `opentelemetry-api` — not the
+SDK, nothing vendor-specific. Until your application installs a provider, the instruments are
+no-ops and cost nothing.
+
+Anything that speaks OpenTelemetry can collect it. For example, with
+<a href="https://logfire.pydantic.dev" target="_blank">Logfire</a>:
+
+```python
+import logfire
+import zuvloop
+
+logfire.configure()  # installs the OTel providers
+
+
+async def main() -> None: ...
+
+
+zuvloop.run(main())
+```
+
+That's all — there is no zuvloop-specific setup. Spans and counters are emitted
+as events happen, and the loop gauges are sampled automatically while the loop
+runs (only when a real provider is installed, so an uninstrumented program never
+pays for sampling).
+
+You get:
+
+- **`zuvloop.slow_callback`** spans — with real start/end timestamps measured by `uv_hrtime()`
+  in native code, and the awaiting call graph attached (via `asyncio.format_call_graph()`),
+  so you see *why* a callback was running, not just its repr.
+- **`zuvloop.unhandled_exception`** spans — with the exception recorded.
+- Counters, a callback-duration histogram, and live loop gauges (`loop_count`, `events`,
+  `idle_time_ns`, `ready`, `timers`, `watchers`, ...).
+
+And because zuvloop schedules real `asyncio.Task` objects, the Python 3.14 introspection tools
+work unchanged:
+
+```console
+$ python -m asyncio ps <pid>
+$ python -m asyncio pstree <pid>
+```
+
+## Compatibility
+
+zuvloop is checked against CPython's own conformance suite and against the test suites of the
+projects that exercise an event loop hardest — run unmodified, with the loop swapped underneath:
+
+| Suite | Result |
+| --- | --- |
+| CPython `test_asyncio` | 88 passed, 4 skipped, none failing |
+| uvicorn | 1257 passed, no failures |
+| aiohttp | 4473 passed, 36 failed — 33 of which also fail on stock asyncio |
+
+`scripts/conformance.py` runs CPython's `EventLoopTestsMixin`, `SubprocessTestsMixin` and
+`BaseSockTestsMixin` against zuvloop, downloading the source of whichever interpreter is running
+so the suite always matches it. Each test runs in its own process, so a hang is reported rather
+than stopping the run. Three of the four skips are white-box tests of CPython's own internals -
+two patch `asyncio.base_events.socket`, one counts calls to `BaseEventLoop._run_once` - which no
+loop outside the standard library can satisfy.
+
+Of aiohttp's three remaining failures, two are `blockbuster` reporting a blocking `os.stat` that
+the standard library makes on the same path, and the third is the `loop.time()` difference below.
+
+(For reference: uvloop cannot complete the aiohttp suite — it fails fifteen tests and then hangs.)
+
+There is one intentional difference: **patching `loop.time()` does not move the scheduler**.
+zuvloop keeps its timer heap in native code and reads the clock directly, so monkeypatching
+`time()` — a trick some test suites use to fast-forward timeouts — changes what `loop.time()`
+returns and nothing else. A loop that needs a controllable clock should schedule against one
+explicitly.
+
+Also not implemented: `sendfile()` and `sock_sendfile()` raise `NotImplementedError`. Handles
+returned by `call_soon` and `call_later` implement the `asyncio.Handle` and
+`asyncio.TimerHandle` interfaces but are not instances of those classes; `call_soon_threadsafe`
+does return a real `asyncio.Handle`, because 3.14 requires cancelling one from another thread to
+block until a callback that has already started finishes.
+
+## Development
+
+```console
+$ uv venv --python 3.14
+$ uv pip install -e . --group dev
+$ uv run pytest
+$ uv run mypy
+$ uv run ruff check
+$ uv run --group bench python benchmarks/run.py
+```
+
+The extension is rebuilt by `hatch_build.py` on every install. To rebuild in place:
+
+```console
+$ python scripts/build.py
+```
+
+`vendor/libuv` is an unmodified upstream release tarball; see `vendor/README.md`. Update it with
+`./vendor/update-libuv.sh <version>`.
+
+## License
+
+This project is licensed under the terms of the MIT license.

zuvloop-0.0.1/build.zig

@@ -0,0 +1,134 @@
+const std = @import("std");
+
+const uv_common = [_][]const u8{
+    "src/fs-poll.c",
+    "src/idna.c",
+    "src/inet.c",
+    "src/random.c",
+    "src/strscpy.c",
+    "src/strtok.c",
+    "src/thread-common.c",
+    "src/threadpool.c",
+    "src/timer.c",
+    "src/uv-common.c",
+    "src/uv-data-getter-setters.c",
+    "src/version.c",
+};
+
+const uv_unix = [_][]const u8{
+    "src/unix/async.c",
+    "src/unix/core.c",
+    "src/unix/dl.c",
+    "src/unix/fs.c",
+    "src/unix/getaddrinfo.c",
+    "src/unix/getnameinfo.c",
+    "src/unix/loop-watcher.c",
+    "src/unix/loop.c",
+    "src/unix/pipe.c",
+    "src/unix/poll.c",
+    "src/unix/process.c",
+    "src/unix/random-devurandom.c",
+    "src/unix/signal.c",
+    "src/unix/stream.c",
+    "src/unix/tcp.c",
+    "src/unix/thread.c",
+    "src/unix/tty.c",
+    "src/unix/udp.c",
+};
+
+const uv_darwin = [_][]const u8{
+    "src/unix/bsd-ifaddrs.c",
+    "src/unix/darwin-proctitle.c",
+    "src/unix/darwin.c",
+    "src/unix/fsevents.c",
+    "src/unix/kqueue.c",
+    "src/unix/proctitle.c",
+    "src/unix/random-getentropy.c",
+};
+
+const uv_linux = [_][]const u8{
+    "src/unix/linux.c",
+    "src/unix/procfs-exepath.c",
+    "src/unix/proctitle.c",
+    "src/unix/random-getrandom.c",
+    "src/unix/random-sysctl-linux.c",
+};
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    // hatch-ziglang passes the building interpreter through the environment, so a
+    // wheel is always built against the interpreter that asked for it. The `-D`
+    // options are for building by hand.
+    const python_include = b.option([]const u8, "python-include", "CPython include directory") orelse
+        (b.graph.environ_map.get("HATCH_ZIG_PYTHON_INCLUDE") orelse
+            @panic("python-include is required: pass -Dpython-include or set HATCH_ZIG_PYTHON_INCLUDE"));
+    const ext_suffix = b.option([]const u8, "ext-suffix", "Extension module suffix") orelse
+        (b.graph.environ_map.get("HATCH_ZIG_EXT_SUFFIX") orelse ".so");
+    const os = target.result.os.tag;
+
+    const mod = b.createModule(.{
+        .root_source_file = b.path("zig/module.zig"),
+        .target = target,
+        .optimize = optimize,
+        .link_libc = true,
+        .pic = true,
+    });
+    mod.addIncludePath(.{ .cwd_relative = python_include });
+    mod.addIncludePath(b.path("vendor/libuv/include"));
+    mod.addIncludePath(b.path("vendor/libuv/src"));
+
+    var uv_flags: std.ArrayList([]const u8) = .empty;
+    uv_flags.appendSlice(b.allocator, &.{
+        "-std=gnu11",
+        "-fno-strict-aliasing",
+        "-D_FILE_OFFSET_BITS=64",
+        "-D_LARGEFILE_SOURCE",
+        "-Wno-unused-parameter",
+    }) catch @panic("OOM");
+
+    var uv_files: std.ArrayList([]const u8) = .empty;
+    uv_files.appendSlice(b.allocator, &uv_common) catch @panic("OOM");
+    uv_files.appendSlice(b.allocator, &uv_unix) catch @panic("OOM");
+    switch (os) {
+        .macos, .ios, .watchos, .tvos => {
+            uv_files.appendSlice(b.allocator, &uv_darwin) catch @panic("OOM");
+            uv_flags.appendSlice(b.allocator, &.{
+                "-D_DARWIN_UNLIMITED_SELECT=1",
+                "-D_DARWIN_USE_64_BIT_INODE=1",
+            }) catch @panic("OOM");
+        },
+        .linux => {
+            uv_files.appendSlice(b.allocator, &uv_linux) catch @panic("OOM");
+            uv_flags.appendSlice(b.allocator, &.{
+                "-D_GNU_SOURCE",
+                "-D_POSIX_C_SOURCE=200112",
+            }) catch @panic("OOM");
+        },
+        else => @panic("unsupported target: zuvloop builds on Linux and macOS"),
+    }
+
+    mod.addCSourceFiles(.{
+        .root = b.path("vendor/libuv"),
+        .files = uv_files.items,
+        .flags = uv_flags.items,
+    });
+
+    const lib = b.addLibrary(.{
+        .name = "_zuvloop",
+        .root_module = mod,
+        .linkage = .dynamic,
+    });
+    lib.linker_allow_shlib_undefined = true;
+    lib.bundle_compiler_rt = true;
+    if (os == .linux) mod.linkSystemLibrary("rt", .{});
+
+    // Relative to the install prefix, so with the default `zig-out` the module
+    // lands beside the Python sources, which is where the build hook looks.
+    b.getInstallStep().dependOn(&b.addInstallFileWithDir(
+        lib.getEmittedBin(),
+        .{ .custom = "../zuvloop" },
+        b.fmt("_zuvloop{s}", .{ext_suffix}),
+    ).step);
+}

zuvloop-0.0.1/build.zig.zon

@@ -0,0 +1,12 @@
+.{
+    .name = .zuvloop,
+    .version = "0.1.0",
+    .fingerprint = 0x78121bf4a4379c83,
+    .minimum_zig_version = "0.16.0",
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "zig",
+        "vendor",
+    },
+}