Cookies for analytics and advertising
We use cookies for analytics and advertising, both sent to Google. Refusing changes nothing you can see.Read the privacy page
Converting OGG to WAV gives you plain 16-bit PCM that a game engine, a sampler or an editor will import without needing a Vorbis decoder. The audio itself is unchanged — Vorbis discarded detail permanently and WAV stores what survived at several times the size — so the reason to do this is tooling, and the one thing to save first is your loop points.
Up to 100 files at once. Mixed formats are fine.
They convert one after another and download together as a ZIP.
OGG to WAV
This is the first section rather than a footnote because it is the mistake that costs the most time. A looping music bed or ambience track in a game usually carries loop markers, and in Ogg they are ordinary Vorbis comment fields: LOOPSTART and LOOPLENGTH are the common pair, but engines have used LOOP_START, LOOPEND and half a dozen other names. They are text keys holding sample offsets.
WAV records loops in a completely different place — a binary `smpl` chunk with its own loop list — and nothing here translates one into the other. Open the Ogg in a tag editor, or run `vorbiscomment -l` on it, and write the numbers down before converting. A loop point is a sample offset accurate to one forty-four-thousandth of a second, and no amount of listening afterwards will reconstruct it.
Ogg is a container released by Xiph.Org in 2000 and documented as RFC 3533 in 2003, and Vorbis is the codec that made it matter. It arrived at the moment when MP3 licensing was a real per-title cost for anyone shipping software, and Vorbis was deliberately built to be as good and to cost nothing. Every engine and middleware stack of that era took it up, and the decision stuck.
The result is that `.ogg` is the native asset format of an enormous body of work: id Tech source ports, Minecraft, Unity and Godot projects, FMOD and Wwise banks, and thousands of independent titles. If you are reading this you almost certainly did not choose Ogg either — you opened a game folder and found it, or your project inherited it.
The registry lists three codecs for Ogg: Vorbis, Opus and FLAC. Vorbis is what game assets almost always hold. Opus turns up in newer engine exports and browser recordings. FLAC inside Ogg is uncommon but real, and appears in archival and reference material.
The distinction is not academic. From Vorbis or Opus, the WAV is a larger container for audio that has already been compressed, and it cannot be otherwise. From FLAC, the WAV carries the audio the encoder was given — bit for bit if that audio was 16-bit, because the WAV written here is always 16-bit PCM and a 24-bit archival master is truncated to fit it. VLC's Codec Information panel names the codec in two clicks, and it is worth the two clicks before you decide how much to care about what follows.
Compressed audio has to be decoded before it can be played, and in a game that decode happens under a frame budget. Short effects are therefore normally loaded as PCM regardless of what shipped on disk, which is why engines convert on import and why an authoring tool would rather be handed the PCM directly.
Hardware samplers and grooveboxes go further and contain no decoder at all — they read PCM off a card, and an Ogg is not so much rejected as invisible to them. The same is true of a good deal of DSP and analysis tooling. In all of those cases the WAV is not an upgrade in quality, it is the only shape the audio can arrive in.
Signed 16-bit little-endian PCM, at the sample rate and channel count of the source. Effects are commonly mono at 44,100 Hz and music stereo at the same rate; both come through unchanged, and unusual rates such as 22,050 or 32,000 are preserved rather than normalised.
Sixteen bits is the right depth here and raising it would be pointless. Vorbis decodes to floating-point samples internally, but the information content is fixed by what the encoder kept — writing 24-bit would make every file half as large again while adding nothing. If a mastering stage wants floats, it will convert on load.
Sixteen-bit stereo at 44,100 Hz is 10.1 megabytes a minute; mono is half. Individually that is nothing — a two-second effect that was 30 KB as Vorbis becomes about 350 KB. Across a folder of two thousand effects it is the difference between a 60 MB directory and a 700 MB one, which is exactly why the game shipped Vorbis in the first place.
So convert what you are working on, not what you own. The sensible pattern is to pull out the handful of assets you are editing, work on them as WAV, and encode back to the format the engine expects when you are done. If you genuinely need a lossless local archive of a project's audio, FLAC is the right target: same fidelity, roughly half the bytes, and every editor reads it.
Ogg stores metadata as Vorbis-style comments, which is an open-ended list of uppercase key-value pairs — and game pipelines have used that openness enthusiastically for loop points, mix-bus assignments, localisation keys and build stamps.
A WAV's RIFF INFO chunk has room for title, artist, album, track number, genre, date and comment, in ISO 8859-1 only. Everything else — every custom key, the cover art, the album artist, the lyrics — is dropped rather than written somewhere nothing reads. If a pipeline depends on any of those fields, extract them to a sidecar file before converting; a converted WAV will not carry them back.
The decode uses the codecs on your own device, so whether a given Ogg opens depends on the browser you are in rather than on anything this page can decide. Opus is available everywhere because calls required it. Vorbis is widely but not uniformly supported, and FLAC inside Ogg is narrower still — the registry marks Ogg's support as patchy, and that is not a hedge.
When the codec is missing, the conversion stops and says that nothing in the file could be converted and that it may use a codec this browser cannot read. It does not write an empty WAV and call it done. If you hit that message, try the same file in another browser before deciding the asset is damaged; the file is usually fine and the machine is the limitation.
Drop up to 100 files at once and they come back as a single ZIP, with a 100 MB ceiling per file — far above any effect and comfortable for most music beds. There is no queue, because the decoding is happening on your processor rather than on a server somebody has to pay for.
Two practical notes. The hundred is the batch, not a guideline: a folder of five thousand short effects is fifty drops, and the files past the hundredth in any one of them are listed and left alone. And the licence on a game's audio does not change because you changed its container: extracted assets are still the publisher's work, and converting them for personal modding is a different thing from redistributing them.
| OGG | WAV | |
|---|---|---|
| Full name | Ogg Audio | Waveform Audio |
| File extension | .ogg, .oga | .wav, .wave |
| Media type | audio/ogg | audio/wav |
| Compression | Lossy — file size is bought with quality | Uncompressed |
| First published | 2000 | 1991 |
| Published by | Xiph.Org | Microsoft |
| Specification | RFC 3533 | RIFF WAVE |
| Licensing | Open standard | Published, not standardised |
| Standing today | Current | Current |
| Bit depth | — | 32 |
| Audio channels | — | up to 65,535 |
| Opens in a browser | Current browsers | Every browser |
| Considered instead | MP3, AAC, OPUS | FLAC, AIFF |
document properties can cross over — both OGG and WAV have somewhere to store it.
WAV is a working format and OGG is a finished one. What comes back is editable text and objects rather than a picture of a page, which is usually the reason for the conversion and also where its limits are.
WAV opens in every current browser. OGG has narrower browser support than that. If the file is going onto a web page or into a form, that is usually the whole reason for the conversion.
WAV is a container rather than a single format. What actually plays is the codec inside it — usually PCM — which is why two files with the same extension can behave differently on the same device.
Audacity reads both OGG and WAV, so there is a way to check the result against the original without a second tool.
The two are aimed at different work: OGG at the web and handing a finished file over, WAV at editing and archiving. That is worth weighing before converting, because the reason one exists is usually the reason the other is awkward.
OGG is Xiph.Org's format, published in 2000. The specification is RFC 3533, and it is worth reading if the file has to outlive the tool that wrote it.
WAV comes from Microsoft and dates from 1991, specified as RIFF WAVE. Audacity, Adobe Audition and Reaper all read it.
Because Vorbis was patent-free in 2000 and MP3 was not. Shipping MP3 in a commercial game meant paying Fraunhofer per title; shipping Vorbis meant paying nobody, and Xiph.Org built it with that explicitly in mind and gave the Ogg container the same treatment in RFC 3533. Every engine and middleware stack from that era adopted it, which is why Ogg files fill the asset folders of thousands of titles two decades later.
No, and this is the thing to plan around. Ogg carries loop markers as ordinary Vorbis comment fields — LOOPSTART and LOOPLENGTH, or the equivalent names a particular engine chose — while WAV carries loops in a binary `smpl` chunk. Neither is translated into the other here. Read the comment values out of the Ogg before you convert and re-enter them in whatever tool sets the WAV loop, because the numbers are sample offsets and are not recoverable by ear.
Not if the Ogg holds Vorbis or Opus, which is the usual case — those are lossy, the detail they discarded is gone, and the WAV stores what is left at five to ten times the size. If the Ogg holds FLAC, which happens in archival material, the WAV matches it sample for sample when that FLAC is 16-bit; a 24-bit master is written down to 16 here and loses the bottom eight bits of every sample.
Signed 16-bit little-endian PCM at the sample rate and channel count of the source. Game assets are commonly mono at 44,100 Hz for effects and stereo for music, and both pass through unchanged. That combination is what Unity, Godot, Unreal, FMOD, Wwise, Audacity and every sampler expect to be handed.
Sixteen-bit stereo at 44,100 Hz is 10.1 MB per minute; mono is half that. A two-second effect that was 30 KB as Vorbis is around 350 KB as stereo WAV, which is nothing individually and considerable across a folder of two thousand. Converting an entire asset library to WAV for storage is a mistake; converting the handful you are actually editing is not.
No. Your browser decodes the Ogg with the codec it already has, and a WAV is a header wrapped around the resulting samples — no encoder package is downloaded and no server is involved. That matters for unreleased project audio and it matters for licensed game assets, which stay exactly where they were rather than being copied onto somebody else's infrastructure.