Imported from curiositech/some_claude_skills (.claude/skills/win31-audio-design/SKILL.md). Install upstream with npx skills add curiositech/some_claude_skills --skill win31-audio-design. Copyright stays with the author.

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)

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

Sound Characteristics (What Made Them Satisfying)

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

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

System Sounds

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

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

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.