diff --git a/coloraide/color.py b/coloraide/color.py
index e824b26bb..3b2cc3f2b 100644
--- a/coloraide/color.py
+++ b/coloraide/color.py
@@ -1026,7 +1026,7 @@ def fit(
 
         # Handle special gamut requests
         if space in gamut.SPECIAL_GAMUTS:
-            return cast(Self, gamut.SPECIAL_GAMUTS[space]['fit'](self))
+            return cast(Self, gamut.SPECIAL_GAMUTS[space]['fit'](self, **kwargs))
 
         # If within gamut, just normalize hue range by calling clip.
         if self.in_gamut(space, tolerance=0):
@@ -1049,7 +1049,7 @@ def fit(
         mapping.fit(self, target, **kwargs)
         return self
 
-    def in_gamut(self, space: str | None = None, *, tolerance: float = util.DEF_FIT_TOLERANCE) -> bool:
+    def in_gamut(self, space: str | None = None, *, tolerance: float | None = None, **kwargs: Any) -> bool:
         """Check if current color is in gamut."""
 
         if space is None:
@@ -1057,7 +1057,10 @@ def in_gamut(self, space: str | None = None, *, tolerance: float = util.DEF_FIT_
 
         # Handle special gamut requests
         if space in gamut.SPECIAL_GAMUTS:
-            return cast(bool, gamut.SPECIAL_GAMUTS[space]['check'](self, tolerance=tolerance))
+            return cast(bool, gamut.SPECIAL_GAMUTS[space]['check'](self, tolerance=tolerance, **kwargs))
+
+        if tolerance is None:
+            tolerance = util.DEF_FIT_TOLERANCE
 
         # Check if gamut is in the provided space
         c = self.convert(space, norm=False) if space is not None and space != self.space() else self
diff --git a/coloraide/gamut/__init__.py b/coloraide/gamut/__init__.py
index 29aaa6213..0918fd769 100644
--- a/coloraide/gamut/__init__.py
+++ b/coloraide/gamut/__init__.py
@@ -29,6 +29,10 @@
     'macadam-limits': {
         'check': visible_spectrum.in_macadam_limits,
         'fit': visible_spectrum.fit_macadam_limits
+    },
+    'visible-spectrum': {
+        'check': visible_spectrum.in_visible_spectrum,
+        'fit': visible_spectrum.fit_visible_spectrum
     }
 }   # type: dict[str, dict[str, Callable[..., Any]]]
 
diff --git a/coloraide/gamut/pointer.py b/coloraide/gamut/pointer.py
index 720cba8c1..d81050d72 100644
--- a/coloraide/gamut/pointer.py
+++ b/coloraide/gamut/pointer.py
@@ -11,7 +11,7 @@
 from .. import algebra as alg
 from .. import util
 from ..types import Vector, Matrix, AnyColor, VectorLike  # noqa: F401
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:  #pragma: no cover
     from ..color import Color
@@ -144,7 +144,7 @@ def get_chroma_limit(l: float, h: float) -> float:
     return alg.lerp(alg.lerp(row1[li], row1[li + 1], lf), alg.lerp(row2[li], row2[li + 1], lf), hf)
 
 
-def fit_pointer_gamut(color: AnyColor) -> AnyColor:
+def fit_pointer_gamut(color: AnyColor, **kwargs: Any) -> AnyColor:
     """Fit a color to the Pointer gamut."""
 
     # Convert to CIE LCh with the SC illuminant
@@ -162,7 +162,7 @@ def fit_pointer_gamut(color: AnyColor) -> AnyColor:
     return from_lch_sc(color, [new_l, new_c, h]) if adjusted else color
 
 
-def in_pointer_gamut(color: Color, tolerance: float) -> bool:
+def in_pointer_gamut(color: Color, tolerance: float | None = None, **kwargs: Any) -> bool:
     """
     See if color is within the pointer gamut.
 
@@ -172,6 +172,9 @@ def in_pointer_gamut(color: Color, tolerance: float) -> bool:
     color's chroma does not exceed the limit.
     """
 
+    if tolerance is None:
+        tolerance = util.DEF_FIT_TOLERANCE
+
     # Convert to CIE LCh with the SC illuminant
     l, c, h = to_lch_sc(color)
 
diff --git a/coloraide/gamut/visible_spectrum.py b/coloraide/gamut/visible_spectrum.py
index a45255ed3..b9e5972e6 100644
--- a/coloraide/gamut/visible_spectrum.py
+++ b/coloraide/gamut/visible_spectrum.py
@@ -1,12 +1,13 @@
 """Check if color is in visible gamut."""
 from __future__ import annotations
+import math
 import bisect
 from ..cat import WHITES
 from .. import algebra as alg
 from .. import util
 from ..types import Matrix, AnyColor  # noqa: F401
 from .rosch_macadam_solid import LUT, LUMINANCE, HUE
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:  #pragma: no cover
     from ..color import Color
@@ -73,7 +74,7 @@ def get_chroma_limit(l: float, h: float) -> float:
     return alg.lerp(alg.lerp(row1[li], row1[li + 1], lf), alg.lerp(row2[li], row2[li + 1], lf), hf)
 
 
-def fit_macadam_limits(color: AnyColor) -> AnyColor:
+def fit_macadam_limits(color: AnyColor, **kwargs: Any) -> AnyColor:
     """Fit a color to the approximation of the Macadam limits at the color's given luminance."""
 
     # Convert to xyY
@@ -96,7 +97,7 @@ def fit_macadam_limits(color: AnyColor) -> AnyColor:
     return color.update(color.new('xyz-d65', util.xy_to_xyz((x, y), new_Y), color[-1])) if adjusted else color
 
 
-def in_macadam_limits(color: Color, tolerance: float) -> bool:
+def in_macadam_limits(color: Color, tolerance: float | None = None, **kwargs: Any) -> bool:
     """
     See if color is within the approximation of the Macadam limits for the color's luminance.
 
@@ -105,6 +106,9 @@ def in_macadam_limits(color: Color, tolerance: float) -> bool:
     color's chroma does not exceed the limit.
     """
 
+    if tolerance is None:
+        tolerance = util.DEF_FIT_TOLERANCE
+
     # Convert to xyY
     xyz = (color.convert('xyz-d65', norm=False) if color.space() != 'xyz-d65' else color.normalize(nans=False))[:-1]
     x, y, Y = util.xyz_to_xyY(xyz, WHITES['2deg']['D65'])
@@ -142,3 +146,91 @@ def macadam_limits(luminance: float | None = None) -> Matrix:
     # Luminance exceeds threshold
     else:
         raise ValueError(f'Luminance must be between {LUMINANCE[0]} and {LUMINANCE[-1]}, but was {luminance}')
+
+
+def in_visible_spectrum(
+    color: Color,
+    tolerance: float | None = None,
+    ignore_luminance: bool = False,
+    **kwargs: Any
+) -> bool:
+    """See if color is within the spectral locus."""
+
+    if tolerance is None:
+        tolerance = 1e-3
+
+    # Get white and xyY coordinates
+    white = color.white('xy-1931')
+    l = color.luminance(white=white)
+    xy = color.xy()
+
+    # Get the dominant wavelength which will yield the point on the spectral locus in our direction
+    wave, dominant = color.wavelength()[:2]
+
+    # See if we have an achromatic color
+    if math.isnan(wave):
+        oog_chroma = False
+    else:
+        # Calculate magnitude with vector normalized such that white is the origin
+        xy_temp = alg.subtract(xy, white, dims=alg.D1)
+        m1 = math.sqrt(xy_temp[0] ** 2 + xy_temp[1] ** 2)
+        xy_temp = alg.subtract(dominant, white, dims=alg.D1)
+        m2 = math.sqrt(xy_temp[0] ** 2 + xy_temp[1] ** 2)
+        oog_chroma = m1 > (m2 + tolerance)
+
+    oog_lum = False if ignore_luminance else (l > (1 + tolerance) or l < (0 - tolerance))
+
+    # See if we are within tolerance
+    return not oog_lum and not oog_chroma
+
+
+def fit_visible_spectrum(
+    color: AnyColor,
+    tolerance: float = 1e-3,
+    ignore_luminance: bool = False,
+    **kwargs: Any
+) -> AnyColor:
+    """Fit color to the visible spectrum."""
+
+    # Get white and xyY coordinates
+    white = color.white('xy-1931')
+    l = color.luminance(white=white)
+    xy = color.xy()
+
+    # Get the dominant wavelength which will yield the point on the spectral locus in our direction
+    wave, dominant = color.wavelength()[:2]
+
+    # See if we have an achromatic color
+    if math.isnan(wave):
+        dominant = white
+        oog_chroma = False
+    else:
+        # Calculate magnitude with vector normalized such that white is the origin
+        xy_temp = alg.subtract(xy, white, dims=alg.D1)
+        m1 = math.sqrt(xy_temp[0] ** 2 + xy_temp[1] ** 2)
+        xy_temp = alg.subtract(dominant, white, dims=alg.D1)
+        m2 = math.sqrt(xy_temp[0] ** 2 + xy_temp[1] ** 2)
+
+        # Adjust range to pull in color relative to the spectral locus
+        if tolerance:
+            m2 += tolerance
+            h = math.degrees(math.atan2(xy_temp[1], xy_temp[0])) % 360
+            dominant = list(alg.add(alg.polar_to_rect(m2, h), white, dims=alg.D1))
+
+        # Check if color is outside the spectral locus
+        oog_chroma = m1 > m2
+
+    oog_lum = False if ignore_luminance else (l > 1 or l < 0)
+
+    # Adjust color is out of luminance range or outside the spectral locus limits
+    if oog_lum or l < 0 or oog_chroma:
+        color.update(
+            color.chromaticity(
+                color.space(),
+                [*(dominant if oog_chroma else xy), alg.clamp(l, 0, 1)],
+                'xy-1931',
+                white=white,
+                scale=False
+            )
+        )
+    return color
diff --git a/docs/src/markdown/about/changelog.md b/docs/src/markdown/about/changelog.md
index 7296df305..210cfcd77 100644
--- a/docs/src/markdown/about/changelog.md
+++ b/docs/src/markdown/about/changelog.md
@@ -5,6 +5,7 @@ icon: lucide/scroll-text
 
 ## 8.6
 
+-   **NEW**: Add new special gamut `visible-spectrum`.
 -   **NEW**: Add support for `carryforward` within `average()`.
 -   **ENHANCE**: More accurate dominant wavelength calculations.
 -   **FIX**: Ensure luminance calculations are all in the same white point with `scale` gamut mapping and color
diff --git a/docs/src/markdown/api/index.md b/docs/src/markdown/api/index.md
index 47cf4cf59..9ec1ee31a 100644
--- a/docs/src/markdown/api/index.md
+++ b/docs/src/markdown/api/index.md
@@ -1033,6 +1033,7 @@ def average(
     space: str | None = None,
     out_space: str | None = None,
     premultiplied: bool = True,
+    carryforward: bool = False,
     **kwargs: Any
 ) -> Self:
     ...
@@ -1308,13 +1309,11 @@ Description
 Parameters
 
 - 
-    Some methods could have additional parameters to configure the behavior, these would be done through `**kwargs`.
-    None of built-in gamut mapping methods currently have additional parameters.
-
     Parameters | Defaults           | Description
     ---------- | ------------------ | -----------
     `space`    | `#!py None`        | The color space that the color must be mapped to. If space is `#!py None`, then the current color space will be used.
     `method`   | `#!py None`        | String that specifies which gamut mapping method to use. If `#!py None`, `lch-chroma` will be used.
+    `**kwargs` |                    | Any supported parameters that should be passed to special gamuts.
 
 Return
 
@@ -1327,7 +1326,8 @@ Return
 def in_gamut(
     self, space: str | None = None,
     *,
-    tolerance: float = util.DEF_FIT_TOLERANCE
+    tolerance: float | None = None,
+    **kwargs: Any
 ) -> bool:
     ...
 ```
@@ -1343,7 +1343,8 @@ Parameters
     Parameters | Defaults         | Description
     ---------- | ---------------- | -----------
     `space`    | `#!py None`      | The color space that the color must be fit within. If space is `#!py None`, then the current color space will be used.
-    `tolerance`| `#!py 0.000075`  | Tolerance allowed when checking bounds of color.
+    `tolerance`| `#!py None`      | Tolerance allowed when checking bounds of color. If `#!py None`, the default is used.
+    `**kwargs` |                  | Any supported parameters that should be passed to special gamuts.
 
 Return
 
diff --git a/docs/src/markdown/examples/3d_models.html b/docs/src/markdown/examples/3d_models.html
index 0ef0ef4e6..304a46c8f 100644
--- a/docs/src/markdown/examples/3d_models.html
+++ b/docs/src/markdown/examples/3d_models.html
@@ -216,6 +216,7 @@ <h1>ColorAide Color Space Models</h1>
         options['gamuts'].append(key)
 options['gamuts'].append('pointer-gamut')
 options['gamuts'].append('macadam-limits')
+options['gamuts'].append('visible-spectrum')
 json.dumps(options)
 </script>
 <script id="payload" type="text/python">
@@ -230,8 +231,11 @@ <h1>ColorAide Color Space Models</h1>
 from coloraide import algebra as alg
 from coloraide.color import POSTFIX
 from coloraide.gamut import pointer, visible_spectrum, SPECIAL_GAMUTS
+from coloraide.cmfs import CIE_1931_2DEG as cmfs
+from coloraide import util
 
 FORCE_OWN_GAMUT = {'ryb', 'ryb-biased'}
+QHULL_OPTIONS = "Qbb Qc Qz Qx Q12 QbB"
 
 
 def get_face_color(cmap, simplex, filters):
@@ -414,10 +418,12 @@ <h1>ColorAide Color Space Models</h1>
             radius = c._space.radial_index()
             u.append(c[radius])
             v.append(c[hue])
-            if limit['macadam-limits']:
-                c.fit('macadam-limits')
             if limit['pointer-gamut']:
                 c.fit('pointer-gamut')
+            elif limit['macadam-limits']:
+                c.fit('macadam-limits')
+            elif limit['visible-spectrum']:
+                c.fit('visible-spectrum')
             c.convert(space, norm=False, in_place=True)
 
             store_coords(c, x, y, z, flags)
@@ -435,7 +441,7 @@ <h1>ColorAide Color Space Models</h1>
             cmap.append(s.to_string(hex=True))
 
     # Calculate triangles
-    tri = Delaunay([*zip(u, v)])
+    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
 
     create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
 
@@ -548,10 +554,13 @@ <h1>ColorAide Color Space Models</h1>
         for c in ColorCyl.steps([color, s2], steps=max(3, (resolution // 2) * 2 + 1), space=gspace, hue='specified'):
             u.append(c[2])
             v.append(c['hue'])
-            if limit['macadam-limits']:
-                c.fit('macadam-limits')
             if limit['pointer-gamut']:
                 c.fit('pointer-gamut')
+            elif limit['macadam-limits']:
+                c.fit('macadam-limits')
+            elif limit['visible-spectrum']:
+                c.fit('visible-spectrum')
+
             c.convert(space, norm=False, in_place=True)
 
             store_coords(c, x, y, z, flags)
@@ -569,7 +578,7 @@ <h1>ColorAide Color Space Models</h1>
             cmap.append(s.to_string(hex=True))
 
     # Calculate the triangles
-    tri = Delaunay([*zip(u, v)])
+    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
 
     create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
 
@@ -592,6 +601,7 @@ <h1>ColorAide Color Space Models</h1>
     """Render the Pointer gamut in 3d."""
 
     target = Color.CS_MAP[space]
+    white = target.WHITE
     flags = {
         'is_cyl': target.is_polar(),
         'is_labish': isinstance(target, Labish),
@@ -609,11 +619,29 @@ <h1>ColorAide Color Space Models</h1>
     z = []
     cmap = []
 
-    lightness = [91, *pointer.LIGHTNESS, 14] if gtype == 'pointer-gamut' else visible_spectrum.LUMINANCE
-    hues = pointer.HUE if gtype == 'pointer-gamut' else visible_spectrum.HUE
+    if gtype == 'pointer-gamut':
+        lightness = [91, *pointer.LIGHTNESS, 14]
+        hues = pointer.HUE
+    elif gtype == 'macadam-limits':
+        lightness = visible_spectrum.LUMINANCE
+        hues = visible_spectrum.HUE
+    else:
+        lightness = alg.linspace(1, alg.ATOL, max(3, (resolution // 2) * 2 + 1))
+        xy_pair = [cmfs.xy(r) for r in range(cmfs.start, cmfs.end + 1, cmfs.step)]
+        first, last = xy_pair[0], xy_pair[-1]
+        xy_pair.extend(
+            [[alg.lerp(last[0], first[0], r / 48), alg.lerp(last[1], first[1], r / 48)] for r in range(0, 49, 1)]
+        )
+        hues = [alg.rect_to_polar(*alg.subtract(r, white))[1] for r in xy_pair]
+        lowest = min(hues)
+        idx = hues.index(lowest)
+        hues = list(reversed(hues[:idx])) + list(reversed(hues[idx + 1:]))
+        hues.append(hues[0] + 360)
+        xy_pair = list(reversed(xy_pair[:idx])) + list(reversed(xy_pair[idx + 1:]))
+        xy_pair.append(xy_pair[0])
 
     for l in lightness:
-        for h in hues:
+        for e, h in enumerate(hues):
             if gtype == 'pointer-gamut':
                 # Close out the top or bottom if see lightness beyond the expected range
                 if l == 91:
@@ -629,7 +657,7 @@ <h1>ColorAide Color Space Models</h1>
                 v.append(h)
                 color = Color('xyz-d65', [0, 0, 0])
                 pointer.from_lch_sc(color, [_l, c, h])
-            else:
+            elif gtype == 'macadam-limits':
                 color = Color('white').convert('xyy', in_place=True)
                 if l == -1:
                     u.append(0)
@@ -641,11 +669,16 @@ <h1>ColorAide Color Space Models</h1>
                     u.append(l)
                     v.append(h)
                     color[:-1] = [*xy, l]
+            else:
+                color = Color.chromaticity('xyy', [*xy_pair[e], l], 'xy-1931', white=white, scale=False)
+                u.append(l)
+                v.append(h)
 
-            if limit['macadam-limits']:
-                color.fit('macadam-limits')
-            if limit['pointer-gamut']:
+            if gtype != 'pointer-gamut' and limit['pointer-gamut']:
                 color.fit('pointer-gamut')
+            elif gtype not in ('pointer-gamut', 'macadam-limits') and limit['macadam-limits']:
+                color.fit('macadam-limits')
+
             color.convert(space, norm=False, in_place=True)
             store_coords(color, x, y, z, flags)
 
@@ -662,10 +695,64 @@ <h1>ColorAide Color Space Models</h1>
             cmap.append(s.to_string(hex=True))
 
     # Calculate the triangles
-    tri = Delaunay([*zip(u, v)])
+    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
 
     create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
 
+    # Draw top and bottom of the visible spectrum
+    step = max(int(resolution / 8), 4)
+    if gtype == 'visible-spectrum':
+        for l in (1, alg.ATOL):
+            # 9, 60; 60, 90
+            ranges = list(range(0, 300, 4)) + [300]
+            for r in ranges:
+                start = r
+                end = min(r + (4 if r < 300 else 1000), len(hues) - 1)
+                u = []
+                v = []
+                x = []
+                y = []
+                z = []
+                cmap = []
+                for r in alg.linspace(0, 1, step):
+                    for e in range(start, end + 1, 1):
+                        h = hues[e]
+                        _c, _ = alg.rect_to_polar(*alg.subtract(xy_pair[e], white))
+                        _c = alg.lerp(_c, alg.ATOL, r)
+                        u.append(_c)
+                        v.append(h)
+                        color = Color.chromaticity(
+                            'xyy',
+                            [*alg.add(alg.polar_to_rect(_c, h), white), l],
+                            'xy-1931',
+                            white=white,
+                            scale=False
+                        )
+
+                        if gtype != 'pointer-gamut' and limit['pointer-gamut']:
+                            color.fit('pointer-gamut')
+                        if gtype not in ('pointer-gamut', 'macadam-limits') and limit['macadam-limits']:
+                            color.fit('macadam-limits')
+                        color.convert(space, norm=False, in_place=True)
+                        store_coords(color, x, y, z, flags)
+
+                        # Adjust gamut to fit the display space
+                        s = color.convert('srgb')
+                        if not s.in_gamut():
+                            s.fit(**gmap)
+                        else:
+                            s.clip()
+
+                        if filters:
+                            s.filter(filters[0], **filters[1], in_place=True, out_space=s.space()).clip()
+
+                        cmap.append(s.to_string(hex=True))
+
+                    # Calculate the triangles
+                    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
+
+                    create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
+
     return fig
 
 
@@ -789,7 +876,8 @@ <h1>ColorAide Color Space Models</h1>
         ecolor = None
         limit = {
             'pointer-gamut': config.get('pointer-gamut', False),
-            'macadam-limits': config.get('macadam-limits', False)
+            'macadam-limits': config.get('macadam-limits', False),
+            'visible-spectrum': config.get('visible-spectrum', False)
         }
         if isinstance(edges, str):
             c = Color(edges).convert('srgb').fit(**gmap)
@@ -1093,6 +1181,7 @@ <h1>ColorAide Color Space Models</h1>
     """Plot the spectral locus."""
 
     target = Color.CS_MAP[space]
+    white = target.WHITE
 
     flags = {
         'is_cyl': target.is_polar(),
@@ -1112,12 +1201,30 @@ <h1>ColorAide Color Space Models</h1>
         color = Color.from_wavelength(space, w, scale=False)
         store_coords(color, x, y, z, flags)
         cmap.append(
-            color.convert('srgb', in_place=True).fit('srgb-linear', method='scale').to_string(hex=True, alpha=False)
+            color.convert(
+                'srgb', in_place=True).fit('srgb-linear', method='scale', max_saturation=True
+            ).to_string(hex=True, alpha=False)
         )
         if not w % 20:
             labels.append(str(w))
         else:
             labels.append('')
+    first, last = util.xyz_to_xyY(cmfs[360]), util.xyz_to_xyY(cmfs[780])
+    for r in range(50):
+        color = Color.chromaticity(
+            space,
+            [alg.lerp(last[x], first[x], r / 49) for x in range(3)],
+            'xy-1931',
+            white=white,
+            scale=False
+        )
+        store_coords(color, x, y, z, flags)
+        cmap.append(
+            color.convert(
+                'srgb', in_place=True).fit('srgb-linear', method='scale', max_saturation=True
+            ).to_string(hex=True, alpha=False)
+        )
+        labels.append('')
 
     trace = go.Scatter3d(
         x=x, y=y, z=z,
diff --git a/docs/src/markdown/gamut.md b/docs/src/markdown/gamut.md
index 7873a23e8..d8e94282f 100644
--- a/docs/src/markdown/gamut.md
+++ b/docs/src/markdown/gamut.md
@@ -994,6 +994,53 @@ Steps(
 > ```
 > ///
 
+## Pointer's Gamut
+
+> [!new] New in 2.4
+
+The Pointer's gamut is (an approximation of) the gamut of real surface colors as can be seen by the human eye, based on
+the research by Michael R. Pointer (1980). What this means is that every color that can be reflected by the surface of
+an object of any material should be is inside the Pointer’s gamut. This does not include, however, those that do not
+occur naturally, such as neon lights, etc.
+
+![Pointer's Gamut](images/pointers-gamut.png)
+
+While in the above image, it may appear that most of sRGB is in the gamut, it is important to note that the image is
+showing the maximum range of the gamut. The actual boundary will be different at different luminance levels.
+
+![Pointer's Gamut lightness Levels](images/pointer-gamut-lightness.png)
+
+When viewed in 3D, we can see a lot more of sRGB is sticking out.
+
+![Pointer's Gamut in 3D](images/srgb-pointer-3d.png)
+
+The original gamut's data is described in LCh using illuminant C. Using this color space, we can estimate the chroma
+limit for any color based on it's lightness and hue. We can then reduce the chroma, preserving the lightness and hue.
+The image below shows the out of Pointer's gamut color `#!color red` (indicated by the `x`) which is clamped to the
+Pointer's gamut by reducing the chroma (indicated by the dot).
+
+![Pointer's Gamut Fitted](images/pointer-gamut-fit.png)
+
+The gamuts previously discussed are bound by a color space's limits, but the Pointer's gamut applies to colors more
+generally and was created from observed data via research. Because it doesn't quite fit with the color space gamut API,
+ColorAide exposes two special functions to test if a color is in the Pointer's gamut and to fit a color to the gamut.
+
+ColorAide provides an approximation of this gamut via a 3D LUT in the C illuminant and provides the special gamut name
+`pointer-gamut` that can be used in `in_gamut()` or `fit()` to check if a color is within the Pointer gamut limits or
+compress the color to fit within the Pointer gamut limits.
+
+```py play
+color = Color('red')
+color
+color.in_gamut('pointer-gamut')
+color.fit('pointer-gamut')
+color.in_gamut('pointer-gamut')
+```
+
+> [!note]
+> When gamut mapping in the `pointer-gamut` gamut, the `method` parameter is ignored as its own handling will be
+> applied.
+
 ## MacAdam Limits
 
 > [!new] New in 8.1
@@ -1036,49 +1083,57 @@ color.in_gamut('macadam-limits')
 > When gamut mapping in the `macadam-limits` gamut, the `method` parameter is ignored as its own handling will be
 > applied.
 
-## Pointer's Gamut
+## Visible Spectrum
 
-> [!new] New in 2.4
+> [!new] 8.6
 
-The Pointer's gamut is (an approximation of) the gamut of real surface colors as can be seen by the human eye, based on
-the research by Michael R. Pointer (1980). What this means is that every color that can be reflected by the surface of
-an object of any material should be is inside the Pointer’s gamut. This does not include, however, those that do not
-occur naturally, such as neon lights, etc.
+This provides checks and corrections of colors outside the spectral locus. The limits are defined by the 2D chromaticity
+coordinates. This includes both reflective and emissive colors, but the luminance is not based off any hard data and is
+just clamped between the ranges 0 - 1, regardless of the saturation of the color.
 
-![Pointer's Gamut](images/pointers-gamut.png)
 
-While in the above image, it may appear that most of sRGB is in the gamut, it is important to note that the image is
-showing the maximum range of the gamut. The actual boundary will be different at different luminance levels.
+![Rec. 2020 Within the Visible Spectrum](images/visible-spectrum-3d.png)
 
-![Pointer's Gamut lightness Levels](images/pointer-gamut-lightness.png)
+We can check if a color is within the visible spectrum, by using the special gamut name `visible-spectrum`.
 
-When viewed in 3D, we can see a lot more of sRGB is sticking out.
+```py play
+color = Color('prophoto-rgb', [0, 1, 0]).in_gamut('visible-spectrum')
+```
 
-![Pointer's Gamut in 3D](images/srgb-pointer-3d.png)
+We can also use `fit()` to adjust colors to fit within the visible spectrum. The visible spectrum is a complex shape,
+and the adjustments approximate the best point within the gamut, so colors should be _close_.
 
-The original gamut's data is described in LCh using illuminant C. Using this color space, we can estimate the chroma
-limit for any color based on it's lightness and hue. We can then reduce the chroma, preserving the lightness and hue.
-The image below shows the out of Pointer's gamut color `#!color red` (indicated by the `x`) which is clamped to the
-Pointer's gamut by reducing the chroma (indicated by the dot).
+/// tab | ProPhoto
+![ProPhoto RGB Outside the Visible Spectrum](images/visible-spectrum-prophoto-oog.png)
+///
 
-![Pointer's Gamut Fitted](images/pointer-gamut-fit.png)
+/// tab | ProPhoto Adjusted
+![ProPhoto RGB Inside the Visible Spectrum](images/visible-spectrum-prophoto-ig.png)
+///
 
-The gamuts previously discussed are bound by a color space's limits, but the Pointer's gamut applies to colors more
-generally and was created from observed data via research. Because it doesn't quite fit with the color space gamut API,
-ColorAide exposes two special functions to test if a color is in the Pointer's gamut and to fit a color to the gamut.
+```py play
+Color('prophoto-rgb', [0, 1, 0]).fit('visible-spectrum').in_gamut('visible-spectrum')
+```
 
-ColorAide provides an approximation of this gamut via a 3D LUT in the C illuminant and provides the special gamut name
-`pointer-gamut` that can be used in `in_gamut()` or `fit()` to check if a color is within the Pointer gamut limits or
-compress the color to fit within the Pointer gamut limits.
+It should be noted that many color spaces use rounded primaries. For instance, Rec. 2020 has primaries right on the
+spectral locus, but they are rounded to 3 decimal places. When we use no threshold, these colors appear outside the
+gamut. For this reason, using `visible-spectrum` with `in_gamut()` uses a default tolerance of `1e-3`, a larger
+tolerance than our other gamut checks do. In fact, we also use this same tolerance when trimming non-luminance limits
+of colors when using `fit()`. If desired the tolerance can be changed.
 
 ```py play
-color = Color('red')
-color
-color.in_gamut('pointer-gamut')
-color.fit('pointer-gamut')
-color.in_gamut('pointer-gamut')
+Color('rec2020', [1, 0, 0]).in_gamut('visible-spectrum')
+Color('rec2020', [1, 0, 0]).fit('visible-spectrum')
+Color('rec2020', [1, 0, 0]).in_gamut('visible-spectrum', tolerance=0)
+Color('rec2020', [1, 0, 0]).fit('visible-spectrum', tolerance=0)
 ```
 
-> [!note]
-> When gamut mapping in the `pointer-gamut` gamut, the `method` parameter is ignored as its own handling will be
-> applied.
+Lastly, it when dealing with an HDR color, you may not want the check to fail or if luminance is high, and you may not
+want the correction to touch the luminance. If this is the case, just set `ignore_luminance`.
+
+```py play
+Color('rec2100-hlg', [1, 1, 1]).in_gamut('visible-spectrum')
+Color('rec2100-hlg', [1, 1, 1]).fit('visible-spectrum')
+Color('rec2100-hlg', [1, 1, 1]).in_gamut('visible-spectrum', ignore_luminance=True)
+Color('rec2100-hlg', [1, 1, 1]).fit('visible-spectrum', ignore_luminance=True)
+```
diff --git a/docs/src/markdown/images/visible-spectrum-3d.png b/docs/src/markdown/images/visible-spectrum-3d.png
new file mode 100644
index 000000000..bd4218495
Binary files /dev/null and b/docs/src/markdown/images/visible-spectrum-3d.png differ
diff --git a/docs/src/markdown/images/visible-spectrum-prophoto-ig.png b/docs/src/markdown/images/visible-spectrum-prophoto-ig.png
new file mode 100644
index 000000000..422803502
Binary files /dev/null and b/docs/src/markdown/images/visible-spectrum-prophoto-ig.png differ
diff --git a/docs/src/markdown/images/visible-spectrum-prophoto-oog.png b/docs/src/markdown/images/visible-spectrum-prophoto-oog.png
new file mode 100644
index 000000000..27fc12f77
Binary files /dev/null and b/docs/src/markdown/images/visible-spectrum-prophoto-oog.png differ
diff --git a/tests/test_gamut.py b/tests/test_gamut.py
index c8989a565..091ac64c0 100644
--- a/tests/test_gamut.py
+++ b/tests/test_gamut.py
@@ -679,3 +679,84 @@ def test_macadam_limits_max(self):
 
         for coords1, coords2 in zip(test, expected):
             [self.assertCompare(a, b) for a, b in zip(coords1, coords2)]
+
+
+class TestVisibleSpectrum(util.ColorAsserts, unittest.TestCase):
+    """Test visible spectrum."""
+
+    def test_visible_spectrum(self):
+        """Test gamut check in visible spectrum."""
+
+        self.assertTrue(Color('rec2020', [1, 1, 1]).in_gamut('visible-spectrum'))
+        self.assertTrue(Color('rec2020', [1, 0, 0]).in_gamut('visible-spectrum'))
+        self.assertTrue(Color('rec2020', [0, 1, 0]).in_gamut('visible-spectrum'))
+        self.assertTrue(Color('rec2020', [0, 0, 1]).in_gamut('visible-spectrum'))
+        self.assertFalse(Color('rec2020', [1.1, 1.1, 1.1]).in_gamut('visible-spectrum'))
+        self.assertFalse(Color('prophoto-rgb', [0, 0, 1]).in_gamut('visible-spectrum'))
+
+    def test_visible_spectrum_threshold(self):
+        """Test gamut check using threshold."""
+
+        # Rec. 2020 is right on the spectral locus, but uses rounded primaries
+        self.assertTrue(Color('rec2020', [1, 1, 1]).in_gamut('visible-spectrum', tolerance=0))
+        self.assertFalse(Color('rec2020', [1, 0, 0]).in_gamut('visible-spectrum', tolerance=0))
+        self.assertFalse(Color('rec2020', [0, 1, 0]).in_gamut('visible-spectrum', tolerance=0))
+        self.assertFalse(Color('rec2020', [0, 0, 1]).in_gamut('visible-spectrum', tolerance=0))
+
+    def test_fit_visible_spectrum(self):
+        """Fit colors to visible spectrum."""
+
+        self.assertTrue(
+            Color('rec2020', [1.1, 1.1, 1.1]).fit('visible-spectrum'),
+            Color('rec2020', [1, 1, 1])
+        )
+        self.assertColorEqual(
+            Color('prophoto-rgb', [0, 1, 0]).fit('visible-spectrum'),
+            Color('color(prophoto-rgb 0.14843 0.99272 0.14843)')
+        )
+        self.assertColorEqual(
+            Color('prophoto-rgb', [0, 0, 1]).fit('visible-spectrum'),
+            Color('color(prophoto-rgb 0.00137 0.00137 0.0158)')
+        )
+
+    def test_fit_visible_spectrum_threshold(self):
+        """Fit colors to visible spectrum."""
+
+        # Custom tolerance
+        self.assertColorEqual(
+            Color('rec2020', [0, 1, 0]).fit('visible-spectrum', tolerance=0),
+            Color('color(rec2020 0.03137 0.99995 0.03137)')
+        )
+        self.assertColorEqual(
+            Color('rec2020', [0, 0, 1]).fit('visible-spectrum', tolerance=0),
+            Color('color(rec2020 0.03558 0.03558 0.99779)')
+        )
+
+        # Normal tolerance
+        self.assertColorEqual(
+            Color('rec2020', [1, 0, 0]).fit('visible-spectrum'),
+            Color('rec2020', [1, 0, 0])
+        )
+        self.assertColorEqual(
+            Color('rec2020', [0, 1, 0]).fit('visible-spectrum'),
+            Color('rec2020', [0, 1, 0])
+        )
+        self.assertColorEqual(
+            Color('rec2020', [0, 0, 1]).fit('visible-spectrum'),
+            Color('rec2020', [0, 0, 1])
+        )
+
+    def test_ignore_luminance(self):
+        """Test ignore luminance."""
+
+        self.assertFalse(Color('rec2100-hlg', [1, 1, 1]).in_gamut('visible-spectrum'))
+        self.assertTrue(Color('rec2100-hlg', [1, 1, 1]).in_gamut('visible-spectrum', ignore_luminance=True))
+
+        self.assertColorEqual(
+            Color('rec2100-hlg', [0, 1, 0]).fit('visible-spectrum'),
+            Color('color(rec2100-hlg 0 0.82507 0)')
+        )
+        self.assertColorEqual(
+            Color('rec2100-hlg', [0, 1, 0]).fit('visible-spectrum', ignore_luminance=True),
+            Color('color(rec2100-hlg 0 1 0)')
+        )
diff --git a/tools/gamut_3d_plotly.py b/tools/gamut_3d_plotly.py
index 07105ccd3..4bb9b02fb 100644
--- a/tools/gamut_3d_plotly.py
+++ b/tools/gamut_3d_plotly.py
@@ -19,8 +19,11 @@
 from coloraide import algebra as alg
 from coloraide.color import POSTFIX
 from coloraide.gamut import pointer, visible_spectrum, SPECIAL_GAMUTS
+from coloraide.cmfs import CIE_1931_2DEG as cmfs
+from coloraide import util
 
 FORCE_OWN_GAMUT = {'ryb', 'ryb-biased'}
+QHULL_OPTIONS = "Qbb Qc Qz Qx Q12 QbB"
 
 
 def get_face_color(cmap, simplex, filters):
@@ -203,10 +206,12 @@ def cyl_disc(
             radius = c._space.radial_index()
             u.append(c[radius])
             v.append(c[hue])
-            if limit['macadam-limits']:
-                c.fit('macadam-limits')
             if limit['pointer-gamut']:
                 c.fit('pointer-gamut')
+            elif limit['macadam-limits']:
+                c.fit('macadam-limits')
+            elif limit['visible-spectrum']:
+                c.fit('visible-spectrum')
             c.convert(space, norm=False, in_place=True)
 
             store_coords(c, x, y, z, flags)
@@ -224,7 +229,7 @@ def cyl_disc(
             cmap.append(s.to_string(hex=True))
 
     # Calculate triangles
-    tri = Delaunay([*zip(u, v)])
+    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
 
     create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
 
@@ -337,10 +342,13 @@ def render_space_cyl(fig, space, gamut, resolution, opacity, edges, faces, ecolo
         for c in ColorCyl.steps([color, s2], steps=max(3, (resolution // 2) * 2 + 1), space=gspace, hue='specified'):
             u.append(c[2])
             v.append(c['hue'])
-            if limit['macadam-limits']:
-                c.fit('macadam-limits')
             if limit['pointer-gamut']:
                 c.fit('pointer-gamut')
+            elif limit['macadam-limits']:
+                c.fit('macadam-limits')
+            elif limit['visible-spectrum']:
+                c.fit('visible-spectrum')
+
             c.convert(space, norm=False, in_place=True)
 
             store_coords(c, x, y, z, flags)
@@ -358,7 +366,7 @@ def render_space_cyl(fig, space, gamut, resolution, opacity, edges, faces, ecolo
             cmap.append(s.to_string(hex=True))
 
     # Calculate the triangles
-    tri = Delaunay([*zip(u, v)])
+    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
 
     create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
 
@@ -381,6 +389,7 @@ def render_special_gamut(gtype, fig, space, resolution, opacity, edges, faces, e
     """Render the Pointer gamut in 3d."""
 
     target = Color.CS_MAP[space]
+    white = target.WHITE
     flags = {
         'is_cyl': target.is_polar(),
         'is_labish': isinstance(target, Labish),
@@ -398,11 +407,29 @@ def render_special_gamut(gtype, fig, space, resolution, opacity, edges, faces, e
     z = []
     cmap = []
 
-    lightness = [91, *pointer.LIGHTNESS, 14] if gtype == 'pointer-gamut' else visible_spectrum.LUMINANCE
-    hues = pointer.HUE if gtype == 'pointer-gamut' else visible_spectrum.HUE
+    if gtype == 'pointer-gamut':
+        lightness = [91, *pointer.LIGHTNESS, 14]
+        hues = pointer.HUE
+    elif gtype == 'macadam-limits':
+        lightness = visible_spectrum.LUMINANCE
+        hues = visible_spectrum.HUE
+    else:
+        lightness = alg.linspace(1, alg.ATOL, max(3, (resolution // 2) * 2 + 1))
+        xy_pair = [cmfs.xy(r) for r in range(cmfs.start, cmfs.end + 1, cmfs.step)]
+        first, last = xy_pair[0], xy_pair[-1]
+        xy_pair.extend(
+            [[alg.lerp(last[0], first[0], r / 48), alg.lerp(last[1], first[1], r / 48)] for r in range(0, 49, 1)]
+        )
+        hues = [alg.rect_to_polar(*alg.subtract(r, white))[1] for r in xy_pair]
+        lowest = min(hues)
+        idx = hues.index(lowest)
+        hues = list(reversed(hues[:idx])) + list(reversed(hues[idx + 1:]))
+        hues.append(hues[0] + 360)
+        xy_pair = list(reversed(xy_pair[:idx])) + list(reversed(xy_pair[idx + 1:]))
+        xy_pair.append(xy_pair[0])
 
     for l in lightness:
-        for h in hues:
+        for e, h in enumerate(hues):
             if gtype == 'pointer-gamut':
                 # Close out the top or bottom if see lightness beyond the expected range
                 if l == 91:
@@ -418,7 +445,7 @@ def render_special_gamut(gtype, fig, space, resolution, opacity, edges, faces, e
                 v.append(h)
                 color = Color('xyz-d65', [0, 0, 0])
                 pointer.from_lch_sc(color, [_l, c, h])
-            else:
+            elif gtype == 'macadam-limits':
                 color = Color('white').convert('xyy', in_place=True)
                 if l == -1:
                     u.append(0)
@@ -430,11 +457,16 @@ def render_special_gamut(gtype, fig, space, resolution, opacity, edges, faces, e
                     u.append(l)
                     v.append(h)
                     color[:-1] = [*xy, l]
+            else:
+                color = Color.chromaticity('xyy', [*xy_pair[e], l], 'xy-1931', white=white, scale=False)
+                u.append(l)
+                v.append(h)
 
-            if limit['macadam-limits']:
-                color.fit('macadam-limits')
-            if limit['pointer-gamut']:
+            if gtype != 'pointer-gamut' and limit['pointer-gamut']:
                 color.fit('pointer-gamut')
+            elif gtype not in ('pointer-gamut', 'macadam-limits') and limit['macadam-limits']:
+                color.fit('macadam-limits')
+
             color.convert(space, norm=False, in_place=True)
             store_coords(color, x, y, z, flags)
 
@@ -451,10 +483,64 @@ def render_special_gamut(gtype, fig, space, resolution, opacity, edges, faces, e
             cmap.append(s.to_string(hex=True))
 
     # Calculate the triangles
-    tri = Delaunay([*zip(u, v)])
+    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
 
     create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
 
+    # Draw top and bottom of the visible spectrum
+    step = max(int(resolution / 8), 4)
+    if gtype == 'visible-spectrum':
+        for l in (1, alg.ATOL):
+            # 9, 60; 60, 90
+            ranges = list(range(0, 300, 4)) + [300]
+            for r in ranges:
+                start = r
+                end = min(r + (4 if r < 300 else 1000), len(hues) - 1)
+                u = []
+                v = []
+                x = []
+                y = []
+                z = []
+                cmap = []
+                for r in alg.linspace(0, 1, step):
+                    for e in range(start, end + 1, 1):
+                        h = hues[e]
+                        _c, _ = alg.rect_to_polar(*alg.subtract(xy_pair[e], white))
+                        _c = alg.lerp(_c, alg.ATOL, r)
+                        u.append(_c)
+                        v.append(h)
+                        color = Color.chromaticity(
+                            'xyy',
+                            [*alg.add(alg.polar_to_rect(_c, h), white), l],
+                            'xy-1931',
+                            white=white,
+                            scale=False
+                        )
+
+                        if gtype != 'pointer-gamut' and limit['pointer-gamut']:
+                            color.fit('pointer-gamut')
+                        if gtype not in ('pointer-gamut', 'macadam-limits') and limit['macadam-limits']:
+                            color.fit('macadam-limits')
+                        color.convert(space, norm=False, in_place=True)
+                        store_coords(color, x, y, z, flags)
+
+                        # Adjust gamut to fit the display space
+                        s = color.convert('srgb')
+                        if not s.in_gamut():
+                            s.fit(**gmap)
+                        else:
+                            s.clip()
+
+                        if filters:
+                            s.filter(filters[0], **filters[1], in_place=True, out_space=s.space()).clip()
+
+                        cmap.append(s.to_string(hex=True))
+
+                    # Calculate the triangles
+                    tri = Delaunay([*zip(u, v)], qhull_options=QHULL_OPTIONS)
+
+                    create3d(fig, x, y, z, tri, cmap, edges, faces, ecolor, fcolor, opacity, filters)
+
     return fig
 
 
@@ -578,7 +664,8 @@ def plot_gamut_in_space(
         ecolor = None
         limit = {
             'pointer-gamut': config.get('pointer-gamut', False),
-            'macadam-limits': config.get('macadam-limits', False)
+            'macadam-limits': config.get('macadam-limits', False),
+            'visible-spectrum': config.get('visible-spectrum', False)
         }
         if isinstance(edges, str):
             c = Color(edges).convert('srgb').fit(**gmap)
@@ -882,6 +969,7 @@ def plot_spectral_locus(fig, space):
     """Plot the spectral locus."""
 
     target = Color.CS_MAP[space]
+    white = target.WHITE
 
     flags = {
         'is_cyl': target.is_polar(),
@@ -901,12 +989,30 @@ def plot_spectral_locus(fig, space):
         color = Color.from_wavelength(space, w, scale=False)
         store_coords(color, x, y, z, flags)
         cmap.append(
-            color.convert('srgb', in_place=True).fit('srgb-linear', method='scale').to_string(hex=True, alpha=False)
+            color.convert(
+                'srgb', in_place=True).fit('srgb-linear', method='scale', max_saturation=True
+            ).to_string(hex=True, alpha=False)
         )
         if not w % 20:
             labels.append(str(w))
         else:
             labels.append('')
+    first, last = util.xyz_to_xyY(cmfs[360]), util.xyz_to_xyY(cmfs[780])
+    for r in range(50):
+        color = Color.chromaticity(
+            space,
+            [alg.lerp(last[x], first[x], r / 49) for x in range(3)],
+            'xy-1931',
+            white=white,
+            scale=False
+        )
+        store_coords(color, x, y, z, flags)
+        cmap.append(
+            color.convert(
+                'srgb', in_place=True).fit('srgb-linear', method='scale', max_saturation=True
+            ).to_string(hex=True, alpha=False)
+        )
+        labels.append('')
 
     trace = go.Scatter3d(
         x=x, y=y, z=z,