Audio device, Wave, Sound, Music, AudioStream — every raudio.c binding.
Every raudio.c binding — audio device, Wave (CPU), Sound (short GPU one-shot), Music (streaming BGM), AudioStream (low-level).
Audio.init() / Audio.close() / Audio.is_ready() -> BoolOpen/close the audio device. Required before any Sound/Music/Wave call.
Audio.init()
-- ... audio calls ...
Audio.close()Audio.set_master_volume(volume: Float32) / get_master_volume() -> Float32Global output volume in [0, 1].
Audio.set_master_volume(Float32(0.5))Wave.load(filePath: String) -> WaveLoad WAV/OGG/MP3/FLAC/QOA/XM/MOD from disk.
val w = Wave.load("tests/assets/bounce.wav")Wave.load_from_memory(fileType: String, data: [UInt8], dataSize: Int32) -> WaveLoad Wave from in-memory byte buffer (first live [UInt8] FFI consumer).
val w = Wave.load_from_memory(".wav", bytes, Int32(bytes.length))Wave.is_valid(wave) -> Bool / Wave.unload(wave)Validity guard + release sample buffer.
if Wave.is_valid(w) { Wave.unload(w) }Wave.copy(wave) -> Wave / crop(wave, initFrame, finalFrame) / format(wave, sampleRate, sampleSize, channels)Deep copy; frame-range crop; sample-rate / bit-depth / channel conversion.
val short = Wave.crop(w, Int32(0), Int32(22050))Wave.load_samples(wave) -> [Float32]Read PCM samples into a Float32 array for inspection/DSP.
val samples = Wave.load_samples(w)Wave.export(wave, filePath) -> Bool / Wave.export_as_code(wave, filePath) -> BoolWrite Wave to disk as WAV; emit as C source.
Wave.export(w, "bounce.wav")Wave.to_sound(wave) -> SoundUpload Wave → GPU Sound for playback. The Wave itself is still owned by you.
val s = Wave.to_sound(w)Sound.load(filePath: String) -> SoundLoad sound file directly (internally = LoadWave + LoadSoundFromWave).
val bounce = Sound.load("tests/assets/bounce.wav")Sound.from_wave(wave) / alias(source) / unload_alias(alias)Aliases share sample buffer — cheap way to play overlapping copies of the same one-shot.
val copy = Sound.alias(bounce)
Sound.play(copy)
Sound.unload_alias(copy)Sound.is_valid(sound) / unload(sound)Guard + release.
if Sound.is_valid(bounce) { Sound.unload(bounce) }Sound.play / stop / pause / resume(sound) / is_playing(sound) -> BoolPlayback controls for one-shots.
if Rectangle.collides(paddle, ball) {
Sound.play(bounce)
}Sound.set_volume / set_pitch / set_pan(sound, value: Float32)Per-sound volume [0..1], pitch multiplier (1.0 = normal), pan [0..1] (0.5 = center).
Sound.set_volume(bounce, Float32(0.8))Sound.update(sound, data: [Float32], sampleCount: Int32)Overwrite the sample buffer with new data. Useful for generated sounds.
Sound.update(s, samples, Int32(samples.length))Music.load(filePath: String) -> Music / Music.load_from_memory(fileType, data: [UInt8], dataSize)Streaming long audio from file or memory.
val bgm = Music.load("tests/assets/loop.ogg")Music.is_valid(music) / unload(music)Guard + release.
if Music.is_valid(bgm) { Music.unload(bgm) }Music.play / is_playing / update / stop / pause / resume(music)Call Music.update(m) every frame to feed the decoder's circular buffer.
Music.play(bgm)
while not Window.should_close() {
Music.update(bgm)
}Music.seek(music, position: Float32) / get_time_length(music) / get_time_played(music) -> Float32Seconds-based transport controls.
val t = Music.get_time_played(bgm)
Music.seek(bgm, Float32(30.0))Music.set_volume / set_pitch / set_pan / set_looping(music, value)Per-track mixer parameters plus loop flag. set_looping returns the updated Music value.
var bgm2 = Music.set_looping(bgm, true)AudioStream.load(sampleRate: UInt32, sampleSize: UInt32, channels: UInt32) -> AudioStreamLow-level PCM stream you feed manually. Used internally by Music and exposed for synthesis.
val st = AudioStream.load(UInt32(44100), UInt32(16), UInt32(2))AudioStream.update(stream, data: [Float32], frameCount: Int32) / is_processed(stream) -> BoolSupply new PCM data when is_processed says the next buffer is free.
if AudioStream.is_processed(st) {
AudioStream.update(st, samples, Int32(samples.length))
}AudioStream.is_valid(stream) / unload(stream)Guard + release.
AudioStream.unload(st)AudioStream.play / pause / resume / stop / is_playing(stream)Playback transport.
AudioStream.play(st)AudioStream.set_volume / set_pitch / set_pan(stream, value: Float32)Per-stream mixer params.
AudioStream.set_volume(st, Float32(0.7))AudioStream.set_buffer_size_default(size: Int32)Tweak the default frame-size for newly-loaded streams (affects latency / CPU).
AudioStream.set_buffer_size_default(Int32(4096))The following callback-based audio APIs are declared in raylib.iron, but they are not usable from Iron yet. The missing piece is compiler support for passing Iron closures through this FFI callback shape. Until that lands, use AudioStream.update in the main loop instead.
AudioStream.set_callback(stream, cb: func(Int, UInt32)) (currently unavailable)Per-stream audio-thread callback. This API is documented for completeness, but it is not usable from Iron yet; use the update pattern instead.
-- Not yet available from Iron.AudioStream.attach_processor(stream, cb) / detach_processor(stream) (currently unavailable)Add or remove a per-stream DSP processor. This API is not usable from Iron yet for the same callback-FFI reason.
-- Not yet available from Iron.Audio.attach_mixed_processor(cb) / detach_mixed_processor() (currently unavailable)Master-bus DSP processor applied to every stream. This API is not usable from Iron yet.
-- Not yet available from Iron.*.load_from_memory APIs.