win31-audio-design

name	win31-audio-design
description	Expert in Windows 3.1 era sound vocabulary for modern web/mobile apps. Creates satisfying retro UI sounds using CC-licensed 8-bit audio, Web Audio API, and haptic coordination. Activate on 'win31 sounds', 'retro audio', '90s sound effects', 'chimes', 'tada', 'ding', 'satisfying UI sounds'. NOT for modern flat UI sounds, voice synthesis, or music composition.
allowed-tools	Read,Write,Edit,Bash(ffmpeg:*,node:*,npm:*),mcp__ElevenLabs__text_to_sound_effects,WebFetch
metadata	{"category":"Design & Creative","pairs-with":[{"skill":"windows-3-1-web-designer","reason":"Visual + audio Win31 experience"},{"skill":"sound-engineer","reason":"Advanced audio processing"},{"skill":"mobile-ux-optimizer","reason":"Mobile haptic-audio coordination"}],"tags":["audio","retro","windows","90s","ui-sounds"]}

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().(arrayBuffer);
    ..(name, audioBuffer);
  }

  () {
     buffer = ..(name);
     (!buffer) ;

     ctx = .();
     source = ctx.();
     gain = ctx.();

    source. = buffer;
    gain.. = volume;

    source.(gain);
    gain.(ctx.);
    source.();
  }

  
  () {
     ctx = .();
     osc = ctx.();
     gain = ctx.();

    osc. = ; 
    osc..(frequency, ctx.);

    
    gain..(, ctx.);
    gain..(, ctx. + );

    osc.(gain);
    gain.(ctx.);

    osc.(ctx.);
    osc.(ctx. + );
  }
}

  win31Sounds =  ();

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.; i++) {
    data[i] = .(data[i] * ) / ;
  }

   source = ctx.();
  source. = buffer;
   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:

1. Global sound toggle (on/off)
2. Volume slider (0-100%)
3. 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.