I'm almost positive that he didn't use thinking mode, because I've asked GPT-5 thinking his question verbatim in 10 parallel threads and it said "you can't" and thoroughly explained why every time. Below is the first response I got back.

---

Short answer: you can’t. iOS doesn’t ship a Zstandard encoder/decoder. Apple’s built-in `Compression` framework only exposes LZFSE, LZ4(/RAW), zlib/DEFLATE, and LZMA—no ZSTD knob to turn. ([Microsoft Learn][1], [Apple Developer][2])

If you’re okay with a built-in alternative that’s “zstd-ish” in speed/ratio, use LZFSE via `Compression`’s streaming API. Here’s a minimal streaming compressor you can drop in; it takes chunks of `Data` and yields compressed chunks (no third-party code):

```swift import Compression

final class StreamCompressor { private var stream = compression_stream() private let algo: compression_algorithm private var isInitialized = false

    init(algorithm: compression_algorithm = COMPRESSION_LZFSE) {
        self.algo = algorithm
    }

    func append(_ input: Data, isFinal: Bool, outChunkSize: Int = 64 * 1024) -> [Data] {
        if !isInitialized {
            let status = compression_stream_init(&stream, COMPRESSION_STREAM_ENCODE, algo)
            precondition(status != COMPRESSION_STATUS_ERROR, "compression_stream_init failed")
            isInitialized = true
        }

        var outputs: [Data] = []
        input.withUnsafeBytes { (srcBuf: UnsafeRawBufferPointer) in
            var flags: Int32 = isFinal ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
            stream.src_ptr = srcBuf.bindMemory(to: UInt8.self).baseAddress
            stream.src_size = srcBuf.count

            var out = Data(count: outChunkSize)
            out.withUnsafeMutableBytes { dstBuf in
                while true {
                    stream.dst_ptr = dstBuf.bindMemory(to: UInt8.self).baseAddress
                    stream.dst_size = dstBuf.count

                    let status = compression_stream_process(&stream, flags)
                    let produced = dstBuf.count - stream.dst_size
                    if produced > 0 {
                        outputs.append(Data(bytes: dstBuf.baseAddress!, count: produced))
                    }

                    if status == COMPRESSION_STATUS_OK && stream.src_size == 0 && stream.dst_size > 0 {
                        break // need more input to continue
                    } else if status == COMPRESSION_STATUS_OK && stream.dst_size == 0 {
                        // output buffer filled; loop to drain more
                        continue
                    } else if status == COMPRESSION_STATUS_END {
                        break
                    } else if status == COMPRESSION_STATUS_ERROR {
                        preconditionFailure("compression_stream_process failed")
                    } else {
                        // Shouldn’t happen
                        break
                    }
                }
            }
        }
        return outputs
    }

    deinit {
        if isInitialized {
            compression_stream_destroy(&stream)
        }
    }

} ```

Usage:

```swift let compressor = StreamCompressor(algorithm: COMPRESSION_LZFSE) var compressed: [Data] = [] for (i, chunk) in chunks.enumerated() { let final = i == chunks.count - 1 compressed.append(contentsOf: compressor.append(chunk, isFinal: final)) } // `compressed` now contains the zstd-adjacent (LZFSE) stream ```

If you truly need the ZSTD format (interop requirement), you’ll have to ship the reference C library (`libzstd`) in your app (static link it and call through a tiny Swift wrapper). That’s still “third-party,” even if you vendor the sources instead of using SPM/CocoaPods. There is no system-provided ZSTD on iOS today. ([GitHub][3])

tl;dr: iOS doesn’t expose ZSTD. Use `Compression` with LZFSE for built-in streaming, or vendor `libzstd` and bridge to it if you must emit/ingest ZSTD. ([Microsoft Learn][1], [Apple Developer][2], [GitHub][3])

[1]: https://learn.microsoft.com/en-us/dotnet/api/compression.com... "CompressionAlgorithm Enum (Compression)" [2]: https://developer.apple.com/documentation/compression/compre... "COMPRESSION_LZFSE | Apple Developer Documentation" [3]: https://github.com/facebook/zstd?utm_source=chatgpt.com "facebook/zstd: Zstandard - Fast real-time compression ..."