It's 2016 Today
25 January, 2026
It's 2016 Today started as a small nostalgia experiment. I did not want to make a regular playlist page with a list of songs and a play button. I wanted it to feel like opening a strange live channel from another year, where the video is already running and the whole page quietly says: you are back there now.
The mood mattered as much as the player. The references were simple: music videos on loop, wired earphones, fidget spinners, Pokemon Go, VH1 and MTV, and that very specific internet feeling from around 2016. The product had to stay minimal, dark, and theatrical so the current song could own the screen.
A theatre-mode 2016 music-video stream that everyone enters at the same moment in the same loop.
The Player Feel
The interface is intentionally sparse. The current title sits on the left, the artist on the right, a Spotify shortcut stays in the center, and the video takes over everything else. The page starts muted so the browser allows autoplay, then the first click unmutes and removes the intro overlay.
I also blocked direct interaction with the YouTube frame and scaled the video slightly past its container. That crops away most of the default YouTube surface and makes the player feel closer to a cinematic strip than an embedded video.
The Sync Logic
The important part is that the player is not just local playback. It behaves like a live stream without running a live stream. There is no server deciding the current song, no socket connection, no shared session, and no scheduled job pushing state to visitors. Every browser receives the same static playlist and independently calculates where the stream should be.
The trick is using absolute time as the source of truth. The app counts the seconds since a fixed UTC timestamp, folds that number into the total playlist duration, and gets a loop position. Then it walks through the cumulative song durations to find the current track and the exact offset inside it.
That means if two people open the site at the same real-world moment, they land on the same song and the same timestamp, even if they are in different timezones. The clock is global, the playlist order is deterministic, and the browser simply tells the YouTube iframe which video to load and where to seek.
const GLOBAL_START_TIME = Date.UTC(2016, 0, 1, 0, 0, 0);function getStreamPosition( totalDuration: number, cumulativeDurations: number[],) { if (!totalDuration) { return { index: 0, offset: 0 }; } const elapsedSeconds = Math.floor( (Date.now() - GLOBAL_START_TIME) / 1000, ); const loopPosition = ((elapsedSeconds % totalDuration) + totalDuration) % totalDuration; const index = cumulativeDurations.findIndex( (total) => loopPosition < total, ); const resolvedIndex = index === -1 ? 0 : index; const previousTotal = resolvedIndex === 0 ? 0 : cumulativeDurations[resolvedIndex - 1]; return { index: resolvedIndex, offset: loopPosition - previousTotal };}How It Runs
The app uses a curated playlist of 2016-era tracks, each with a YouTube ID and duration. Before playback, the list is shuffled with a fixed seed of 2016, so the order is stable for every visitor. From there, the app builds cumulative durations locally and finds the song that contains the current global loop position. Because the input data and the clock formula are identical, the result is identical for everyone.
The YouTube iframe API handles the actual media. If the current video is different, the app loads it at the calculated offset. If it is already loaded, it seeks and plays. Every 30 seconds, the player checks for drift and resyncs if it is more than a few seconds off. If YouTube blocks a video, that ID is skipped for the session and the player recalculates against the remaining playable songs.
This keeps the project cheap and simple. The deployed site can be a static Next.js page. The playlist ships with the bundle, timing happens in the browser, media comes from YouTube, and sharing the link is enough for someone else to join the same moment.
Where It Is Now
The result is a lightweight, serverless nostalgia stream. It does not need accounts, a custom audio backend, stored playback state, or scheduled streaming infrastructure. The browser does the timing, YouTube serves the music videos, and the interface keeps the experience focused.
The project is small, but the core idea is strong: a static site can still feel live when everyone is anchored to the same clock. That is what makes it feel less like a playlist and more like a shared moment.
Try it here: its2016.today