diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0d1924..1863f95 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,7 +9,9 @@ The `Unreleased` section name is replaced by the expected version of next releas
 ## [Unreleased]
 
 ### Added
+- Brotli Compression as default
 ### Changed
+- `TryDeflate` -> `TryCompress`
 ### Removed
 ### Fixed
 
diff --git a/src/FsCodec.Box/FsCodec.Box.fsproj b/src/FsCodec.Box/FsCodec.Box.fsproj
index 23c8461..aa9b213 100644
--- a/src/FsCodec.Box/FsCodec.Box.fsproj
+++ b/src/FsCodec.Box/FsCodec.Box.fsproj
@@ -8,7 +8,7 @@
         <Compile Include="CoreCodec.fs" />
         <Compile Include="Codec.fs" />
         <Compile Include="ByteArray.fs" />
-        <Compile Include="TryDeflate.fs" />
+        <Compile Include="TryCompress.fs" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/FsCodec.Box/TryDeflate.fs b/src/FsCodec.Box/TryCompress.fs
similarity index 58%
rename from src/FsCodec.Box/TryDeflate.fs
rename to src/FsCodec.Box/TryCompress.fs
index e4fc0ff..fef97e4 100644
--- a/src/FsCodec.Box/TryDeflate.fs
+++ b/src/FsCodec.Box/TryCompress.fs
@@ -4,14 +4,22 @@ open System
 open System.Runtime.CompilerServices
 open System.Runtime.InteropServices
 
-module private EncodedMaybeDeflated =
+module private EncodedMaybeCompressed =
 
-    type Encoding =
-        | Direct = 0
-        | Deflate = 1
+    module Encoding =
+        let [<Literal>] Direct = 0
+        let [<Literal>] Deflate = 1
+        let [<Literal>] Brotli = 2
     type Encoded = (struct (int * ReadOnlyMemory<byte>))
     let empty : Encoded = int Encoding.Direct, ReadOnlyMemory.Empty
 
+    let private brotliDecompress (data: ReadOnlyMemory<byte>): byte[] =
+        let s = new System.IO.MemoryStream(data.ToArray(), writable = false)
+        use decompressor = new System.IO.Compression.BrotliStream(s, System.IO.Compression.CompressionMode.Decompress)
+        use output = new System.IO.MemoryStream()
+        decompressor.CopyTo(output)
+        output.ToArray()
+
     (* EncodedBody can potentially hold compressed content, that we'll inflate on demand *)
 
     let private inflate (data : ReadOnlyMemory<byte>) : byte[] =
@@ -21,22 +29,33 @@ module private EncodedMaybeDeflated =
         decompressor.CopyTo(output)
         output.ToArray()
     let decode struct (encoding, data) : ReadOnlyMemory<byte> =
-        if encoding = int Encoding.Deflate then inflate data |> ReadOnlyMemory
-        else data
+        match encoding with
+        | Encoding.Deflate    -> inflate data |> ReadOnlyMemory
+        | Encoding.Brotli     -> brotliDecompress data |> ReadOnlyMemory
+        | Encoding.Direct | _ -> data
 
     (* Compression is conditional on the input meeting a minimum size, and the result meeting a required gain *)
 
-    let private deflate (eventBody : ReadOnlyMemory<byte>) : System.IO.MemoryStream =
+    let private brotliCompress (eventBody: ReadOnlyMemory<byte>): System.IO.MemoryStream =
         let output = new System.IO.MemoryStream()
-        let compressor = new System.IO.Compression.DeflateStream(output, System.IO.Compression.CompressionLevel.Optimal, leaveOpen = true)
+        use compressor = new System.IO.Compression.BrotliStream(output, System.IO.Compression.CompressionLevel.Optimal, leaveOpen = true)
         compressor.Write(eventBody.Span)
-        compressor.Flush()
+        compressor.Close()
         output
+
+    // NOTE: this is kept in the codebase to serve as a record of what the encoding implementation looked like for Encoding=1
+    // let private deflate (eventBody : ReadOnlyMemory<byte>) : System.IO.MemoryStream =
+    //     let output = new System.IO.MemoryStream()
+    //     let compressor = new System.IO.Compression.DeflateStream(output, System.IO.Compression.CompressionLevel.Optimal, leaveOpen = true)
+    //     compressor.Write(eventBody.Span)
+    //     compressor.Flush()
+    //     output
+
     let encodeUncompressed (raw : ReadOnlyMemory<byte>) : Encoded = 0, raw
     let encode minSize minGain (raw : ReadOnlyMemory<byte>) : Encoded =
         if raw.Length < minSize then encodeUncompressed raw
-        else match deflate raw with
-             | tmp when raw.Length > int tmp.Length + minGain -> int Encoding.Deflate, tmp.ToArray() |> ReadOnlyMemory
+        else match brotliCompress raw with
+             | tmp when raw.Length > int tmp.Length + minGain -> int Encoding.Brotli, tmp.ToArray() |> ReadOnlyMemory
              | _ -> encodeUncompressed raw
 
 type [<Struct>] CompressionOptions = { minSize : int; minGain : int } with
@@ -50,40 +69,40 @@ type [<Struct>] CompressionOptions = { minSize : int; minGain : int } with
     static member Uncompressed = { minSize = Int32.MaxValue; minGain = 0 }
 
 [<Extension; AbstractClass; Sealed>]
-type Deflate =
+type Compression =
 
     static member Utf8ToEncodedDirect (x : ReadOnlyMemory<byte>) : struct (int * ReadOnlyMemory<byte>) =
-        EncodedMaybeDeflated.encodeUncompressed x
-    static member Utf8ToEncodedTryDeflate options (x : ReadOnlyMemory<byte>) : struct (int * ReadOnlyMemory<byte>) =
-        EncodedMaybeDeflated.encode options.minSize options.minGain x
+        EncodedMaybeCompressed.encodeUncompressed x
+    static member Utf8ToEncodedTryCompress options (x : ReadOnlyMemory<byte>) : struct (int * ReadOnlyMemory<byte>) =
+        EncodedMaybeCompressed.encode options.minSize options.minGain x
     static member EncodedToUtf8(x) : ReadOnlyMemory<byte> =
-        EncodedMaybeDeflated.decode x
+        EncodedMaybeCompressed.decode x
     static member EncodedToByteArray(x) : byte[] =
-        let u8 = EncodedMaybeDeflated.decode x in u8.ToArray()
+        let u8 = EncodedMaybeCompressed.decode x in u8.ToArray()
 
     /// <summary>Adapts an <c>IEventCodec</c> rendering to <c>ReadOnlyMemory<byte></c> Event Bodies to attempt to compress the UTF-8 data.<br/>
     /// If sufficient compression, as defined by <c>options</c> is not achieved, the body is saved as-is.<br/>
     /// The <c>int</c> conveys a flag indicating whether compression was applied.</summary>
     [<Extension>]
-    static member EncodeTryDeflate<'Event, 'Context>(native : IEventCodec<'Event, ReadOnlyMemory<byte>, 'Context>, [<Optional; DefaultParameterValue null>] ?options)
+    static member EncodeTryCompress<'Event, 'Context>(native : IEventCodec<'Event, ReadOnlyMemory<byte>, 'Context>, [<Optional; DefaultParameterValue null>] ?options)
         : IEventCodec<'Event, struct (int * ReadOnlyMemory<byte>), 'Context> =
         let opts = defaultArg options CompressionOptions.Default
-        FsCodec.Core.EventCodec.Map(native, Deflate.Utf8ToEncodedTryDeflate opts, Func<_, _> Deflate.EncodedToUtf8)
+        FsCodec.Core.EventCodec.Map(native, Compression.Utf8ToEncodedTryCompress opts, Func<_, _> Compression.EncodedToUtf8)
 
-    /// Adapts an <c>IEventCodec</c> rendering to <c>ReadOnlyMemory<byte></c> Event Bodies to encode as per <c>EncodeTryDeflate</c>, but without attempting compression.<br/>
+    /// Adapts an <c>IEventCodec</c> rendering to <c>ReadOnlyMemory<byte></c> Event Bodies to encode as per <c>EncodeTryCompress</c>, but without attempting compression.<br/>
     [<Extension>]
     static member EncodeUncompressed<'Event, 'Context>(native : IEventCodec<'Event, ReadOnlyMemory<byte>, 'Context>)
         : IEventCodec<'Event, struct (int * ReadOnlyMemory<byte>), 'Context> =
-        FsCodec.Core.EventCodec.Map(native, Func<_, _> Deflate.Utf8ToEncodedDirect, Func<_, _> Deflate.EncodedToUtf8)
+        FsCodec.Core.EventCodec.Map(native, Func<_, _> Compression.Utf8ToEncodedDirect, Func<_, _> Compression.EncodedToUtf8)
 
     /// Adapts an <c>IEventCodec</c> rendering to <c>int * ReadOnlyMemory<byte></c> Event Bodies to render and/or consume from Uncompressed <c>ReadOnlyMemory<byte></c>.
     [<Extension>]
     static member ToUtf8Codec<'Event, 'Context>(native : IEventCodec<'Event, struct (int * ReadOnlyMemory<byte>), 'Context>)
         : IEventCodec<'Event, ReadOnlyMemory<byte>, 'Context> =
-        FsCodec.Core.EventCodec.Map(native, Func<_, _> Deflate.EncodedToUtf8, Func<_, _> Deflate.Utf8ToEncodedDirect)
+        FsCodec.Core.EventCodec.Map(native, Func<_, _> Compression.EncodedToUtf8, Func<_, _> Compression.Utf8ToEncodedDirect)
 
     /// Adapts an <c>IEventCodec</c> rendering to <c>int * ReadOnlyMemory<byte></c> Event Bodies to render and/or consume from Uncompressed <c>byte[]</c>.
     [<Extension>]
     static member ToByteArrayCodec<'Event, 'Context>(native : IEventCodec<'Event, struct (int * ReadOnlyMemory<byte>), 'Context>)
         : IEventCodec<'Event, byte[], 'Context> =
-        FsCodec.Core.EventCodec.Map(native, Func<_, _> Deflate.EncodedToByteArray, Func<_, _> Deflate.Utf8ToEncodedDirect)
+        FsCodec.Core.EventCodec.Map(native, Func<_, _> Compression.EncodedToByteArray, Func<_, _> Compression.Utf8ToEncodedDirect)
diff --git a/tests/FsCodec.Tests/FsCodec.Tests.fsproj b/tests/FsCodec.Tests/FsCodec.Tests.fsproj
index db5a8f9..3f17ca8 100644
--- a/tests/FsCodec.Tests/FsCodec.Tests.fsproj
+++ b/tests/FsCodec.Tests/FsCodec.Tests.fsproj
@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <Compile Include="StreamNameTests.fs" />
-    <Compile Include="TryDeflateTests.fs" />
+    <Compile Include="TryCompressTests.fs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/FsCodec.Tests/TryDeflateTests.fs b/tests/FsCodec.Tests/TryCompressTests.fs
similarity index 66%
rename from tests/FsCodec.Tests/TryDeflateTests.fs
rename to tests/FsCodec.Tests/TryCompressTests.fs
index 91f92c1..c48bbba 100644
--- a/tests/FsCodec.Tests/TryDeflateTests.fs
+++ b/tests/FsCodec.Tests/TryCompressTests.fs
@@ -1,4 +1,4 @@
-module FsCodec.Tests.DeflateTests
+module FsCodec.Tests.CompressionTests
 
 open System
 open Swensen.Unquote
@@ -28,9 +28,9 @@ module StringUtf8 =
         let res' = roundtrip sut value
         res' =! ValueSome value
 
-module TryDeflate =
+module TryCompress =
 
-    let sut = FsCodec.Deflate.EncodeTryDeflate(StringUtf8.sut)
+    let sut = FsCodec.Compression.EncodeTryCompress(StringUtf8.sut)
 
     let compressibleValue = String('x', 5000)
 
@@ -52,10 +52,10 @@ module TryDeflate =
 
 module Uncompressed =
 
-    let sut = FsCodec.Deflate.EncodeUncompressed(StringUtf8.sut)
+    let sut = FsCodec.Compression.EncodeUncompressed(StringUtf8.sut)
 
     // Borrow a demonstrably compressible value
-    let value = TryDeflate.compressibleValue
+    let value = TryCompress.compressibleValue
 
     let [<Fact>] roundtrips () =
         let res' = roundtrip sut value
@@ -66,3 +66,21 @@ module Uncompressed =
         let encoded = sut.Encode((), value)
         let struct (_encoding, result) = encoded.Data
         true =! directResult.Span.SequenceEqual(result.Span)
+
+
+module Decoding =
+    let raw = struct(0, Text.Encoding.UTF8.GetBytes("Hello World") |> ReadOnlyMemory)
+    let deflated = struct(1, Convert.FromBase64String("8kjNyclXCM8vykkBAAAA//8=") |> ReadOnlyMemory)
+    let brotli = struct(2, Convert.FromBase64String("CwWASGVsbG8gV29ybGQ=") |> ReadOnlyMemory)
+
+    let [<Fact>] ``Can decode all known bodies`` () =
+        let decode = FsCodec.Compression.EncodedToByteArray >> Text.Encoding.UTF8.GetString
+        test <@ decode raw = "Hello World"  @>
+        test <@ decode deflated = "Hello World"  @>
+        test <@ decode brotli = "Hello World"  @>
+
+    let [<Fact>] ``Defaults to leaving the memory alone if unknown`` () =
+        let struct(_, mem) = raw
+        let body = struct(99, mem)
+        let decoded = body |> FsCodec.Compression.EncodedToByteArray |> Text.Encoding.UTF8.GetString
+        test <@ decoded = "Hello World" @>