Hackage :: [Package]

quic-simple: Quick-start wrappers for QUIC

[ bsd3, library, network ] [ Propose Tags ] [ Report a vulnerability ]

A few layers over QUIC, to get the first bytes out faster. The top level is RPC-like, using Serialise as a codec. Copypaste the code and peel layers as you go to get more power and flexibility.

[Skip to Readme]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

  • No Candidates
Versions [RSS] 0.1.0.0, 0.1.0.1, 0.1.1.0, 0.1.2.0 (info)
Change log CHANGELOG.md
Dependencies async, base (>=4.7 && <5), bytestring, crypton, crypton-x509, iproute, network, quic (>=0.3.2), ram, serialise, stm, time-hourglass, tls [details]
License BSD-3-Clause
Copyright 2025 IC Rainbow
Author IC Rainbow
Maintainer aenor.realm@gmail.com
Uploaded by AlexanderBondarenko at 2026-09-03T18:26:27Z
Category Network
Source repo head: git clone https://gitlab.com/dpwiz/quic-simple
Distributions
Downloads 119 total (22 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2026-09-03 [all 1 reports]

Readme for quic-simple-0.1.2.0

[back to package description]

quic-simple

A set of wrappers for getting started with QUIC easier.

  • QUIC.runServer [("127.0.0.1", 14443)] \conn stream -> -- start a generic server with random TLS credentials and auto-accept the first stream.
  • QUIC.runClient "127.0.0.1" "14443" \conn stream -> -- start a generic client and request an initial stream.
  • (writeQ, readQ) <- Stream.codec encode decodeIncremental stream -- convert a stream to a pair of queues.
  • (writeQ, readQ) <- Stream.serialise stream -- run a CBOR codec over a stream.

Handshakes and multiple streams per connection, with import Network.QUIC.Simple.Stream qualified as Stream:

  • Stream.sendMessage stream hello / (reply, leftovers) <- Stream.recvMessage stream -- exchange one-shot CBOR messages on a bare stream.
  • stream <- Stream.open conn header -- request a stream and announce its protocol with a header message.
  • Stream.acceptLoop conn \header leftovers stream -> -- accept the peer's streams and dispatch them by header, each in its own thread.
  • Stream.serialiseFrom leftovers stream / Stream.consume leftovers stream sink -- continue a stream after its header with CBOR messages or raw bytes.

An extra-simple pair of wrappers for QUIC and dirty RPC:

  • QUIC.runServerSimple "127.0.0.1" 14443 handleCall -- start a CBOR server running streamSerialise.
  • (stop, call) <- QUIC.startClientSimple "127.0.0.1" "14443" -- spawn a CBOR client running streamSerialise.

See tests for copypastable examples of different wrapping levels.