Win31 Audio Design

Win31 Audio Design: Satisfying Retro Sound Vocabulary

Expert in creating authentic Windows 3.1 era sound experiences for modern web and mobile applications. Focuses on CC-licensed alternatives to the classic sound vocabulary while capturing the satisfying, lo-fi essence of early 90s computing.

When to Use

Use for:

• Win31-themed web applications needing audio feedback
• Retro game interfaces with 90s desktop sounds
• Mobile apps wanting satisfying micro-interaction sounds
• Converting modern flat sounds to vintage 8-bit aesthetic
• Creating sound palettes that evoke early Windows nostalgia

Do NOT use for:

• Modern flat/material sound design → sound-engineer
• Voice synthesis → voice-audio-engineer
• Music composition → DAW tools
• Film sound design → Linear audio workflows

Windows 3.1 Sound Vocabulary

The Original Sounds (Copyrighted - DO NOT USE)

| File | Character | Duration | Function |

|------|-----------|----------|----------|

| CHIMES.WAV | Ethereal bells | ~1.5s | System notifications |

| CHORD.WAV | Major chord resolve | ~1.2s | Task completion |

| DING.WAV | Single bell strike | ~0.5s | Attention/alert |

| TADA.WAV | Triumphant fanfare | ~2s | Startup/major success |

| RINGIN.WAV | Rising tone | ~0.3s | Modal open |

| RINGOUT.WAV | Falling tone | ~0.2s | Modal close |

Legal Warning: These sounds are copyrighted by Microsoft. We create INSPIRED alternatives, never copies.

Sound Characteristics (What Made Them Satisfying)

| Quality | Win31 Sound Profile |

|---------|---------------------|

| Sample Rate | 11kHz-22kHz (lo-fi charm) |

| Bit Depth | 8-bit (quantization warmth) |

| Frequency Range | 400Hz-4kHz (no sub-bass, gentle highs) |

| Envelope | Fast attack, medium decay, no sustain |

| Reverb | Dry or short room (no cathedral halls) |

| Character | Bright, plasticky, cheerful |

The Win31 "Ding" Formula

┌─────────────────────────────────────────────────────┐
│ Attack: 5-10ms    │ Pure sine starts BRIGHT         │
│ Peak: ~880Hz (A5) │ Classic 8-bit "bleep"           │
│ Decay: 200-400ms  │ Natural damping feel            │
│ Overtones: 2nd+3rd│ Bell-like shimmer               │
│ Processing: 8-bit │ Adds warmth via quantization    │
└─────────────────────────────────────────────────────┘

CC-Licensed Sound Resources

Recommended Sources

| Source | License | Best For |

|--------|---------|----------|

| Dominik Braun's 107 Retro Sounds | CC BY 4.0 | UI blips, beeps, positive feedback |

| LittleRobotSoundFactory (Freesound) | CC0/CC BY | 8-bit game sounds |

| OpenGameArt 512 SFX | CC0 | Comprehensive retro library |

| Gritty Retro UI (Exechamp) | CC0 | UI-specific clicks and tones |

Attribution Template

Audio: [Sound Name] by [Creator] from [Source]
Licensed under [CC BY 4.0 / CC0]
https://[source-url]

Sound Palette for Win31 Apps

Interaction Sounds

| Action | Sound Character | Duration | Frequency |

|--------|-----------------|----------|-----------|

| Button click | Soft plastic "tik" | 20-40ms | 800-1200Hz |

| Button release | Subtle "tok" | 15-30ms | 600-900Hz |

| Toggle on | Rising chirp | 80-120ms | 600→1200Hz |

| Toggle off | Falling chirp | 80-120ms | 1200→600Hz |

| Window open | Ascending arpeggio | 150-250ms | C4-E4-G4 |

| Window close | Descending arpeggio | 100-200ms | G4-E4-C4 |

| Error | Low buzz + descending | 300-500ms | 200-400Hz |

| Success | Bright ding + shimmer | 200-400ms | 880Hz + harmonics |

| Notification | Double chime | 400-600ms | 660Hz, 880Hz |

System Sounds

| Event | Sound Character | Duration |

|-------|-----------------|----------|

| Startup | Triumphant chord resolve | 1.5-2.5s |

| Shutdown | Gentle descending phrase | 1-2s |

| Critical error | Harsh double-buzz | 400-600ms |

| Task complete | Satisfying "da-ding!" | 300-500ms |

| Navigation | Soft whoosh + settle | 100-200ms |

Web Audio Implementation

Basic Sound Player

// Win31-style sound manager for web
class Win31SoundManager {
  private audioContext: AudioContext | null = null;
  private sounds: Map<string, AudioBuffer> = new Map();

  constructor() {
    // Lazy init on first user interaction (browser policy)
  }

  private getContext(): AudioContext {
    if (!this.audioContext) {
      this.audioContext = new AudioContext({ sampleRate: 22050 }); // Lo-fi!
    }
    return this.audioContext;
  }

  async loadSound(name: string, url: string) {
    const response = await fetch(url);
    const arrayBuffer = await response.arrayBuffer();
    const audioBuffer = await this.getContext().decodeAudioData(arrayBuffer);
    this.sounds.set(name, audioBuffer);
  }

  play(name: string, volume = 0.5) {
    const buffer = this.sounds.get(name);
    if (!buffer) return;

    const ctx = this.getContext();
    const source = ctx.createBufferSource();
    const gain = ctx.createGain();

    source.buffer = buffer;
    gain.gain.value = volume;

    source.connect(gain);
    gain.connect(ctx.destination);
    source.start(0);
  }

  // Procedural 8-bit "ding"
  playDing(frequency = 880) {
    const ctx = this.getContext();
    const osc = ctx.createOscillator();
    const gain = ctx.createGain();

    osc.type = 'triangle'; // Softer than sine, more 8-bit
    osc.frequency.setValueAtTime(frequency, ctx.currentTime);

    // Fast attack, medium decay
    gain.gain.setValueAtTime(0.3, ctx.currentTime);
    gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + 0.4);

    osc.connect(gain);
    gain.connect(ctx.destination);

    osc.start(ctx.currentTime);
    osc.stop(ctx.currentTime + 0.4);
  }
}

export const win31Sounds = new Win31SoundManager();

Synthesized Retro Sounds

// Generate Win31-style sounds procedurally
function createChime(ctx: AudioContext, baseFreq = 660): AudioBufferSourceNode {
  const duration = 1.5;
  const sampleRate = ctx.sampleRate;
  const buffer = ctx.createBuffer(1, duration * sampleRate, sampleRate);
  const data = buffer.getChannelData(0);

  // Two-tone chime (like CHIMES.WAV character)
  for (let i = 0; i < data.length; i++) {
    const t = i / sampleRate;
    const env = Math.exp(-t * 3); // Decay envelope

    // Two harmonically related tones
    const tone1 = Math.sin(2 * Math.PI * baseFreq * t);
    const tone2 = Math.sin(2 * Math.PI * baseFreq * 1.5 * t) * 0.5;

    data[i] = (tone1 + tone2) * env * 0.3;
  }

  // 8-bit quantization for authentic lo-fi
  for (let i = 0; i < data.length; i++) {
    data[i] = Math.round(data[i] * 127) / 127;
  }

  const source = ctx.createBufferSource();
  source.buffer = buffer;
  return source;
}

Mobile Haptic Coordination

iOS Haptic-Sound Pairing

| Sound Event | Haptic Type | Intensity |

|-------------|-------------|-----------|

| Button click | .light | 0.5 |

| Toggle switch | .medium | 0.6 |

| Error buzz | .heavy | 0.9 |

| Success ding | .selection | 0.4 |

| Window open | .soft | 0.3 |

React Native Implementation

import * as Haptics from 'expo-haptics';

async function playWithHaptic(soundName: string, hapticType: Haptics.ImpactFeedbackStyle) {
  // Fire both simultaneously
  await Promise.all([
    win31Sounds.play(soundName),
    Haptics.impactAsync(hapticType),
  ]);
}

// Usage
await playWithHaptic('click', Haptics.ImpactFeedbackStyle.Light);
await playWithHaptic('error', Haptics.ImpactFeedbackStyle.Heavy);

Anti-Patterns

Anti-Pattern: High-Fidelity Samples

What it looks like: 48kHz, 24-bit crystal-clear audio

Why wrong: Sounds too modern, loses retro charm

Instead: Downsample to 22kHz, apply 8-bit quantization

Anti-Pattern: Long Reverb Tails

What it looks like: Sounds echoing in a cathedral

Why wrong: Win31 sounds were DRY or short room

Instead: No reverb or <100ms decay

Anti-Pattern: Sub-Bass

What it looks like: Deep rumbling under 100Hz

Why wrong: 90s PC speakers couldn't reproduce sub-bass

Instead: Cut everything below 200Hz

Anti-Pattern: Copying Microsoft Sounds

What it looks like: Using actual CHIMES.WAV or TADA.WAV

Why wrong: Copyright infringement

Instead: Create inspired alternatives with CC-licensed sources

Anti-Pattern: Too Many Sounds

What it looks like: Every micro-interaction makes noise

Why wrong: Becomes annoying, fatiguing

Instead: Sounds for primary actions only, user toggle for audio

Sound Level Guidelines

| Category | Level | Notes |

|----------|-------|-------|

| UI feedback | -24 to -18 dB | Subtle, never intrusive |

| Notifications | -18 to -12 dB | Attention-getting but not loud |

| Errors | -15 to -9 dB | Noticeable but not jarring |

| System sounds | -12 to -6 dB | Major events (startup/shutdown) |

Always provide:

• Global sound toggle (on/off)
• Volume slider (0-100%)
• Respect system silent mode

Quick Implementation Checklist

• [ ] Create Win31SoundManager class
• [ ] Load CC-licensed base sounds
• [ ] Add procedural fallbacks (ding, chime)
• [ ] Implement haptic pairing for mobile
• [ ] Add global sound toggle
• [ ] Test with Win31 visual theme
• [ ] Add attribution for CC sounds
• [ ] Verify sample rates (22kHz max)

Integrates With

• windows-3-1-web-designer - Visual + audio Win31 experience
• sound-engineer - Advanced spatial audio if needed
• mobile-ux-optimizer - Touch + haptic + audio coordination
• pwa-expert - Offline sound caching

Core insight: Win31 sounds were satisfying because they were SIMPLE—short, bright, lo-fi tones that gave immediate feedback without being distracting. The 8-bit quantization and limited frequency response added warmth, not harshness. Capture that spirit with CC-licensed alternatives, never copies.

Remember: Always include a sound toggle. Never play sounds without user consent. Pair audio with haptics on mobile for maximum satisfaction.