diff --git a/CHANGELOG.md b/CHANGELOG.md
index 78e4c663..a5f5717a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Changed
+- Adds a new method `try_seek` to all sources. It returns either an error or
+  seeks to the given position. A few sources are "unsupported" they return the
+  error `Unsupported`.
 - `Source` trait is now also implemented for `Box<dyn Source>` and `&mut Source`
 - `fn new_vorbis` is now also available when the `symphonia-vorbis` feature is enabled
 
diff --git a/Cargo.toml b/Cargo.toml
index 2fd86547..dce36150 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,6 +17,7 @@ lewton = { version = "0.10", optional = true }
 minimp3_fixed = { version = "0.5.4", optional = true}
 symphonia = { version = "0.5.2", optional = true, default-features = false }
 crossbeam-channel = { version = "0.5.8", optional = true }
+thiserror = "1.0.49"
 
 [features]
 default = ["flac", "vorbis", "wav", "mp3"]
@@ -38,6 +39,8 @@ symphonia-wav = ["symphonia/wav", "symphonia/pcm", "symphonia/adpcm"]
 
 [dev-dependencies]
 quickcheck = "0.9.2"
+rstest = "0.18.2"
+rstest_reuse = "0.6.0"
 
 [[example]]
 name = "music_m4a"
diff --git a/assets/RL.flac b/assets/RL.flac
new file mode 100644
index 00000000..f95dceb3
Binary files /dev/null and b/assets/RL.flac differ
diff --git a/assets/RL.m4a b/assets/RL.m4a
new file mode 100644
index 00000000..1df9a800
Binary files /dev/null and b/assets/RL.m4a differ
diff --git a/assets/RL.mp3 b/assets/RL.mp3
new file mode 100644
index 00000000..ffc8c185
Binary files /dev/null and b/assets/RL.mp3 differ
diff --git a/assets/RL.wav b/assets/RL.wav
new file mode 100644
index 00000000..7124123e
Binary files /dev/null and b/assets/RL.wav differ
diff --git a/examples/seek_mp3.rs b/examples/seek_mp3.rs
new file mode 100644
index 00000000..a384d047
--- /dev/null
+++ b/examples/seek_mp3.rs
@@ -0,0 +1,18 @@
+use std::io::BufReader;
+use std::time::Duration;
+
+fn main() {
+    let (_stream, handle) = rodio::OutputStream::try_default().unwrap();
+    let sink = rodio::Sink::try_new(&handle).unwrap();
+
+    let file = std::fs::File::open("assets/music.mp3").unwrap();
+    sink.append(rodio::Decoder::new(BufReader::new(file)).unwrap());
+
+    std::thread::sleep(std::time::Duration::from_secs(2));
+    sink.try_seek(Duration::from_secs(0)).unwrap();
+
+    std::thread::sleep(std::time::Duration::from_secs(2));
+    sink.try_seek(Duration::from_secs(4)).unwrap();
+
+    sink.sleep_until_end();
+}
diff --git a/src/buffer.rs b/src/buffer.rs
index 916de48b..46d24f06 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -11,13 +11,14 @@
 //!
 
 use std::time::Duration;
-use std::vec::IntoIter as VecIntoIter;
 
+use crate::source::SeekError;
 use crate::{Sample, Source};
 
 /// A buffer of samples treated as a source.
 pub struct SamplesBuffer<S> {
-    data: VecIntoIter<S>,
+    data: Vec<S>,
+    pos: usize,
     channels: u16,
     sample_rate: u32,
     duration: Duration,
@@ -53,7 +54,8 @@ where
         );
 
         SamplesBuffer {
-            data: data.into_iter(),
+            data,
+            pos: 0,
             channels,
             sample_rate,
             duration,
@@ -84,6 +86,27 @@ where
     fn total_duration(&self) -> Option<Duration> {
         Some(self.duration)
     }
+
+    // this is fast because all the samples are in memory already
+    // and due to the constant sample_rate we can jump to the right
+    // sample directly
+    //
+    /// This jumps in memory till the sample for `pos`.
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        let curr_channel = self.pos % self.channels() as usize;
+        let new_pos = pos.as_secs_f32() * self.sample_rate() as f32 * self.channels() as f32;
+        // saturate pos at the end of the source
+        let new_pos = new_pos as usize;
+        let new_pos = new_pos.min(self.data.len());
+
+        // make sure the next sample is for the right channel
+        let new_pos = new_pos.next_multiple_of(self.channels() as usize);
+        let new_pos = new_pos - curr_channel;
+
+        self.pos = new_pos;
+        Ok(())
+    }
 }
 
 impl<S> Iterator for SamplesBuffer<S>
@@ -94,12 +117,14 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<S> {
-        self.data.next()
+        let sample = self.data.get(self.pos)?;
+        self.pos += 1;
+        Some(*sample)
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        self.data.size_hint()
+        (self.data.len(), Some(self.data.len()))
     }
 }
 
@@ -144,4 +169,32 @@ mod tests {
         assert_eq!(buf.next(), Some(6));
         assert_eq!(buf.next(), None);
     }
+
+    #[cfg(test)]
+    mod try_seek {
+        use super::*;
+        use std::time::Duration;
+
+        #[test]
+        fn channel_order_stays_correct() {
+            const SAMPLE_RATE: u32 = 100;
+            const CHANNELS: u16 = 2;
+            let mut buf = SamplesBuffer::new(
+                CHANNELS,
+                SAMPLE_RATE,
+                (0..2000i16).into_iter().collect::<Vec<_>>(),
+            );
+            buf.try_seek(Duration::from_secs(5)).unwrap();
+            assert_eq!(
+                buf.next(),
+                Some(5i16 * SAMPLE_RATE as i16 * CHANNELS as i16)
+            );
+
+            assert!(buf.next().is_some_and(|s| s % 2 == 1));
+            assert!(buf.next().is_some_and(|s| s % 2 == 0));
+
+            buf.try_seek(Duration::from_secs(6)).unwrap();
+            assert!(buf.next().is_some_and(|s| s % 2 == 1),);
+        }
+    }
 }
diff --git a/src/conversions/channels.rs b/src/conversions/channels.rs
index 6b472e98..ddc12868 100644
--- a/src/conversions/channels.rs
+++ b/src/conversions/channels.rs
@@ -46,6 +46,12 @@ where
     pub fn into_inner(self) -> I {
         self.input
     }
+
+    /// Get mutable access to the iterator
+    #[inline]
+    pub fn inner_mut(&mut self) -> &mut I {
+        &mut self.input
+    }
 }
 
 impl<I> Iterator for ChannelCountConverter<I>
diff --git a/src/conversions/sample.rs b/src/conversions/sample.rs
index ad11d12d..7ee97624 100644
--- a/src/conversions/sample.rs
+++ b/src/conversions/sample.rs
@@ -23,6 +23,12 @@ impl<I, O> DataConverter<I, O> {
     pub fn into_inner(self) -> I {
         self.input
     }
+
+    /// get mutable access to the iterator
+    #[inline]
+    pub fn inner_mut(&mut self) -> &mut I {
+        &mut self.input
+    }
 }
 
 impl<I, O> Iterator for DataConverter<I, O>
diff --git a/src/conversions/sample_rate.rs b/src/conversions/sample_rate.rs
index 21e11e57..36aa5a5a 100644
--- a/src/conversions/sample_rate.rs
+++ b/src/conversions/sample_rate.rs
@@ -102,6 +102,12 @@ where
         self.input
     }
 
+    /// get mutable access to the iterator
+    #[inline]
+    pub fn inner_mut(&mut self) -> &mut I {
+        &mut self.input
+    }
+
     fn next_input_frame(&mut self) {
         self.current_frame_pos_in_chunk += 1;
 
diff --git a/src/decoder/flac.rs b/src/decoder/flac.rs
index 3d789f4b..9dbc0c43 100644
--- a/src/decoder/flac.rs
+++ b/src/decoder/flac.rs
@@ -3,6 +3,7 @@ use std::io::{Read, Seek, SeekFrom};
 use std::mem;
 use std::time::Duration;
 
+use crate::source::SeekError;
 use crate::Source;
 
 use claxon::FlacReader;
@@ -79,6 +80,13 @@ where
         self.samples
             .map(|s| Duration::from_micros(s * 1_000_000 / self.sample_rate as u64))
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
 
 impl<R> Iterator for FlacDecoder<R>
diff --git a/src/decoder/mod.rs b/src/decoder/mod.rs
index f887ce78..56230d08 100644
--- a/src/decoder/mod.rs
+++ b/src/decoder/mod.rs
@@ -8,6 +8,7 @@ use std::mem;
 use std::str::FromStr;
 use std::time::Duration;
 
+use crate::source::SeekError;
 use crate::Source;
 
 #[cfg(feature = "symphonia")]
@@ -22,7 +23,7 @@ mod mp3;
 #[cfg(feature = "symphonia")]
 mod read_seek_source;
 #[cfg(feature = "symphonia")]
-mod symphonia;
+pub mod symphonia;
 #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
 mod vorbis;
 #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
@@ -59,6 +60,129 @@ where
     None(::std::marker::PhantomData<R>),
 }
 
+impl<R: Read + Seek> DecoderImpl<R> {
+    #[inline]
+    fn next(&mut self) -> Option<i16> {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.next(),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.next(),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.next(),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.next(),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.next(),
+            DecoderImpl::None(_) => None,
+        }
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.size_hint(),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.size_hint(),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.size_hint(),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.size_hint(),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.size_hint(),
+            DecoderImpl::None(_) => (0, None),
+        }
+    }
+
+    #[inline]
+    fn current_frame_len(&self) -> Option<usize> {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.current_frame_len(),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.current_frame_len(),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.current_frame_len(),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.current_frame_len(),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.current_frame_len(),
+            DecoderImpl::None(_) => Some(0),
+        }
+    }
+
+    #[inline]
+    fn channels(&self) -> u16 {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.channels(),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.channels(),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.channels(),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.channels(),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.channels(),
+            DecoderImpl::None(_) => 0,
+        }
+    }
+
+    #[inline]
+    fn sample_rate(&self) -> u32 {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.sample_rate(),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.sample_rate(),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.sample_rate(),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.sample_rate(),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.sample_rate(),
+            DecoderImpl::None(_) => 1,
+        }
+    }
+
+    #[inline]
+    fn total_duration(&self) -> Option<Duration> {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.total_duration(),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.total_duration(),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.total_duration(),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.total_duration(),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.total_duration(),
+            DecoderImpl::None(_) => Some(Duration::default()),
+        }
+    }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        match self {
+            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
+            DecoderImpl::Wav(source) => source.try_seek(pos),
+            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
+            DecoderImpl::Vorbis(source) => source.try_seek(pos),
+            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
+            DecoderImpl::Flac(source) => source.try_seek(pos),
+            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
+            DecoderImpl::Mp3(source) => source.try_seek(pos),
+            #[cfg(feature = "symphonia")]
+            DecoderImpl::Symphonia(source) => source.try_seek(pos),
+            DecoderImpl::None(_) => Err(SeekError::NotSupported {
+                underlying_source: "DecoderImpl::None",
+            }),
+        }
+    }
+}
+
 impl<R> Decoder<R>
 where
     R: Read + Seek + Send + Sync + 'static,
@@ -265,36 +389,12 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<i16> {
-        match &mut self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.next(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.next(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.next(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.next(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.next(),
-            DecoderImpl::None(_) => None,
-        }
+        self.0.next()
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.size_hint(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.size_hint(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.size_hint(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.size_hint(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.size_hint(),
-            DecoderImpl::None(_) => (0, None),
-        }
+        self.0.size_hint()
     }
 }
 
@@ -304,70 +404,26 @@ where
 {
     #[inline]
     fn current_frame_len(&self) -> Option<usize> {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.current_frame_len(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.current_frame_len(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.current_frame_len(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.current_frame_len(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.current_frame_len(),
-            DecoderImpl::None(_) => Some(0),
-        }
+        self.0.current_frame_len()
     }
 
     #[inline]
     fn channels(&self) -> u16 {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.channels(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.channels(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.channels(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.channels(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.channels(),
-            DecoderImpl::None(_) => 0,
-        }
+        self.0.channels()
     }
 
-    #[inline]
     fn sample_rate(&self) -> u32 {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.sample_rate(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.sample_rate(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.sample_rate(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.sample_rate(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.sample_rate(),
-            DecoderImpl::None(_) => 1,
-        }
+        self.0.sample_rate()
     }
 
     #[inline]
     fn total_duration(&self) -> Option<Duration> {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.total_duration(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.total_duration(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.total_duration(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.total_duration(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.total_duration(),
-            DecoderImpl::None(_) => Some(Duration::default()),
-        }
+        self.0.total_duration()
+    }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.0.try_seek(pos)
     }
 }
 
@@ -379,19 +435,7 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<i16> {
-        if let Some(sample) = match &mut self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.next(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.next(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.next(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.next(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.next(),
-            DecoderImpl::None(_) => None,
-        } {
+        if let Some(sample) = self.0.next() {
             Some(sample)
         } else {
             let decoder = mem::replace(&mut self.0, DecoderImpl::None(Default::default()));
@@ -448,19 +492,7 @@ where
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => (source.size_hint().0, None),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => (source.size_hint().0, None),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => (source.size_hint().0, None),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => (source.size_hint().0, None),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => (source.size_hint().0, None),
-            DecoderImpl::None(_) => (0, None),
-        }
+        self.0.size_hint()
     }
 }
 
@@ -470,59 +502,27 @@ where
 {
     #[inline]
     fn current_frame_len(&self) -> Option<usize> {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.current_frame_len(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.current_frame_len(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.current_frame_len(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.current_frame_len(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.current_frame_len(),
-            DecoderImpl::None(_) => Some(0),
-        }
+        self.0.current_frame_len()
     }
 
     #[inline]
     fn channels(&self) -> u16 {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.channels(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.channels(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.channels(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.channels(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.channels(),
-            DecoderImpl::None(_) => 0,
-        }
+        self.0.channels()
     }
 
     #[inline]
     fn sample_rate(&self) -> u32 {
-        match &self.0 {
-            #[cfg(all(feature = "wav", not(feature = "symphonia-wav")))]
-            DecoderImpl::Wav(source) => source.sample_rate(),
-            #[cfg(all(feature = "vorbis", not(feature = "symphonia-vorbis")))]
-            DecoderImpl::Vorbis(source) => source.sample_rate(),
-            #[cfg(all(feature = "flac", not(feature = "symphonia-flac")))]
-            DecoderImpl::Flac(source) => source.sample_rate(),
-            #[cfg(all(feature = "minimp3", not(feature = "symphonia-mp3")))]
-            DecoderImpl::Mp3(source) => source.sample_rate(),
-            #[cfg(feature = "symphonia")]
-            DecoderImpl::Symphonia(source) => source.sample_rate(),
-            DecoderImpl::None(_) => 1,
-        }
+        self.0.sample_rate()
     }
 
     #[inline]
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.0.try_seek(pos)
+    }
 }
 
 /// Error that can happen when creating a decoder.
diff --git a/src/decoder/mp3.rs b/src/decoder/mp3.rs
index b40118cc..de53f61a 100644
--- a/src/decoder/mp3.rs
+++ b/src/decoder/mp3.rs
@@ -1,14 +1,18 @@
 use std::io::{Read, Seek, SeekFrom};
 use std::time::Duration;
 
+use crate::source::SeekError;
 use crate::Source;
 
-use minimp3_fixed::{Decoder, Frame};
+use minimp3::Decoder;
+use minimp3::Frame;
+use minimp3_fixed as minimp3;
 
 pub struct Mp3Decoder<R>
 where
     R: Read + Seek,
 {
+    // decoder: SeekDecoder<R>,
     decoder: Decoder<R>,
     current_frame: Frame,
     current_frame_offset: usize,
@@ -22,8 +26,16 @@ where
         if !is_mp3(data.by_ref()) {
             return Err(data);
         }
+        // let mut decoder = SeekDecoder::new(data)
         let mut decoder = Decoder::new(data);
-        let current_frame = decoder.next_frame().unwrap();
+        // parameters are correct and minimp3 is used correctly
+        // thus if we crash here one of these invariants is broken:
+        // .expect("should be able to allocate memory, perform IO");
+        // let current_frame = decoder.decode_frame()
+        let current_frame = decoder.next_frame()
+            // the reader makes enough data available therefore 
+            // if we crash here the invariant broken is:
+            .expect("data should not corrupt");
 
         Ok(Mp3Decoder {
             decoder,
@@ -59,6 +71,20 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        // TODO waiting for PR in minimp3_fixed or minimp3
+
+        // let pos = (pos.as_secs_f32() * self.sample_rate() as f32) as u64;
+        // // do not trigger a sample_rate, channels and frame len update
+        // // as the seek only takes effect after the current frame is done
+        // self.decoder.seek_samples(pos)?;
+        // Ok(())
+
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
 
 impl<R> Iterator for Mp3Decoder<R>
@@ -67,14 +93,15 @@ where
 {
     type Item = i16;
 
-    #[inline]
     fn next(&mut self) -> Option<i16> {
-        if self.current_frame_offset == self.current_frame.data.len() {
-            match self.decoder.next_frame() {
-                Ok(frame) => self.current_frame = frame,
-                _ => return None,
+        if self.current_frame_offset == self.current_frame_len().unwrap() {
+            if let Ok(frame) = self.decoder.next_frame() {
+                // if let Ok(frame) = self.decoder.decode_frame() {
+                self.current_frame = frame;
+                self.current_frame_offset = 0;
+            } else {
+                return None;
             }
-            self.current_frame_offset = 0;
         }
 
         let v = self.current_frame.data[self.current_frame_offset];
diff --git a/src/decoder/symphonia.rs b/src/decoder/symphonia.rs
index dde0f819..b3e5b215 100644
--- a/src/decoder/symphonia.rs
+++ b/src/decoder/symphonia.rs
@@ -4,34 +4,38 @@ use symphonia::{
         audio::{AudioBufferRef, SampleBuffer, SignalSpec},
         codecs::{Decoder, DecoderOptions},
         errors::Error,
-        formats::{FormatOptions, FormatReader},
+        formats::{FormatOptions, FormatReader, SeekedTo},
         io::MediaSourceStream,
         meta::MetadataOptions,
         probe::Hint,
-        units,
+        units::{self, Time},
     },
     default::get_probe,
 };
 
-use crate::Source;
+use crate::{source, Source};
 
 use super::DecoderError;
 
 // Decoder errors are not considered fatal.
 // The correct action is to just get a new packet and try again.
 // But a decode error in more than 3 consecutive packets is fatal.
-const MAX_DECODE_ERRORS: usize = 3;
+const MAX_DECODE_RETRIES: usize = 3;
 
-pub struct SymphoniaDecoder {
+pub(crate) struct SymphoniaDecoder {
     decoder: Box<dyn Decoder>,
     current_frame_offset: usize,
     format: Box<dyn FormatReader>,
+    total_duration: Option<Time>,
     buffer: SampleBuffer<i16>,
     spec: SignalSpec,
 }
 
 impl SymphoniaDecoder {
-    pub fn new(mss: MediaSourceStream, extension: Option<&str>) -> Result<Self, DecoderError> {
+    pub(crate) fn new(
+        mss: MediaSourceStream,
+        extension: Option<&str>,
+    ) -> Result<Self, DecoderError> {
         match SymphoniaDecoder::init(mss, extension) {
             Err(e) => match e {
                 Error::IoError(e) => Err(DecoderError::IoError(e.to_string())),
@@ -48,7 +52,7 @@ impl SymphoniaDecoder {
         }
     }
 
-    pub fn into_inner(self) -> MediaSourceStream {
+    pub(crate) fn into_inner(self) -> MediaSourceStream {
         self.format.into_inner()
     }
 
@@ -74,6 +78,11 @@ impl SymphoniaDecoder {
 
         let mut decoder = symphonia::default::get_codecs()
             .make(&stream.codec_params, &DecoderOptions { verify: true })?;
+        let total_duration = stream
+            .codec_params
+            .time_base
+            .zip(stream.codec_params.n_frames)
+            .map(|(base, frames)| base.calc_time(frames));
 
         let mut decode_errors: usize = 0;
         let decoded = loop {
@@ -83,7 +92,7 @@ impl SymphoniaDecoder {
                 Err(e) => match e {
                     Error::DecodeError(_) => {
                         decode_errors += 1;
-                        if decode_errors > MAX_DECODE_ERRORS {
+                        if decode_errors > MAX_DECODE_RETRIES {
                             return Err(e);
                         } else {
                             continue;
@@ -99,6 +108,7 @@ impl SymphoniaDecoder {
             decoder,
             current_frame_offset: 0,
             format: probed.format,
+            total_duration,
             buffer,
             spec,
         }))
@@ -131,36 +141,115 @@ impl Source for SymphoniaDecoder {
 
     #[inline]
     fn total_duration(&self) -> Option<Duration> {
-        None
+        self.total_duration
+            .map(|Time { seconds, frac }| Duration::new(seconds, (1f64 / frac) as u32))
+    }
+
+    fn try_seek(&mut self, pos: Duration) -> Result<(), source::SeekError> {
+        use symphonia::core::formats::{SeekMode, SeekTo};
+
+        let seek_beyond_end = self
+            .total_duration()
+            .is_some_and(|dur| dur.saturating_sub(pos).as_millis() < 1);
+
+        let time = if seek_beyond_end {
+            let time = self.total_duration.expect("if guarantees this is Some");
+            skip_back_a_tiny_bit(time) // some decoders can only seek to just before the end
+        } else {
+            pos.as_secs_f64().into()
+        };
+
+        // make sure the next sample is for the right channel
+        let to_skip = self.current_frame_offset % self.channels() as usize;
+
+        let seek_res = self
+            .format
+            .seek(
+                SeekMode::Accurate,
+                SeekTo::Time {
+                    time,
+                    track_id: None,
+                },
+            )
+            .map_err(SeekError::BaseSeek)?;
+
+        self.refine_position(seek_res)?;
+        self.current_frame_offset += to_skip;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum SeekError {
+    #[error("Could not get next packet while refining seek position: {0:?}")]
+    Refining(symphonia::core::errors::Error),
+    #[error("Format reader failed to seek: {0:?}")]
+    BaseSeek(symphonia::core::errors::Error),
+    #[error("Decoding failed retrying on the next packet failed: {0:?}")]
+    Retrying(symphonia::core::errors::Error),
+    #[error("Decoding failed on multiple consecutive packets: {0:?}")]
+    Decoding(symphonia::core::errors::Error),
+}
+
+impl SymphoniaDecoder {
+    /// note frame offset must be set after
+    fn refine_position(&mut self, seek_res: SeekedTo) -> Result<(), source::SeekError> {
+        let mut samples_to_pass = seek_res.required_ts - seek_res.actual_ts;
+        let packet = loop {
+            let candidate = self.format.next_packet().map_err(SeekError::Refining)?;
+            if candidate.dur() > samples_to_pass {
+                break candidate;
+            } else {
+                samples_to_pass -= candidate.dur();
+            }
+        };
+
+        let mut decoded = self.decoder.decode(&packet);
+        for _ in 0..MAX_DECODE_RETRIES {
+            if decoded.is_err() {
+                let packet = self.format.next_packet().map_err(SeekError::Retrying)?;
+                decoded = self.decoder.decode(&packet);
+            }
+        }
+
+        let decoded = decoded.map_err(SeekError::Decoding)?;
+        self.spec = decoded.spec().to_owned();
+        self.buffer = SymphoniaDecoder::get_buffer(decoded, &self.spec);
+        self.current_frame_offset = samples_to_pass as usize * self.channels() as usize;
+        Ok(())
     }
 }
 
+fn skip_back_a_tiny_bit(
+    Time {
+        mut seconds,
+        mut frac,
+    }: Time,
+) -> Time {
+    frac -= 0.0001;
+    if frac < 0.0 {
+        seconds = seconds.saturating_sub(1);
+        frac = 1.0 - frac;
+    }
+    Time { seconds, frac }
+}
+
 impl Iterator for SymphoniaDecoder {
     type Item = i16;
 
     #[inline]
     fn next(&mut self) -> Option<i16> {
-        if self.current_frame_offset == self.buffer.len() {
-            let mut decode_errors: usize = 0;
-            let decoded = loop {
-                match self.format.next_packet() {
-                    Ok(packet) => match self.decoder.decode(&packet) {
-                        Ok(decoded) => break decoded,
-                        Err(e) => match e {
-                            Error::DecodeError(_) => {
-                                decode_errors += 1;
-                                if decode_errors > MAX_DECODE_ERRORS {
-                                    return None;
-                                } else {
-                                    continue;
-                                }
-                            }
-                            _ => return None,
-                        },
-                    },
-                    Err(_) => return None,
+        if self.current_frame_offset >= self.buffer.len() {
+            let packet = self.format.next_packet().ok()?;
+            let mut decoded = self.decoder.decode(&packet);
+            for _ in 0..MAX_DECODE_RETRIES {
+                if decoded.is_err() {
+                    let packet = self.format.next_packet().ok()?;
+                    decoded = self.decoder.decode(&packet);
                 }
-            };
+            }
+            let decoded = decoded.ok()?;
             self.spec = decoded.spec().to_owned();
             self.buffer = SymphoniaDecoder::get_buffer(decoded, &self.spec);
             self.current_frame_offset = 0;
diff --git a/src/decoder/vorbis.rs b/src/decoder/vorbis.rs
index a02cbc0c..a620c221 100644
--- a/src/decoder/vorbis.rs
+++ b/src/decoder/vorbis.rs
@@ -1,7 +1,7 @@
 use std::io::{Read, Seek, SeekFrom};
 use std::time::Duration;
-use std::vec;
 
+use crate::source::SeekError;
 use crate::Source;
 
 use lewton::inside_ogg::OggStreamReader;
@@ -12,7 +12,8 @@ where
     R: Read + Seek,
 {
     stream_reader: OggStreamReader<R>,
-    current_data: vec::IntoIter<i16>,
+    current_data: Vec<i16>,
+    next: usize,
 }
 
 impl<R> VorbisDecoder<R>
@@ -42,7 +43,8 @@ where
 
         VorbisDecoder {
             stream_reader,
-            current_data: data.into_iter(),
+            current_data: data,
+            next: 0,
         }
     }
     pub fn into_inner(self) -> OggStreamReader<R> {
@@ -73,6 +75,22 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    /// seek is broken, https://github.com/RustAudio/lewton/issues/73.
+    // We could work around it by:
+    //  - using unsafe to create an instance of Self
+    //  - use mem::swap to turn the &mut self into a mut self
+    //  - take out the underlying Read+Seek
+    //  - make a new self and seek
+    //
+    // If this issue is fixed use the implementation in
+    // commit: 3bafe32388b4eb7a48c6701e6c65044dc8c555e6
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
 
 impl<R> Iterator for VorbisDecoder<R>
@@ -83,24 +101,29 @@ where
 
     #[inline]
     fn next(&mut self) -> Option<i16> {
-        if let Some(sample) = self.current_data.next() {
-            if self.current_data.len() == 0 {
+        if let Some(sample) = self.current_data.get(self.next).copied() {
+            self.next += 1;
+            if self.current_data.is_empty() {
                 if let Ok(Some(data)) = self.stream_reader.read_dec_packet_itl() {
-                    self.current_data = data.into_iter();
+                    self.current_data = data;
+                    self.next = 0;
                 }
             }
             Some(sample)
         } else {
             if let Ok(Some(data)) = self.stream_reader.read_dec_packet_itl() {
-                self.current_data = data.into_iter();
+                self.current_data = data;
+                self.next = 0;
             }
-            self.current_data.next()
+            let sample = self.current_data.get(self.next).copied();
+            self.next += 1;
+            sample
         }
     }
 
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.current_data.size_hint().0, None)
+        (self.current_data.len(), None)
     }
 }
 
diff --git a/src/decoder/wav.rs b/src/decoder/wav.rs
index 5b5c4267..5fac5039 100644
--- a/src/decoder/wav.rs
+++ b/src/decoder/wav.rs
@@ -1,6 +1,7 @@
 use std::io::{Read, Seek, SeekFrom};
 use std::time::Duration;
 
+use crate::source::SeekError;
 use crate::Source;
 
 use hound::{SampleFormat, WavReader};
@@ -56,7 +57,7 @@ where
     R: Read + Seek,
 {
     reader: WavReader<R>,
-    samples_read: u32,
+    samples_read: u32, // wav header is u32 so this suffices
 }
 
 impl<R> Iterator for SamplesIterator<R>
@@ -128,6 +129,30 @@ where
     fn total_duration(&self) -> Option<Duration> {
         Some(self.total_duration)
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        let file_len = self.reader.reader.duration();
+
+        let new_pos = pos.as_secs_f32() * self.sample_rate() as f32;
+        let new_pos = new_pos as u32;
+        let new_pos = new_pos.min(file_len); // saturate pos at the end of the source
+
+        // make sure the next sample is for the right channel
+        let to_skip = self.reader.samples_read % self.channels() as u32;
+
+        self.reader
+            .reader
+            .seek(new_pos)
+            .map_err(SeekError::HoundDecoder)?;
+        self.reader.samples_read = new_pos * self.channels() as u32;
+
+        for _ in 0..to_skip {
+            self.next();
+        }
+
+        Ok(())
+    }
 }
 
 impl<R> Iterator for WavDecoder<R>
diff --git a/src/dynamic_mixer.rs b/src/dynamic_mixer.rs
index 045aed8e..c2abd1c7 100644
--- a/src/dynamic_mixer.rs
+++ b/src/dynamic_mixer.rs
@@ -4,7 +4,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use crate::source::{Source, UniformSourceIterator};
+use crate::source::{SeekError, Source, UniformSourceIterator};
 use crate::Sample;
 
 /// Builds a new mixer.
@@ -106,6 +106,42 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+
+        // uncomment when #510 is implemented (query position of playback)
+
+        // let mut org_positions = Vec::with_capacity(self.current_sources.len());
+        // let mut encounterd_err = None;
+        //
+        // for source in &mut self.current_sources {
+        //     let pos = /* source.playback_pos() */ todo!();
+        //     if let Err(e) = source.try_seek(pos) {
+        //         encounterd_err = Some(e);
+        //         break;
+        //     } else {
+        //         // store pos in case we need to roll back
+        //         org_positions.push(pos);
+        //     }
+        // }
+        //
+        // if let Some(e) = encounterd_err {
+        //     // rollback seeks that happend before err
+        //     for (pos, source) in org_positions
+        //         .into_iter()
+        //         .zip(self.current_sources.iter_mut())
+        //     {
+        //         source.try_seek(pos)?;
+        //     }
+        //     Err(e)
+        // } else {
+        //     Ok(())
+        // }
+    }
 }
 
 impl<S> Iterator for DynamicMixer<S>
diff --git a/src/queue.rs b/src/queue.rs
index b50ce939..c06b3672 100644
--- a/src/queue.rs
+++ b/src/queue.rs
@@ -4,7 +4,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use crate::source::{Empty, Source, Zero};
+use crate::source::{Empty, SeekError, Source, Zero};
 use crate::Sample;
 
 #[cfg(feature = "crossbeam-channel")]
@@ -172,6 +172,20 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    /// Only seeks within the current source.
+    // We can not go back to previous sources. We could implement seek such
+    // that it advances the queue if the position is beyond the current song.
+    //
+    // We would then however need to enable seeking backwards across sources too.
+    // That no longer seems in line with the queue behaviour.
+    //
+    // A final pain point is that we would need the total duration for the
+    // next few songs.
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.current.try_seek(pos)
+    }
 }
 
 impl<S> Iterator for SourcesQueueOutput<S>
diff --git a/src/sink.rs b/src/sink.rs
index b808e3de..056b8e65 100644
--- a/src/sink.rs
+++ b/src/sink.rs
@@ -3,10 +3,11 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 #[cfg(feature = "crossbeam-channel")]
-use crossbeam_channel::Receiver;
+use crossbeam_channel::{Receiver, Sender};
 #[cfg(not(feature = "crossbeam-channel"))]
-use std::sync::mpsc::Receiver;
+use std::sync::mpsc::{Receiver, Sender};
 
+use crate::source::SeekError;
 use crate::stream::{OutputStreamHandle, PlayError};
 use crate::{queue, source::Done, Sample, Source};
 use cpal::FromSample;
@@ -25,12 +26,44 @@ pub struct Sink {
     detached: bool,
 }
 
+struct SeekOrder {
+    pos: Duration,
+    feedback: Sender<Result<(), SeekError>>,
+}
+
+impl SeekOrder {
+    fn new(pos: Duration) -> (Self, Receiver<Result<(), SeekError>>) {
+        #[cfg(not(feature = "crossbeam-channel"))]
+        let (tx, rx) = {
+            use std::sync::mpsc;
+            mpsc::channel()
+        };
+
+        #[cfg(feature = "crossbeam-channel")]
+        let (tx, rx) = {
+            use crossbeam_channel::bounded;
+            bounded(1)
+        };
+        (Self { pos, feedback: tx }, rx)
+    }
+
+    fn attempt<S>(self, maybe_seekable: &mut S)
+    where
+        S: Source,
+        S::Item: Sample + Send,
+    {
+        let res = maybe_seekable.try_seek(self.pos);
+        let _ignore_reciever_dropped = self.feedback.send(res);
+    }
+}
+
 struct Controls {
     pause: AtomicBool,
     volume: Mutex<f32>,
     stopped: AtomicBool,
     speed: Mutex<f32>,
     to_clear: Mutex<u32>,
+    seek: Mutex<Option<SeekOrder>>,
 }
 
 impl Sink {
@@ -56,6 +89,7 @@ impl Sink {
                 stopped: AtomicBool::new(false),
                 speed: Mutex::new(1.0),
                 to_clear: Mutex::new(0),
+                seek: Mutex::new(None),
             }),
             sound_count: Arc::new(AtomicUsize::new(0)),
             detached: false,
@@ -89,6 +123,7 @@ impl Sink {
             .amplify(1.0)
             .skippable()
             .stoppable()
+            // if you change the duration update the docs for try_seek!
             .periodic_access(Duration::from_millis(5), move |src| {
                 if controls.stopped.load(Ordering::SeqCst) {
                     src.stop();
@@ -107,6 +142,9 @@ impl Sink {
                 amp.inner_mut()
                     .inner_mut()
                     .set_factor(*controls.speed.lock().unwrap());
+                if let Some(seek) = controls.seek.lock().unwrap().take() {
+                    seek.attempt(amp)
+                }
                 start_played.store(true, Ordering::SeqCst);
             })
             .convert_samples();
@@ -159,6 +197,40 @@ impl Sink {
         self.controls.pause.store(false, Ordering::SeqCst);
     }
 
+    // There is no `can_seek()` method as it is impossible to use correctly. Between
+    // checking if a source supports seeking and actually seeking the sink can
+    // switch to a new source.
+
+    /// Attempts to seek to a given position in the current source.
+    ///
+    /// This blocks between 0 and ~5 milliseconds.
+    ///
+    /// As long as the duration of the source is known, seek is guaranteed to saturate
+    /// at the end of the source. For example given a source that reports a total duration
+    /// of 42 seconds calling `try_seek()` with 60 seconds as argument will seek to
+    /// 42 seconds.
+    ///
+    /// # Errors
+    /// This function will return [`SeekError::NotSupported`] if one of the underlying
+    /// sources does not support seeking.  
+    ///
+    /// It will return an error if an implementation ran
+    /// into one during the seek.  
+    ///
+    /// When seeking beyond the end of a source this
+    /// function might return an error if the duration of the source is not known.
+    pub fn try_seek(&self, pos: Duration) -> Result<(), SeekError> {
+        let (order, feedback) = SeekOrder::new(pos);
+        *self.controls.seek.lock().unwrap() = Some(order);
+        match feedback.recv() {
+            Ok(seek_res) => seek_res,
+            // The feedback channel closed. Probably another seekorder was set
+            // invalidating this one and closing the feedback channel
+            // ... or the audio thread panicked.
+            Err(_) => Ok(()),
+        }
+    }
+
     /// Pauses playback of this sink.
     ///
     /// No effect if already paused.
diff --git a/src/source/amplify.rs b/src/source/amplify.rs
index 4f57a282..42e6955c 100644
--- a/src/source/amplify.rs
+++ b/src/source/amplify.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `Amplify` object.
 pub fn amplify<I>(input: I, factor: f32) -> Amplify<I>
 where
@@ -93,4 +95,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/blt.rs b/src/source/blt.rs
index fe1c2f3c..853b6974 100644
--- a/src/source/blt.rs
+++ b/src/source/blt.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 
 use crate::Source;
 
+use super::SeekError;
+
 // Implemented following http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt
 
 /// Internal function that builds a `BltFilter` object.
@@ -173,6 +175,11 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
 
 #[derive(Clone, Debug)]
diff --git a/src/source/buffered.rs b/src/source/buffered.rs
index 6bd8b4e2..16c03128 100644
--- a/src/source/buffered.rs
+++ b/src/source/buffered.rs
@@ -5,6 +5,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `Buffered` object.
 #[inline]
 pub fn buffered<I>(input: I) -> Buffered<I>
@@ -239,6 +241,15 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.total_duration
     }
+
+    /// Can not support seek, in the end state we lose the underlying source
+    /// which makes seeking back impossible.
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
 
 impl<I> Clone for Buffered<I>
diff --git a/src/source/channel_volume.rs b/src/source/channel_volume.rs
index 69dc869e..87ee9919 100644
--- a/src/source/channel_volume.rs
+++ b/src/source/channel_volume.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Combines channels in input into a single mono source, then plays that mono sound
 /// to each channel at the volume given for that channel.
 #[derive(Clone, Debug)]
@@ -138,4 +140,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/delay.rs b/src/source/delay.rs
index 5233f3e3..c79c7e70 100644
--- a/src/source/delay.rs
+++ b/src/source/delay.rs
@@ -2,19 +2,24 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
+fn remaining_samples(until_playback: Duration, sample_rate: u32, channels: u16) -> usize {
+    let ns = until_playback.as_secs() * 1_000_000_000 + until_playback.subsec_nanos() as u64;
+    let samples = ns * channels as u64 * sample_rate as u64 / 1_000_000_000;
+    samples as usize
+}
+
 /// Internal function that builds a `Delay` object.
 pub fn delay<I>(input: I, duration: Duration) -> Delay<I>
 where
     I: Source,
     I::Item: Sample,
 {
-    let duration_ns = duration.as_secs() * 1000000000 + duration.subsec_nanos() as u64;
-    let samples = duration_ns * input.sample_rate() as u64 / 1000000000 * input.channels() as u64;
-
     Delay {
-        input,
-        remaining_samples: samples as usize,
+        remaining_samples: remaining_samples(duration, input.sample_rate(), input.channels()),
         requested_duration: duration,
+        input,
     }
 }
 
@@ -105,4 +110,29 @@ where
             .total_duration()
             .map(|val| val + self.requested_duration)
     }
+
+    /// Pos is seen from the perspective of the api user.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// use std::time::Duration;
+    ///
+    /// let mut source = inner_source.delay(Duration::from_secs(10));
+    /// source.try_seek(Duration::from_secs(15));
+    ///
+    /// // inner_source is now at pos: Duration::from_secs(5);
+    /// ```
+    ///
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        if pos < self.requested_duration {
+            self.input.try_seek(Duration::ZERO)?;
+            let until_playback = self.requested_duration - pos;
+            self.remaining_samples =
+                remaining_samples(until_playback, self.sample_rate(), self.channels());
+        }
+        let compensated_for_delay = pos.saturating_sub(self.requested_duration);
+        self.input.try_seek(compensated_for_delay)
+    }
 }
diff --git a/src/source/done.rs b/src/source/done.rs
index c1fd76ca..dc6d6760 100644
--- a/src/source/done.rs
+++ b/src/source/done.rs
@@ -4,6 +4,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// When the inner source is empty this decrements an `AtomicUsize`.
 #[derive(Debug, Clone)]
 pub struct Done<I> {
@@ -87,4 +89,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/empty.rs b/src/source/empty.rs
index d4c808b1..3c8f4722 100644
--- a/src/source/empty.rs
+++ b/src/source/empty.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// An empty source.
 #[derive(Debug, Copy, Clone)]
 pub struct Empty<S>(PhantomData<S>);
@@ -53,4 +55,11 @@ where
     fn total_duration(&self) -> Option<Duration> {
         Some(Duration::new(0, 0))
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
diff --git a/src/source/empty_callback.rs b/src/source/empty_callback.rs
index 163f3bea..1752c366 100644
--- a/src/source/empty_callback.rs
+++ b/src/source/empty_callback.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// An empty source which executes a callback function
 pub struct EmptyCallback<S> {
     pub phantom_data: PhantomData<S>,
@@ -52,4 +54,11 @@ where
     fn total_duration(&self) -> Option<Duration> {
         Some(Duration::new(0, 0))
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
diff --git a/src/source/fadein.rs b/src/source/fadein.rs
index 25d83d24..68cf4298 100644
--- a/src/source/fadein.rs
+++ b/src/source/fadein.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `FadeIn` object.
 pub fn fadein<I>(input: I, duration: Duration) -> FadeIn<I>
 where
@@ -105,4 +107,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/from_iter.rs b/src/source/from_iter.rs
index 1ea46024..45e4b23a 100644
--- a/src/source/from_iter.rs
+++ b/src/source/from_iter.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Builds a source that chains sources provided by an iterator.
 ///
 /// The `iterator` parameter is an iterator that produces a source. The source is then played.
@@ -135,6 +137,15 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        if let Some(source) = self.current_source.as_mut() {
+            source.try_seek(pos)
+        } else {
+            Ok(())
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/src/source/mix.rs b/src/source/mix.rs
index 8afb99fd..f2396546 100644
--- a/src/source/mix.rs
+++ b/src/source/mix.rs
@@ -2,6 +2,7 @@ use std::cmp;
 use std::time::Duration;
 
 use crate::source::uniform::UniformSourceIterator;
+use crate::source::SeekError;
 use crate::{Sample, Source};
 use cpal::{FromSample, Sample as CpalSample};
 
@@ -119,4 +120,25 @@ where
             _ => None,
         }
     }
+
+    /// Will only attempt a seek if both underlying sources support seek.
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+
+        // uncomment when #510 is implemented (query position of playback)
+        // TODO use source_intact to check if rollback makes sense
+
+        // let org_pos = self.input1.playback_pos();
+        // self.input1.try_seek(pos)?;
+        //
+        // let res = self.input2.try_seek(pos);
+        // if res.is_err() { // rollback seek in input1
+        //     self.input1.try_seek(org_pos)?;
+        // }
+        //
+        // res
+    }
 }
diff --git a/src/source/mod.rs b/src/source/mod.rs
index bb6ff66a..bec9a729 100644
--- a/src/source/mod.rs
+++ b/src/source/mod.rs
@@ -151,6 +151,7 @@ where
     fn total_duration(&self) -> Option<Duration>;
 
     /// Stores the source in a buffer in addition to returning it. This iterator can be cloned.
+
     #[inline]
     fn buffered(self) -> Buffered<Self>
     where
@@ -353,7 +354,7 @@ where
         blt::high_pass(self, freq)
     }
 
-    /// Applies a low-pass filter to the source while allowing the q (badnwidth) to be changed.
+    /// Applies a low-pass filter to the source while allowing the q (bandwidth) to be changed.
     #[inline]
     fn low_pass_with_q(self, freq: u32, q: f32) -> BltFilter<Self>
     where
@@ -363,7 +364,7 @@ where
         blt::low_pass_with_q(self, freq, q)
     }
 
-    /// Applies a high-pass filter to the source while allowing the q (badnwidth) to be changed.
+    /// Applies a high-pass filter to the source while allowing the q (bandwidth) to be changed.
     #[inline]
     fn high_pass_with_q(self, freq: u32, q: f32) -> BltFilter<Self>
     where
@@ -372,6 +373,61 @@ where
     {
         blt::high_pass_with_q(self, freq, q)
     }
+
+    // There is no `can_seek()` method as it is impossible to use correctly. Between
+    // checking if a source supports seeking and actually seeking the sink can
+    // switch to a new source.
+
+    /// Attempts to seek to a given position in the current source.
+    ///
+    /// As long as the duration of the source is known seek is guaranteed to saturate
+    /// at the end of the source. For example given a source that reports a total duration
+    /// of 42 seconds calling `try_seek()` with 60 seconds as argument will seek to
+    /// 42 seconds.
+    ///
+    /// # Errors
+    /// This function will return [`SeekError::NotSupported`] if one of the underlying
+    /// sources does not support seeking.
+    ///
+    /// It will return an error if an implementation ran
+    /// into one during the seek.  
+    ///
+    /// Seeking beyond the end of a source might return an error if the total duration of
+    /// the source is not known.
+    #[allow(unused_variables)]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
+}
+
+// We might add decoders requiring new error types, without non_exhaustive
+// this would break users builds
+#[non_exhaustive]
+#[derive(Debug, thiserror::Error)]
+pub enum SeekError {
+    #[error("Streaming is not supported by source: {underlying_source}")]
+    NotSupported { underlying_source: &'static str },
+    #[cfg(feature = "symphonia")]
+    #[error("Error seeking: {0}")]
+    SymphoniaDecoder(#[from] crate::decoder::symphonia::SeekError),
+    #[cfg(feature = "wav")]
+    #[error("Error seeking in wav source: {0}")]
+    HoundDecoder(std::io::Error),
+    #[error("An error occurred")]
+    Other(Box<dyn std::error::Error + Send>),
+}
+
+impl SeekError {
+    pub fn source_intact(&self) -> bool {
+        match self {
+            SeekError::NotSupported { .. } => true,
+            SeekError::SymphoniaDecoder(_) => false,
+            SeekError::HoundDecoder(_) => false,
+            SeekError::Other(_) => false,
+        }
+    }
 }
 
 macro_rules! source_pointer_impl {
@@ -396,6 +452,11 @@ macro_rules! source_pointer_impl {
             fn total_duration(&self) -> Option<Duration> {
                 (**self).total_duration()
             }
+
+            #[inline]
+            fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+                (**self).try_seek(pos)
+            }
         }
     };
 }
diff --git a/src/source/pausable.rs b/src/source/pausable.rs
index 75e102f4..c41dfc1a 100644
--- a/src/source/pausable.rs
+++ b/src/source/pausable.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `Pausable` object.
 pub fn pausable<I>(source: I, paused: bool) -> Pausable<I>
 where
@@ -115,4 +117,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/periodic.rs b/src/source/periodic.rs
index 4d718a1c..58ed89a1 100644
--- a/src/source/periodic.rs
+++ b/src/source/periodic.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `PeriodicAccess` object.
 pub fn periodic<I, F>(source: I, period: Duration, modifier: F) -> PeriodicAccess<I, F>
 where
@@ -117,6 +119,11 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
 
 #[cfg(test)]
diff --git a/src/source/repeat.rs b/src/source/repeat.rs
index c8c8695d..90b652f2 100644
--- a/src/source/repeat.rs
+++ b/src/source/repeat.rs
@@ -4,6 +4,8 @@ use crate::source::buffered::Buffered;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `Repeat` object.
 pub fn repeat<I>(input: I) -> Repeat<I>
 where
@@ -84,6 +86,11 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.inner.try_seek(pos)
+    }
 }
 
 impl<I> Clone for Repeat<I>
diff --git a/src/source/samples_converter.rs b/src/source/samples_converter.rs
index 827f071b..84beb4c8 100644
--- a/src/source/samples_converter.rs
+++ b/src/source/samples_converter.rs
@@ -4,6 +4,8 @@ use std::time::Duration;
 use crate::{Sample, Source};
 use cpal::{FromSample, Sample as CpalSample};
 
+use super::SeekError;
+
 /// An iterator that reads from a `Source` and converts the samples to a specific rate and
 /// channels count.
 ///
@@ -95,4 +97,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.inner.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.inner.try_seek(pos)
+    }
 }
diff --git a/src/source/sine.rs b/src/source/sine.rs
index cbe5a8f5..44aa48ee 100644
--- a/src/source/sine.rs
+++ b/src/source/sine.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 
 use crate::Source;
 
+use super::SeekError;
+
 /// An infinite source that produces a sine.
 ///
 /// Always has a rate of 48kHz and one channel.
@@ -55,4 +57,13 @@ impl Source for SineWave {
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        // This is a constant sound, normal seeking would not have any effect.
+        // While changing the phase of the sine wave could change how it sounds in
+        // combination with another sound (beating) such precision is not the intend
+        // of seeking
+        Ok(())
+    }
 }
diff --git a/src/source/skip.rs b/src/source/skip.rs
index b0cbec6c..06cc1bdb 100644
--- a/src/source/skip.rs
+++ b/src/source/skip.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 const NS_PER_SECOND: u128 = 1_000_000_000;
 
 /// Internal function that builds a `SkipDuration` object.
@@ -157,6 +159,11 @@ where
                 .unwrap_or_else(|| Duration::from_secs(0))
         })
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
 
 #[cfg(test)]
diff --git a/src/source/skippable.rs b/src/source/skippable.rs
index 44ee7a7d..400a4fec 100644
--- a/src/source/skippable.rs
+++ b/src/source/skippable.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 use crate::Sample;
 use crate::Source;
 
+use super::SeekError;
+
 /// Internal function that builds a `Skippable` object.
 pub fn skippable<I>(source: I) -> Skippable<I> {
     Skippable {
@@ -89,4 +91,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/spatial.rs b/src/source/spatial.rs
index e846ecd1..2976703b 100644
--- a/src/source/spatial.rs
+++ b/src/source/spatial.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 use crate::source::ChannelVolume;
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Combines channels in input into a single mono source, then plays that mono sound
 /// to each channel at the volume given for that channel.
 #[derive(Clone)]
@@ -117,4 +119,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/speed.rs b/src/source/speed.rs
index 5598be9f..d24cb8ac 100644
--- a/src/source/speed.rs
+++ b/src/source/speed.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `Speed` object.
 pub fn speed<I>(input: I, factor: f32) -> Speed<I> {
     Speed { input, factor }
@@ -91,16 +93,17 @@ where
 
     #[inline]
     fn total_duration(&self) -> Option<Duration> {
-        // TODO: the crappy API of duration makes this code difficult to write
-        if let Some(duration) = self.input.total_duration() {
-            let as_ns = duration.as_secs() * 1000000000 + duration.subsec_nanos() as u64;
-            let new_val = (as_ns as f32 / self.factor) as u64;
-            Some(Duration::new(
-                new_val / 1000000000,
-                (new_val % 1000000000) as u32,
-            ))
-        } else {
-            None
-        }
+        self.input.total_duration().map(|d| d.mul_f32(self.factor))
+    }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        /* TODO: This might be wrong, I do not know how speed achieves its speedup
+         * so I can not reason about the correctness.
+         * <dvdsk noreply@davidsk.dev> */
+
+        // even after 24 hours of playback f32 has enough precision
+        let pos_accounting_for_speedup = pos.mul_f32(self.factor);
+        self.input.try_seek(pos_accounting_for_speedup)
     }
 }
diff --git a/src/source/stoppable.rs b/src/source/stoppable.rs
index afaa35f4..71ba8d2f 100644
--- a/src/source/stoppable.rs
+++ b/src/source/stoppable.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `Stoppable` object.
 pub fn stoppable<I>(source: I) -> Stoppable<I> {
     Stoppable {
@@ -88,4 +90,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.input.total_duration()
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/take.rs b/src/source/take.rs
index 533069f9..980b6920 100644
--- a/src/source/take.rs
+++ b/src/source/take.rs
@@ -2,6 +2,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// Internal function that builds a `TakeDuration` object.
 pub fn take_duration<I>(input: I, duration: Duration) -> TakeDuration<I>
 where
@@ -176,4 +178,9 @@ where
             None
         }
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        self.input.try_seek(pos)
+    }
 }
diff --git a/src/source/uniform.rs b/src/source/uniform.rs
index 823cb5db..fcaee5c5 100644
--- a/src/source/uniform.rs
+++ b/src/source/uniform.rs
@@ -6,6 +6,8 @@ use cpal::FromSample;
 use crate::conversions::{ChannelCountConverter, DataConverter, SampleRateConverter};
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// An iterator that reads from a `Source` and converts the samples to a specific rate and
 /// channels count.
 ///
@@ -137,6 +139,20 @@ where
     fn total_duration(&self) -> Option<Duration> {
         self.total_duration
     }
+
+    #[inline]
+    fn try_seek(&mut self, pos: Duration) -> Result<(), SeekError> {
+        if let Some(input) = self.inner.as_mut() {
+            input
+                .inner_mut()
+                .inner_mut()
+                .inner_mut()
+                .inner_mut()
+                .try_seek(pos)
+        } else {
+            Ok(())
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -145,6 +161,13 @@ struct Take<I> {
     n: Option<usize>,
 }
 
+impl<I> Take<I> {
+    #[inline]
+    pub fn inner_mut(&mut self) -> &mut I {
+        &mut self.iter
+    }
+}
+
 impl<I> Iterator for Take<I>
 where
     I: Iterator,
diff --git a/src/source/zero.rs b/src/source/zero.rs
index 079d8588..5337a90c 100644
--- a/src/source/zero.rs
+++ b/src/source/zero.rs
@@ -3,6 +3,8 @@ use std::time::Duration;
 
 use crate::{Sample, Source};
 
+use super::SeekError;
+
 /// An infinite source that produces zero.
 #[derive(Clone, Debug)]
 pub struct Zero<S> {
@@ -77,4 +79,9 @@ where
     fn total_duration(&self) -> Option<Duration> {
         None
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Ok(())
+    }
 }
diff --git a/src/spatial_sink.rs b/src/spatial_sink.rs
index 0edd8f09..cb787bc0 100644
--- a/src/spatial_sink.rs
+++ b/src/spatial_sink.rs
@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use cpal::FromSample;
 
-use crate::source::Spatial;
+use crate::source::{SeekError, Spatial};
 use crate::stream::{OutputStreamHandle, PlayError};
 use crate::{Sample, Sink, Source};
 
@@ -173,4 +173,26 @@ impl SpatialSink {
     pub fn len(&self) -> usize {
         self.sink.len()
     }
+
+    /// Attempts to seek to a given position in the current source.
+    ///
+    /// This blocks between 0 and ~5 milliseconds.
+    ///
+    /// As long as the duration of the source is known seek is guaranteed to saturate
+    /// at the end of the source. For example given a source that reports a total duration
+    /// of 42 seconds calling `try_seek()` with 60 seconds as argument will seek to
+    /// 42 seconds.
+    ///
+    /// # Errors
+    /// This function will return [`SeekError::NotSupported`] if one of the underlying
+    /// sources does not support seeking.  
+    ///
+    /// It will return an error if an implementation ran
+    /// into one during the seek.  
+    ///
+    /// When seeking beyond the end of a source this
+    /// function might return an error if the duration of the source is not known.
+    pub fn try_seek(&self, pos: Duration) -> Result<(), SeekError> {
+        self.sink.try_seek(pos)
+    }
 }
diff --git a/src/static_buffer.rs b/src/static_buffer.rs
index c6264aa1..95184423 100644
--- a/src/static_buffer.rs
+++ b/src/static_buffer.rs
@@ -13,6 +13,7 @@
 use std::slice::Iter as SliceIter;
 use std::time::Duration;
 
+use crate::source::SeekError;
 use crate::{Sample, Source};
 
 /// A buffer of samples treated as a source.
@@ -84,6 +85,13 @@ where
     fn total_duration(&self) -> Option<Duration> {
         Some(self.duration)
     }
+
+    #[inline]
+    fn try_seek(&mut self, _: Duration) -> Result<(), SeekError> {
+        Err(SeekError::NotSupported {
+            underlying_source: std::any::type_name::<Self>(),
+        })
+    }
 }
 
 impl<S> Iterator for StaticSamplesBuffer<S>
diff --git a/tests/seek.rs b/tests/seek.rs
new file mode 100644
index 00000000..41015da2
--- /dev/null
+++ b/tests/seek.rs
@@ -0,0 +1,240 @@
+use std::io::{BufReader, Read, Seek};
+use std::path::Path;
+use std::time::Duration;
+
+use rodio::{Decoder, Source};
+use rstest::rstest;
+use rstest_reuse::{self, *};
+
+#[template]
+#[rstest]
+// note: disabled, broken decoder see issue: #516
+// #[cfg_attr(feature = "symphonia-vorbis"), case("ogg", true, "symphonia")],
+#[cfg_attr(
+    all(feature = "minimp3", not(feature = "symphonia-mp3")),
+    case("mp3", false, "minimp3")
+)]
+#[cfg_attr(
+    all(feature = "wav", not(feature = "symphonia-wav")),
+    case("wav", true, "hound")
+)]
+#[cfg_attr(
+    all(feature = "flac", not(feature = "symphonia-flac")),
+    case("flac", false, "claxon")
+)]
+#[cfg_attr(feature = "symphonia-mp3", case("mp3", true, "symphonia"))]
+#[cfg_attr(feature = "symponia-isomp4", case("m4a", true, "symphonia"))]
+#[cfg_attr(feature = "symphonia-wav", case("wav", true, "symphonia"))]
+#[cfg_attr(feature = "symphonia-flac", case("flac", true, "symphonia"))]
+fn all_decoders(
+    #[case] format: &'static str,
+    #[case] supports_seek: bool,
+    #[case] decoder_name: &'static str,
+) {
+}
+
+#[template]
+#[rstest]
+// note: disabled, broken decoder see issue: #516
+// #[cfg_attr(feature = "symphonia-vorbis"), case("ogg", true, "symphonia")],
+#[cfg_attr(
+    all(feature = "wav", not(feature = "symphonia-wav")),
+    case("wav", "hound")
+)]
+#[cfg_attr(feature = "symphonia-mp3", case("mp3", "symphonia"))]
+#[cfg_attr(feature = "symponia-isomp4", case("m4a", "symphonia"))]
+#[cfg_attr(feature = "symphonia-wav", case("wav", "symphonia"))]
+#[cfg_attr(feature = "symphonia-flac", case("flac", "symphonia"))]
+fn supported_decoders(#[case] format: &'static str, #[case] decoder_name: &'static str) {}
+
+#[apply(all_decoders)]
+#[trace]
+fn seek_returns_err_if_unsupported(
+    #[case] format: &'static str,
+    #[case] supports_seek: bool,
+    #[case] decoder_name: &'static str,
+) {
+    let mut decoder = get_music(format);
+    let res = decoder.try_seek(Duration::from_millis(2500));
+    assert_eq!(res.is_ok(), supports_seek, "decoder: {decoder_name}");
+}
+
+#[apply(supported_decoders)]
+#[trace]
+fn seek_beyond_end_saturates(#[case] format: &'static str, #[case] decoder_name: &'static str) {
+    let mut decoder = get_music(format);
+    println!("seeking beyond end for: {format}\t decoded by: {decoder_name}");
+    let res = decoder.try_seek(Duration::from_secs(999));
+
+    assert!(res.is_ok(), "err: {res:?}");
+    assert!(time_remaining(decoder) < Duration::from_secs(1));
+}
+
+#[apply(supported_decoders)]
+#[trace]
+fn seek_results_in_correct_remaining_playtime(
+    #[case] format: &'static str,
+    #[case] decoder_name: &'static str,
+) {
+    println!("checking seek duration for: {format}\t decoded by: {decoder_name}");
+
+    let decoder = get_music(format);
+    let total_duration = time_remaining(decoder);
+    dbg!(total_duration);
+
+    const SEEK_BEFORE_END: Duration = Duration::from_secs(5);
+    let mut decoder = get_music(format);
+    decoder.try_seek(total_duration - SEEK_BEFORE_END).unwrap();
+
+    let after_seek = time_remaining(decoder);
+    let expected = SEEK_BEFORE_END;
+
+    if after_seek.as_millis().abs_diff(expected.as_millis()) > 250 {
+        panic!(
+            "Seek did not result in expected leftover playtime
+    leftover time: {after_seek:?}
+    expected time left in source: {SEEK_BEFORE_END:?}"
+        );
+    }
+}
+
+#[apply(supported_decoders)]
+#[trace]
+fn seek_possible_after_exausting_source(
+    #[case] format: &'static str,
+    #[case] _decoder_name: &'static str,
+) {
+    let mut source = get_music(format);
+    while source.next().is_some() {}
+    assert!(source.next().is_none());
+
+    source.try_seek(Duration::from_secs(0)).unwrap();
+    assert!(source.next().is_some());
+}
+
+#[apply(supported_decoders)]
+#[trace]
+fn seek_does_not_break_channel_order(
+    #[case] format: &'static str,
+    #[case] _decoder_name: &'static str,
+) {
+    let mut source = get_rl(format).convert_samples();
+    let channels = source.channels();
+    assert_eq!(channels, 2, "test needs a stereo beep file");
+
+    let beep_range = second_channel_beep_range(&mut source);
+    let beep_start = Duration::from_secs_f32(
+        beep_range.start as f32 / source.channels() as f32 / source.sample_rate() as f32,
+    );
+
+    let mut source = get_rl(format).convert_samples();
+
+    let mut channel_offset = 0;
+    for offset in [1, 4, 7, 40, 41, 120, 179]
+        .map(|offset| offset as f32 / (source.sample_rate() as f32))
+        .map(Duration::from_secs_f32)
+    {
+        source.next(); // WINDOW is even, make the amount of calls to next
+                       // uneven to force issues with channels alternating
+                       // between seek to surface
+        channel_offset = (channel_offset + 1) % 2;
+
+        source.try_seek(beep_start + offset).unwrap();
+        let samples: Vec<_> = source.by_ref().take(100).collect();
+        let channel0 = 0 + channel_offset;
+        assert!(
+            is_silent(&samples, source.channels(), channel0),
+            "channel0 should be silent, 
+    channel0 starts at idx: {channel0}
+    seek: {beep_start:?} + {offset:?}
+    samples: {samples:?}"
+        );
+        let channel1 = (1 + channel_offset) % 2;
+        assert!(
+            !is_silent(&samples, source.channels(), channel1),
+            "channel1 should not be silent, 
+    channel1; starts at idx: {channel1}
+    seek: {beep_start:?} + {offset:?}
+    samples: {samples:?}"
+        );
+    }
+}
+
+fn second_channel_beep_range<R: rodio::Source>(source: &mut R) -> std::ops::Range<usize>
+where
+    R: Iterator<Item = f32>,
+{
+    let channels = source.channels() as usize;
+    let samples: Vec<f32> = source.by_ref().collect();
+
+    const WINDOW: usize = 50;
+    let beep_starts = samples
+        .chunks_exact(WINDOW)
+        .enumerate()
+        .map(|(idx, chunk)| (idx * WINDOW, chunk))
+        .find(|(_, s)| {
+            s.iter()
+                .skip(1)
+                .step_by(channels)
+                .map(|s| s.abs())
+                .sum::<f32>()
+                > 0.1
+        })
+        .expect("track should not be silent")
+        .0
+        .next_multiple_of(channels);
+
+    const BASICALLY_ZERO: f32 = 0.0001;
+    let beep_ends = samples
+        .chunks_exact(WINDOW)
+        .enumerate()
+        .map(|(idx, chunk)| (idx * WINDOW, chunk))
+        .skip(beep_starts / WINDOW)
+        .find(|(_, s)| {
+            s.iter()
+                .skip(1)
+                .step_by(channels)
+                .all(|s| s.abs() < BASICALLY_ZERO)
+        })
+        .expect("beep should end")
+        .0
+        .next_multiple_of(channels);
+
+    let samples = &samples[beep_starts..beep_starts + 100];
+    assert!(is_silent(samples, channels as u16, 0), "{samples:?}");
+    assert!(!is_silent(samples, channels as u16, 1), "{samples:?}");
+
+    beep_starts..beep_ends
+}
+
+fn is_silent(samples: &[f32], channels: u16, channel: usize) -> bool {
+    assert_eq!(samples.len(), 100);
+    let channel = samples.iter().skip(channel).step_by(channels as usize);
+    let volume =
+        channel.map(|s| s.abs()).sum::<f32>() as f32 / samples.len() as f32 * channels as f32;
+
+    const BASICALLY_ZERO: f32 = 0.0001;
+    volume < BASICALLY_ZERO
+}
+
+fn time_remaining(decoder: Decoder<impl Read + Seek>) -> Duration {
+    let rate = decoder.sample_rate() as f64;
+    let n_channels = decoder.channels() as f64;
+    let n_samples = decoder.into_iter().count() as f64;
+    Duration::from_secs_f64(n_samples / rate / n_channels)
+}
+
+fn get_music(format: &str) -> Decoder<impl Read + Seek> {
+    let asset = Path::new("assets/music").with_extension(format);
+    let file = std::fs::File::open(asset).unwrap();
+    let decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
+    decoder
+}
+
+fn get_rl(format: &str) -> Decoder<impl Read + Seek> {
+    let asset = Path::new("assets/RL").with_extension(format);
+    println!("opening: {}", asset.display());
+    let file = std::fs::File::open(asset).unwrap();
+    let decoder = rodio::Decoder::new(BufReader::new(file)).unwrap();
+    decoder
+}