diff --git a/packages/example/public/road-loop.mp4 b/packages/example/public/road-loop.mp4
new file mode 100644
index 00000000000..eab62833bc6
Binary files /dev/null and b/packages/example/public/road-loop.mp4 differ
diff --git a/packages/example/src/OffthreadRemoteVideo/NewPerfectlyLoopedVideo.tsx b/packages/example/src/OffthreadRemoteVideo/NewPerfectlyLoopedVideo.tsx
new file mode 100644
index 00000000000..590cb5fda35
--- /dev/null
+++ b/packages/example/src/OffthreadRemoteVideo/NewPerfectlyLoopedVideo.tsx
@@ -0,0 +1,36 @@
+import {Video} from '@remotion/media';
+import {CalculateMetadataFunction, Composition, staticFile} from 'remotion';
+// https://www.remotion.dev/docs/mediabunny/metadata
+import {getMediaMetadata} from '../get-media-metadata';
+
+const src = staticFile('road-loop.mp4');
+
+export const calculateMetadataFn: CalculateMetadataFunction<
+	Record<string, unknown>
+> = async () => {
+	const {durationInSeconds, dimensions, fps} = await getMediaMetadata(src);
+
+	return {
+		durationInFrames: Math.round(durationInSeconds * fps!) * 4,
+		fps: fps!,
+		width: dimensions!.width,
+		height: dimensions!.height,
+	};
+};
+
+export const Component = () => {
+	return <Video loop src={src} />;
+};
+
+export const NewPerfectlyLoopedVideoComp = () => {
+	return (
+		<Composition
+			component={Component}
+			id="NewPerfectlyLoopedVideo"
+			calculateMetadata={calculateMetadataFn}
+		/>
+	);
+};
+
+// In Root.tsx:
+// <NewVideoComp />
diff --git a/packages/example/src/Root.tsx b/packages/example/src/Root.tsx
index bc16df0387a..2c287fe2807 100644
--- a/packages/example/src/Root.tsx
+++ b/packages/example/src/Root.tsx
@@ -136,6 +136,7 @@ import {NewAudioExample} from './NewAudio/NewAudio';
 import {ChangingTrimBeforeValue} from './OffthreadRemoteVideo/ChangingTrimBefore';
 import {LoopedOffthreadRemoteVideo} from './OffthreadRemoteVideo/LoopedOffthreadRemoteVideo';
 import {MultiChannelAudio} from './OffthreadRemoteVideo/MultiChannelAudio';
+import {NewPerfectlyLoopedVideoComp} from './OffthreadRemoteVideo/NewPerfectlyLoopedVideo';
 import {NewVideoComp} from './OffthreadRemoteVideo/NewRemoteVideo';
 import {OffthreadRemoteSeries} from './OffthreadRemoteVideo/OffthreadRemoteSeries';
 import {ParseAndDownloadMedia} from './ParseAndDownloadMedia';
@@ -781,6 +782,7 @@ export const Index: React.FC = () => {
 				/>
 				<OffthreadRemoteVideo />
 				<NewVideoComp />
+				<NewPerfectlyLoopedVideoComp />
 				<OffthreadRemoteSeries />
 				<LoopedOffthreadRemoteVideo />
 				<MultiChannelAudio />
diff --git a/packages/media/src/audio-iterator-manager.ts b/packages/media/src/audio-iterator-manager.ts
index 29066fa6949..63574a8f60f 100644
--- a/packages/media/src/audio-iterator-manager.ts
+++ b/packages/media/src/audio-iterator-manager.ts
@@ -27,6 +27,11 @@ export const audioIteratorManager = ({
 	let audioBufferIterator: AudioIterator | null = null;
 	let audioIteratorsCreated = 0;
 
+	// secondary iterator for pre-warming loop audio
+	let loopTransitionIterator: AudioIterator | null = null;
+	let loopTransitionFirstChunk: WrappedAudioBuffer | null = null;
+	let loopSwapCount = 0;
+
 	const scheduleAudioChunk = ({
 		buffer,
 		mediaTimestamp,
@@ -224,10 +229,97 @@ export const audioIteratorManager = ({
 			}
 
 			if (audioSatisfyResult.type === 'ended') {
+				// current iterator ended - try prewarmed if available
+				if (loopTransitionIterator) {
+					audioBufferIterator?.destroy();
+					// swap the iterator with pre-warmed one
+					audioBufferIterator = loopTransitionIterator;
+					loopTransitionIterator = null;
+					loopSwapCount++;
+
+					if (loopTransitionFirstChunk) {
+						onAudioChunk({
+							getIsPlaying,
+							buffer: loopTransitionFirstChunk,
+							playbackRate,
+							scheduleAudioNode,
+						});
+						loopTransitionFirstChunk = null;
+					}
+
+					for (let i = 0; i < 2; i++) {
+						const result = await audioBufferIterator.getNext();
+
+						if (nonce.isStale()) {
+							return;
+						}
+
+						if (!result.value) {
+							break;
+						}
+
+						onAudioChunk({
+							getIsPlaying,
+							buffer: result.value,
+							playbackRate,
+							scheduleAudioNode,
+						});
+					}
+
+					return;
+				}
+
+				// Audio iterator has ended, but we're seeking to a valid time. This happens when looping - restart the iterator from the new position.
+				await startAudioIterator({
+					nonce,
+					playbackRate,
+					startFromSecond: newTime,
+					getIsPlaying,
+					scheduleAudioNode,
+				});
 				return;
 			}
 
 			if (audioSatisfyResult.type === 'not-satisfied') {
+				// Current iterator can't satisfy - try prewarmed if available
+				if (loopTransitionIterator) {
+					audioBufferIterator?.destroy();
+					audioBufferIterator = loopTransitionIterator;
+					loopTransitionIterator = null;
+					loopSwapCount++;
+
+					if (loopTransitionFirstChunk) {
+						onAudioChunk({
+							getIsPlaying,
+							buffer: loopTransitionFirstChunk,
+							playbackRate,
+							scheduleAudioNode,
+						});
+						loopTransitionFirstChunk = null;
+					}
+
+					for (let i = 0; i < 2; i++) {
+						const result = await audioBufferIterator.getNext();
+
+						if (nonce.isStale()) {
+							return;
+						}
+
+						if (!result.value) {
+							break;
+						}
+
+						onAudioChunk({
+							getIsPlaying,
+							buffer: result.value,
+							playbackRate,
+							scheduleAudioNode,
+						});
+					}
+
+					return;
+				}
+
 				await startAudioIterator({
 					nonce,
 					playbackRate,
@@ -331,6 +423,7 @@ export const audioIteratorManager = ({
 		},
 		seek,
 		getAudioIteratorsCreated: () => audioIteratorsCreated,
+		getLoopSwapCount: () => loopSwapCount,
 		setMuted: (newMuted: boolean) => {
 			muted = newMuted;
 			gainNode.gain.value = muted ? 0 : currentVolume;
@@ -340,6 +433,33 @@ export const audioIteratorManager = ({
 			gainNode.gain.value = muted ? 0 : currentVolume;
 		},
 		scheduleAudioChunk,
+		prepareLoopTransition: async ({
+			startTimeInSeconds,
+		}: {
+			startTimeInSeconds: number;
+		}) => {
+			// Idempotent - if we already have a prewarmed iterator, skip
+			if (loopTransitionIterator) {
+				return;
+			}
+
+			loopTransitionIterator = makeAudioIterator(audioSink, startTimeInSeconds);
+
+			try {
+				// Pre-warm the decoder by fetching the first chunk
+				// This initializes the AudioDecoder and starts decoding
+				// We store the chunk to schedule it later without losing audio data
+				const result = await loopTransitionIterator.getNext();
+				if (result.value) {
+					loopTransitionFirstChunk = result.value;
+				}
+			} catch (e) {
+				loopTransitionIterator?.destroy();
+				loopTransitionIterator = null;
+				loopTransitionFirstChunk = null;
+				throw e;
+			}
+		},
 	};
 };
 
diff --git a/packages/media/src/media-player.ts b/packages/media/src/media-player.ts
index 0036f0272b2..515bb96dc36 100644
--- a/packages/media/src/media-player.ts
+++ b/packages/media/src/media-player.ts
@@ -46,12 +46,13 @@ export class MediaPlayer {
 
 	private playing = false;
 	private loop = false;
+
 	private fps: number;
 
 	private trimBefore: number | undefined;
 	private trimAfter: number | undefined;
 
-	private totalDuration: number | undefined;
+	private mediaDurationInSeconds: number | undefined;
 
 	private debugOverlay = false;
 
@@ -192,7 +193,7 @@ export class MediaPlayer {
 				return {type: 'disposed'};
 			}
 
-			this.totalDuration = durationInSeconds;
+			this.mediaDurationInSeconds = durationInSeconds;
 
 			const audioTrack = audioTracks[this.audioStreamIndex] ?? null;
 
@@ -229,7 +230,7 @@ export class MediaPlayer {
 				loop: this.loop,
 				trimBefore: this.trimBefore,
 				trimAfter: this.trimAfter,
-				mediaDurationInSeconds: this.totalDuration,
+				mediaDurationInSeconds: this.mediaDurationInSeconds,
 				fps: this.fps,
 				ifNoMediaDuration: 'infinity',
 				src: this.src,
@@ -309,7 +310,7 @@ export class MediaPlayer {
 			loop: this.loop,
 			trimBefore: this.trimBefore,
 			trimAfter: this.trimAfter,
-			mediaDurationInSeconds: this.totalDuration ?? null,
+			mediaDurationInSeconds: this.mediaDurationInSeconds ?? null,
 			fps: this.fps,
 			ifNoMediaDuration: 'infinity',
 			src: this.src,
@@ -319,6 +320,13 @@ export class MediaPlayer {
 			throw new Error(`should have asserted that the time is not null`);
 		}
 
+		const shouldPrepareLoopTransition =
+			this.shouldPrepareLoopTransition(newTime);
+
+		if (shouldPrepareLoopTransition) {
+			this.prepareSeamlessLoop();
+		}
+
 		const nonce = this.nonceManager.createAsyncOperation();
 		await this.seekPromiseChain;
 
@@ -335,6 +343,7 @@ export class MediaPlayer {
 		}
 
 		const currentPlaybackTime = this.getPlaybackTime();
+
 		if (currentPlaybackTime === newTime) {
 			return;
 		}
@@ -362,7 +371,7 @@ export class MediaPlayer {
 			loop: this.loop,
 			trimBefore: this.trimBefore,
 			trimAfter: this.trimAfter,
-			mediaDurationInSeconds: this.totalDuration ?? null,
+			mediaDurationInSeconds: this.mediaDurationInSeconds ?? null,
 			fps: this.fps,
 			ifNoMediaDuration: 'infinity',
 			src: this.src,
@@ -428,7 +437,7 @@ export class MediaPlayer {
 			loop: this.loop,
 			trimBefore: this.trimBefore,
 			trimAfter: this.trimAfter,
-			mediaDurationInSeconds: this.totalDuration ?? null,
+			mediaDurationInSeconds: this.mediaDurationInSeconds ?? null,
 			fps: this.fps,
 			ifNoMediaDuration: 'infinity',
 			src: this.src,
@@ -518,6 +527,67 @@ export class MediaPlayer {
 		this.loop = loop;
 	}
 
+	private getLoopDuration(): number {
+		if (!this.mediaDurationInSeconds) {
+			return 0;
+		}
+
+		const loopDurationInSeconds =
+			Internals.calculateMediaDuration({
+				trimBefore: this.trimBefore,
+				trimAfter: this.trimAfter,
+				mediaDurationInFrames: this.mediaDurationInSeconds * this.fps,
+				playbackRate: 1,
+			}) / this.fps;
+
+		return loopDurationInSeconds;
+	}
+
+	private shouldPrepareLoopTransition(mediaTime: number): boolean {
+		if (!this.loop || !this.mediaDurationInSeconds) {
+			return false;
+		}
+
+		const thresholdInSeconds = 1.0;
+		const loopStartMediaTime = (this.trimBefore ?? 0) / this.fps;
+
+		const loopDuration = this.getLoopDuration();
+
+		const positionInLoop = mediaTime - loopStartMediaTime;
+		const timeUntilEndSec = loopDuration - positionInLoop;
+
+		return timeUntilEndSec <= thresholdInSeconds && timeUntilEndSec > 0;
+	}
+
+	private prepareSeamlessLoop(): void {
+		if (!this.mediaDurationInSeconds) {
+			return;
+		}
+
+		const startTimeInSeconds = getTimeInSeconds({
+			unloopedTimeInSeconds: 0,
+			playbackRate: this.playbackRate,
+			loop: this.loop,
+			trimBefore: this.trimBefore,
+			trimAfter: this.trimAfter,
+			mediaDurationInSeconds: this.mediaDurationInSeconds,
+			fps: this.fps,
+			ifNoMediaDuration: 'infinity',
+			src: this.src,
+		});
+
+		if (startTimeInSeconds === null) {
+			return;
+		}
+
+		this.audioIteratorManager?.prepareLoopTransition({
+			startTimeInSeconds,
+		});
+		this.videoIteratorManager?.prepareLoopTransition({
+			startTime: startTimeInSeconds,
+		});
+	}
+
 	public async dispose(): Promise<void> {
 		if (this.initializationPromise) {
 			try {
diff --git a/packages/media/src/test/audio-iterator.test.ts b/packages/media/src/test/audio-iterator.test.ts
index 0a78924be4c..c9d537143d1 100644
--- a/packages/media/src/test/audio-iterator.test.ts
+++ b/packages/media/src/test/audio-iterator.test.ts
@@ -58,6 +58,7 @@ test('media player should work', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -72,6 +73,7 @@ test('media player should work', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -86,6 +88,7 @@ test('media player should work', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -128,6 +131,7 @@ test('should not create too many iterators when the audio ends', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -141,6 +145,7 @@ test('should not create too many iterators when the audio ends', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -154,6 +159,7 @@ test('should not create too many iterators when the audio ends', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -192,6 +198,7 @@ test('should create more iterators when seeking ', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -205,6 +212,7 @@ test('should create more iterators when seeking ', async () => {
 		getIsPlaying,
 		nonce: makeNonceManager().createAsyncOperation(),
 		playbackRate,
+
 		bufferState: {
 			delayPlayback: () => ({
 				unblock: () => {},
@@ -274,6 +282,7 @@ test('should not schedule duplicate chunks with playbackRate=0.5', async () => {
 			getIsPlaying: () => true,
 			nonce: makeNonceManager().createAsyncOperation(),
 			playbackRate,
+
 			bufferState: {
 				delayPlayback: () => ({
 					unblock: () => {},
@@ -285,3 +294,138 @@ test('should not schedule duplicate chunks with playbackRate=0.5', async () => {
 	const uniqueChunks = [...new Set(scheduledChunks)];
 	expect(scheduledChunks.length).toBe(uniqueChunks.length);
 });
+
+test('should schedule audio when looping back to beginning after reaching end', async () => {
+	const {manager, fps, playbackRate, getIsPlaying} = await prepare();
+
+	const scheduledChunks: number[] = [];
+	const scheduleAudioNode = (
+		node: AudioBufferSourceNode,
+		mediaTimestamp: number,
+	) => {
+		node.start(mediaTimestamp);
+		setTimeout(
+			() => {
+				node.stop();
+			},
+			(node.buffer?.duration ?? 0) * 1000,
+		);
+		scheduledChunks.push(mediaTimestamp);
+	};
+
+	// Seek near the end of the video
+	await manager.seek({
+		newTime: 9.97,
+		scheduleAudioNode,
+		fps,
+		getIsPlaying,
+		nonce: makeNonceManager().createAsyncOperation(),
+		playbackRate,
+
+		bufferState: {
+			delayPlayback: () => ({
+				unblock: () => {},
+			}),
+		},
+	});
+
+	// The audio iterator should now be at the end
+	const chunksBeforeLoop = scheduledChunks.length;
+	expect(chunksBeforeLoop).toBeGreaterThan(0);
+
+	// Now loop back to the beginning (simulating loop behavior)
+	await manager.seek({
+		newTime: 0,
+		scheduleAudioNode,
+		fps,
+		getIsPlaying,
+		nonce: makeNonceManager().createAsyncOperation(),
+		playbackRate,
+
+		bufferState: {
+			delayPlayback: () => ({
+				unblock: () => {},
+			}),
+		},
+	});
+
+	// BUG: Audio should be scheduled after looping, but it's not
+	const chunksAfterLoop = scheduledChunks.length;
+	expect(chunksAfterLoop).toBeGreaterThan(chunksBeforeLoop);
+
+	// Should have created 2 iterators: one for near the end, one for the loop
+	const created = manager.getAudioIteratorsCreated();
+	expect(created).toBe(2);
+
+	// Verify we have chunks from both the end and the beginning
+	expect(scheduledChunks.some((t) => t > 9.9)).toBe(true);
+	expect(scheduledChunks.some((t) => t < 0.1)).toBe(true);
+});
+
+test('should use pre-warmed iterator when looping with prepareLoopTransition', async () => {
+	const {manager, fps, playbackRate, getIsPlaying} = await prepare();
+
+	const scheduledChunks: number[] = [];
+	const scheduleAudioNode = (
+		node: AudioBufferSourceNode,
+		mediaTimestamp: number,
+	) => {
+		node.start(mediaTimestamp);
+		setTimeout(
+			() => {
+				node.stop();
+			},
+			(node.buffer?.duration ?? 0) * 1000,
+		);
+		scheduledChunks.push(mediaTimestamp);
+	};
+
+	// simulate loop scenario & preparing for loop
+	await manager.prepareLoopTransition({startTimeInSeconds: 0});
+
+	await manager.seek({
+		newTime: 9.97,
+		scheduleAudioNode,
+		fps,
+		getIsPlaying,
+		nonce: makeNonceManager().createAsyncOperation(),
+		playbackRate,
+		bufferState: {
+			delayPlayback: () => ({unblock: () => {}}),
+		},
+	});
+
+	const chunksBeforeLoop = scheduledChunks.length;
+	const iteratorsBeforeLoop = manager.getAudioIteratorsCreated();
+
+	expect(iteratorsBeforeLoop).toBe(1);
+
+	await manager.seek({
+		newTime: 0,
+		scheduleAudioNode,
+		fps,
+		getIsPlaying,
+		nonce: makeNonceManager().createAsyncOperation(),
+		playbackRate,
+		bufferState: {
+			delayPlayback: () => ({unblock: () => {}}),
+		},
+	});
+
+	const chunksAfterLoop = scheduledChunks.length;
+	expect(chunksAfterLoop).toBeGreaterThan(chunksBeforeLoop);
+
+	const loopChunks = scheduledChunks.slice(chunksBeforeLoop);
+	expect(loopChunks.some((t) => t < 0.1)).toBe(true);
+
+	// Key assertion: No new iterator was created during the loop!
+	// We reused the pre-warmed one, so iterator count stays at 1
+	const iteratorsAfterLoop = manager.getAudioIteratorsCreated();
+	expect(iteratorsAfterLoop).toBe(1);
+
+	// Most robust assertion: Verify the swap occurred exactly once
+	expect(manager.getLoopSwapCount()).toBe(1);
+
+	expect(scheduledChunks.some((t) => t > 9.9)).toBe(true);
+	expect(scheduledChunks.some((t) => t < 0.1)).toBe(true);
+});
diff --git a/packages/media/src/video-iterator-manager.ts b/packages/media/src/video-iterator-manager.ts
index cff28222fd9..6013de0fe3e 100644
--- a/packages/media/src/video-iterator-manager.ts
+++ b/packages/media/src/video-iterator-manager.ts
@@ -29,11 +29,14 @@ export const videoIteratorManager = ({
 	let videoFrameIterator: VideoIterator | null = null;
 	let framesRendered = 0;
 
+	let loopTransitionIterator: VideoIterator | null = null;
+	let loopSwapCount = 0;
+
 	canvas.width = videoTrack.displayWidth;
 	canvas.height = videoTrack.displayHeight;
 
 	const canvasSink = new CanvasSink(videoTrack, {
-		poolSize: 2,
+		poolSize: 3,
 		fit: 'contain',
 		alpha: true,
 	});
@@ -109,6 +112,15 @@ export const videoIteratorManager = ({
 			return;
 		}
 
+		// if cannot satisfy seek, use loop transition iterator if available
+		if (loopTransitionIterator) {
+			videoFrameIterator.destroy();
+			videoFrameIterator = loopTransitionIterator;
+			loopTransitionIterator = null;
+			loopSwapCount++;
+			return;
+		}
+
 		// Intentionally not awaited, letting audio start as well
 		startVideoIterator(newTime, nonce).catch(() => {
 			// Ignore errors, might be stale or disposed
@@ -121,12 +133,34 @@ export const videoIteratorManager = ({
 		seek,
 		destroy: () => {
 			videoFrameIterator?.destroy();
+			loopTransitionIterator?.destroy();
 			context.clearRect(0, 0, canvas.width, canvas.height);
 			videoFrameIterator = null;
+			loopTransitionIterator = null;
 		},
 		getVideoFrameIterator: () => videoFrameIterator,
 		drawFrame,
 		getFramesRendered: () => framesRendered,
+		getLoopSwapCount: () => loopSwapCount,
+		prepareLoopTransition: async ({startTime}: {startTime: number}) => {
+			// skip if already created
+			if (loopTransitionIterator) {
+				return;
+			}
+
+			const iterator = createVideoIterator(startTime, canvasSink);
+			loopTransitionIterator = iterator;
+
+			try {
+				// Pre-warm the decoder by fetching the first frame
+				// This initializes the VideoDecoder and starts decoding
+				await iterator.getNext();
+			} catch (e) {
+				loopTransitionIterator?.destroy();
+				loopTransitionIterator = null;
+				throw e;
+			}
+		},
 	};
 };