Skip to main content
skill CX Codex

win31-audio-design — Claude Code skill for Windows 3.1 retro sounds

win31-audio-design — a skill that builds Windows 3.1-style UI audio: 8-bit sounds, Web Audio API code, and haptic coordination for web and mobile apps.

MIT 165 installs ★ 274 updated 2026-10-30

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add curiositech/some_claude_skills --skill win31-audio-design -a claude-code
Open on GitHub

What win31-audio-design does

This skill assembles a sound vocabulary from the early 90s. Short dings, tada fanfares, lo-fi samples at 11–22 kHz with 8-bit depth. The original CHIMES.WAV and TADA.WAV are Microsoft property, so the skill points to CC-licensed alternatives from Freesound, OpenGameArt, and similar collections.

Inside you get lookup tables: frequencies, durations, envelope shapes. A button click is a soft "tik" at 20–40 ms, a window opens with a rising C4-E4-G4 arpeggio. There's a TypeScript Win31SoundManager class with lazy AudioContext init and a procedural ding built on createOscillator.

You need ffmpeg, node, and npm on the machine. ElevenLabs sound effects are available through an MCP integration. The README is blunt about what not to do: flat modern UI sounds, voice synthesis, and music composition are out of scope.

What it helps with

  • build a sound palette for a retro-styled interface
  • find CC-licensed 8-bit samples instead of copyrighted ones
  • write a Web Audio API sound manager
  • match frequency and duration to each UI action
  • generate a synthesized ding without a sample file

Example prompts for the agent

  • Pick a notification sound for a retro UI: a double chime at 660 and 880 Hz
  • Generate a TypeScript sound manager with a procedural ding
  • Find a CC0 click sample that fits a Windows 3.1-style interface

How to install win31-audio-design

1Skills CLI (Vercel)

npx skills add curiositech/some_claude_skills --skill win31-audio-design -a claude-code

2Manually: put the files in place

~/.claude/skills/win31-audio-design/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/win31-audio-design/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about win31-audio-design

How do I install win31-audio-design in Claude Code?

Run npx skills add curiositech/some_claude_skills --skill win31-audio-design -a claude-code. The skill lands at ~/.claude/skills/win31-audio-design/SKILL.md.

What does win31-audio-design do?

It creates retro sound design for web and mobile interfaces in a Windows 3.1 style: CC-licensed 8-bit samples, frequency and envelope specs, and Web Audio API code.

Why not use the actual Windows 3.1 sound files?

CHIMES.WAV, TADA.WAV and the rest are Microsoft copyright. The skill works with inspired alternatives under CC0 or CC BY 4.0 licenses.

Source text

SKILL.md · MIT
---
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](https://dominik-braun.net/retro-sounds/) | CC BY 4.0 | UI blips, beeps, positive feedback |
| [LittleRobotSoundFactory (Freesound)](https://freesound.org/people/LittleRobotSoundFactory/packs/16681/) | CC0/CC BY | 8-bit game sounds |
| [OpenGameArt 512 SFX](https://opengameart.org/content/512-sound-effects-8-bit-style) | CC0 | Comprehensive retro library |
| [Gritty Retro UI (Exechamp)](https://freesound.org/people/Exechamp/packs/28921/) | 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

```typescript
// 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

```typescript
// 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

```typescript
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 &lt;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.

© curiositech · MIT · curiositech/some_claude_skills

Similar skills

All skills for Design →

From the same set180

The whole set →
interview-loop-strategist interview-loop-strategist builds an end-to-end interview preparation roadmap for senior ML and AI engineering roles at Anthropic and peer teams. It structures timelines, mock sessions, and project narratives. CX Codex +1 173installs interview-simulator interview-simulator — a skill for designing mock interview sessions with voice, whiteboard review, proctoring, and adaptive difficulty. Use it to plan the platform and session flow. CX Codex +1 169installs code-architecture code-architecture is a Claude Code skill for organizing code within a single application. It covers clean and hexagonal architecture, feature-based folders, dependency inversion, and module boundaries. CX Codex +1 169installs design-system-documenter design-system-documenter converts raw token files into developer documentation featuring reference tables, implementation code, and WCAG contrast checks. CX Codex +1 165installs human-centered-design-fundamentals The human-centered-design-fundamentals skill helps assess how people understand actions and system state in an interface. Use it to investigate user errors and make products easier to understand. CX Codex +1 161installs llm-router llm-router picks a model and provider for each task by complexity, budget, and quality needs. Cheap work goes to Haiku, hard problems to Sonnet or Opus. CX Codex +1 160installs systems-thinking systems-thinking is a Claude Code skill that maps stocks, flows, and feedback loops in complex systems. It kicks in for persistent problems or unintended effects of a policy or intervention. CX Codex +1 160installs hiring-manager-deep-dive hiring-manager-deep-dive prepares you for Staff+ hiring manager interviews, with frameworks for presenting project impact, handling disagreement, and showing leadership beyond your team. CX Codex +1 160installs

Project sponsors

Companies that keep this analytics open