QUIC & HTTP/3 Library for Delphi & C++ Builder | sgcQUIC

sgcQUIC — QUIC & HTTP/3 for Delphi, C++ Builder & .NET

A complete QUIC and HTTP/3 stack for Delphi, C++ Builder and .NET. sgcQUIC gives you four palette components — a raw QUIC transport client and server (RFC 9000) plus an HTTP/3 client and server (RFC 9114) — built on the native QUIC engine in OpenSSL 3.5. QPACK header compression, Alt-Svc discovery, 0-RTT, connection migration and WebTransport ship in the box, and the same API runs in Object Pascal and C#.

Quick answer: yes, Delphi can speak HTTP/3. sgcQUIC is the QUIC and HTTP/3 library for Delphi, C++ Builder and .NET, and as of August 2026 it is the only one that ships both a client and a server for either protocol. It installs as four palette components on top of the native QUIC engine in OpenSSL 3.5, with full source code.

QUIC transport (RFC 9000)
HTTP/3 (RFC 9114) + QPACK
OpenSSL 3.5 native QUIC
Delphi / C++ Builder / .NET
WebTransport (RFC 9220)
Download Free Trial Browse Features
THE LANDSCAPE

Your Options for QUIC and HTTP/3 in Delphi

HTTP/3 is a finished standard carrying a large share of world web traffic, and every major browser and CDN speaks it. The Object Pascal ecosystem has been slower to follow. Here is where each established Delphi networking library stands on QUIC and HTTP/3, according to its own vendor documentation.

Library QUIC (RFC 9000) HTTP/3 (RFC 9114) What the vendor documents
sgcQUIC Client and server Client and server Four components on the OpenSSL 3.5 builtin QUIC engine, with QPACK, Alt-Svc, 0-RTT, connection migration and WebTransport.
Indy No No A TCP and UDP socket framework with the classic high-level protocols. QUIC is not part of the library.
ICS (Overbyte) No No The ICS download page states it plainly: “ICS has no plans for QUIC support.”
TMS Sparkle / FNC WebSocket No No An HTTP and HTTPS client plus a server on the http.sys stack. Neither QUIC nor HTTP/3 is documented.
/n software IPWorks No No A broad suite covering HTTP, WebSockets, gRPC, FTP and more. Neither QUIC nor HTTP/3 is documented.
Devart SecureBridge No No SSH, SFTP, TLS, WebSocket and SignalR, all over TCP. Neither QUIC nor HTTP/3 is documented.
mORMot 2 No No The maintainer has said HTTP/2 is not supported and not planned, and that the framework relies on REST over WebSockets instead.

Compiled from vendor documentation in August 2026: ICS download page, TMS Sparkle, IPWorks, Devart SecureBridge, mORMot 2, Indy. If a vendor ships QUIC after this date, this table gets updated.

HOW IT WORKS

The Same HTTP Semantics, a New Transport

HTTP/3 keeps the methods, status codes and headers you already know and replaces TCP with QUIC, a UDP-based transport with TLS 1.3 built in. sgcQUIC drives it through the native QUIC support in OpenSSL 3.5, so you get modern transport from Delphi, C++ Builder or .NET without a separate library.

One handshake, no head-of-line blocking

QUIC (RFC 9000) combines the transport and TLS 1.3 handshakes into a single flight and removes transport-level head-of-line blocking — a lost packet only stalls the streams whose data it carried, not the whole connection.

Built on OpenSSL 3.5 native QUIC

The engine is detected automatically when OpenSSL loads. With the shipped OpenSSL 3.5 binaries you get the qmBuiltin engine, which supports multiple streams per connection and is the engine the components are built around.

QPACK header compression

HTTP/3 compresses headers with QPACK (RFC 9204), the HTTP/3 replacement for HPACK, designed for QUIC's out-of-order delivery with dynamic-table updates carried on dedicated encoder and decoder streams.

Connection migration

QUIC connections are identified by a connection ID rather than the address four-tuple, so a session survives the client changing network — a connection can follow a device from Wi-Fi to mobile data without a new handshake.

0-RTT and multiple streams

A fresh connection completes in a single round trip and a resumed session can carry 0-RTT data in the first flight. On the builtin engine, EnableMultiStream and OpenStream put several independent QUIC streams on one connection.

WebTransport sessions

WebTransport (RFC 9220) is negotiated over Extended CONNECT and hands the application QUIC streams directly, built for low-latency bidirectional traffic on top of the builtin engine.

COMPONENTS

Four Components, Two Layers

A raw QUIC transport pair for streams and datagrams, and an HTTP/3 pair that speaks request/response over the same engine. Each links to its own page with Delphi, C++ Builder and .NET examples.

TsgcQUICClient

Raw QUIC transport client. Opens a QUIC connection, sends and receives bytes over one or many streams (RFC 9000), with 0-RTT and connection migration — QUIC without HTTP semantics.

View component →

TsgcQUICServer

Raw QUIC transport server. Binds a UDP port, terminates TLS 1.3 and raises an event for every QUIC connection and stream, so you build your own protocol on top of QUIC.

View component →

TsgcHTTP3Client

HTTP/3 client (RFC 9114). All the verbs as blocking or asynchronous calls, QPACK compression, Alt-Svc discovery, server push, Extended CONNECT tunnels and WebTransport sessions.

View component →

TsgcHTTP3Server

HTTP/3 server. Serves requests over QUIC, descends from TsgcQUICServer, raises an event per request and can push responses, open WebTransport sessions and send datagrams.

View component →

See the full feature matrix →

QuickStart

A GET Request Over HTTP/3

Connect to a host and port, then issue requests. The default port is 443. The same API in Delphi, C++ Builder and .NET.

uses
  sgcHTTP3_Client;

var
  oClient: TsgcHTTP3Client;
  vBody: string;
begin
  oClient := TsgcHTTP3Client.Create(nil);
  oClient.OnResponse := OnResponseHandler;
  oClient.OnAltSvc   := OnAltSvcHandler;

  oClient.Connect('www.example.com', 443);
  vBody := oClient.Get('https://www.example.com/');   // request over QUIC
  oClient.Disconnect;
end;
// includes: sgcHTTP3_Client.hpp

TsgcHTTP3Client *oClient = new TsgcHTTP3Client(NULL);
oClient->OnResponse = OnResponseHandler;
oClient->OnAltSvc   = OnAltSvcHandler;

oClient->Connect("www.example.com", 443);
String vBody = oClient->Get("https://www.example.com/");   // request over QUIC
oClient->Disconnect();
using esegece.sgcWebSockets;

var oClient = new TsgcHTTP3Client();
oClient.OnResponse += OnResponseHandler;
oClient.OnAltSvc   += OnAltSvcHandler;

oClient.Connect("www.example.com", 443);
var vBody = oClient.Get("https://www.example.com/");   // request over QUIC
oClient.Disconnect();
CHOOSING A TRANSPORT

HTTP/3, HTTP/2, WebSocket or Raw QUIC?

QUIC does not replace everything you already run. It wins in specific conditions, and it costs you a UDP path through the network. Use this to decide which transport your feature actually needs.

Reach for HTTP/3

Your client is on a lossy or mobile network, you fetch many resources at once, or the endpoint already advertises HTTP/3 through Alt-Svc. HTTP/3 removes transport-level head-of-line blocking, so one lost packet no longer stalls every other request in flight. Use TsgcHTTP3Client.

Stay on HTTP/2

Your traffic runs inside a datacentre or over a reliable link, or a proxy or firewall in the path blocks UDP. HTTP/2 already gives you multiplexing and header compression over TCP, and it is far more likely to traverse a corporate network untouched.

HTTP/2 client for Delphi →

Stay on WebSocket

You need long-lived, symmetric, message-oriented push between client and server, and you need it to work through every proxy in the world today. WebSocket over TLS remains the most compatible bidirectional transport in production.

sgcWebSockets →

Go down to raw QUIC

You are carrying your own protocol and HTTP semantics only get in the way, for example media, telemetry or game state. TsgcQUICClient and TsgcQUICServer hand you QUIC streams and datagrams directly, with TLS 1.3 and connection migration already handled.

TsgcQUICClient →

Full real-time transport decision guide →

STANDARDS

The RFCs sgcQUIC Implements

A standards-based stack, not a proprietary transport.

RFC 9000 — QUIC

The QUIC transport: a single combined transport + TLS 1.3 handshake, independent streams, connection IDs and migration. Exposed directly through TsgcQUICClient and TsgcQUICServer.

RFC 9114 — HTTP/3

HTTP semantics over QUIC: the methods, status codes and headers you know, mapped onto QUIC streams. Implemented by TsgcHTTP3Client and TsgcHTTP3Server.

RFC 9204 — QPACK

Header compression for HTTP/3, designed for QUIC's out-of-order delivery, with a dynamic table synchronised over dedicated encoder and decoder streams.

RFC 9220 — WebTransport

Bootstrapping WebTransport over HTTP/3 with Extended CONNECT, handing the application QUIC streams for low-latency bidirectional traffic.

PRICING

An Add-On to sgcWebSockets

sgcQUIC is licensed as an add-on. All licenses include full source code, 1 year of updates and a 70% renewal discount.

sgcQUIC

€149

Single, Team and Site licenses available. Full source code included.

  • TsgcQUICClient & TsgcQUICServer
  • TsgcHTTP3Client & TsgcHTTP3Server
  • Delphi, C++ Builder & .NET
  • Full Source Code
  • 1 Year Updates

★ Requires sgcWebSockets

sgcQUIC requires sgcWebSockets Enterprise.

View Pricing & Order
FAQ

QUIC and HTTP/3 in Delphi, Frequently Asked

The questions developers ask before adding HTTP/3 to a Delphi, C++ Builder or .NET application.

Not out of the box. The Delphi RTL and Indy are TCP-based and have no QUIC transport, and ICS states it has no plans for QUIC support. sgcQUIC adds it: install the components and TsgcHTTP3Client issues HTTP/3 requests over QUIC, while TsgcHTTP3Server answers them. It builds on the native QUIC engine in OpenSSL 3.5, so there is no separate C library to bind or ship.
Yes. sgcQUIC implements RFC 9000 directly through TsgcQUICClient and TsgcQUICServer, so you can carry your own protocol over QUIC streams and datagrams without HTTP semantics. As of August 2026 no other Delphi networking library documents QUIC support, so if you need the raw transport in Object Pascal this is the option.
Yes. TsgcHTTP3Server descends from TsgcQUICServer, binds a UDP port, terminates TLS 1.3 and raises an event per request. It can push responses, open WebTransport sessions and send datagrams. Most QUIC stacks available to other languages are client-only or need a reverse proxy in front, so a native in-process HTTP/3 server is unusual outside of Go and Rust.
sgcQUIC follows the sgcWebSockets support matrix, Delphi 7 through Delphi 13 Florence and the matching C++ Builder versions, plus a .NET implementation with the same API. The trial installer is per IDE version and already contains the QUIC and HTTP/3 components, so there is no separate download.
Yes, OpenSSL 3.5 or later. QUIC arrived as a native engine in OpenSSL 3.5, and sgcQUIC detects it automatically when OpenSSL loads. With the shipped 3.5 binaries you get the qmBuiltin engine, which supports several independent streams on one connection and is what the components are designed around. A qmCustom path also exists for quictls-style builds, limited to a single stream per connection.
Win32, Win64 and Linux64 are the primary targets, plus macOS, iOS and Android wherever the OpenSSL 3.5 QUIC engine is available. Remember that QUIC runs over UDP, normally on port 443, so the path between client and server has to allow UDP. Some corporate networks still block it, which is why HTTP/3 clients fall back to HTTP/2.
WebTransport (RFC 9220) is the modern successor to WebSocket for browser to server traffic. It is negotiated over HTTP/3 using Extended CONNECT and hands the application QUIC streams and unreliable datagrams directly, which suits low-latency bidirectional workloads. sgcQUIC supports WebTransport sessions on the builtin engine, on both the client and the server side.
sgcQUIC is an add-on to sgcWebSockets Enterprise, and it is also included in the All-Access bundle. Single, Team and Site licenses are available, each with full source code and one year of updates. Download the trial to evaluate all four components in your own project before buying.
3,000+Developers
20+Years
761+Components
30+API Integrations
5Platforms
30-Day Money-Back GuaranteeNot satisfied? Request a full refund within 30 days of purchase. See refund policy

Ship QUIC and HTTP/3 Without Leaving Your IDE

Add the transport the modern web is moving to — to your Delphi, C++ Builder or .NET application, with the language you already use.

Download Free Trial View Pricing
MORE FROM ESEGECE

Other Products by eSeGeCe

Pair sgcQUIC with our other Delphi, C++ Builder and .NET component libraries.

sgcWebSockets

Enterprise WebSocket, HTTP/2, MQTT, AMQP, WebRTC and AI/LLM components. sgcQUIC is an add-on to sgcWebSockets Enterprise.

Learn more →

sgcHTML

89 data-aware server-side HTML/UI components for Delphi, C++ Builder and .NET, with Bootstrap 5 and htmx.

Learn more →

sgcSign

Enterprise digital signatures — XAdES, PAdES, CAdES and ASiC with 10 key providers and 21 EU country profiles.

Learn more →

sgcOpenAPI

OpenAPI 3.0 parser and SDK generator. Turn any OpenAPI spec into a strongly-typed Delphi client in seconds.

Learn more →

sgcBiometrics

Native Windows Hello, fingerprint and Windows Biometric Framework components for Delphi and C++ Builder.

Learn more →

sgcIndy

Updated Indy TCP/IP components with modern TLS, IPv6 and HTTP/2 support for Delphi 7 through 13.

Learn more →

sgcAI

15 AI, LLM and MCP components for Delphi and C++ Builder. One chat component reaches OpenAI, Anthropic, Gemini, DeepSeek, Ollama, Grok and Mistral. Standalone, the sgcWebSockets Core runtime is bundled in.

Learn more →

sgcMQ

MQTT 3.1.1 and 5.0, AMQP 0.9.1, AMQP 1.0, Apache Kafka and STOMP client components for Delphi and C++ Builder. Standalone, the sgcWebSockets Core runtime is bundled in.

Learn more →

sgcSocial

WhatsApp Business Cloud API and Telegram TDLib clients. Standalone, the sgcWebSockets Core runtime is included.

Learn more →