diff --git a/Cargo.toml b/Cargo.toml
index 289ddb41..6c2ab3f2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,15 +1,29 @@
-[package]
-name = "async-compression"
-version = "0.4.18"
+[workspace]
+members = ["crates/*"]
+resolver = "2"
+
+[workspace.package]
 authors = ["Wim Looman <wim@nemo157.com>", "Allen Bui <fairingrey@gmail.com>"]
 edition = "2018"
 license = "MIT OR Apache-2.0"
-keywords = ["compression", "gzip", "zstd", "brotli", "async"]
-categories = ["compression", "asynchronous"]
 repository = "https://github.com/Nullus157/async-compression"
+
+[workspace.dependencies]
+compression-codecs = { version = "0.1.0", path = "crates/compression-codecs" }
+compression-core = { version = "0.1.0", path = "crates/compression-core" }
+
+[package]
+name = "async-compression"
+version = "0.4.18"
 description = """
 Adaptors between compression crates and Rust's modern asynchronous IO types.
 """
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords = ["compression", "gzip", "zstd", "brotli", "async"]
+categories = ["compression", "asynchronous"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -22,28 +36,27 @@ all-implementations = ["futures-io", "tokio"]
 all-algorithms = ["brotli", "bzip2", "deflate", "gzip", "lzma", "xz", "zlib", "zstd", "deflate64"]
 
 # algorithms
-deflate = ["flate2"]
-gzip = ["flate2"]
-lzma = ["xz2"]
-xz = ["xz2"]
-zlib = ["flate2"]
-zstd = ["libzstd", "zstd-safe"]
-zstdmt = ["zstd", "zstd-safe/zstdmt"]
-deflate64 = ["dep:deflate64"]
+brotli = ["compression-codecs/brotli"]
+bzip2 = ["compression-codecs/bzip2"]
+deflate = ["compression-codecs/deflate", "flate2"]
+deflate64 = ["compression-codecs/deflate64"]
+flate2 = ["compression-codecs/flate2"]
+gzip = ["compression-codecs/gzip", "flate2"]
+lzma = ["compression-codecs/lzma", "xz2"]
+xz = ["compression-codecs/xz", "xz2"]
+xz2 = ["compression-codecs/xz2"]
+zlib = ["compression-codecs/zlib", "flate2"]
+zstd = ["compression-codecs/zstd"]
+zstdmt = ["compression-codecs/zstdmt"]
+libzstd = ["compression-codecs/libzstd"]
+zstd-safe = ["compression-codecs/zstd-safe"]
 
 [dependencies]
-brotli = { version = "7.0", optional = true }
-bzip2 = { version = "0.5.0", optional = true }
-flate2 = { version = "1.0.13", optional = true }
 futures-core = { version = "0.3", default-features = false }
 futures-io = { version = "0.3", default-features = false, features = ["std"], optional = true }
-libzstd = { package = "zstd", version = "0.13.1", optional = true, default-features = false }
-memchr = "2"
 pin-project-lite = "0.2"
 tokio = { version = "1.24.2", optional = true, default-features = false }
-xz2 = { version = "0.1.6", optional = true }
-zstd-safe = { version = "7", optional = true, default-features = false }
-deflate64 = { version = "0.1.5", optional = true }
+compression-codecs.workspace = true
 
 [dev-dependencies]
 bytes = "1"
diff --git a/crates/compression-codecs/Cargo.toml b/crates/compression-codecs/Cargo.toml
new file mode 100644
index 00000000..e57a37b1
--- /dev/null
+++ b/crates/compression-codecs/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "compression-codecs"
+version = "0.1.0"
+description = """
+Adaptors for various compression algorithms.
+"""
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords = ["compression", "gzip", "zstd", "brotli"]
+categories = ["compression"]
+
+[dependencies]
+# Workspace dependencies.
+compression-core.workspace = true
+
+# Compression algorithms.
+brotli = { version = "7.0", optional = true }
+bzip2 = { version = "0.5.0", optional = true }
+deflate64 = { version = "0.1.5", optional = true }
+flate2 = { version = "1.0.13", optional = true }
+libzstd = { package = "zstd", version = "0.13.1", optional = true, default-features = false }
+memchr = "2"
+xz2 = { version = "0.1.6", optional = true }
+zstd-safe = { version = "7", optional = true, default-features = false }
+
+[features]
+all = ["brotli", "bzip2", "deflate", "gzip", "lzma", "xz", "zlib", "zstd", "deflate64"]
+
+# Individual algorithms.
+deflate = ["flate2"]
+deflate64 = ["dep:deflate64"]
+gzip = ["flate2"]
+lzma = ["xz2"]
+xz = ["xz2"]
+zlib = ["flate2"]
+zstd = ["libzstd", "zstd-safe"]
+zstdmt = ["zstd", "zstd-safe/zstdmt"]
\ No newline at end of file
diff --git a/src/codec/brotli/decoder.rs b/crates/compression-codecs/src/brotli/decoder.rs
similarity index 94%
rename from src/codec/brotli/decoder.rs
rename to crates/compression-codecs/src/brotli/decoder.rs
index be115b14..95fbd063 100644
--- a/src/codec/brotli/decoder.rs
+++ b/crates/compression-codecs/src/brotli/decoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{Decode, PartialBuffer};
 use std::{fmt, io};
 
 use brotli::{enc::StandardAlloc, BrotliDecompressStream, BrotliResult, BrotliState};
@@ -9,7 +9,7 @@ pub struct BrotliDecoder {
 }
 
 impl BrotliDecoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             state: Box::new(BrotliState::new(
                 StandardAlloc::default(),
@@ -25,7 +25,7 @@ impl BrotliDecoder {
         output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
     ) -> io::Result<BrotliResult> {
         let in_buf = input.unwritten();
-        let mut out_buf = output.unwritten_mut();
+        let out_buf = output.unwritten_mut();
 
         let mut input_len = 0;
         let mut output_len = 0;
@@ -53,6 +53,12 @@ impl BrotliDecoder {
     }
 }
 
+impl Default for BrotliDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for BrotliDecoder {
     fn reinit(&mut self) -> io::Result<()> {
         self.state = Box::new(BrotliState::new(
diff --git a/src/codec/brotli/encoder.rs b/crates/compression-codecs/src/brotli/encoder.rs
similarity index 93%
rename from src/codec/brotli/encoder.rs
rename to crates/compression-codecs/src/brotli/encoder.rs
index dc974e3b..8f24f448 100644
--- a/src/codec/brotli/encoder.rs
+++ b/crates/compression-codecs/src/brotli/encoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{Encode, PartialBuffer};
 use std::{fmt, io};
 
 use brotli::enc::{
@@ -12,7 +12,7 @@ pub struct BrotliEncoder {
 }
 
 impl BrotliEncoder {
-    pub(crate) fn new(params: BrotliEncoderParams) -> Self {
+    pub fn new(params: BrotliEncoderParams) -> Self {
         let mut state = BrotliEncoderStateStruct::new(StandardAlloc::default());
         state.params = params;
         Self { state }
@@ -25,7 +25,7 @@ impl BrotliEncoder {
         op: BrotliEncoderOperation,
     ) -> io::Result<()> {
         let in_buf = input.unwritten();
-        let mut out_buf = output.unwritten_mut();
+        let out_buf = output.unwritten_mut();
 
         let mut input_len = 0;
         let mut output_len = 0;
diff --git a/crates/compression-codecs/src/brotli/mod.rs b/crates/compression-codecs/src/brotli/mod.rs
new file mode 100644
index 00000000..33e55a8f
--- /dev/null
+++ b/crates/compression-codecs/src/brotli/mod.rs
@@ -0,0 +1,6 @@
+pub use brotli;
+
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::BrotliDecoder, encoder::BrotliEncoder};
diff --git a/src/codec/bzip2/decoder.rs b/crates/compression-codecs/src/bzip2/decoder.rs
similarity index 95%
rename from src/codec/bzip2/decoder.rs
rename to crates/compression-codecs/src/bzip2/decoder.rs
index f392a17e..eb6d67fa 100644
--- a/src/codec/bzip2/decoder.rs
+++ b/crates/compression-codecs/src/bzip2/decoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{Decode, PartialBuffer};
 use std::{fmt, io};
 
 use bzip2::{Decompress, Status};
@@ -19,7 +19,7 @@ impl fmt::Debug for BzDecoder {
 }
 
 impl BzDecoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             decompress: Decompress::new(false),
         }
@@ -45,6 +45,12 @@ impl BzDecoder {
     }
 }
 
+impl Default for BzDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for BzDecoder {
     fn reinit(&mut self) -> io::Result<()> {
         self.decompress = Decompress::new(false);
diff --git a/src/codec/bzip2/encoder.rs b/crates/compression-codecs/src/bzip2/encoder.rs
similarity index 97%
rename from src/codec/bzip2/encoder.rs
rename to crates/compression-codecs/src/bzip2/encoder.rs
index f17bdbfb..faf0ba07 100644
--- a/src/codec/bzip2/encoder.rs
+++ b/crates/compression-codecs/src/bzip2/encoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{Encode, PartialBuffer};
 use std::{fmt, io};
 
 use bzip2::{Action, Compress, Compression, Status};
@@ -39,7 +39,7 @@ impl BzEncoder {
     ///
     /// Allowable values range from 0 to 250 inclusive. 0 is a special case,
     /// equivalent to using the default value of 30.
-    pub(crate) fn new(level: Compression, work_factor: u32) -> Self {
+    pub fn new(level: Compression, work_factor: u32) -> Self {
         Self {
             compress: Compress::new(level, work_factor),
         }
diff --git a/crates/compression-codecs/src/bzip2/mod.rs b/crates/compression-codecs/src/bzip2/mod.rs
new file mode 100644
index 00000000..1781b5ba
--- /dev/null
+++ b/crates/compression-codecs/src/bzip2/mod.rs
@@ -0,0 +1,6 @@
+pub use bzip2;
+
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::BzDecoder, encoder::BzEncoder};
diff --git a/src/codec/deflate/decoder.rs b/crates/compression-codecs/src/deflate/decoder.rs
similarity index 72%
rename from src/codec/deflate/decoder.rs
rename to crates/compression-codecs/src/deflate/decoder.rs
index e5f51671..6300ca49 100644
--- a/src/codec/deflate/decoder.rs
+++ b/crates/compression-codecs/src/deflate/decoder.rs
@@ -1,20 +1,28 @@
-use crate::util::PartialBuffer;
+use compression_core::Decode;
+
+use crate::{flate::FlateDecoder, PartialBuffer};
 use std::io::Result;
 
 #[derive(Debug)]
 pub struct DeflateDecoder {
-    inner: crate::codec::FlateDecoder,
+    inner: FlateDecoder,
 }
 
 impl DeflateDecoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
-            inner: crate::codec::FlateDecoder::new(false),
+            inner: FlateDecoder::new(false),
         }
     }
 }
 
-impl crate::codec::Decode for DeflateDecoder {
+impl Default for DeflateDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Decode for DeflateDecoder {
     fn reinit(&mut self) -> Result<()> {
         self.inner.reinit()?;
         Ok(())
diff --git a/src/codec/deflate/encoder.rs b/crates/compression-codecs/src/deflate/encoder.rs
similarity index 78%
rename from src/codec/deflate/encoder.rs
rename to crates/compression-codecs/src/deflate/encoder.rs
index bad75b85..a801faea 100644
--- a/src/codec/deflate/encoder.rs
+++ b/crates/compression-codecs/src/deflate/encoder.rs
@@ -1,17 +1,17 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{flate::FlateEncoder, Encode, PartialBuffer};
 use std::io::Result;
 
 use flate2::Compression;
 
 #[derive(Debug)]
 pub struct DeflateEncoder {
-    inner: crate::codec::FlateEncoder,
+    inner: FlateEncoder,
 }
 
 impl DeflateEncoder {
-    pub(crate) fn new(level: Compression) -> Self {
+    pub fn new(level: Compression) -> Self {
         Self {
-            inner: crate::codec::FlateEncoder::new(level, false),
+            inner: FlateEncoder::new(level, false),
         }
     }
 }
diff --git a/crates/compression-codecs/src/deflate/mod.rs b/crates/compression-codecs/src/deflate/mod.rs
new file mode 100644
index 00000000..8b57f721
--- /dev/null
+++ b/crates/compression-codecs/src/deflate/mod.rs
@@ -0,0 +1,4 @@
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::DeflateDecoder, encoder::DeflateEncoder};
diff --git a/src/codec/deflate64/decoder.rs b/crates/compression-codecs/src/deflate64/decoder.rs
similarity index 92%
rename from src/codec/deflate64/decoder.rs
rename to crates/compression-codecs/src/deflate64/decoder.rs
index 5c8f1f0b..c8ad5ddb 100644
--- a/src/codec/deflate64/decoder.rs
+++ b/crates/compression-codecs/src/deflate64/decoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{Decode, PartialBuffer};
 use std::io::{Error, ErrorKind, Result};
 
 use deflate64::InflaterManaged;
@@ -9,7 +9,7 @@ pub struct Deflate64Decoder {
 }
 
 impl Deflate64Decoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             inflater: Box::new(InflaterManaged::new()),
         }
@@ -35,6 +35,12 @@ impl Deflate64Decoder {
     }
 }
 
+impl Default for Deflate64Decoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for Deflate64Decoder {
     fn reinit(&mut self) -> Result<()> {
         self.inflater = Box::new(InflaterManaged::new());
diff --git a/crates/compression-codecs/src/deflate64/mod.rs b/crates/compression-codecs/src/deflate64/mod.rs
new file mode 100644
index 00000000..b437bd24
--- /dev/null
+++ b/crates/compression-codecs/src/deflate64/mod.rs
@@ -0,0 +1,3 @@
+mod decoder;
+
+pub use self::decoder::Deflate64Decoder;
diff --git a/src/codec/flate/decoder.rs b/crates/compression-codecs/src/flate/decoder.rs
similarity index 96%
rename from src/codec/flate/decoder.rs
rename to crates/compression-codecs/src/flate/decoder.rs
index 70c28c24..51860420 100644
--- a/src/codec/flate/decoder.rs
+++ b/crates/compression-codecs/src/flate/decoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{Decode, PartialBuffer};
 use std::io;
 
 use flate2::{Decompress, FlushDecompress, Status};
@@ -10,7 +10,7 @@ pub struct FlateDecoder {
 }
 
 impl FlateDecoder {
-    pub(crate) fn new(zlib_header: bool) -> Self {
+    pub fn new(zlib_header: bool) -> Self {
         Self {
             zlib_header,
             decompress: Decompress::new(zlib_header),
diff --git a/src/codec/flate/encoder.rs b/crates/compression-codecs/src/flate/encoder.rs
similarity index 94%
rename from src/codec/flate/encoder.rs
rename to crates/compression-codecs/src/flate/encoder.rs
index 5e8a066d..ec5ba64d 100644
--- a/src/codec/flate/encoder.rs
+++ b/crates/compression-codecs/src/flate/encoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{Encode, PartialBuffer};
 use std::io;
 
 use flate2::{Compress, Compression, FlushCompress, Status};
@@ -10,14 +10,14 @@ pub struct FlateEncoder {
 }
 
 impl FlateEncoder {
-    pub(crate) fn new(level: Compression, zlib_header: bool) -> Self {
+    pub fn new(level: Compression, zlib_header: bool) -> Self {
         Self {
             compress: Compress::new(level, zlib_header),
             flushed: true,
         }
     }
 
-    pub(crate) fn get_ref(&self) -> &Compress {
+    pub fn get_ref(&self) -> &Compress {
         &self.compress
     }
 
diff --git a/crates/compression-codecs/src/flate/mod.rs b/crates/compression-codecs/src/flate/mod.rs
new file mode 100644
index 00000000..772c892c
--- /dev/null
+++ b/crates/compression-codecs/src/flate/mod.rs
@@ -0,0 +1,6 @@
+pub use flate2;
+
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::FlateDecoder, encoder::FlateEncoder};
diff --git a/src/codec/gzip/decoder.rs b/crates/compression-codecs/src/gzip/decoder.rs
similarity index 93%
rename from src/codec/gzip/decoder.rs
rename to crates/compression-codecs/src/gzip/decoder.rs
index 4bb42606..57480c7c 100644
--- a/src/codec/gzip/decoder.rs
+++ b/crates/compression-codecs/src/gzip/decoder.rs
@@ -1,9 +1,7 @@
 use crate::{
-    codec::{
-        gzip::header::{self, Header},
-        Decode,
-    },
-    util::PartialBuffer,
+    flate::FlateDecoder,
+    gzip::header::{self, Header},
+    Decode, PartialBuffer,
 };
 use std::io::{Error, ErrorKind, Result};
 
@@ -19,7 +17,7 @@ enum State {
 
 #[derive(Debug)]
 pub struct GzipDecoder {
-    inner: crate::codec::FlateDecoder,
+    inner: FlateDecoder,
     crc: Crc,
     state: State,
     header: Header,
@@ -54,9 +52,9 @@ fn check_footer(crc: &Crc, input: &[u8]) -> Result<()> {
 }
 
 impl GzipDecoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
-            inner: crate::codec::FlateDecoder::new(false),
+            inner: FlateDecoder::new(false),
             crc: Crc::new(),
             state: State::Header(header::Parser::default()),
             header: Header::default(),
@@ -83,7 +81,7 @@ impl GzipDecoder {
 
                     let res = inner(self, input, output);
 
-                    if (output.written().len() > prior) {
+                    if output.written().len() > prior {
                         // update CRC even if there was an error
                         self.crc.update(&output.written()[prior..]);
                     }
@@ -118,6 +116,12 @@ impl GzipDecoder {
     }
 }
 
+impl Default for GzipDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for GzipDecoder {
     fn reinit(&mut self) -> Result<()> {
         self.inner.reinit()?;
diff --git a/src/codec/gzip/encoder.rs b/crates/compression-codecs/src/gzip/encoder.rs
similarity index 95%
rename from src/codec/gzip/encoder.rs
rename to crates/compression-codecs/src/gzip/encoder.rs
index 5fcf35c0..c31b2e58 100644
--- a/src/codec/gzip/encoder.rs
+++ b/crates/compression-codecs/src/gzip/encoder.rs
@@ -1,4 +1,4 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{flate::FlateEncoder, Encode, PartialBuffer};
 use std::io;
 
 use flate2::{Compression, Crc};
@@ -13,7 +13,7 @@ enum State {
 
 #[derive(Debug)]
 pub struct GzipEncoder {
-    inner: crate::codec::FlateEncoder,
+    inner: FlateEncoder,
     crc: Crc,
     state: State,
 }
@@ -31,9 +31,9 @@ fn header(level: Compression) -> Vec<u8> {
 }
 
 impl GzipEncoder {
-    pub(crate) fn new(level: Compression) -> Self {
+    pub fn new(level: Compression) -> Self {
         Self {
-            inner: crate::codec::FlateEncoder::new(level, false),
+            inner: FlateEncoder::new(level, false),
             crc: Crc::new(),
             state: State::Header(header(level).into()),
         }
diff --git a/src/codec/gzip/header.rs b/crates/compression-codecs/src/gzip/header.rs
similarity index 98%
rename from src/codec/gzip/header.rs
rename to crates/compression-codecs/src/gzip/header.rs
index 9faa638d..325c3464 100644
--- a/src/codec/gzip/header.rs
+++ b/crates/compression-codecs/src/gzip/header.rs
@@ -1,8 +1,9 @@
-use crate::util::PartialBuffer;
+use crate::PartialBuffer;
 use std::io;
 
 #[derive(Debug, Default)]
 struct Flags {
+    #[allow(dead_code, reason = "not currently used")]
     ascii: bool,
     crc: bool,
     extra: bool,
diff --git a/crates/compression-codecs/src/gzip/mod.rs b/crates/compression-codecs/src/gzip/mod.rs
new file mode 100644
index 00000000..e0c5be3a
--- /dev/null
+++ b/crates/compression-codecs/src/gzip/mod.rs
@@ -0,0 +1,5 @@
+mod decoder;
+mod encoder;
+mod header;
+
+pub use self::{decoder::GzipDecoder, encoder::GzipEncoder};
diff --git a/crates/compression-codecs/src/lib.rs b/crates/compression-codecs/src/lib.rs
new file mode 100644
index 00000000..2c897fc8
--- /dev/null
+++ b/crates/compression-codecs/src/lib.rs
@@ -0,0 +1,29 @@
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg))]
+
+// Re-export `compression_core` for convenience.
+pub use compression_core::*;
+
+mod unshared;
+
+#[cfg(feature = "brotli")]
+pub mod brotli;
+#[cfg(feature = "bzip2")]
+pub mod bzip2;
+#[cfg(feature = "deflate")]
+pub mod deflate;
+#[cfg(feature = "deflate64")]
+pub mod deflate64;
+#[cfg(feature = "flate2")]
+pub mod flate;
+#[cfg(feature = "gzip")]
+pub mod gzip;
+#[cfg(feature = "lzma")]
+pub mod lzma;
+#[cfg(feature = "xz")]
+pub mod xz;
+#[cfg(feature = "xz2")]
+pub mod xz2;
+#[cfg(feature = "zlib")]
+pub mod zlib;
+#[cfg(feature = "zstd")]
+pub mod zstd;
diff --git a/src/codec/lzma/decoder.rs b/crates/compression-codecs/src/lzma/decoder.rs
similarity index 77%
rename from src/codec/lzma/decoder.rs
rename to crates/compression-codecs/src/lzma/decoder.rs
index 2a62b2f6..683b49ee 100644
--- a/src/codec/lzma/decoder.rs
+++ b/crates/compression-codecs/src/lzma/decoder.rs
@@ -1,26 +1,32 @@
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{xz2::Xz2Decoder, Decode, PartialBuffer};
 
 use std::io::Result;
 
 #[derive(Debug)]
 pub struct LzmaDecoder {
-    inner: crate::codec::Xz2Decoder,
+    inner: Xz2Decoder,
 }
 
 impl LzmaDecoder {
     pub fn new() -> Self {
         Self {
-            inner: crate::codec::Xz2Decoder::new(u64::MAX),
+            inner: Xz2Decoder::new(u64::MAX),
         }
     }
 
     pub fn with_memlimit(memlimit: u64) -> Self {
         Self {
-            inner: crate::codec::Xz2Decoder::new(memlimit),
+            inner: Xz2Decoder::new(memlimit),
         }
     }
 }
 
+impl Default for LzmaDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for LzmaDecoder {
     fn reinit(&mut self) -> Result<()> {
         self.inner.reinit()
diff --git a/src/codec/lzma/encoder.rs b/crates/compression-codecs/src/lzma/encoder.rs
similarity index 81%
rename from src/codec/lzma/encoder.rs
rename to crates/compression-codecs/src/lzma/encoder.rs
index 5441ec23..f3898af1 100644
--- a/src/codec/lzma/encoder.rs
+++ b/crates/compression-codecs/src/lzma/encoder.rs
@@ -1,16 +1,19 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{
+    xz2::{Xz2Encoder, Xz2FileFormat},
+    Encode, PartialBuffer,
+};
 
 use std::io::Result;
 
 #[derive(Debug)]
 pub struct LzmaEncoder {
-    inner: crate::codec::Xz2Encoder,
+    inner: Xz2Encoder,
 }
 
 impl LzmaEncoder {
     pub fn new(level: u32) -> Self {
         Self {
-            inner: crate::codec::Xz2Encoder::new(crate::codec::Xz2FileFormat::Lzma, level),
+            inner: Xz2Encoder::new(Xz2FileFormat::Lzma, level),
         }
     }
 }
diff --git a/crates/compression-codecs/src/lzma/mod.rs b/crates/compression-codecs/src/lzma/mod.rs
new file mode 100644
index 00000000..eccd7735
--- /dev/null
+++ b/crates/compression-codecs/src/lzma/mod.rs
@@ -0,0 +1,4 @@
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::LzmaDecoder, encoder::LzmaEncoder};
diff --git a/crates/compression-codecs/src/unshared.rs b/crates/compression-codecs/src/unshared.rs
new file mode 100644
index 00000000..35c2945d
--- /dev/null
+++ b/crates/compression-codecs/src/unshared.rs
@@ -0,0 +1,39 @@
+#![allow(dead_code)] // unused without any features
+
+use core::fmt::{self, Debug};
+
+/// Wraps a type and only allows unique borrowing, the main use case is to wrap a `!Sync` type and
+/// implement `Sync` for it as this type blocks having multiple shared references to the inner
+/// value.
+///
+/// # Safety
+///
+/// We must be careful when accessing `inner`, there must be no way to create a shared reference to
+/// it from a shared reference to an `Unshared`, as that would allow creating shared references on
+/// multiple threads.
+///
+/// As an example deriving or implementing `Clone` is impossible, two threads could attempt to
+/// clone a shared `Unshared<T>` reference which would result in accessing the same inner value
+/// concurrently.
+pub struct Unshared<T> {
+    inner: T,
+}
+
+impl<T> Unshared<T> {
+    pub fn new(inner: T) -> Self {
+        Unshared { inner }
+    }
+
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+}
+
+/// Safety: See comments on main docs for `Unshared`
+unsafe impl<T> Sync for Unshared<T> {}
+
+impl<T> Debug for Unshared<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct(core::any::type_name::<T>()).finish()
+    }
+}
diff --git a/src/codec/xz/decoder.rs b/crates/compression-codecs/src/xz/decoder.rs
similarity index 88%
rename from src/codec/xz/decoder.rs
rename to crates/compression-codecs/src/xz/decoder.rs
index 69128d44..ddd63275 100644
--- a/src/codec/xz/decoder.rs
+++ b/crates/compression-codecs/src/xz/decoder.rs
@@ -1,29 +1,35 @@
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{xz2::Xz2Decoder, Decode, PartialBuffer};
 
 use std::io::{Error, ErrorKind, Result};
 
 #[derive(Debug)]
 pub struct XzDecoder {
-    inner: crate::codec::Xz2Decoder,
+    inner: Xz2Decoder,
     skip_padding: Option<u8>,
 }
 
 impl XzDecoder {
     pub fn new() -> Self {
         Self {
-            inner: crate::codec::Xz2Decoder::new(u64::MAX),
+            inner: Xz2Decoder::new(u64::MAX),
             skip_padding: None,
         }
     }
 
     pub fn with_memlimit(memlimit: u64) -> Self {
         Self {
-            inner: crate::codec::Xz2Decoder::new(memlimit),
+            inner: Xz2Decoder::new(memlimit),
             skip_padding: None,
         }
     }
 }
 
+impl Default for XzDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for XzDecoder {
     fn reinit(&mut self) -> Result<()> {
         self.skip_padding = Some(4);
diff --git a/src/codec/xz/encoder.rs b/crates/compression-codecs/src/xz/encoder.rs
similarity index 80%
rename from src/codec/xz/encoder.rs
rename to crates/compression-codecs/src/xz/encoder.rs
index a3a23a27..7353e504 100644
--- a/src/codec/xz/encoder.rs
+++ b/crates/compression-codecs/src/xz/encoder.rs
@@ -1,16 +1,19 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{
+    xz2::{Xz2Encoder, Xz2FileFormat},
+    Encode, PartialBuffer,
+};
 
 use std::io::Result;
 
 #[derive(Debug)]
 pub struct XzEncoder {
-    inner: crate::codec::Xz2Encoder,
+    inner: Xz2Encoder,
 }
 
 impl XzEncoder {
     pub fn new(level: u32) -> Self {
         Self {
-            inner: crate::codec::Xz2Encoder::new(crate::codec::Xz2FileFormat::Xz, level),
+            inner: Xz2Encoder::new(Xz2FileFormat::Xz, level),
         }
     }
 }
diff --git a/crates/compression-codecs/src/xz/mod.rs b/crates/compression-codecs/src/xz/mod.rs
new file mode 100644
index 00000000..11062c07
--- /dev/null
+++ b/crates/compression-codecs/src/xz/mod.rs
@@ -0,0 +1,4 @@
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::XzDecoder, encoder::XzEncoder};
diff --git a/src/codec/xz2/decoder.rs b/crates/compression-codecs/src/xz2/decoder.rs
similarity index 98%
rename from src/codec/xz2/decoder.rs
rename to crates/compression-codecs/src/xz2/decoder.rs
index 158976a7..befe4c14 100644
--- a/src/codec/xz2/decoder.rs
+++ b/crates/compression-codecs/src/xz2/decoder.rs
@@ -2,18 +2,12 @@ use std::{fmt, io};
 
 use xz2::stream::{Action, Status, Stream};
 
-use crate::{codec::Decode, util::PartialBuffer};
+use crate::{Decode, PartialBuffer};
 
 pub struct Xz2Decoder {
     stream: Stream,
 }
 
-impl fmt::Debug for Xz2Decoder {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Xz2Decoder").finish_non_exhaustive()
-    }
-}
-
 impl Xz2Decoder {
     pub fn new(mem_limit: u64) -> Self {
         Self {
@@ -22,6 +16,12 @@ impl Xz2Decoder {
     }
 }
 
+impl fmt::Debug for Xz2Decoder {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Xz2Decoder").finish_non_exhaustive()
+    }
+}
+
 impl Decode for Xz2Decoder {
     fn reinit(&mut self) -> io::Result<()> {
         *self = Self::new(self.stream.memlimit());
diff --git a/src/codec/xz2/encoder.rs b/crates/compression-codecs/src/xz2/encoder.rs
similarity index 97%
rename from src/codec/xz2/encoder.rs
rename to crates/compression-codecs/src/xz2/encoder.rs
index cf5d7cdb..a79688d3 100644
--- a/src/codec/xz2/encoder.rs
+++ b/crates/compression-codecs/src/xz2/encoder.rs
@@ -2,10 +2,9 @@ use std::{fmt, io};
 
 use xz2::stream::{Action, Check, LzmaOptions, Status, Stream};
 
-use crate::{
-    codec::{Encode, Xz2FileFormat},
-    util::PartialBuffer,
-};
+use crate::{Encode, PartialBuffer};
+
+use super::Xz2FileFormat;
 
 pub struct Xz2Encoder {
     stream: Stream,
diff --git a/src/codec/xz2/mod.rs b/crates/compression-codecs/src/xz2/mod.rs
similarity index 51%
rename from src/codec/xz2/mod.rs
rename to crates/compression-codecs/src/xz2/mod.rs
index b881208f..3e7b61a2 100644
--- a/src/codec/xz2/mod.rs
+++ b/crates/compression-codecs/src/xz2/mod.rs
@@ -1,3 +1,5 @@
+pub use xz2;
+
 mod decoder;
 mod encoder;
 
@@ -6,4 +8,4 @@ pub enum Xz2FileFormat {
     Lzma,
 }
 
-pub(crate) use self::{decoder::Xz2Decoder, encoder::Xz2Encoder};
+pub use self::{decoder::Xz2Decoder, encoder::Xz2Encoder};
diff --git a/src/codec/zlib/decoder.rs b/crates/compression-codecs/src/zlib/decoder.rs
similarity index 72%
rename from src/codec/zlib/decoder.rs
rename to crates/compression-codecs/src/zlib/decoder.rs
index 8c159a91..3f7d8ed2 100644
--- a/src/codec/zlib/decoder.rs
+++ b/crates/compression-codecs/src/zlib/decoder.rs
@@ -1,20 +1,28 @@
-use crate::util::PartialBuffer;
+use compression_core::Decode;
+
+use crate::{flate::FlateDecoder, PartialBuffer};
 use std::io::Result;
 
 #[derive(Debug)]
 pub struct ZlibDecoder {
-    inner: crate::codec::FlateDecoder,
+    inner: FlateDecoder,
 }
 
 impl ZlibDecoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
-            inner: crate::codec::FlateDecoder::new(true),
+            inner: FlateDecoder::new(true),
         }
     }
 }
 
-impl crate::codec::Decode for ZlibDecoder {
+impl Default for ZlibDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Decode for ZlibDecoder {
     fn reinit(&mut self) -> Result<()> {
         self.inner.reinit()?;
         Ok(())
diff --git a/src/codec/zlib/encoder.rs b/crates/compression-codecs/src/zlib/encoder.rs
similarity index 73%
rename from src/codec/zlib/encoder.rs
rename to crates/compression-codecs/src/zlib/encoder.rs
index 934516c9..9dc1462c 100644
--- a/src/codec/zlib/encoder.rs
+++ b/crates/compression-codecs/src/zlib/encoder.rs
@@ -1,21 +1,21 @@
-use crate::{codec::Encode, util::PartialBuffer};
+use crate::{flate::FlateEncoder, Encode, PartialBuffer};
 use std::io::Result;
 
 use flate2::Compression;
 
 #[derive(Debug)]
 pub struct ZlibEncoder {
-    inner: crate::codec::FlateEncoder,
+    inner: FlateEncoder,
 }
 
 impl ZlibEncoder {
-    pub(crate) fn new(level: Compression) -> Self {
+    pub fn new(level: Compression) -> Self {
         Self {
-            inner: crate::codec::FlateEncoder::new(level, true),
+            inner: FlateEncoder::new(level, true),
         }
     }
 
-    pub(crate) fn get_ref(&self) -> &crate::codec::FlateEncoder {
+    pub fn get_ref(&self) -> &FlateEncoder {
         &self.inner
     }
 }
diff --git a/crates/compression-codecs/src/zlib/mod.rs b/crates/compression-codecs/src/zlib/mod.rs
new file mode 100644
index 00000000..137a4314
--- /dev/null
+++ b/crates/compression-codecs/src/zlib/mod.rs
@@ -0,0 +1,4 @@
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::ZlibDecoder, encoder::ZlibEncoder};
diff --git a/src/codec/zstd/decoder.rs b/crates/compression-codecs/src/zstd/decoder.rs
similarity index 80%
rename from src/codec/zstd/decoder.rs
rename to crates/compression-codecs/src/zstd/decoder.rs
index d1a92f78..44bb6816 100644
--- a/src/codec/zstd/decoder.rs
+++ b/crates/compression-codecs/src/zstd/decoder.rs
@@ -1,8 +1,9 @@
 use std::io;
 use std::io::Result;
 
-use crate::{codec::Decode, unshared::Unshared, util::PartialBuffer};
+use crate::{unshared::Unshared, Decode, PartialBuffer};
 use libzstd::stream::raw::{Decoder, Operation};
+use zstd_safe::DParameter;
 
 #[derive(Debug)]
 pub struct ZstdDecoder {
@@ -10,30 +11,36 @@ pub struct ZstdDecoder {
 }
 
 impl ZstdDecoder {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self {
             decoder: Unshared::new(Decoder::new().unwrap()),
         }
     }
 
-    pub(crate) fn new_with_params(params: &[crate::zstd::DParameter]) -> Self {
+    pub fn new_with_params(params: impl Iterator<Item = DParameter>) -> Self {
         let mut decoder = Decoder::new().unwrap();
         for param in params {
-            decoder.set_parameter(param.as_zstd()).unwrap();
+            decoder.set_parameter(param).unwrap();
         }
         Self {
             decoder: Unshared::new(decoder),
         }
     }
 
-    pub(crate) fn new_with_dict(dictionary: &[u8]) -> io::Result<Self> {
-        let mut decoder = Decoder::with_dictionary(dictionary)?;
+    pub fn new_with_dict(dictionary: &[u8]) -> io::Result<Self> {
+        let decoder = Decoder::with_dictionary(dictionary)?;
         Ok(Self {
             decoder: Unshared::new(decoder),
         })
     }
 }
 
+impl Default for ZstdDecoder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Decode for ZstdDecoder {
     fn reinit(&mut self) -> Result<()> {
         self.decoder.get_mut().reinit()?;
diff --git a/src/codec/zstd/encoder.rs b/crates/compression-codecs/src/zstd/encoder.rs
similarity index 78%
rename from src/codec/zstd/encoder.rs
rename to crates/compression-codecs/src/zstd/encoder.rs
index ca3f5317..e6a522e7 100644
--- a/src/codec/zstd/encoder.rs
+++ b/crates/compression-codecs/src/zstd/encoder.rs
@@ -1,7 +1,8 @@
-use crate::{codec::Encode, unshared::Unshared, util::PartialBuffer};
-use libzstd::stream::raw::{CParameter, Encoder, Operation};
+use crate::{unshared::Unshared, Encode, PartialBuffer};
+use libzstd::stream::raw::{Encoder, Operation};
 use std::io;
 use std::io::Result;
+use zstd_safe::CParameter;
 
 #[derive(Debug)]
 pub struct ZstdEncoder {
@@ -9,24 +10,24 @@ pub struct ZstdEncoder {
 }
 
 impl ZstdEncoder {
-    pub(crate) fn new(level: i32) -> Self {
+    pub fn new(level: i32) -> Self {
         Self {
             encoder: Unshared::new(Encoder::new(level).unwrap()),
         }
     }
 
-    pub(crate) fn new_with_params(level: i32, params: &[crate::zstd::CParameter]) -> Self {
+    pub fn new_with_params(level: i32, params: impl Iterator<Item = CParameter>) -> Self {
         let mut encoder = Encoder::new(level).unwrap();
         for param in params {
-            encoder.set_parameter(param.as_zstd()).unwrap();
+            encoder.set_parameter(param).unwrap();
         }
         Self {
             encoder: Unshared::new(encoder),
         }
     }
 
-    pub(crate) fn new_with_dict(level: i32, dictionary: &[u8]) -> io::Result<Self> {
-        let mut encoder = Encoder::with_dictionary(level, dictionary)?;
+    pub fn new_with_dict(level: i32, dictionary: &[u8]) -> io::Result<Self> {
+        let encoder = Encoder::with_dictionary(level, dictionary)?;
         Ok(Self {
             encoder: Unshared::new(encoder),
         })
diff --git a/crates/compression-codecs/src/zstd/mod.rs b/crates/compression-codecs/src/zstd/mod.rs
new file mode 100644
index 00000000..5073f546
--- /dev/null
+++ b/crates/compression-codecs/src/zstd/mod.rs
@@ -0,0 +1,6 @@
+pub use libzstd;
+
+mod decoder;
+mod encoder;
+
+pub use self::{decoder::ZstdDecoder, encoder::ZstdEncoder};
diff --git a/crates/compression-core/Cargo.toml b/crates/compression-core/Cargo.toml
new file mode 100644
index 00000000..75313ba7
--- /dev/null
+++ b/crates/compression-core/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "compression-core"
+version = "0.1.0"
+description = """
+Abstractions for compression algorithms.
+"""
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords = ["compression", "gzip", "zstd", "brotli"]
+categories = ["compression"]
+
+[dependencies]
diff --git a/crates/compression-core/src/lib.rs b/crates/compression-core/src/lib.rs
new file mode 100644
index 00000000..7bf08a1f
--- /dev/null
+++ b/crates/compression-core/src/lib.rs
@@ -0,0 +1,127 @@
+/// Buffer containing partially written data.
+#[derive(Debug, Default)]
+pub struct PartialBuffer<B: AsRef<[u8]>> {
+    /// Underlying buffer.
+    buffer: B,
+    /// Index up to which data has been written.
+    index: usize,
+}
+
+impl<B: AsRef<[u8]>> PartialBuffer<B> {
+    /// Create a new [`PartialBuffer`] from the given underlying buffer.
+    pub fn new(buffer: B) -> Self {
+        Self { buffer, index: 0 }
+    }
+
+    /// Written part of the buffer.
+    pub fn written(&self) -> &[u8] {
+        &self.buffer.as_ref()[..self.index]
+    }
+
+    /// Unwritten part of the buffer.
+    pub fn unwritten(&self) -> &[u8] {
+        &self.buffer.as_ref()[self.index..]
+    }
+
+    /// Advance the written part.
+    pub fn advance(&mut self, amount: usize) {
+        self.index += amount;
+    }
+
+    /// Mutable reference to the underlying buffer.
+    pub fn get_mut(&mut self) -> &mut B {
+        &mut self.buffer
+    }
+
+    /// Convert the [`PartialBuffer`] back into the underlying buffer.
+    pub fn into_inner(self) -> B {
+        self.buffer
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> PartialBuffer<B> {
+    /// Mutable reference to the unwritten part of the buffer.
+    pub fn unwritten_mut(&mut self) -> &mut [u8] {
+        &mut self.buffer.as_mut()[self.index..]
+    }
+
+    /// Copy the unwritten part of another buffer into this buffer, advancing both buffers.
+    pub fn copy_unwritten_from<C: AsRef<[u8]>>(&mut self, other: &mut PartialBuffer<C>) {
+        let len = std::cmp::min(self.unwritten().len(), other.unwritten().len());
+
+        self.unwritten_mut()[..len].copy_from_slice(&other.unwritten()[..len]);
+
+        self.advance(len);
+        other.advance(len);
+    }
+}
+
+impl<B: AsRef<[u8]> + Default> PartialBuffer<B> {
+    /// Take out the underlying buffer replacing it with a default.
+    pub fn take(&mut self) -> Self {
+        core::mem::replace(self, Self::new(B::default()))
+    }
+}
+
+impl<B: AsRef<[u8]> + AsMut<[u8]>> From<B> for PartialBuffer<B> {
+    fn from(buffer: B) -> Self {
+        Self::new(buffer)
+    }
+}
+
+/// Abstraction for encoders.
+pub trait Encode {
+    /// Encode the provided input buffer into the provided output buffer.
+    fn encode(
+        &mut self,
+        input: &mut PartialBuffer<impl AsRef<[u8]>>,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+    ) -> std::io::Result<()>;
+
+    /// Flush the internal buffers into the provided output buffer.
+    ///
+    /// Returns `true` iff the internal buffers have been completely flushed.
+    fn flush(
+        &mut self,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+    ) -> std::io::Result<bool>;
+
+    /// Finish the encoding into the provided output buffer.
+    ///
+    /// Returns `true` iff the internal buffers have been completely flushed.
+    fn finish(
+        &mut self,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+    ) -> std::io::Result<bool>;
+}
+
+/// Abstraction for decoders.
+pub trait Decode {
+    /// Reinitializes this decoder, preparing it to decode a new member/frame of data.
+    fn reinit(&mut self) -> std::io::Result<()>;
+
+    /// Encode the provided input buffer into the provided output buffer.
+    ///
+    /// Returns `true` iff the end of the input stream has been reached.
+    fn decode(
+        &mut self,
+        input: &mut PartialBuffer<impl AsRef<[u8]>>,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+    ) -> std::io::Result<bool>;
+
+    /// Flush the internal buffers into the provided output buffer.
+    ///
+    /// Returns `true` iff the internal buffers have been completely flushed.
+    fn flush(
+        &mut self,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+    ) -> std::io::Result<bool>;
+
+    /// Finish the decoding into the provided output buffer.
+    ///
+    /// Returns `true` iff the internal buffers have been completely flushed.
+    fn finish(
+        &mut self,
+        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
+    ) -> std::io::Result<bool>;
+}
diff --git a/src/brotli.rs b/src/brotli.rs
index 70b622a5..28c975ea 100644
--- a/src/brotli.rs
+++ b/src/brotli.rs
@@ -1,6 +1,8 @@
 //! This module contains Brotli-specific types for async-compression.
 
-use brotli::enc::backward_references::{BrotliEncoderMode, BrotliEncoderParams};
+use compression_codecs::brotli::brotli::enc::backward_references::{
+    BrotliEncoderMode, BrotliEncoderParams,
+};
 
 /// Brotli compression parameters builder. This is a stable wrapper around Brotli's own encoder
 /// params type, to abstract over different versions of the Brotli library.
diff --git a/src/codec/brotli/mod.rs b/src/codec/brotli/mod.rs
deleted file mode 100644
index ab4dd7ac..00000000
--- a/src/codec/brotli/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::BrotliDecoder, encoder::BrotliEncoder};
diff --git a/src/codec/bzip2/mod.rs b/src/codec/bzip2/mod.rs
deleted file mode 100644
index 2abd9282..00000000
--- a/src/codec/bzip2/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::BzDecoder, encoder::BzEncoder};
diff --git a/src/codec/deflate/mod.rs b/src/codec/deflate/mod.rs
deleted file mode 100644
index bd75f911..00000000
--- a/src/codec/deflate/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::DeflateDecoder, encoder::DeflateEncoder};
diff --git a/src/codec/deflate64/mod.rs b/src/codec/deflate64/mod.rs
deleted file mode 100644
index 78dee675..00000000
--- a/src/codec/deflate64/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod decoder;
-
-pub(crate) use self::decoder::Deflate64Decoder;
diff --git a/src/codec/flate/mod.rs b/src/codec/flate/mod.rs
deleted file mode 100644
index 38934c3e..00000000
--- a/src/codec/flate/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::FlateDecoder, encoder::FlateEncoder};
diff --git a/src/codec/gzip/mod.rs b/src/codec/gzip/mod.rs
deleted file mode 100644
index 90be4e1f..00000000
--- a/src/codec/gzip/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod decoder;
-mod encoder;
-mod header;
-
-pub(crate) use self::{decoder::GzipDecoder, encoder::GzipEncoder};
diff --git a/src/codec/lzma/mod.rs b/src/codec/lzma/mod.rs
deleted file mode 100644
index 4a9e73bb..00000000
--- a/src/codec/lzma/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::LzmaDecoder, encoder::LzmaEncoder};
diff --git a/src/codec/mod.rs b/src/codec/mod.rs
deleted file mode 100644
index 23eda276..00000000
--- a/src/codec/mod.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use crate::util::PartialBuffer;
-use std::io::Result;
-
-#[cfg(feature = "brotli")]
-mod brotli;
-#[cfg(feature = "bzip2")]
-mod bzip2;
-#[cfg(feature = "deflate")]
-mod deflate;
-#[cfg(feature = "deflate64")]
-mod deflate64;
-#[cfg(feature = "flate2")]
-mod flate;
-#[cfg(feature = "gzip")]
-mod gzip;
-#[cfg(feature = "lzma")]
-mod lzma;
-#[cfg(feature = "xz")]
-mod xz;
-#[cfg(feature = "xz2")]
-mod xz2;
-#[cfg(feature = "zlib")]
-mod zlib;
-#[cfg(feature = "zstd")]
-mod zstd;
-
-#[cfg(feature = "brotli")]
-pub(crate) use self::brotli::{BrotliDecoder, BrotliEncoder};
-#[cfg(feature = "bzip2")]
-pub(crate) use self::bzip2::{BzDecoder, BzEncoder};
-#[cfg(feature = "deflate")]
-pub(crate) use self::deflate::{DeflateDecoder, DeflateEncoder};
-#[cfg(feature = "deflate64")]
-pub(crate) use self::deflate64::Deflate64Decoder;
-#[cfg(feature = "flate2")]
-pub(crate) use self::flate::{FlateDecoder, FlateEncoder};
-#[cfg(feature = "gzip")]
-pub(crate) use self::gzip::{GzipDecoder, GzipEncoder};
-#[cfg(feature = "lzma")]
-pub(crate) use self::lzma::{LzmaDecoder, LzmaEncoder};
-#[cfg(feature = "xz")]
-pub(crate) use self::xz::{XzDecoder, XzEncoder};
-#[cfg(feature = "xz2")]
-pub(crate) use self::xz2::{Xz2Decoder, Xz2Encoder, Xz2FileFormat};
-#[cfg(feature = "zlib")]
-pub(crate) use self::zlib::{ZlibDecoder, ZlibEncoder};
-#[cfg(feature = "zstd")]
-pub(crate) use self::zstd::{ZstdDecoder, ZstdEncoder};
-
-pub trait Encode {
-    fn encode(
-        &mut self,
-        input: &mut PartialBuffer<impl AsRef<[u8]>>,
-        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
-    ) -> Result<()>;
-
-    /// Returns whether the internal buffers are flushed
-    fn flush(&mut self, output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>)
-        -> Result<bool>;
-
-    /// Returns whether the internal buffers are flushed and the end of the stream is written
-    fn finish(
-        &mut self,
-        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
-    ) -> Result<bool>;
-}
-
-pub trait Decode {
-    /// Reinitializes this decoder ready to decode a new member/frame of data.
-    fn reinit(&mut self) -> Result<()>;
-
-    /// Returns whether the end of the stream has been read
-    fn decode(
-        &mut self,
-        input: &mut PartialBuffer<impl AsRef<[u8]>>,
-        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
-    ) -> Result<bool>;
-
-    /// Returns whether the internal buffers are flushed
-    fn flush(&mut self, output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>)
-        -> Result<bool>;
-
-    /// Returns whether the internal buffers are flushed
-    fn finish(
-        &mut self,
-        output: &mut PartialBuffer<impl AsRef<[u8]> + AsMut<[u8]>>,
-    ) -> Result<bool>;
-}
diff --git a/src/codec/xz/mod.rs b/src/codec/xz/mod.rs
deleted file mode 100644
index 7178e154..00000000
--- a/src/codec/xz/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::XzDecoder, encoder::XzEncoder};
diff --git a/src/codec/zlib/mod.rs b/src/codec/zlib/mod.rs
deleted file mode 100644
index 9ccfae61..00000000
--- a/src/codec/zlib/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::ZlibDecoder, encoder::ZlibEncoder};
diff --git a/src/codec/zstd/mod.rs b/src/codec/zstd/mod.rs
deleted file mode 100644
index e6b5525f..00000000
--- a/src/codec/zstd/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-mod decoder;
-mod encoder;
-
-pub(crate) use self::{decoder::ZstdDecoder, encoder::ZstdEncoder};
diff --git a/src/futures/bufread/generic/decoder.rs b/src/futures/bufread/generic/decoder.rs
index e97f0fc7..733751ec 100644
--- a/src/futures/bufread/generic/decoder.rs
+++ b/src/futures/bufread/generic/decoder.rs
@@ -4,7 +4,7 @@ use core::{
 };
 use std::io::{IoSlice, Result};
 
-use crate::{codec::Decode, util::PartialBuffer};
+use compression_codecs::{Decode, PartialBuffer};
 use futures_core::ready;
 use futures_io::{AsyncBufRead, AsyncRead, AsyncWrite};
 use pin_project_lite::pin_project;
diff --git a/src/futures/bufread/generic/encoder.rs b/src/futures/bufread/generic/encoder.rs
index c73019c4..849ceb29 100644
--- a/src/futures/bufread/generic/encoder.rs
+++ b/src/futures/bufread/generic/encoder.rs
@@ -4,7 +4,7 @@ use core::{
 };
 use std::io::Result;
 
-use crate::{codec::Encode, util::PartialBuffer};
+use compression_codecs::{Encode, PartialBuffer};
 use futures_core::ready;
 use futures_io::{AsyncBufRead, AsyncRead, AsyncWrite, IoSlice};
 use pin_project_lite::pin_project;
diff --git a/src/futures/bufread/macros/decoder.rs b/src/futures/bufread/macros/decoder.rs
index ba886c72..6caf6ce6 100644
--- a/src/futures/bufread/macros/decoder.rs
+++ b/src/futures/bufread/macros/decoder.rs
@@ -1,5 +1,5 @@
 macro_rules! decoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! decoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::futures::bufread::Decoder<$inner, crate::codec::$name>,
+                inner: crate::futures::bufread::Decoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
@@ -17,7 +17,7 @@ macro_rules! decoder {
             /// emit a uncompressed stream.
             pub fn new(read: $inner) -> $name<$inner> {
                 $name {
-                    inner: crate::futures::bufread::Decoder::new(read, crate::codec::$name::new()),
+                    inner: crate::futures::bufread::Decoder::new(read, compression_codecs::$algo::$name::new()),
                 }
             }
 
diff --git a/src/futures/bufread/macros/encoder.rs b/src/futures/bufread/macros/encoder.rs
index f26833eb..07ba129c 100644
--- a/src/futures/bufread/macros/encoder.rs
+++ b/src/futures/bufread/macros/encoder.rs
@@ -1,5 +1,5 @@
 macro_rules! encoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! encoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::futures::bufread::Encoder<$inner, crate::codec::$name>,
+                inner: crate::futures::bufread::Encoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
diff --git a/src/futures/write/generic/decoder.rs b/src/futures/write/generic/decoder.rs
index 0d905d1d..c127289e 100644
--- a/src/futures/write/generic/decoder.rs
+++ b/src/futures/write/generic/decoder.rs
@@ -4,11 +4,8 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::{
-    codec::Decode,
-    futures::write::{AsyncBufWrite, BufWriter},
-    util::PartialBuffer,
-};
+use crate::futures::write::{AsyncBufWrite, BufWriter};
+use compression_codecs::{Decode, PartialBuffer};
 use futures_core::ready;
 use futures_io::{AsyncBufRead, AsyncRead, AsyncWrite, IoSliceMut};
 use pin_project_lite::pin_project;
diff --git a/src/futures/write/generic/encoder.rs b/src/futures/write/generic/encoder.rs
index fbeafe64..3e7cfa4f 100644
--- a/src/futures/write/generic/encoder.rs
+++ b/src/futures/write/generic/encoder.rs
@@ -4,11 +4,8 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::{
-    codec::Encode,
-    futures::write::{AsyncBufWrite, BufWriter},
-    util::PartialBuffer,
-};
+use crate::futures::write::{AsyncBufWrite, BufWriter};
+use compression_codecs::{Encode, PartialBuffer};
 use futures_core::ready;
 use futures_io::{AsyncBufRead, AsyncRead, AsyncWrite, IoSliceMut};
 use pin_project_lite::pin_project;
diff --git a/src/futures/write/macros/decoder.rs b/src/futures/write/macros/decoder.rs
index 55cb1aa5..3fa5f57f 100644
--- a/src/futures/write/macros/decoder.rs
+++ b/src/futures/write/macros/decoder.rs
@@ -1,5 +1,5 @@
 macro_rules! decoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! decoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::futures::write::Decoder<$inner, crate::codec::$name>,
+                inner: crate::futures::write::Decoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
@@ -50,7 +50,7 @@ macro_rules! decoder {
             /// to the given stream.
             pub fn new(read: $inner) -> $name<$inner> {
                 $name {
-                    inner: crate::futures::write::Decoder::new(read, crate::codec::$name::new()),
+                    inner: crate::futures::write::Decoder::new(read, compression_codecs::$algo::$name::new()),
                 }
             }
 
diff --git a/src/futures/write/macros/encoder.rs b/src/futures/write/macros/encoder.rs
index 7e0f929a..6a2da306 100644
--- a/src/futures/write/macros/encoder.rs
+++ b/src/futures/write/macros/encoder.rs
@@ -1,5 +1,5 @@
 macro_rules! encoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! encoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::futures::write::Encoder<$inner, crate::codec::$name>,
+                inner: crate::futures::write::Encoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
diff --git a/src/lib.rs b/src/lib.rs
index 91d906c3..dc2f58d6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -144,7 +144,6 @@ use std::convert::TryInto;
 
 #[macro_use]
 mod macros;
-mod codec;
 
 #[cfg(feature = "futures-io")]
 pub mod futures;
@@ -182,8 +181,8 @@ impl Level {
     #[cfg(feature = "brotli")]
     fn into_brotli(
         self,
-        mut params: ::brotli::enc::backward_references::BrotliEncoderParams,
-    ) -> ::brotli::enc::backward_references::BrotliEncoderParams {
+        mut params: compression_codecs::brotli::brotli::enc::backward_references::BrotliEncoderParams,
+    ) -> compression_codecs::brotli::brotli::enc::backward_references::BrotliEncoderParams {
         match self {
             Self::Fastest => params.quality = 0,
             Self::Best => params.quality = 11,
@@ -195,50 +194,51 @@ impl Level {
     }
 
     #[cfg(feature = "bzip2")]
-    fn into_bzip2(self) -> bzip2::Compression {
-        let fastest = bzip2::Compression::fast();
-        let best = bzip2::Compression::best();
+    fn into_bzip2(self) -> compression_codecs::bzip2::bzip2::Compression {
+        let fastest = compression_codecs::bzip2::bzip2::Compression::fast();
+        let best = compression_codecs::bzip2::bzip2::Compression::best();
 
         match self {
             Self::Fastest => fastest,
             Self::Best => best,
-            Self::Precise(quality) => bzip2::Compression::new(
+            Self::Precise(quality) => compression_codecs::bzip2::bzip2::Compression::new(
                 quality
                     .try_into()
                     .unwrap_or(0)
                     .clamp(fastest.level(), best.level()),
             ),
-            Self::Default => bzip2::Compression::default(),
+            Self::Default => compression_codecs::bzip2::bzip2::Compression::default(),
         }
     }
 
     #[cfg(feature = "flate2")]
-    fn into_flate2(self) -> flate2::Compression {
-        let fastest = flate2::Compression::fast();
-        let best = flate2::Compression::best();
-        let none = flate2::Compression::none();
+    fn into_flate2(self) -> compression_codecs::flate::flate2::Compression {
+        let fastest = compression_codecs::flate::flate2::Compression::fast();
+        let best = compression_codecs::flate::flate2::Compression::best();
+        let none = compression_codecs::flate::flate2::Compression::none();
 
         match self {
             Self::Fastest => fastest,
             Self::Best => best,
-            Self::Precise(quality) => flate2::Compression::new(
+            Self::Precise(quality) => compression_codecs::flate::flate2::Compression::new(
                 quality
                     .try_into()
                     .unwrap_or(0)
                     .clamp(none.level(), best.level()),
             ),
-            Self::Default => flate2::Compression::default(),
+            Self::Default => compression_codecs::flate::flate2::Compression::default(),
         }
     }
 
     #[cfg(feature = "zstd")]
     fn into_zstd(self) -> i32 {
-        let (fastest, best) = libzstd::compression_level_range().into_inner();
+        let (fastest, best) =
+            compression_codecs::zstd::libzstd::compression_level_range().into_inner();
         match self {
             Self::Fastest => fastest,
             Self::Best => best,
             Self::Precise(quality) => quality.clamp(fastest, best),
-            Self::Default => libzstd::DEFAULT_COMPRESSION_LEVEL,
+            Self::Default => compression_codecs::zstd::libzstd::DEFAULT_COMPRESSION_LEVEL,
         }
     }
 
diff --git a/src/macros.rs b/src/macros.rs
index 75909638..b9e248e2 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -7,7 +7,7 @@ macro_rules! algos {
         decoder! {
             #[doc = concat!("A ", $algo_s, " decoder, or decompressor")]
             #[cfg(feature = $algo_s)]
-            $decoder<$inner>
+            $algo::$decoder<$inner>
 
             { $($decoder_methods)* }
         }
@@ -16,7 +16,7 @@ macro_rules! algos {
         encoder! {
             #[doc = concat!("A ", $algo_s, " encoder, or compressor.")]
             #[cfg(feature = $algo_s)]
-            $encoder<$inner> {
+            $algo::$encoder<$inner> {
                 pub fn new(inner: $inner) -> Self {
                     Self::with_quality(inner, crate::Level::Default)
                 }
@@ -33,7 +33,7 @@ macro_rules! algos {
         decoder! {
             #[doc = concat!("A ", $algo_s, " decoder, or decompressor")]
             #[cfg(feature = $algo_s)]
-            $decoder<$inner>
+            $algo::$decoder<$inner>
 
             { $($decoder_methods)* }
         }
@@ -43,12 +43,12 @@ macro_rules! algos {
         algos!(@algo brotli ["brotli"] BrotliDecoder BrotliEncoder <$inner>
         { @enc
             pub fn with_quality(inner: $inner, level: crate::Level) -> Self {
-                let params = brotli::enc::backward_references::BrotliEncoderParams::default();
+                let params = compression_codecs::brotli::brotli::enc::BrotliEncoderParams::default();
 
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::BrotliEncoder::new(level.into_brotli(params)),
+                        compression_codecs::brotli::BrotliEncoder::new(level.into_brotli(params)),
                     ),
                 }
             }
@@ -65,7 +65,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::BrotliEncoder::new(params),
+                        compression_codecs::brotli::BrotliEncoder::new(params),
                     ),
                 }
             }
@@ -80,7 +80,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::BzEncoder::new(level.into_bzip2(), 0),
+                        compression_codecs::bzip2::BzEncoder::new(level.into_bzip2(), 0),
                     ),
                 }
             }
@@ -94,7 +94,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::DeflateEncoder::new(level.into_flate2()),
+                        compression_codecs::deflate::DeflateEncoder::new(level.into_flate2()),
                     ),
                 }
             }
@@ -102,7 +102,7 @@ macro_rules! algos {
         { @dec }
         );
 
-        algos!(@algo deflate ["deflate64"] Deflate64Decoder Deflate64Encoder <$inner>
+        algos!(@algo deflate64 ["deflate64"] Deflate64Decoder Deflate64Encoder <$inner>
         { @dec }
         );
 
@@ -113,7 +113,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::GzipEncoder::new(level.into_flate2()),
+                        compression_codecs::gzip::GzipEncoder::new(level.into_flate2()),
                     ),
                 }
             }
@@ -127,7 +127,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::ZlibEncoder::new(level.into_flate2()),
+                        compression_codecs::zlib::ZlibEncoder::new(level.into_flate2()),
                     ),
                 }
             }
@@ -152,7 +152,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::ZstdEncoder::new(level.into_zstd()),
+                        compression_codecs::zstd::ZstdEncoder::new(level.into_zstd()),
                     ),
                 }
             }
@@ -173,7 +173,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::ZstdEncoder::new_with_params(level.into_zstd(), params),
+                        compression_codecs::zstd::ZstdEncoder::new_with_params(level.into_zstd(), params.iter().map(|p| p.as_zstd())),
                     ),
                 }
             }
@@ -192,7 +192,7 @@ macro_rules! algos {
                 Ok(Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::ZstdEncoder::new_with_dict(level.into_zstd(), dictionary)?,
+                        compression_codecs::zstd::ZstdEncoder::new_with_dict(level.into_zstd(), dictionary)?,
                     ),
                 })
             }
@@ -204,7 +204,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Decoder::new(
                         inner,
-                        crate::codec::ZstdDecoder::new_with_params(params),
+                        compression_codecs::zstd::ZstdDecoder::new_with_params(params.iter().map(|p| p.as_zstd())),
                     ),
                 }
             }
@@ -224,7 +224,7 @@ macro_rules! algos {
                 Ok(Self {
                     inner: crate::$($mod::)+generic::Decoder::new(
                         inner,
-                        crate::codec::ZstdDecoder::new_with_dict(dictionary)?,
+                        compression_codecs::zstd::ZstdDecoder::new_with_dict(dictionary)?,
                     ),
                 })
             }
@@ -238,7 +238,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::XzEncoder::new(level.into_xz2()),
+                        compression_codecs::xz::XzEncoder::new(level.into_xz2()),
                     ),
                 }
             }
@@ -253,7 +253,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Decoder::new(
                         read,
-                        crate::codec::XzDecoder::with_memlimit(memlimit),
+                        compression_codecs::xz::XzDecoder::with_memlimit(memlimit),
                     ),
                 }
             }
@@ -267,7 +267,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Encoder::new(
                         inner,
-                        crate::codec::LzmaEncoder::new(level.into_xz2()),
+                        compression_codecs::lzma::LzmaEncoder::new(level.into_xz2()),
                     ),
                 }
             }
@@ -282,7 +282,7 @@ macro_rules! algos {
                 Self {
                     inner: crate::$($mod::)+generic::Decoder::new(
                         read,
-                        crate::codec::LzmaDecoder::with_memlimit(memlimit),
+                        compression_codecs::lzma::LzmaDecoder::with_memlimit(memlimit),
                     ),
                 }
             }
diff --git a/src/tokio/bufread/generic/decoder.rs b/src/tokio/bufread/generic/decoder.rs
index c4fdb985..af6ac061 100644
--- a/src/tokio/bufread/generic/decoder.rs
+++ b/src/tokio/bufread/generic/decoder.rs
@@ -4,7 +4,7 @@ use core::{
 };
 use std::io::{IoSlice, Result};
 
-use crate::{codec::Decode, util::PartialBuffer};
+use compression_codecs::{Decode, PartialBuffer};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
diff --git a/src/tokio/bufread/generic/encoder.rs b/src/tokio/bufread/generic/encoder.rs
index bb4bccda..c09a644d 100644
--- a/src/tokio/bufread/generic/encoder.rs
+++ b/src/tokio/bufread/generic/encoder.rs
@@ -4,7 +4,7 @@ use core::{
 };
 use std::io::{IoSlice, Result};
 
-use crate::{codec::Encode, util::PartialBuffer};
+use compression_codecs::{Encode, PartialBuffer};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
diff --git a/src/tokio/bufread/macros/decoder.rs b/src/tokio/bufread/macros/decoder.rs
index a3c36ac1..5f02195f 100644
--- a/src/tokio/bufread/macros/decoder.rs
+++ b/src/tokio/bufread/macros/decoder.rs
@@ -1,5 +1,5 @@
 macro_rules! decoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! decoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::tokio::bufread::Decoder<$inner, crate::codec::$name>,
+                inner: crate::tokio::bufread::Decoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
@@ -17,7 +17,7 @@ macro_rules! decoder {
             /// emit a uncompressed stream.
             pub fn new(read: $inner) -> $name<$inner> {
                 $name {
-                    inner: crate::tokio::bufread::Decoder::new(read, crate::codec::$name::new()),
+                    inner: crate::tokio::bufread::Decoder::new(read, compression_codecs::$algo::$name::new()),
                 }
             }
 
diff --git a/src/tokio/bufread/macros/encoder.rs b/src/tokio/bufread/macros/encoder.rs
index f43f0631..77fc9b64 100644
--- a/src/tokio/bufread/macros/encoder.rs
+++ b/src/tokio/bufread/macros/encoder.rs
@@ -1,5 +1,5 @@
 macro_rules! encoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! encoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::tokio::bufread::Encoder<$inner, crate::codec::$name>,
+                inner: crate::tokio::bufread::Encoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
diff --git a/src/tokio/write/generic/decoder.rs b/src/tokio/write/generic/decoder.rs
index d03dd30c..94b19aa6 100644
--- a/src/tokio/write/generic/decoder.rs
+++ b/src/tokio/write/generic/decoder.rs
@@ -4,11 +4,8 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::{
-    codec::Decode,
-    tokio::write::{AsyncBufWrite, BufWriter},
-    util::PartialBuffer,
-};
+use crate::tokio::write::{AsyncBufWrite, BufWriter};
+use compression_codecs::{Decode, PartialBuffer};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
diff --git a/src/tokio/write/generic/encoder.rs b/src/tokio/write/generic/encoder.rs
index f5a83aa5..3b1aa4d0 100644
--- a/src/tokio/write/generic/encoder.rs
+++ b/src/tokio/write/generic/encoder.rs
@@ -4,11 +4,8 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::{
-    codec::Encode,
-    tokio::write::{AsyncBufWrite, BufWriter},
-    util::PartialBuffer,
-};
+use crate::tokio::write::{AsyncBufWrite, BufWriter};
+use compression_codecs::{Encode, PartialBuffer};
 use futures_core::ready;
 use pin_project_lite::pin_project;
 use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, ReadBuf};
diff --git a/src/tokio/write/macros/decoder.rs b/src/tokio/write/macros/decoder.rs
index bc3f1541..86966246 100644
--- a/src/tokio/write/macros/decoder.rs
+++ b/src/tokio/write/macros/decoder.rs
@@ -1,5 +1,5 @@
 macro_rules! decoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! decoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::tokio::write::Decoder<$inner, crate::codec::$name>,
+                inner: crate::tokio::write::Decoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
@@ -17,7 +17,7 @@ macro_rules! decoder {
             /// to the given stream.
             pub fn new(read: $inner) -> $name<$inner> {
                 $name {
-                    inner: crate::tokio::write::Decoder::new(read, crate::codec::$name::new()),
+                    inner: crate::tokio::write::Decoder::new(read, compression_codecs::$algo::$name::new()),
                 }
             }
 
diff --git a/src/tokio/write/macros/encoder.rs b/src/tokio/write/macros/encoder.rs
index a2a25e63..8ce35c20 100644
--- a/src/tokio/write/macros/encoder.rs
+++ b/src/tokio/write/macros/encoder.rs
@@ -1,5 +1,5 @@
 macro_rules! encoder {
-    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
+    ($(#[$attr:meta])* $algo:ident::$name:ident<$inner:ident> $({ $($inherent_methods:tt)* })*) => {
         pin_project_lite::pin_project! {
             $(#[$attr])*
             ///
@@ -8,7 +8,7 @@ macro_rules! encoder {
             #[derive(Debug)]
             pub struct $name<$inner> {
                 #[pin]
-                inner: crate::tokio::write::Encoder<$inner, crate::codec::$name>,
+                inner: crate::tokio::write::Encoder<$inner, compression_codecs::$algo::$name>,
             }
         }
 
diff --git a/src/util.rs b/src/util.rs
index 370bf19f..068e7d07 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,61 +1,2 @@
 pub fn _assert_send<T: Send>() {}
 pub fn _assert_sync<T: Sync>() {}
-
-#[derive(Debug, Default)]
-pub struct PartialBuffer<B: AsRef<[u8]>> {
-    buffer: B,
-    index: usize,
-}
-
-impl<B: AsRef<[u8]>> PartialBuffer<B> {
-    pub(crate) fn new(buffer: B) -> Self {
-        Self { buffer, index: 0 }
-    }
-
-    pub(crate) fn written(&self) -> &[u8] {
-        &self.buffer.as_ref()[..self.index]
-    }
-
-    pub(crate) fn unwritten(&self) -> &[u8] {
-        &self.buffer.as_ref()[self.index..]
-    }
-
-    pub(crate) fn advance(&mut self, amount: usize) {
-        self.index += amount;
-    }
-
-    pub(crate) fn get_mut(&mut self) -> &mut B {
-        &mut self.buffer
-    }
-
-    pub(crate) fn into_inner(self) -> B {
-        self.buffer
-    }
-}
-
-impl<B: AsRef<[u8]> + AsMut<[u8]>> PartialBuffer<B> {
-    pub(crate) fn unwritten_mut(&mut self) -> &mut [u8] {
-        &mut self.buffer.as_mut()[self.index..]
-    }
-
-    pub(crate) fn copy_unwritten_from<C: AsRef<[u8]>>(&mut self, other: &mut PartialBuffer<C>) {
-        let len = std::cmp::min(self.unwritten().len(), other.unwritten().len());
-
-        self.unwritten_mut()[..len].copy_from_slice(&other.unwritten()[..len]);
-
-        self.advance(len);
-        other.advance(len);
-    }
-}
-
-impl<B: AsRef<[u8]> + Default> PartialBuffer<B> {
-    pub(crate) fn take(&mut self) -> Self {
-        std::mem::replace(self, Self::new(B::default()))
-    }
-}
-
-impl<B: AsRef<[u8]> + AsMut<[u8]>> From<B> for PartialBuffer<B> {
-    fn from(buffer: B) -> Self {
-        Self::new(buffer)
-    }
-}
diff --git a/src/zstd.rs b/src/zstd.rs
index 931cd556..f95531a7 100644
--- a/src/zstd.rs
+++ b/src/zstd.rs
@@ -1,5 +1,7 @@
 //! This module contains zstd-specific types for async-compression.
 
+use compression_codecs::zstd::libzstd;
+
 /// A compression parameter for zstd. This is a stable wrapper around zstd's own `CParameter`
 /// type, to abstract over different versions of the zstd library.
 ///
diff --git a/tests/gzip.rs b/tests/gzip.rs
index d9cd4eff..b561e016 100644
--- a/tests/gzip.rs
+++ b/tests/gzip.rs
@@ -11,7 +11,7 @@ use utils::algos::gzip::futures::bufread;
 
 #[allow(unused)]
 fn compress_with_header(data: &[u8]) -> Vec<u8> {
-    use flate2::{Compression, GzBuilder};
+    use compression_codecs::flate::flate2::{Compression, GzBuilder};
     use std::io::Write;
 
     let mut bytes = Vec::new();
diff --git a/tests/utils/algos.rs b/tests/utils/algos.rs
index b82bdba5..354bef73 100644
--- a/tests/utils/algos.rs
+++ b/tests/utils/algos.rs
@@ -71,13 +71,13 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use brotli::{enc::backward_references::BrotliEncoderParams, CompressorReader};
+                use compression_codecs::brotli::brotli::{enc::backward_references::BrotliEncoderParams, CompressorReader};
                 let params = BrotliEncoderParams { quality: 1, ..Default::default() };
                 to_vec(CompressorReader::with_params(bytes, 0, &params))
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use brotli::Decompressor;
+                use compression_codecs::brotli::brotli::Decompressor;
                 to_vec(Decompressor::new(bytes, 0))
             }
         }
@@ -88,12 +88,12 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use bzip2::{bufread::BzEncoder, Compression};
+                use compression_codecs::bzip2::bzip2::{bufread::BzEncoder, Compression};
                 to_vec(BzEncoder::new(bytes, Compression::fast()))
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use bzip2::bufread::BzDecoder;
+                use compression_codecs::bzip2::bzip2::bufread::BzDecoder;
                 to_vec(BzDecoder::new(bytes))
             }
         }
@@ -104,12 +104,12 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use flate2::{bufread::DeflateEncoder, Compression};
+                use compression_codecs::flate::flate2::{bufread::DeflateEncoder, Compression};
                 to_vec(DeflateEncoder::new(bytes, Compression::fast()))
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use flate2::bufread::DeflateDecoder;
+                use compression_codecs::flate::flate2::bufread::DeflateDecoder;
                 to_vec(DeflateDecoder::new(bytes))
             }
         }
@@ -120,12 +120,12 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use flate2::{bufread::ZlibEncoder, Compression};
+                use compression_codecs::flate::flate2::{bufread::ZlibEncoder, Compression};
                 to_vec(ZlibEncoder::new(bytes, Compression::fast()))
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use flate2::bufread::ZlibDecoder;
+                use compression_codecs::flate::flate2::bufread::ZlibDecoder;
                 to_vec(ZlibDecoder::new(bytes))
             }
         }
@@ -136,12 +136,12 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use flate2::{bufread::GzEncoder, Compression};
+                use compression_codecs::flate::flate2::{bufread::GzEncoder, Compression};
                 to_vec(GzEncoder::new(bytes, Compression::fast()))
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use flate2::bufread::GzDecoder;
+                use compression_codecs::flate::flate2::bufread::GzDecoder;
                 to_vec(GzDecoder::new(bytes))
             }
         }
@@ -152,13 +152,13 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use libzstd::stream::read::Encoder;
-                use libzstd::DEFAULT_COMPRESSION_LEVEL;
+                use compression_codecs::zstd::libzstd::stream::read::Encoder;
+                use compression_codecs::zstd::libzstd::DEFAULT_COMPRESSION_LEVEL;
                 to_vec(Encoder::new(bytes, DEFAULT_COMPRESSION_LEVEL).unwrap())
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use libzstd::stream::read::Decoder;
+                use compression_codecs::zstd::libzstd::stream::read::Decoder;
                 to_vec(Decoder::new(bytes).unwrap())
             }
         }
@@ -169,13 +169,13 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use xz2::bufread::XzEncoder;
+                use compression_codecs::xz2::xz2::bufread::XzEncoder;
 
                 to_vec(XzEncoder::new(bytes, 0))
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use xz2::bufread::XzDecoder;
+                use compression_codecs::xz2::xz2::bufread::XzDecoder;
 
                 to_vec(XzDecoder::new(bytes))
             }
@@ -187,8 +187,8 @@ algos! {
             pub use crate::utils::impls::sync::to_vec;
 
             pub fn compress(bytes: &[u8]) -> Vec<u8> {
-                use xz2::bufread::XzEncoder;
-                use xz2::stream::{LzmaOptions, Stream};
+                use compression_codecs::xz2::xz2::bufread::XzEncoder;
+                use compression_codecs::xz2::xz2::stream::{LzmaOptions, Stream};
 
                 to_vec(XzEncoder::new_stream(
                     bytes,
@@ -197,8 +197,8 @@ algos! {
             }
 
             pub fn decompress(bytes: &[u8]) -> Vec<u8> {
-                use xz2::bufread::XzDecoder;
-                use xz2::stream::Stream;
+                use compression_codecs::xz2::xz2::bufread::XzDecoder;
+                use compression_codecs::xz2::xz2::stream::Stream;
 
                 to_vec(XzDecoder::new_stream(
                     bytes,