Audio File I/O

Kodio supports reading and writing audio files in common container formats. The API works across all Kotlin Multiplatform targets, including platforms without filesystem access.

Supported formats

Format	Read	Write	Extensions
WAV	PCM int (8/16/24/32-bit), IEEE float (32/64-bit)	PCM int, IEEE float	`.wav`, `.wave`
AIFF	PCM int (8/16/24/32-bit), IEEE float (32/64-bit)	PCM int, IEEE float	`.aiff`, `.aif`
AU	PCM int (8/16/24/32-bit), IEEE float (32/64-bit)	PCM int, IEEE float	`.au`, `.snd`

Specify the format with AudioFileFormat.Wav, AudioFileFormat.Aiff, or AudioFileFormat.Au.

Saving recordings

Save a recording to disk. The default format is WAV:

recording.saveAs(Path("my-recording.wav"))

Save as AIFF or AU:

recording.saveAs(Path("my-recording.aiff"), fileFormat = AudioFileFormat.Aiff)
recording.saveAs(Path("my-recording.au"), fileFormat = AudioFileFormat.Au)

For more control over the output, use the AudioFlow extensions:

// Write to a file
audioFlow.writeToFile(AudioFileFormat.Wav, Path("output.wav"))
audioFlow.writeToFile(AudioFileFormat.Aiff, Path("output.aiff"))

// Write to any kotlinx.io Sink
audioFlow.writeToSink(AudioFileFormat.Au, sink)

// Collect into an in-memory Buffer
val buffer = audioFlow.collectAsBuffer(AudioFileFormat.Wav)

Loading audio files

Kodio provides three ways to load audio files, for all KMP platforms.

From Compose resources or byte arrays

Use fromBytes() to load audio from Compose Multiplatform resources, network responses, or any in-memory byte array:

// Compose resource (WAV)
val recording = AudioRecording.fromBytes(
    Res.readBytes("files/notification.wav")
)

// AIFF from bytes
val aiffRecording = AudioRecording.fromBytes(
    bytes = aiffData,
    fileFormat = AudioFileFormat.Aiff
)

// Network response
val wavData: ByteArray = httpClient.get(url).body()
val recording = AudioRecording.fromBytes(wavData)

This works on all platforms, including web and sandboxed mobile environments.

From a file path

Use fromFile() for direct filesystem access. The format is auto-detected from the file extension:

val wavRecording = AudioRecording.fromFile(Path("recording.wav"))
val aiffRecording = AudioRecording.fromFile(Path("recording.aiff"))
val auRecording = AudioRecording.fromFile(Path("recording.au"))

From a stream

Use fromSource() to load from any kotlinx.io.Source, such as an Android ContentResolver stream:

// Android ContentResolver
val source = contentResolver.openInputStream(uri)!!
    .asSource()
    .buffered()
val recording = AudioRecording.fromSource(source, AudioFileFormat.Wav)

All three methods accept an optional AudioFileFormat parameter (defaults to Wav):

// Explicit format
val recording = AudioRecording.fromBytes(data, AudioFileFormat.Aiff)

Error handling

Read errors

Loading can throw the following errors:

AudioFileReadError.InvalidFile: The data is not a valid audio file (for example missing header or corrupt structure).
AudioFileReadError.UnsupportedFormat: The file uses an encoding Kodio doesn't support (for example compressed ADPCM).
AudioFileReadError.IO: A filesystem-level error occurred while reading.

try {
    val recording = AudioRecording.fromFile(Path("audio.wav"))
} catch (e: AudioFileReadError.InvalidFile) {
    println("Not a valid audio file: ${e.message}")
} catch (e: AudioFileReadError.UnsupportedFormat) {
    println("Format not supported: ${e.message}")
} catch (e: AudioFileReadError.IO) {
    println("Could not read file: ${e.cause}")
}

Write errors

Saving can throw the following errors:

AudioFileWriteError.UnsupportedFormat: The audio format cannot be written to the target container (for example planar layout to WAV).
AudioFileWriteError.IO: A filesystem-level error occurred while writing.

Platform guide

Platform	Recommended method	Notes
Compose Multiplatform	`fromBytes(Res.readBytes(...))`	Works everywhere, uses Compose resource system
JVM / Desktop	`fromFile(Path(...))`	Direct filesystem access
Android	`fromSource(inputStream.asSource())`	Use ContentResolver for user-selected files
iOS / macOS	`fromFile(Path(...))` or `fromBytes(...)`	Filesystem or bundled resources
Web (JS / Wasm)	`fromBytes(...)`	No filesystem; use fetch or bundled assets

Last modified: 03 July 2026