diff --git a/app/internal_packages/custom-sounds/lib/notification-sound.ts b/app/internal_packages/custom-sounds/lib/notification-sound.ts
new file mode 100644
index 0000000000..d849439af7
--- /dev/null
+++ b/app/internal_packages/custom-sounds/lib/notification-sound.ts
@@ -0,0 +1,50 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+export const NOTIFICATION_SOUND_VOLUME_CONFIG_KEY = 'core.notifications.soundVolume';
+export const CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY = 'core.notifications.customSoundPath';
+export const SUPPORTED_NOTIFICATION_SOUND_EXTENSIONS = ['mp3', 'ogg', 'wav', 'm4a', 'aac', 'flac'];
+export const MAX_CUSTOM_NOTIFICATION_SOUND_BYTES = 25 * 1024 * 1024;
+
+type FileStats = { size: number; isFile: () => boolean };
+type StatFile = (candidate: string) => FileStats;
+
+export function isSupportedNotificationSoundPath(filePath: unknown): filePath is string {
+  if (typeof filePath !== 'string' || !filePath) return false;
+  const extension = path.extname(filePath).slice(1).toLowerCase();
+  return SUPPORTED_NOTIFICATION_SOUND_EXTENSIONS.includes(extension);
+}
+
+export function resolveCustomNotificationSound(
+  filePath: unknown,
+  statFile: StatFile = fs.statSync
+): string | undefined {
+  if (!isSupportedNotificationSoundPath(filePath) || !path.isAbsolute(filePath)) return undefined;
+
+  try {
+    const stats = statFile(filePath);
+    if (!stats.isFile() || stats.size < 1 || stats.size > MAX_CUSTOM_NOTIFICATION_SOUND_BYTES) {
+      return undefined;
+    }
+  } catch (error) {
+    return undefined;
+  }
+
+  return pathToFileURL(path.resolve(filePath)).toString();
+}
+
+export function notificationSoundPlaybackOptions(
+  config: { get: (key: string) => any },
+  statFile: StatFile = fs.statSync
+) {
+  const volumePercent = Number(config.get(NOTIFICATION_SOUND_VOLUME_CONFIG_KEY));
+  const source = resolveCustomNotificationSound(
+    config.get(CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY),
+    statFile
+  );
+  return {
+    volume: volumePercent / 100,
+    ...(source ? { source } : {}),
+  };
+}
diff --git a/app/internal_packages/custom-sounds/specs/notification-sound-spec.ts b/app/internal_packages/custom-sounds/specs/notification-sound-spec.ts
new file mode 100644
index 0000000000..ce6f516075
--- /dev/null
+++ b/app/internal_packages/custom-sounds/specs/notification-sound-spec.ts
@@ -0,0 +1,79 @@
+import path from 'path';
+import { pathToFileURL } from 'url';
+import {
+  CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY,
+  MAX_CUSTOM_NOTIFICATION_SOUND_BYTES,
+  NOTIFICATION_SOUND_VOLUME_CONFIG_KEY,
+  isSupportedNotificationSoundPath,
+  notificationSoundPlaybackOptions,
+  resolveCustomNotificationSound,
+} from '../lib/notification-sound';
+
+describe('notification sound settings', () => {
+  const regularFile =
+    (size = 1024) =>
+    () => ({ size, isFile: () => true });
+
+  it('recognizes supported extensions case-insensitively', () => {
+    expect(isSupportedNotificationSoundPath('/sounds/mail.ogg')).toBe(true);
+    expect(isSupportedNotificationSoundPath('/sounds/mail.MP3')).toBe(true);
+    expect(isSupportedNotificationSoundPath('/sounds/mail.txt')).toBe(false);
+    expect(isSupportedNotificationSoundPath('')).toBe(false);
+  });
+
+  it('resolves an existing supported file to a file URL', () => {
+    const filePath = path.resolve('/sounds/mail tone.ogg');
+    expect(resolveCustomNotificationSound(filePath, regularFile())).toBe(
+      pathToFileURL(filePath).toString()
+    );
+  });
+
+  it('falls back for missing, unsupported, and relative files', () => {
+    const missingFile = () => {
+      throw new Error('ENOENT');
+    };
+    expect(
+      resolveCustomNotificationSound(path.resolve('/sounds/missing.ogg'), missingFile)
+    ).toBeUndefined();
+    expect(
+      resolveCustomNotificationSound(path.resolve('/sounds/mail.txt'), regularFile())
+    ).toBeUndefined();
+    expect(resolveCustomNotificationSound('sounds/mail.ogg', regularFile())).toBeUndefined();
+    expect(resolveCustomNotificationSound(undefined, regularFile())).toBeUndefined();
+  });
+
+  it('falls back for non-regular, empty, and oversized files', () => {
+    const directory = () => ({ size: 1024, isFile: () => false });
+    const filePath = path.resolve('/sounds/mail.ogg');
+
+    expect(resolveCustomNotificationSound(filePath, directory)).toBeUndefined();
+    expect(resolveCustomNotificationSound(filePath, regularFile(0))).toBeUndefined();
+    expect(
+      resolveCustomNotificationSound(filePath, regularFile(MAX_CUSTOM_NOTIFICATION_SOUND_BYTES + 1))
+    ).toBeUndefined();
+    expect(
+      resolveCustomNotificationSound(filePath, regularFile(MAX_CUSTOM_NOTIFICATION_SOUND_BYTES))
+    ).toBe(pathToFileURL(filePath).toString());
+  });
+
+  it('builds playback options from independent volume and custom-path preferences', () => {
+    const customPath = path.resolve('/sounds/mail.ogg');
+    const config = {
+      get: (key) => {
+        if (key === NOTIFICATION_SOUND_VOLUME_CONFIG_KEY) return 25;
+        if (key === CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY) return customPath;
+        return undefined;
+      },
+    };
+
+    expect(notificationSoundPlaybackOptions(config, regularFile())).toEqual({
+      volume: 0.25,
+      source: pathToFileURL(customPath).toString(),
+    });
+    expect(
+      notificationSoundPlaybackOptions(config, () => {
+        throw new Error('ENOENT');
+      })
+    ).toEqual({ volume: 0.25 });
+  });
+});
diff --git a/app/internal_packages/preferences/lib/tabs/config-schema-item.tsx b/app/internal_packages/preferences/lib/tabs/config-schema-item.tsx
index eace53e7bc..34e7096645 100644
--- a/app/internal_packages/preferences/lib/tabs/config-schema-item.tsx
+++ b/app/internal_packages/preferences/lib/tabs/config-schema-item.tsx
@@ -39,6 +39,10 @@ class ConfigSchemaItem extends React.Component<ConfigSchemaItemProps> {
     event.target.blur();
   };
 
+  _onChangeNumber = (event) => {
+    this.props.config.set(this.props.keyPath, Number(event.target.value));
+  };
+
   render() {
     if (!this._appliesToPlatform()) return false;
 
@@ -100,6 +104,30 @@ class ConfigSchemaItem extends React.Component<ConfigSchemaItemProps> {
           {note}
         </div>
       );
+    } else if (
+      this.props.configSchema.type === 'number' &&
+      this.props.configSchema.minimum !== undefined &&
+      this.props.configSchema.maximum !== undefined
+    ) {
+      const value = Number(this.props.config.get(this.props.keyPath));
+      return (
+        <div className="item config-schema-range-item">
+          <label htmlFor={this.props.keyPath}>
+            {this.props.configSchema.title}:{' '}
+            <output>{`${value}${this.props.configSchema.unit || ''}`}</output>
+          </label>
+          <input
+            id={this.props.keyPath}
+            type="range"
+            min={this.props.configSchema.minimum}
+            max={this.props.configSchema.maximum}
+            step={this.props.configSchema.multipleOf || 1}
+            value={value}
+            onChange={this._onChangeNumber}
+          />
+          {note}
+        </div>
+      );
     }
     return <span />;
   }
diff --git a/app/internal_packages/preferences/lib/tabs/notifications-section.tsx b/app/internal_packages/preferences/lib/tabs/notifications-section.tsx
new file mode 100644
index 0000000000..e67e07af36
--- /dev/null
+++ b/app/internal_packages/preferences/lib/tabs/notifications-section.tsx
@@ -0,0 +1,89 @@
+import React from 'react';
+import path from 'path';
+import { localized, SoundRegistry } from 'mailspring-exports';
+import ConfigSchemaItem from './config-schema-item';
+import { ConfigLike, ConfigSchemaLike } from '../types';
+import {
+  CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY,
+  SUPPORTED_NOTIFICATION_SOUND_EXTENSIONS,
+  isSupportedNotificationSoundPath,
+  notificationSoundPlaybackOptions,
+  resolveCustomNotificationSound,
+} from '../../../custom-sounds/lib/notification-sound';
+
+export default class NotificationsSection extends React.Component<{
+  config: ConfigLike;
+  configSchema: ConfigSchemaLike;
+}> {
+  _chooseSound = () => {
+    AppEnv.showOpenDialog(
+      {
+        title: localized('Choose a notification sound'),
+        buttonLabel: localized('Choose'),
+        properties: ['openFile'],
+        filters: [
+          {
+            name: localized('Audio files'),
+            extensions: SUPPORTED_NOTIFICATION_SOUND_EXTENSIONS,
+          },
+        ],
+      },
+      (paths) => {
+        if (!paths || paths.length === 0) return;
+        if (!isSupportedNotificationSoundPath(paths[0])) {
+          AppEnv.showErrorDialog(
+            localized(
+              'Please choose an audio file with one of these extensions: %@',
+              SUPPORTED_NOTIFICATION_SOUND_EXTENSIONS.join(', ')
+            )
+          );
+          return;
+        }
+        this.props.config.set(CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY, paths[0]);
+      }
+    );
+  };
+
+  _resetSound = () => {
+    this.props.config.set(CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY, '');
+  };
+
+  _playTestSound = () => {
+    SoundRegistry.playSound('new-mail', notificationSoundPlaybackOptions(this.props.config));
+  };
+
+  render() {
+    const customPath = this.props.config.get(CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY);
+    const customSource = resolveCustomNotificationSound(customPath);
+    return (
+      <div>
+        <ConfigSchemaItem
+          configSchema={this.props.configSchema}
+          keyName={localized('Notifications')}
+          keyPath="core.notifications"
+          config={this.props.config}
+        />
+        <div className="notification-sound-controls">
+          <div className="notification-sound-file">
+            {customPath
+              ? customSource
+                ? localized('Custom sound: %@', path.basename(customPath))
+                : localized('Custom sound unavailable; using the default sound')
+              : localized('Using the default notification sound')}
+          </div>
+          <button className="btn btn-small" onClick={this._chooseSound}>
+            {localized('Choose Sound…')}
+          </button>
+          {customPath && (
+            <button className="btn btn-small" onClick={this._resetSound}>
+              {localized('Reset to Default')}
+            </button>
+          )}
+          <button className="btn btn-small" onClick={this._playTestSound}>
+            {localized('Play Test Sound')}
+          </button>
+        </div>
+      </div>
+    );
+  }
+}
diff --git a/app/internal_packages/preferences/lib/tabs/preferences-general.tsx b/app/internal_packages/preferences/lib/tabs/preferences-general.tsx
index 4d78a02f16..47c17c535e 100644
--- a/app/internal_packages/preferences/lib/tabs/preferences-general.tsx
+++ b/app/internal_packages/preferences/lib/tabs/preferences-general.tsx
@@ -6,6 +6,7 @@ import ConfigSchemaItem from './config-schema-item';
 import WorkspaceSection from './workspace-section';
 import SendingSection from './sending-section';
 import LanguageSection from './language-section';
+import NotificationsSection from './notifications-section';
 import { ConfigLike, ConfigSchemaLike } from '../types';
 
 class PreferencesGeneral extends React.Component<{
@@ -95,10 +96,8 @@ class PreferencesGeneral extends React.Component<{
 
         <div className="two-columns-flexbox" style={{ paddingTop: 30 }}>
           <div style={{ flex: 1 }}>
-            <ConfigSchemaItem
+            <NotificationsSection
               configSchema={this.props.configSchema.properties.notifications}
-              keyName={localized('Notifications')}
-              keyPath="core.notifications"
               config={this.props.config}
             />
           </div>
diff --git a/app/internal_packages/preferences/lib/types.ts b/app/internal_packages/preferences/lib/types.ts
index bb4846c35c..11c4e0bde3 100644
--- a/app/internal_packages/preferences/lib/types.ts
+++ b/app/internal_packages/preferences/lib/types.ts
@@ -1,5 +1,5 @@
 export interface ConfigLike {
-  get: (key: string) => string;
+  get: (key: string) => any;
   toggle: (key: string) => void;
   set: (key: string, val: any) => void;
 }
@@ -15,4 +15,9 @@ export interface ConfigSchemaLike {
   enum?: string;
   enumLabels: string;
   platforms?: string[];
+  platform?: string;
+  minimum?: number;
+  maximum?: number;
+  multipleOf?: number;
+  unit?: string;
 }
diff --git a/app/internal_packages/preferences/specs/config-schema-item-spec.tsx b/app/internal_packages/preferences/specs/config-schema-item-spec.tsx
new file mode 100644
index 0000000000..fdea34f62c
--- /dev/null
+++ b/app/internal_packages/preferences/specs/config-schema-item-spec.tsx
@@ -0,0 +1,40 @@
+import React from 'react';
+import { cleanup, fireEvent, render } from '@testing-library/react';
+import ConfigSchemaItem from '../lib/tabs/config-schema-item';
+
+describe('ConfigSchemaItem', () => {
+  afterEach(cleanup);
+
+  it('renders and persists a bounded numeric range value as a number', () => {
+    const config = {
+      get: jasmine.createSpy('get').andReturn(65),
+      set: jasmine.createSpy('set'),
+      toggle: jasmine.createSpy('toggle'),
+    };
+    const configSchema = {
+      type: 'number',
+      title: 'Notification sound volume',
+      minimum: 0,
+      maximum: 100,
+      multipleOf: 1,
+      unit: '%',
+    } as any;
+
+    const { container } = render(
+      <ConfigSchemaItem
+        keyPath="core.notifications.soundVolume"
+        config={config}
+        configSchema={configSchema}
+      />
+    );
+
+    const range = container.querySelector('input[type="range"]') as HTMLInputElement;
+    expect(range.min).toBe('0');
+    expect(range.max).toBe('100');
+    expect(range.value).toBe('65');
+    expect(container.querySelector('output').textContent).toBe('65%');
+
+    fireEvent.change(range, { target: { value: '40' } });
+    expect(config.set).toHaveBeenCalledWith('core.notifications.soundVolume', 40);
+  });
+});
diff --git a/app/internal_packages/preferences/specs/notifications-section-spec.tsx b/app/internal_packages/preferences/specs/notifications-section-spec.tsx
new file mode 100644
index 0000000000..f6dcbe92a4
--- /dev/null
+++ b/app/internal_packages/preferences/specs/notifications-section-spec.tsx
@@ -0,0 +1,80 @@
+import React from 'react';
+import { cleanup, fireEvent, render } from '@testing-library/react';
+import { SoundRegistry } from 'mailspring-exports';
+import NotificationsSection from '../lib/tabs/notifications-section';
+import {
+  CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY,
+  NOTIFICATION_SOUND_VOLUME_CONFIG_KEY,
+} from '../../custom-sounds/lib/notification-sound';
+
+describe('NotificationsSection', () => {
+  afterEach(cleanup);
+
+  const configSchema = {
+    type: 'object',
+    properties: {
+      sounds: { type: 'boolean', title: 'Play sound' },
+      soundVolume: {
+        type: 'number',
+        title: 'Volume',
+        minimum: 0,
+        maximum: 100,
+        multipleOf: 1,
+        unit: '%',
+      },
+      customSoundPath: { type: 'string', advanced: true },
+    },
+  } as any;
+
+  it('selects and resets a supported custom sound', () => {
+    let customPath = '';
+    const config = {
+      get: jasmine.createSpy('get').andCallFake((key) => {
+        if (key === CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY) return customPath;
+        if (key === NOTIFICATION_SOUND_VOLUME_CONFIG_KEY) return 100;
+        if (key === 'core.notifications.sounds') return true;
+        return undefined;
+      }),
+      set: jasmine.createSpy('set').andCallFake((key, value) => {
+        if (key === CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY) customPath = value;
+      }),
+      toggle: jasmine.createSpy('toggle'),
+    };
+    spyOn(AppEnv, 'showOpenDialog').andCallFake((options, callback) => {
+      callback(['/sounds/mail.ogg']);
+    });
+    const { getByText } = render(
+      <NotificationsSection config={config} configSchema={configSchema} />
+    );
+
+    fireEvent.click(getByText('Choose Sound…'));
+    expect(config.set).toHaveBeenCalledWith(
+      CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY,
+      '/sounds/mail.ogg'
+    );
+
+    const resetView = render(<NotificationsSection config={config} configSchema={configSchema} />);
+    fireEvent.click(resetView.getByText('Reset to Default'));
+    expect(config.set).toHaveBeenCalledWith(CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY, '');
+  });
+
+  it('previews the notification sound with the configured volume', () => {
+    const config = {
+      get: jasmine.createSpy('get').andCallFake((key) => {
+        if (key === NOTIFICATION_SOUND_VOLUME_CONFIG_KEY) return 40;
+        if (key === CUSTOM_NOTIFICATION_SOUND_CONFIG_KEY) return '';
+        if (key === 'core.notifications.sounds') return true;
+        return undefined;
+      }),
+      set: jasmine.createSpy('set'),
+      toggle: jasmine.createSpy('toggle'),
+    };
+    spyOn(SoundRegistry, 'playSound');
+    const { getByText } = render(
+      <NotificationsSection config={config} configSchema={configSchema} />
+    );
+
+    fireEvent.click(getByText('Play Test Sound'));
+    expect(SoundRegistry.playSound).toHaveBeenCalledWith('new-mail', { volume: 0.4 });
+  });
+});
diff --git a/app/internal_packages/preferences/styles/preferences.less b/app/internal_packages/preferences/styles/preferences.less
index 046ca4edc6..63290f015f 100644
--- a/app/internal_packages/preferences/styles/preferences.less
+++ b/app/internal_packages/preferences/styles/preferences.less
@@ -16,6 +16,35 @@
     margin: 4px 0 0 0;
   }
 
+  .config-schema-range-item {
+    label,
+    input[type='range'] {
+      display: block;
+      width: 100%;
+    }
+
+    output {
+      float: right;
+      color: @text-color-very-subtle;
+    }
+  }
+
+  .notification-sound-controls {
+    padding-top: @padding-small-vertical;
+
+    .notification-sound-file {
+      margin-bottom: @padding-small-vertical;
+      color: @text-color-very-subtle;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .btn {
+      margin: 0 @padding-small-horizontal @padding-small-vertical 0;
+    }
+  }
+
   height: 100%;
   background-color: @background-primary;
   color: @text-color;
diff --git a/app/internal_packages/unread-notifications/lib/main.ts b/app/internal_packages/unread-notifications/lib/main.ts
index fda1780251..d846550794 100644
--- a/app/internal_packages/unread-notifications/lib/main.ts
+++ b/app/internal_packages/unread-notifications/lib/main.ts
@@ -11,6 +11,7 @@ import {
   DatabaseChangeRecord,
   TaskFactory,
 } from 'mailspring-exports';
+import { notificationSoundPlaybackOptions } from '../../custom-sounds/lib/notification-sound';
 
 const WAIT_FOR_CHANGES_DELAY = 400;
 
@@ -236,7 +237,7 @@ export class Notifier {
   _playNewMailSound = _.debounce(
     () => {
       if (!AppEnv.config.get('core.notifications.sounds')) return;
-      SoundRegistry.playSound('new-mail');
+      SoundRegistry.playSound('new-mail', notificationSoundPlaybackOptions(AppEnv.config));
     },
     5000,
     true
diff --git a/app/internal_packages/unread-notifications/specs/main-spec.es6 b/app/internal_packages/unread-notifications/specs/main-spec.es6
index 4d2d7fef77..3bb6188ab8 100644
--- a/app/internal_packages/unread-notifications/specs/main-spec.es6
+++ b/app/internal_packages/unread-notifications/specs/main-spec.es6
@@ -445,6 +445,7 @@ describe('UnreadNotifications', function UnreadNotifications() {
     spyOn(AppEnv.config, 'get').andCallFake(config => {
       if (config === 'core.notifications.enabled') return true;
       if (config === 'core.notifications.sounds') return true;
+      if (config === 'core.notifications.soundVolume') return 35;
       return undefined;
     });
 
@@ -456,7 +457,7 @@ describe('UnreadNotifications', function UnreadNotifications() {
         objectsRawJSON: getObjectsRawJson(['1'])
       });
       expect(AppEnv.config.get.calls[1].args[0]).toBe('core.notifications.sounds');
-      expect(SoundRegistry.playSound).toHaveBeenCalledWith('new-mail');
+      expect(SoundRegistry.playSound).toHaveBeenCalledWith('new-mail', { volume: 0.35 });
     });
   });
 
diff --git a/app/spec/content-security-policy-spec.ts b/app/spec/content-security-policy-spec.ts
new file mode 100644
index 0000000000..7fc75bc855
--- /dev/null
+++ b/app/spec/content-security-policy-spec.ts
@@ -0,0 +1,15 @@
+import fs from 'fs';
+import path from 'path';
+
+describe('main window Content Security Policy', () => {
+  it('allows local files as media without allowing them as scripts', () => {
+    const { resourcePath } = AppEnv.getLoadSettings();
+    const indexHtml = fs.readFileSync(path.join(resourcePath, 'static', 'index.html'), 'utf8');
+    const browserMain = fs.readFileSync(path.join(resourcePath, 'src', 'browser', 'main.js'), 'utf8');
+
+    for (const policySource of [indexHtml, browserMain]) {
+      expect(policySource).toContain('media-src mailspring: file:');
+      expect(policySource).not.toContain("script-src 'self' file:");
+    }
+  });
+});
diff --git a/app/spec/native-notifications-spec.ts b/app/spec/native-notifications-spec.ts
new file mode 100644
index 0000000000..0d45df2f4c
--- /dev/null
+++ b/app/spec/native-notifications-spec.ts
@@ -0,0 +1,23 @@
+import NativeNotifications from '../src/native-notifications';
+
+describe('NativeNotifications Windows toast XML', () => {
+  it('silences individual notification toasts so SoundRegistry controls audio', () => {
+    const xml = (NativeNotifications as any).buildWindowsToastXml({
+      id: 'notification-id',
+      title: 'New message',
+      threadId: 'thread-id',
+    });
+
+    expect(xml).toContain('<audio silent="true"/>');
+  });
+
+  it('silences summary toasts so SoundRegistry controls audio', () => {
+    const xml = (NativeNotifications as any).buildWindowsSummaryToastXml(
+      'notification-id',
+      5,
+      ['Ada', 'Grace']
+    );
+
+    expect(xml).toContain('<audio silent="true"/>');
+  });
+});
diff --git a/app/spec/registries/sound-registry-spec.ts b/app/spec/registries/sound-registry-spec.ts
new file mode 100644
index 0000000000..ea27383a72
--- /dev/null
+++ b/app/spec/registries/sound-registry-spec.ts
@@ -0,0 +1,91 @@
+import NativeNotifications from '../../src/native-notifications';
+import { SoundRegistry, normalizeSoundVolume } from '../../src/registries/sound-registry';
+
+describe('SoundRegistry', () => {
+  describe('normalizeSoundVolume', () => {
+    it('uses full volume when no valid volume is provided', () => {
+      expect(normalizeSoundVolume(undefined)).toBe(1);
+      expect(normalizeSoundVolume(null)).toBe(0);
+      expect(normalizeSoundVolume('not-a-number')).toBe(1);
+      expect(normalizeSoundVolume(Number.NaN)).toBe(1);
+    });
+
+    it('accepts numeric values and numeric strings', () => {
+      expect(normalizeSoundVolume(0)).toBe(0);
+      expect(normalizeSoundVolume(0.5)).toBe(0.5);
+      expect(normalizeSoundVolume(1)).toBe(1);
+      expect(normalizeSoundVolume('0.35')).toBe(0.35);
+    });
+
+    it('clamps values to the HTML audio volume range', () => {
+      expect(normalizeSoundVolume(-1)).toBe(0);
+      expect(normalizeSoundVolume(2)).toBe(1);
+      expect(normalizeSoundVolume(Number.NEGATIVE_INFINITY)).toBe(1);
+      expect(normalizeSoundVolume(Number.POSITIVE_INFINITY)).toBe(1);
+    });
+  });
+
+  describe('playSound', () => {
+    let originalAudio;
+    let audioInstances;
+
+    beforeEach(() => {
+      originalAudio = window.Audio;
+      audioInstances = [];
+      (window as any).Audio = function MockAudio() {
+        const audio = {
+          src: '',
+          volume: 1,
+          autoplay: false,
+          play: jasmine.createSpy('play').andReturn(Promise.resolve()),
+        };
+        audioInstances.push(audio);
+        return audio;
+      };
+      spyOn(AppEnv, 'inSpecMode').andReturn(false);
+      spyOn(NativeNotifications, 'doNotDisturb').andReturn(Promise.resolve(false));
+    });
+
+    afterEach(() => {
+      (window as any).Audio = originalAudio;
+    });
+
+    it('applies a per-play source and volume without changing the registered sound', async () => {
+      const registry = new SoundRegistry();
+      registry.register('new-mail', 'mailspring://custom-sounds/default.ogg');
+
+      await registry.playSound('new-mail', { source: 'file:///sounds/custom.ogg', volume: 0.4 });
+      await registry.playSound('new-mail');
+
+      expect(audioInstances[0].src).toBe('file:///sounds/custom.ogg');
+      expect(audioInstances[0].volume).toBe(0.4);
+      expect(audioInstances[1].src).toBe('mailspring://custom-sounds/default.ogg');
+      expect(audioInstances[1].volume).toBe(1);
+    });
+
+    it('falls back to the registered sound when a custom source cannot play', async () => {
+      const registry = new SoundRegistry();
+      registry.register('new-mail', 'mailspring://custom-sounds/default.ogg');
+      let instance = 0;
+      (window as any).Audio = function MockAudio() {
+        const audio = {
+          src: '',
+          volume: 1,
+          autoplay: false,
+          play: jasmine
+            .createSpy('play')
+            .andReturn(instance++ === 0 ? Promise.reject(new Error('decode failed')) : Promise.resolve()),
+        };
+        audioInstances.push(audio);
+        return audio;
+      };
+
+      await registry.playSound('new-mail', { source: 'file:///sounds/broken.ogg', volume: 0.2 });
+
+      expect(audioInstances.length).toBe(2);
+      expect(audioInstances[0].src).toBe('file:///sounds/broken.ogg');
+      expect(audioInstances[1].src).toBe('mailspring://custom-sounds/default.ogg');
+      expect(audioInstances[1].volume).toBe(0.2);
+    });
+  });
+});
diff --git a/app/src/browser/main.js b/app/src/browser/main.js
index 2cabb5f867..4596f3a667 100644
--- a/app/src/browser/main.js
+++ b/app/src/browser/main.js
@@ -410,7 +410,7 @@ const start = () => {
         responseHeaders: {
           ...details.responseHeaders,
           'Content-Security-Policy': [
-            "default-src * mailspring:; script-src 'self' 'unsafe-inline' chrome-extension://react-developer-tools; style-src * 'unsafe-inline' mailspring:; img-src * data: mailspring: file:; object-src none; media-src mailspring:; manifest-src none;",
+            "default-src * mailspring:; script-src 'self' 'unsafe-inline' chrome-extension://react-developer-tools; style-src * 'unsafe-inline' mailspring:; img-src * data: mailspring: file:; object-src none; media-src mailspring: file:; manifest-src none;",
           ],
         },
       });
diff --git a/app/src/config-schema.ts b/app/src/config-schema.ts
index 7ada78d2f8..697e3581f3 100644
--- a/app/src/config-schema.ts
+++ b/app/src/config-schema.ts
@@ -366,6 +366,20 @@ export default {
             default: true,
             title: localized('Play sound when receiving new mail'),
           },
+          soundVolume: {
+            type: 'number',
+            default: 100,
+            minimum: 0,
+            maximum: 100,
+            multipleOf: 1,
+            unit: '%',
+            title: localized('Notification sound volume'),
+          },
+          customSoundPath: {
+            type: 'string',
+            default: '',
+            advanced: true,
+          },
           unsnoozeToTop: {
             type: 'boolean',
             default: true,
diff --git a/app/src/registries/sound-registry.ts b/app/src/registries/sound-registry.ts
index e9cb4484f6..a4fa8268d6 100644
--- a/app/src/registries/sound-registry.ts
+++ b/app/src/registries/sound-registry.ts
@@ -1,36 +1,69 @@
 import path from 'path';
 import NativeNotifications from '../native-notifications';
 
-class SoundRegistry {
+export interface SoundPlaybackOptions {
+  volume?: number;
+  source?: string;
+}
+
+export function normalizeSoundVolume(volume: unknown): number {
+  if (volume === undefined) return 1;
+
+  const numericVolume = Number(volume);
+  if (!Number.isFinite(numericVolume)) return 1;
+  return Math.min(1, Math.max(0, numericVolume));
+}
+
+export class SoundRegistry {
   private _sounds = {};
 
-  async playSound(name: string) {
+  private _audioForSource(src: string | string[], volume: number) {
+    const audio = new Audio();
+    const { resourcePath } = AppEnv.getLoadSettings();
+
+    if (typeof src === 'string') {
+      if (/^(mailspring|file):/.test(src)) {
+        audio.src = src;
+      } else {
+        audio.src = path.join(resourcePath, 'static', 'sounds', src);
+      }
+    } else if (src instanceof Array) {
+      const args = [resourcePath].concat(src);
+      audio.src = path.join.apply(this, args);
+    }
+    audio.volume = volume;
+    audio.autoplay = true;
+    return audio;
+  }
+
+  async playSound(name: string, options: SoundPlaybackOptions = {}) {
     if (AppEnv.inSpecMode()) {
       return;
     }
     if (await NativeNotifications.doNotDisturb()) {
       return;
     }
-    const src = this._sounds[name];
+    const registeredSource = this._sounds[name];
+    const src = options.source || registeredSource;
     if (!src) {
       return;
     }
 
-    const a = new Audio();
-    const { resourcePath } = AppEnv.getLoadSettings();
-
-    if (typeof src === 'string') {
-      if (src.indexOf('mailspring://') === 0) {
-        a.src = src;
-      } else {
-        a.src = path.join(resourcePath, 'static', 'sounds', src);
+    const volume = normalizeSoundVolume(options.volume);
+    try {
+      await this._audioForSource(src, volume).play();
+    } catch (error) {
+      if (options.source && registeredSource && options.source !== registeredSource) {
+        try {
+          await this._audioForSource(registeredSource, volume).play();
+          return;
+        } catch (fallbackError) {
+          console.warn(`Unable to play the default sound '${name}'.`, fallbackError);
+          return;
+        }
       }
-    } else if (src instanceof Array) {
-      const args = [resourcePath].concat(src);
-      a.src = path.join.apply(this, args);
+      console.warn(`Unable to play sound '${name}'.`, error);
     }
-    a.autoplay = true;
-    a.play();
   }
 
   register(name: string | { [key: string]: string[] }, rpath?: string) {
diff --git a/app/static/index.html b/app/static/index.html
index 930d45e93c..74d6e704c0 100644
--- a/app/static/index.html
+++ b/app/static/index.html
@@ -3,7 +3,7 @@
 <head>
   <title>Mailspring</title>
 
-  <meta http-equiv="Content-Security-Policy" content="default-src * mailspring:; script-src 'self' chrome-extension://react-developer-tools; style-src * 'unsafe-inline' mailspring:; img-src * data: mailspring: file:; object-src none; media-src mailspring:; manifest-src none;">
+  <meta http-equiv="Content-Security-Policy" content="default-src * mailspring:; script-src 'self' chrome-extension://react-developer-tools; style-src * 'unsafe-inline' mailspring:; img-src * data: mailspring: file:; object-src none; media-src mailspring: file:; manifest-src none;">
 
   <script src="index.js"></script>
 </head>
diff --git a/plans/notification-sound-customization-pr.md b/plans/notification-sound-customization-pr.md
new file mode 100644
index 0000000000..796291d201
--- /dev/null
+++ b/plans/notification-sound-customization-pr.md
@@ -0,0 +1,55 @@
+# Add notification sound volume and custom sounds
+
+## Summary
+
+- Add a 0–100 new-mail notification volume slider in General > Notifications.
+- Add a native custom-sound picker for MP3, OGG, WAV, M4A, AAC, and FLAC files,
+  with Play Test Sound and reset-to-default actions.
+- Keep both settings scoped to new-mail notifications so sent-message and other UI
+  sounds retain their existing behavior.
+- Resolve custom files at playback time and fall back to the bundled sound when a
+  selection is missing, unsupported, or cannot be played.
+- Permit local files only as media resources, without expanding the script policy,
+  and reject relative paths, non-regular files, empty files, and files over 25 MiB.
+- Extend `SoundRegistry` with reusable per-play volume and source options, keeping
+  the preference UI, sound selection, and audio playback concerns separate.
+- Add regression coverage for the silent Windows toast behavior established by
+  #2619, which ensures native toast audio does not bypass Mailspring's playback
+  settings.
+
+The work is organized as two focused commits in this PR: the first introduces the
+volume control and reusable playback option, and the second adds custom sound
+selection on top of that foundation.
+
+## Testing
+
+- Added registry coverage for muted, intermediate, full, invalid, and out-of-range
+  volume values, custom sources, and decode-error fallback.
+- Added resolver coverage for supported extensions, file URLs, missing files, and
+  unsupported selections.
+- Added preference UI coverage for slider persistence and choose, reset, and test
+  actions.
+- Added new-mail integration coverage showing that configured sound options apply
+  only to notification playback.
+- Added regression coverage for silent individual and summary Windows toast XML.
+- `npm run lint:check`
+- Targeted Electron specs: 31 passing
+- Real external-file playback in Electron: MP3, OGG, WAV, M4A, AAC, and FLAC all
+  passed through the production resolver and Content Security Policy.
+- `npm run build` (produced the macOS arm64 app and ZIP)
+
+`npm run typecheck` reaches the full project and reports three existing errors
+outside this change: the `marginType` option in `print-window.ts` and two `inert`
+attribute errors in `sheet-container.tsx`. It reports no errors in files changed by
+this PR.
+
+## Feature requests and related material
+
+- Volume support request: https://community.getmailspring.com/t/how-do-i-reduce-the-volume-of-the-sound-when-receiving-new-mail/1639/2
+- Custom notification sound discussion: https://community.getmailspring.com/t/custom-notification-sound/530
+- Existing bundled-file replacement workaround: https://community.getmailspring.com/t/custom-notification-sound/530/2
+- Windows/system-sound discussion: https://community.getmailspring.com/t/custom-notification-sound/530/5
+- Original GitHub feature request: https://github.com/Foundry376/Mailspring/issues/415
+- Related Windows sound-routing prior art: https://github.com/Foundry376/Mailspring/pull/2619
+
+Per-filter notification sounds remain out of scope for this change.
diff --git a/plans/notification-sound-volume.md b/plans/notification-sound-volume.md
new file mode 100644
index 0000000000..f26702decb
--- /dev/null
+++ b/plans/notification-sound-volume.md
@@ -0,0 +1,68 @@
+# Notification Sound Customization Implementation Plan
+
+## Goal
+
+Deliver two independently reviewable changes in one pull request:
+
+1. A user-facing 0–100 preference that controls only Mailspring's new-mail
+   notification sound volume.
+2. A user-facing custom notification sound picker with reset and safe fallback.
+
+Per-filter sounds are intentionally out of scope.
+
+## References
+
+- https://community.getmailspring.com/t/how-do-i-reduce-the-volume-of-the-sound-when-receiving-new-mail/1639/2
+- https://community.getmailspring.com/t/custom-notification-sound/530
+- https://community.getmailspring.com/t/custom-notification-sound/530/5
+- https://github.com/Foundry376/Mailspring/issues/415
+- https://github.com/Foundry376/Mailspring/pull/2619
+
+## Work Plan
+
+### Change 1: Notification volume
+
+1. Inspect the current playback path, preference conventions, test infrastructure,
+   and related Windows sound-routing fix in PR #2619.
+2. Extend `SoundRegistry` with a reusable per-play volume option and clamp invalid
+   values at the browser audio boundary.
+3. Add a schema-backed 0–100 range control and pass only the new-mail preference
+   to notification playback, leaving send and UI sounds unchanged.
+4. Preserve and add regression coverage for the silent Windows toast declaration
+   from PR #2619 so native toast audio cannot bypass application-controlled sound.
+5. Add focused registry, notification integration, preference UI, and Windows XML
+   tests.
+
+### Change 2: Custom notification sound
+
+1. Add a notification-sound preference service that resolves the bundled default
+   or a persisted custom file without coupling file selection to playback.
+2. Add select, preview, and reset controls using Electron's native file dialog;
+   constrain selection to browser-supported audio formats.
+3. Handle moved, deleted, unreadable, and malformed selections by falling back to
+   the bundled sound without breaking notifications.
+4. Permit local files only as media resources in the main-window CSP, while
+   retaining the existing script policy.
+5. Reject relative paths, non-regular files, empty files, and files larger than 25
+   MiB before handing a custom source to Chromium's media decoder.
+6. Add focused resolver, preference UI, notification integration, and CSP tests.
+
+### Final verification and handoff
+
+1. Run targeted tests, formatting/lint/type checks, and the documented local build;
+   fix regressions found within scope.
+2. Review each change independently for modularity and unrelated changes.
+3. Prepare one PR description referencing the relevant forum discussions, GitHub
+   issue, and PR #2619 as related Windows sound-routing prior art.
+
+## Verification Checklist
+
+- Existing users retain the current effective volume by default.
+- Muting or lowering notification volume does not disable visual notifications.
+- Values remain bounded to the browser audio API's valid range.
+- Preference changes apply without requiring an application restart, if supported
+  by the existing configuration flow.
+- A custom sound can be selected, previewed, and reset to the bundled default.
+- Missing or unreadable custom files safely use the bundled default sound.
+- The volume and custom-sound changes remain separable for review and release.
+- Tests and local build commands are reported with exact outcomes.