diff --git a/Userland/Applications/VideoPlayer/VideoPlayerWidget.cpp b/Userland/Applications/VideoPlayer/VideoPlayerWidget.cpp
index f4d53ca8c4..bafc0f523a 100644
--- a/Userland/Applications/VideoPlayer/VideoPlayerWidget.cpp
+++ b/Userland/Applications/VideoPlayer/VideoPlayerWidget.cpp
@@ -38,6 +38,17 @@ VideoPlayerWidget::VideoPlayerWidget(GUI::Window& window)
     m_seek_slider = player_controls_widget.add<GUI::HorizontalSlider>();
     m_seek_slider->set_fixed_height(20);
     m_seek_slider->set_enabled(false);
+    m_seek_slider->on_change = [&](int value) {
+        if (!m_playback_manager)
+            return;
+        update_seek_slider_max();
+        auto progress = value / static_cast<double>(m_seek_slider->max());
+        auto duration = m_playback_manager->duration().to_milliseconds();
+        Time timestamp = Time::from_milliseconds(static_cast<i64>(round(progress * static_cast<double>(duration))));
+        set_current_timestamp(timestamp);
+        m_playback_manager->seek_to_timestamp(timestamp);
+    };
+    m_seek_slider->set_jump_to_cursor(true);
 
     auto& toolbar_container = player_controls_widget.add<GUI::ToolbarContainer>();
     m_toolbar = toolbar_container.add<GUI::Toolbar>();
@@ -56,7 +67,7 @@ VideoPlayerWidget::VideoPlayerWidget(GUI::Window& window)
     m_toolbar->add_action(*m_play_pause_action);
     m_toolbar->add<GUI::VerticalSeparator>();
     m_timestamp_label = m_toolbar->add<GUI::Label>();
-    m_timestamp_label->set_fixed_width(50);
+    m_timestamp_label->set_autosize(true);
 
     m_toolbar->add<GUI::Widget>(); // Filler widget
 
@@ -89,6 +100,7 @@ void VideoPlayerWidget::open_file(StringView filename)
 
     close_file();
     m_playback_manager = load_file_result.release_value();
+    update_seek_slider_max();
     resume_playback();
 }
 
@@ -162,6 +174,46 @@ void VideoPlayerWidget::on_decoding_error(Video::DecoderError const& error)
     GUI::MessageBox::show(&m_window, String::formatted(text_format, error.string_literal()), "Video Player encountered an error"sv);
 }
 
+void VideoPlayerWidget::update_seek_slider_max()
+{
+    if (!m_playback_manager) {
+        m_seek_slider->set_enabled(false);
+        return;
+    }
+
+    m_seek_slider->set_max(static_cast<int>(min(m_playback_manager->duration().to_milliseconds(), NumericLimits<int>::max())));
+    m_seek_slider->set_enabled(true);
+}
+
+void VideoPlayerWidget::set_current_timestamp(Time timestamp)
+{
+    set_time_label(timestamp);
+    if (!m_playback_manager)
+        return;
+    auto progress = static_cast<double>(timestamp.to_milliseconds()) / static_cast<double>(m_playback_manager->duration().to_milliseconds());
+    m_seek_slider->set_value(static_cast<int>(round(progress * m_seek_slider->max())), GUI::AllowCallback::No);
+}
+
+void VideoPlayerWidget::set_time_label(Time timestamp)
+{
+    StringBuilder string_builder;
+    auto append_time = [&](Time time) {
+        auto seconds = time.to_seconds();
+        string_builder.appendff("{:02}:{:02}:{:02}", seconds / 3600, seconds / 60, seconds % 60);
+    };
+
+    append_time(timestamp);
+
+    if (m_playback_manager) {
+        string_builder.append(" / "sv);
+        append_time(m_playback_manager->duration());
+    } else {
+        string_builder.append(" / --:--:--.---"sv);
+    }
+
+    m_timestamp_label->set_text(string_builder.string_view());
+}
+
 void VideoPlayerWidget::event(Core::Event& event)
 {
     if (event.type() == Video::EventType::DecoderErrorOccurred) {
@@ -174,9 +226,8 @@ void VideoPlayerWidget::event(Core::Event& event)
         m_video_display->set_bitmap(frame_event.frame());
         m_video_display->repaint();
 
-        m_seek_slider->set_max(m_playback_manager->duration().to_milliseconds());
-        m_seek_slider->set_value(m_playback_manager->current_playback_time().to_milliseconds());
-        m_seek_slider->set_enabled(true);
+        update_seek_slider_max();
+        set_current_timestamp(m_playback_manager->current_playback_time());
 
         frame_event.accept();
     } else if (event.type() == Video::EventType::PlaybackStatusChange) {
diff --git a/Userland/Applications/VideoPlayer/VideoPlayerWidget.h b/Userland/Applications/VideoPlayer/VideoPlayerWidget.h
index 9f3abe1ddc..2ef81d5251 100644
--- a/Userland/Applications/VideoPlayer/VideoPlayerWidget.h
+++ b/Userland/Applications/VideoPlayer/VideoPlayerWidget.h
@@ -36,6 +36,9 @@ private:
     VideoPlayerWidget(GUI::Window&);
 
     void update_play_pause_icon();
+    void update_seek_slider_max();
+    void set_current_timestamp(Time);
+    void set_time_label(Time);
     void on_decoding_error(Video::DecoderError const&);
     void display_next_frame();
 
diff --git a/Userland/Libraries/LibVideo/Containers/Demuxer.h b/Userland/Libraries/LibVideo/Containers/Demuxer.h
index 3ed163b7f3..dacc121678 100644
--- a/Userland/Libraries/LibVideo/Containers/Demuxer.h
+++ b/Userland/Libraries/LibVideo/Containers/Demuxer.h
@@ -28,7 +28,7 @@ public:
         return sample.release_nonnull<VideoSample>();
     }
 
-    virtual DecoderErrorOr<void> seek_to_most_recent_keyframe(Track track, size_t timestamp) = 0;
+    virtual DecoderErrorOr<void> seek_to_most_recent_keyframe(Track track, Time timestamp) = 0;
 
     virtual DecoderErrorOr<Time> duration() = 0;
 
diff --git a/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.cpp b/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.cpp
index 59abd6bdf7..cab16d4d89 100644
--- a/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.cpp
+++ b/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.cpp
@@ -53,9 +53,9 @@ DecoderErrorOr<MatroskaDemuxer::TrackStatus*> MatroskaDemuxer::get_track_status(
     return &m_track_statuses.get(track).release_value();
 }
 
-DecoderErrorOr<void> MatroskaDemuxer::seek_to_most_recent_keyframe(Track track, size_t timestamp)
+DecoderErrorOr<void> MatroskaDemuxer::seek_to_most_recent_keyframe(Track track, Time timestamp)
 {
-    if (timestamp == 0) {
+    if (timestamp.is_zero()) {
         // Removing the track status will cause us to start from the beginning.
         m_track_statuses.remove(track);
         return {};
diff --git a/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.h b/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.h
index 54db43215d..3578a99cca 100644
--- a/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.h
+++ b/Userland/Libraries/LibVideo/Containers/Matroska/MatroskaDemuxer.h
@@ -27,7 +27,7 @@ public:
 
     DecoderErrorOr<Vector<Track>> get_tracks_for_type(TrackType type) override;
 
-    DecoderErrorOr<void> seek_to_most_recent_keyframe(Track track, size_t timestamp) override;
+    DecoderErrorOr<void> seek_to_most_recent_keyframe(Track track, Time timestamp) override;
 
     DecoderErrorOr<Time> duration() override;
 
diff --git a/Userland/Libraries/LibVideo/PlaybackManager.cpp b/Userland/Libraries/LibVideo/PlaybackManager.cpp
index 68abdbf3b5..7f95371268 100644
--- a/Userland/Libraries/LibVideo/PlaybackManager.cpp
+++ b/Userland/Libraries/LibVideo/PlaybackManager.cpp
@@ -55,8 +55,6 @@ void PlaybackManager::set_playback_status(PlaybackStatus status)
         if (status == PlaybackStatus::Playing) {
             if (old_status == PlaybackStatus::Stopped || old_status == PlaybackStatus::Corrupted) {
                 restart_playback();
-                m_frame_queue->clear();
-                m_skipped_frames = 0;
             }
             m_last_present_in_real_time = Time::now_monotonic();
             m_present_timer->start(0);
@@ -94,6 +92,8 @@ bool PlaybackManager::prepare_next_frame()
 
 Time PlaybackManager::current_playback_time()
 {
+    if (m_last_present_in_media_time.is_negative())
+        return Time::zero();
     if (is_playing())
         return m_last_present_in_media_time + (Time::now_monotonic() - m_last_present_in_real_time);
     return m_last_present_in_media_time;
@@ -165,6 +165,11 @@ void PlaybackManager::update_presented_frame()
             return;
         }
 
+        if (m_last_present_in_media_time.is_negative()) {
+            m_last_present_in_media_time = m_next_frame->timestamp();
+            dbgln_if(PLAYBACK_MANAGER_DEBUG, "We've seeked, set last media time to the next frame {}ms", m_last_present_in_media_time.to_milliseconds());
+        }
+
         auto frame_time_ms = (m_next_frame->timestamp() - current_playback_time()).to_milliseconds();
         VERIFY(frame_time_ms <= NumericLimits<int>::max());
         dbgln_if(PLAYBACK_MANAGER_DEBUG, "Time until next frame is {}ms", frame_time_ms);
@@ -176,15 +181,26 @@ void PlaybackManager::update_presented_frame()
     m_decode_timer->start(0);
 }
 
-void PlaybackManager::restart_playback()
+void PlaybackManager::seek_to_timestamp(Time timestamp)
 {
-    m_last_present_in_media_time = Time::zero();
+    dbgln_if(PLAYBACK_MANAGER_DEBUG, "Seeking to {}ms", timestamp.to_milliseconds());
+    m_last_present_in_media_time = Time::min();
     m_last_present_in_real_time = Time::zero();
-    auto result = m_demuxer->seek_to_most_recent_keyframe(m_selected_video_track, 0);
+    m_frame_queue->clear();
+    m_next_frame.clear();
+    m_skipped_frames = 0;
+    // FIXME: When the demuxer is getting samples off the main thread in the future, this needs to
+    //        mutex so that seeking can't happen while that thread is getting a sample.
+    auto result = m_demuxer->seek_to_most_recent_keyframe(m_selected_video_track, timestamp);
     if (result.is_error())
         on_decoder_error(result.release_error());
 }
 
+void PlaybackManager::restart_playback()
+{
+    seek_to_timestamp(Time::zero());
+}
+
 void PlaybackManager::post_decoder_error(DecoderError error)
 {
     m_main_loop.post_event(m_event_handler, make<DecoderErrorEvent>(error));
diff --git a/Userland/Libraries/LibVideo/PlaybackManager.h b/Userland/Libraries/LibVideo/PlaybackManager.h
index e14f84bf0e..d8686a7968 100644
--- a/Userland/Libraries/LibVideo/PlaybackManager.h
+++ b/Userland/Libraries/LibVideo/PlaybackManager.h
@@ -101,6 +101,7 @@ public:
     void resume_playback();
     void pause_playback();
     void restart_playback();
+    void seek_to_timestamp(Time);
     bool is_playing() const { return m_status == PlaybackStatus::Playing; }
     bool is_buffering() const { return m_status == PlaybackStatus::Buffering; }
     bool is_stopped() const { return m_status == PlaybackStatus::Stopped; }