diff --git a/apps/electron-app/index.html b/apps/electron-app/index.html
index a09a0d5..b966cb0 100644
--- a/apps/electron-app/index.html
+++ b/apps/electron-app/index.html
@@ -13,6 +13,7 @@
 				style-src 'self' 'unsafe-inline';
 				connect-src 'self' https://*.trycloudflare.com wss: ws: http: https:;
 				img-src 'self' data:;
+				media-src 'self' blob: file:;
 			"
 		/>
 		<style>
diff --git a/apps/electron-app/src/common/nodes.ts b/apps/electron-app/src/common/nodes.ts
index be5607a..9d6559b 100644
--- a/apps/electron-app/src/common/nodes.ts
+++ b/apps/electron-app/src/common/nodes.ts
@@ -34,6 +34,7 @@ import { Switch } from '../render/components/react-flow/nodes/Switch';
 import { Proximity } from '../render/components/react-flow/nodes/Proximity';
 import { Llm } from '../render/components/react-flow/nodes/Llm';
 import { Hotkey } from '../render/components/react-flow/nodes/Hotkey';
+import { AudioPlayer } from '../render/components/react-flow/nodes/AudioPlayer/AudioPlayer';
 import { Node } from '@xyflow/react';
 
 export function isNodeTypeACodeType(node?: Node) {
@@ -80,6 +81,7 @@ export const NODE_TYPES: Record<string, (props: any) => JSX.Element> = {
 	Trigger: Trigger,
 	Vibration: Vibration,
 	Hotkey: Hotkey,
+	AudioPlayer: AudioPlayer,
 } as const;
 
 export type NodeType = keyof typeof NODE_TYPES;
diff --git a/apps/electron-app/src/main/file.ts b/apps/electron-app/src/main/file.ts
index 5aa57d8..a25a426 100644
--- a/apps/electron-app/src/main/file.ts
+++ b/apps/electron-app/src/main/file.ts
@@ -48,3 +48,31 @@ export async function importFlow(): Promise<FlowState | null> {
 		});
 	});
 }
+
+export async function selectAudioFiles(): Promise<string[]> {
+	const result = await dialog.showOpenDialog({
+		title: 'Select Audio Files',
+		filters: [
+			{ name: 'Audio files', extensions: ['mp3', 'wav', 'ogg', 'm4a', 'aac', 'flac'] },
+			{ name: 'All files', extensions: ['*'] },
+		],
+		properties: ['openFile', 'multiSelections'],
+	});
+
+	if (result.canceled || !result.filePaths) {
+		return [];
+	}
+
+	return result.filePaths;
+}
+
+export async function readAudioFile(filePath: string): Promise<Buffer> {
+	return new Promise<Buffer>((resolve, reject) => {
+		fs.readFile(filePath, (err, data) => {
+			if (err) {
+				return reject(err);
+			}
+			resolve(data);
+		});
+	});
+}
diff --git a/apps/electron-app/src/main/ipc.ts b/apps/electron-app/src/main/ipc.ts
index 4c818bb..022ca83 100644
--- a/apps/electron-app/src/main/ipc.ts
+++ b/apps/electron-app/src/main/ipc.ts
@@ -3,7 +3,7 @@ import { app, ipcMain, Menu } from 'electron';
 import { mainWindowReady } from './window';
 
 import log from 'electron-log/node';
-import { exportFlow } from './file';
+import { exportFlow, selectAudioFiles, readAudioFile } from './file';
 import { ensureRunnerProcess, getRunnerProcess, killRunnerProcess } from './board-connection';
 import { checkConnectedPort, setupUSBDeviceListeners, stopPortPolling } from './port-manager';
 import { Timer } from './utils';
@@ -51,6 +51,16 @@ ipcMain.on('ipc-external-value', (_event, data: { nodeId: string; value: unknown
 	runnerProcess?.send({ type: 'setExternal', nodeId: data.nodeId, value: data.value });
 });
 
+ipcMain.handle('ipc-select-audio-files', async () => {
+	return await selectAudioFiles();
+});
+
+ipcMain.handle('ipc-read-audio-file', async (_event, filePath: string) => {
+	const buffer = await readAudioFile(filePath);
+	// Convert buffer to base64 for transmission
+	return buffer.toString('base64');
+});
+
 killRunnerProcess().catch(log.debug);
 
 app.on('before-quit', async event => {
diff --git a/apps/electron-app/src/main/window.ts b/apps/electron-app/src/main/window.ts
index 4dbe718..b6ecee8 100644
--- a/apps/electron-app/src/main/window.ts
+++ b/apps/electron-app/src/main/window.ts
@@ -50,7 +50,7 @@ export function handleSecondInstance(commandLine: string[]) {
 export async function recreateWindowWhenNeeded() {
 	if (windows.length === 0) {
 		await createWindow();
-		await new Promise(resolve => setTimeout(resolve, 500));
+		await new Promise(resolve => setTimeout(resolve, 250));
 	}
 
 	return Promise.resolve();
diff --git a/apps/electron-app/src/preload.ts b/apps/electron-app/src/preload.ts
index bc79150..c08b70c 100644
--- a/apps/electron-app/src/preload.ts
+++ b/apps/electron-app/src/preload.ts
@@ -13,7 +13,9 @@ export type Channels =
 	| 'ipc-deep-link'
 	| 'ipc-export-flow'
 	| 'ipc-flow'
-	| 'ipc-board';
+	| 'ipc-board'
+	| 'ipc-select-audio-files'
+	| 'ipc-read-audio-file';
 
 type IpcCallback<Data> = (response: IpcResponse<Data>) => void;
 type Listener = (event: IpcRendererEvent, response: IpcResponse<any>) => void;
@@ -54,6 +56,10 @@ export const electronHandler = {
 			console.debug('[IPC] <once>', channel);
 			ipcRenderer.once(channel, (_event, args) => callback(args));
 		},
+		invoke<Data>(channel: Channels, data?: Data): Promise<any> {
+			logger.debug('[IPC] <invoke>', channel, data);
+			return ipcRenderer.invoke(channel, data);
+		},
 	},
 	os: {
 		isMac: process.platform === 'darwin',
diff --git a/apps/electron-app/src/render/components/react-flow/nodes/AudioPlayer/AudioFileEditor.tsx b/apps/electron-app/src/render/components/react-flow/nodes/AudioPlayer/AudioFileEditor.tsx
new file mode 100644
index 0000000..b1f0484
--- /dev/null
+++ b/apps/electron-app/src/render/components/react-flow/nodes/AudioPlayer/AudioFileEditor.tsx
@@ -0,0 +1,288 @@
+import {
+	Button,
+	Dialog,
+	DialogClose,
+	DialogContent,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	Empty,
+	EmptyDescription,
+	EmptyHeader,
+	EmptyMedia,
+	Item,
+	ItemActions,
+	ItemContent,
+	ItemDescription,
+	ItemTitle,
+} from '@microflow/ui';
+import { useState, useRef, useEffect } from 'react';
+import { Icons } from '@microflow/ui';
+
+export function AudioFileEditor(props: Props) {
+	const [editedFiles, setEditedFiles] = useState<string[]>(props.audioFiles);
+	const [playingIndex, setPlayingIndex] = useState<number | null>(null);
+	const audioRef = useRef<HTMLAudioElement | null>(null);
+
+	const handleAddFiles = async () => {
+		try {
+			const filePaths = await window.electron.ipcRenderer.invoke('ipc-select-audio-files');
+			if (filePaths && filePaths.length > 0) {
+				setEditedFiles(prev => [...prev, ...filePaths]);
+			}
+		} catch (error) {
+			console.error('Error selecting audio files:', error);
+		}
+	};
+
+	const getFileName = (filePath: string, index: number) => {
+		try {
+			// Extract file name from path
+			const pathParts = filePath.split(/[/\\]/);
+			const fileNameWithExt = pathParts[pathParts.length - 1] || `Audio file ${index + 1}`;
+
+			// Extract extension to determine mime type
+			const extension = fileNameWithExt.split('.').pop()?.toLowerCase() || '';
+			const mimeTypeMap: Record<string, string> = {
+				mp3: 'MP3',
+				wav: 'WAV',
+				ogg: 'OGG',
+				m4a: 'M4A',
+				aac: 'AAC',
+				flac: 'FLAC',
+			};
+			const mimeType = mimeTypeMap[extension] || extension.toUpperCase() || 'UNKNOWN';
+
+			// Remove extension from fileName
+			const fileName =
+				extension && fileNameWithExt.endsWith(`.${extension}`)
+					? fileNameWithExt.slice(0, -(extension.length + 1))
+					: fileNameWithExt;
+
+			return { fileName, mimeType };
+		} catch {
+			return { fileName: `Audio file ${index + 1}`, mimeType: 'UNKNOWN' };
+		}
+	};
+
+	const handlePlayPause = async (index: number, filePath: string) => {
+		// If clicking the same audio that's playing, pause it
+		if (playingIndex === index && audioRef.current) {
+			audioRef.current.pause();
+			setPlayingIndex(null);
+			audioRef.current = null;
+			return;
+		}
+
+		// Stop any currently playing audio
+		if (audioRef.current) {
+			audioRef.current.pause();
+			audioRef.current = null;
+		}
+
+		let blobUrl: string | null = null;
+
+		const cleanup = () => {
+			if (blobUrl) {
+				URL.revokeObjectURL(blobUrl);
+				blobUrl = null;
+			}
+			setPlayingIndex(null);
+			audioRef.current = null;
+		};
+
+		try {
+			// Read file via IPC and create blob URL
+			const base64Data = await window.electron.ipcRenderer.invoke('ipc-read-audio-file', filePath);
+
+			// Convert base64 to binary
+			const binaryString = atob(base64Data);
+			const bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) {
+				bytes[i] = binaryString.charCodeAt(i);
+			}
+
+			// Determine MIME type from file extension
+			const extension = filePath.split('.').pop()?.toLowerCase() || '';
+			const mimeTypeMap: Record<string, string> = {
+				mp3: 'audio/mpeg',
+				wav: 'audio/wav',
+				ogg: 'audio/ogg',
+				m4a: 'audio/mp4',
+				aac: 'audio/aac',
+				flac: 'audio/flac',
+			};
+			const mimeType = mimeTypeMap[extension] || 'audio/mpeg';
+
+			// Create blob and blob URL
+			const blob = new Blob([bytes], { type: mimeType });
+			blobUrl = URL.createObjectURL(blob);
+
+			const audio = new Audio();
+			audioRef.current = audio;
+			setPlayingIndex(index);
+
+			// Set up event handlers before setting src
+			audio.onended = () => {
+				cleanup();
+			};
+
+			audio.onerror = e => {
+				const error = audio.error;
+				console.warn('Error playing audio:', {
+					error: error?.code,
+					message: error?.message,
+					filePath,
+					readyState: audio.readyState,
+				});
+				cleanup();
+			};
+
+			// Fallback timeout in case canplay doesn't fire
+			let timeout: NodeJS.Timeout | null = null;
+
+			audio.oncanplay = () => {
+				if (timeout) {
+					clearTimeout(timeout);
+					timeout = null;
+				}
+				// Audio is ready to play
+				audio.play().catch(error => {
+					console.warn('Error calling play():', error);
+					cleanup();
+				});
+			};
+
+			// Set the source and let it load
+			audio.src = blobUrl;
+			audio.load();
+
+			// Fallback: if canplay doesn't fire, try playing after a short delay
+			timeout = setTimeout(() => {
+				if (audio.readyState >= 2 && audio.paused) {
+					audio.play().catch(error => {
+						console.warn('Error playing audio (timeout fallback):', { error });
+						cleanup();
+					});
+				}
+			}, 500);
+		} catch (error) {
+			console.warn('Error reading audio file:', error);
+			cleanup();
+		}
+	};
+
+	// Cleanup audio on unmount
+	useEffect(() => {
+		return () => {
+			if (audioRef.current) {
+				audioRef.current.pause();
+				// Revoke any blob URLs
+				if (audioRef.current.src && audioRef.current.src.startsWith('blob:')) {
+					URL.revokeObjectURL(audioRef.current.src);
+				}
+				audioRef.current = null;
+			}
+		};
+	}, []);
+
+	return (
+		<Dialog
+			open={true}
+			onOpenChange={open => {
+				if (!open) {
+					// Stop any playing audio when closing
+					if (audioRef.current) {
+						audioRef.current.pause();
+						// Revoke any blob URLs
+						if (audioRef.current.src && audioRef.current.src.startsWith('blob:')) {
+							URL.revokeObjectURL(audioRef.current.src);
+						}
+						audioRef.current = null;
+					}
+					setPlayingIndex(null);
+					props.onClose();
+				}
+			}}
+		>
+			<DialogContent className='max-w-2xl'>
+				<DialogHeader>
+					<DialogTitle>Manage Audio Files</DialogTitle>
+				</DialogHeader>
+				<section className='flex flex-col space-y-4'>
+					<div className='space-y-2 max-h-96 overflow-y-auto'>
+						{editedFiles.map((filePath, index) => (
+							<Item variant='outline' key={index}>
+								<ItemContent>
+									<ItemTitle>{getFileName(filePath, index).fileName}</ItemTitle>
+									<ItemDescription>{getFileName(filePath, index).mimeType}</ItemDescription>
+								</ItemContent>
+								<ItemActions>
+									<Button
+										variant='outline'
+										size='sm'
+										onClick={() => handlePlayPause(index, filePath)}
+									>
+										{playingIndex === index ? <Icons.Pause size={16} /> : <Icons.Play size={16} />}
+									</Button>
+									<Button
+										variant='destructive'
+										size='sm'
+										onClick={() => {
+											setEditedFiles(prev => prev.filter((_, i) => i !== index));
+										}}
+									>
+										<Icons.Trash2 size={16} />
+									</Button>
+								</ItemActions>
+							</Item>
+						))}
+					</div>
+					{editedFiles.length === 0 && (
+						<Empty>
+							<EmptyHeader>
+								<EmptyMedia variant='icon'>
+									<Icons.Music2Icon />
+								</EmptyMedia>
+								<EmptyDescription>No audio files selected</EmptyDescription>
+							</EmptyHeader>
+						</Empty>
+					)}
+
+					<Button variant='ghost' onClick={handleAddFiles} className='w-full'>
+						<Icons.Plus size={16} />
+						Add Audio Files
+					</Button>
+				</section>
+				<DialogFooter>
+					<Button
+						variant='destructive'
+						onClick={() => {
+							setEditedFiles([]);
+						}}
+						disabled={editedFiles.length === 0}
+					>
+						Clear All
+					</Button>
+					<DialogClose asChild>
+						<Button
+							onClick={() => {
+								props.onSave({
+									audioFiles: editedFiles,
+								});
+							}}
+						>
+							Save
+						</Button>
+					</DialogClose>
+				</DialogFooter>
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+type Props = {
+	audioFiles: string[];
+	onSave: (data: { audioFiles: string[] }) => void;
+	onClose: () => void;
+};
diff --git a/apps/electron-app/src/render/components/react-flow/nodes/AudioPlayer/AudioPlayer.tsx b/apps/electron-app/src/render/components/react-flow/nodes/AudioPlayer/AudioPlayer.tsx
new file mode 100644
index 0000000..a3dc4c4
--- /dev/null
+++ b/apps/electron-app/src/render/components/react-flow/nodes/AudioPlayer/AudioPlayer.tsx
@@ -0,0 +1,95 @@
+import {
+	type Data,
+	type Value,
+	dataSchema,
+} from '@microflow/runtime/src/audioplayer/audioplayer.types';
+import { Position } from '@xyflow/react';
+import { useState } from 'react';
+import { Handle } from '../../Handle';
+import { BaseNode, NodeContainer, useNodeControls, useNodeData, useNodeId } from '../Node';
+import { useNodeValue } from '../../../../stores/node-data';
+import { button } from 'leva';
+import { AudioFileEditor } from './AudioFileEditor';
+import { IconWithValue } from '../../IconWithValue';
+
+export function AudioPlayer(props: Props) {
+	return (
+		<NodeContainer {...props}>
+			<Value />
+			<Settings />
+			<Handle type='target' position={Position.Left} id='play' offset={-0.5} />
+			<Handle type='target' position={Position.Left} id='stop' offset={0.5} />
+		</NodeContainer>
+	);
+}
+
+function Value() {
+	const data = useNodeData<Data>();
+	const isPlaying = useNodeValue<Value>(false);
+
+	return (
+		<IconWithValue
+			icon={isPlaying ? 'Volume2' : 'VolumeOff'}
+			value={data.audioFiles.length}
+			suffix=' files'
+			iconClassName={isPlaying ? 'text-green-500' : 'text-muted-foreground'}
+		/>
+	);
+}
+
+function Settings() {
+	const data = useNodeData<Data>();
+	const [editorOpened, setEditorOpened] = useState(false);
+	const { render, setNodeData } = useNodeControls<Data>(
+		{
+			volume: {
+				value: data.volume ?? 1,
+				min: 0,
+				max: 1,
+				step: 0.1,
+				label: 'volume',
+			},
+			loop: {
+				value: data.loop ?? false,
+				label: 'loop',
+			},
+			'manage files': button(() => {
+				setEditorOpened(true);
+			}),
+		},
+		[]
+	);
+
+	return (
+		<>
+			{render()}
+			{editorOpened && (
+				<AudioFileEditor
+					audioFiles={data.audioFiles}
+					onClose={() => {
+						setEditorOpened(false);
+					}}
+					onSave={newData => {
+						setNodeData({
+							...data,
+							audioFiles: newData.audioFiles,
+						});
+						setEditorOpened(false);
+					}}
+				/>
+			)}
+		</>
+	);
+}
+
+type Props = BaseNode<Data>;
+AudioPlayer.defaultProps = {
+	data: {
+		...dataSchema.parse({}),
+		group: 'flow',
+		tags: ['output', 'event'],
+		label: 'Audio Player',
+		icon: 'MusicIcon',
+		description: 'Select and play audio files from your device',
+	} satisfies Props['data'],
+};
diff --git a/packages/runtime/index.ts b/packages/runtime/index.ts
index 7ec9c21..afba3f7 100644
--- a/packages/runtime/index.ts
+++ b/packages/runtime/index.ts
@@ -27,4 +27,5 @@ export * from './src/smooth/smooth';
 export * from './src/switch/switch';
 export * from './src/trigger/trigger';
 export * from './src/hotkey/hotkey';
+export * from './src/audioplayer/audioplayer';
 export { Board } from 'johnny-five';
diff --git a/packages/runtime/package.json b/packages/runtime/package.json
index f2c0983..37a21a7 100644
--- a/packages/runtime/package.json
+++ b/packages/runtime/package.json
@@ -10,6 +10,7 @@
 	"devDependencies": {
 		"@types/johnny-five": "2.1.10",
 		"@types/node-pixel": "^0.11.2",
+		"@types/play-sound": "^1.1.2",
 		"typescript": "5.8.3"
 	},
 	"dependencies": {
@@ -18,6 +19,7 @@
 		"johnny-five": "https://github.com/xiduzo/johnny-five.git",
 		"langchain": "^0.3.19",
 		"node-pixel": "^0.11.0",
+		"play-sound": "^1.1.6",
 		"zod": "^4.1.13"
 	}
 }
diff --git a/packages/runtime/src/audioplayer/audioplayer.ts b/packages/runtime/src/audioplayer/audioplayer.ts
new file mode 100644
index 0000000..c5d50fc
--- /dev/null
+++ b/packages/runtime/src/audioplayer/audioplayer.ts
@@ -0,0 +1,60 @@
+import * as fs from 'fs';
+import { transformValueToNumber } from '../_utils/transformUnknownValues';
+import { Code } from '../base';
+import type { Data, Value } from './audioplayer.types';
+import { dataSchema } from './audioplayer.types';
+import player from 'play-sound';
+import { ChildProcess } from 'child_process';
+
+export class AudioPlayer extends Code<Value, Data> {
+	private currentProcess: ChildProcess | null = null;
+	private readonly audioPlayer = player();
+	private playId = 0;
+
+	constructor(data: Data) {
+		super(dataSchema.parse(data), false);
+	}
+
+	play(index?: unknown) {
+		const filePath = this.data.audioFiles.at(Math.round(transformValueToNumber(index) - 1));
+		if (!filePath) return;
+
+		this.playTrack(filePath);
+	}
+
+	private playTrack(filePath: string) {
+		if (!fs.existsSync(filePath)) return;
+
+		this.stop();
+
+		this.value = true;
+		const currentPlayId = ++this.playId;
+
+		this.currentProcess = this.audioPlayer.play(filePath, err => {
+			if (currentPlayId === this.playId) this.value = false;
+			if (err) return;
+			if (!this.data.loop) return;
+			if (currentPlayId !== this.playId) return;
+
+			setTimeout(() => {
+				this.playTrack(filePath);
+			}, 0);
+		});
+	}
+
+	stop() {
+		try {
+			this.currentProcess?.kill();
+		} catch (error) {
+			console.error(error);
+		} finally {
+			this.currentProcess = null;
+			this.value = false;
+		}
+	}
+
+	destroy() {
+		this.stop();
+		super.destroy();
+	}
+}
diff --git a/packages/runtime/src/audioplayer/audioplayer.types.ts b/packages/runtime/src/audioplayer/audioplayer.types.ts
new file mode 100644
index 0000000..61972ae
--- /dev/null
+++ b/packages/runtime/src/audioplayer/audioplayer.types.ts
@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { baseDataSchema } from '../base.types';
+
+export const valueSchema = z.boolean();
+export type Value = z.infer<typeof valueSchema>;
+
+export const dataSchema = baseDataSchema.extend({
+	instance: z.literal('AudioPlayer').default('AudioPlayer'),
+	audioFiles: z.array(z.string()).default([]).describe('Array of file paths'),
+	loop: z.boolean().default(false),
+	volume: z.number().min(0).max(1).default(1),
+});
+
+export type Data = z.infer<typeof dataSchema>;
diff --git a/yarn.lock b/yarn.lock
index 527755a..49187f7 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2505,9 +2505,11 @@ __metadata:
     "@langchain/ollama": ^0.2.0
     "@types/johnny-five": 2.1.10
     "@types/node-pixel": ^0.11.2
+    "@types/play-sound": ^1.1.2
     johnny-five: "https://github.com/xiduzo/johnny-five.git"
     langchain: ^0.3.19
     node-pixel: ^0.11.0
+    play-sound: ^1.1.6
     typescript: 5.8.3
     zod: ^4.1.13
   languageName: unknown
@@ -6065,6 +6067,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/play-sound@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "@types/play-sound@npm:1.1.2"
+  dependencies:
+    "@types/node": "*"
+  checksum: 0e0c532f196b947876685b0b992d29e58efcb41173d9aac1d833d96f7172a9649ec67c5ccee4d31285362bc0cb10edd0891993bafce84ec85a5ead8ef1a97282
+  languageName: node
+  linkType: hard
+
 "@types/postcss-url@npm:10.0.4":
   version: 10.0.4
   resolution: "@types/postcss-url@npm:10.0.4"
@@ -10410,6 +10421,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"find-exec@npm:1.0.3":
+  version: 1.0.3
+  resolution: "find-exec@npm:1.0.3"
+  dependencies:
+    shell-quote: ^1.8.1
+  checksum: 6be934f01a8f0728e6d29de4eb74470c8577f9d31c3d4bda752a3f0fb13ddfab7ba82d0e6d814b7792bf5fc2b5faf05fd5079e5ae5643aa75876e3fd22e03815
+  languageName: node
+  linkType: hard
+
 "find-up@npm:^2.0.0":
   version: 2.1.0
   resolution: "find-up@npm:2.1.0"
@@ -15265,6 +15285,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"play-sound@npm:^1.1.6":
+  version: 1.1.6
+  resolution: "play-sound@npm:1.1.6"
+  dependencies:
+    find-exec: 1.0.3
+  checksum: 3a974a9a48e3639f54ba15acf29b8935537532a3e219444a97ce8cab49de0064d5735f9ca64e6a83ef4ca7cbecbd0a0b83db7c6c0495e047e332fed81316dc89
+  languageName: node
+  linkType: hard
+
 "plist@npm:^3.0.0, plist@npm:^3.0.5, plist@npm:^3.1.0":
   version: 3.1.0
   resolution: "plist@npm:3.1.0"