How do I get the parent from a AudioMixerGroup Object

The title says it all.

I have a SoundSource that plays into an AudioMixerGroup. I can get the MixerGroups’ mixer with AudioMixerGroup.audioMixer but I would like to walk the complete tree of all MixerGroups up↑ to the Master.

something like this: GroupA1 → GroupA → Master

Getting groups with AudioMixer.FindMatchingGroups( doesn’t help because I have to know what they are called for that.


Hi @MrFuzzzy i know is a little bit late, but in case you have not found a solution for this (or if some else needs a solution for this same issue) I am posting my solution. So here is what I did to get the “hierarchy” of MixerSoundGroups:

private class GD //FYI, GD stands for GroupData
    public GD Parent;
    public AudioMixerGroup Group;
    public List<GD> Children;
    public int Depth;

    public GD(AudioMixerGroup group, GD parent, int depth)
         Group = group;
         Children = new List<GD>();
         Parent = parent;
         Depth = depth;

private GD GetGroupsData(AudioMixer mixer)
    AudioMixerGroup[] groups = mixer.FindMatchingGroups("Master");
    GD masterData = new GD(groups[0], null, 0);
    SetChildren(masterData, mixer);
    return masterData;

private void SetChildren(GD parent, AudioMixer mixer)
    if (parent== null)

    AudioMixerGroup[] children = mixer.FindMatchingGroups(;

    if (children.Length != 0)
        int i = 0;
        while (i < children.Length)
            GD child = new GD(children*, parent, parent.Depth + 1);*

SetChildren(child, mixer);
int subChildrenCount = mixer.FindMatchingGroups(
i += subChildrenCount > 0 ? subChildrenCount + 1 : 1;

//Somwhere in your code call ‘GetGroupsData’ like this:
GD masterData = GetGroupsData(youAudioMixerInstance);

I wrote another one that handles hierarchies with duplicated names and sub-branches.

using System;
using System.Collections.Generic;
using UnityEngine.Audio;

public static class AudioMixerGroupExtensions
    /// <summary>
    /// This method resolves the 'Hierarchy' of the AudioMixer's AudioMixerGroups.
    /// It resolves the correct hierarchy even if AudioMixerGroup names or even
    /// whole branches are duplicated. It can do this because AudioMixer.FindMatchingGroups returns
    /// it's results in a depth-first order.
    /// </summary>
    /// <param name="mixer">The <see cref="AudioMixer"/> to resolve the hierarchy for.</param>
    /// <returns>A AudioMixerGroupHierarchy</returns>
    public static IAudioMixerGroupHierarchy GetMixerGroupHierarchy(this AudioMixer mixer)
        return AudioMixerGroupHierarchy.ResolveHierarchy(mixer);
    private class AudioMixerGroupHierarchy : IAudioMixerGroupHierarchy
        private readonly AudioMixerGroupHierarchy parent;
        private readonly AudioMixerGroup mixerGroup;
        private readonly List<AudioMixerGroupHierarchy> children;
        private readonly string path;
        private readonly int depth;

        private AudioMixerGroupHierarchy(AudioMixerGroup mixerGroup, AudioMixerGroupHierarchy parent, int depth)
            this.mixerGroup = mixerGroup;
            this.parent = parent;
            this.depth = depth;
            path = $"{parent?.path}/{}";
            children = new List<AudioMixerGroupHierarchy>();

        internal static IAudioMixerGroupHierarchy ResolveHierarchy(AudioMixer mixer)
            // We are relying on the fact that FindMatchingGroups returns
            // the mixers in a depth-first order, meaning as we iterate
            // the list we will never see an element whose parent we have
            // not seen before
            var depthFirstOrderedMixerGroups = mixer.FindMatchingGroups("");
            var root = new AudioMixerGroupHierarchy(depthFirstOrderedMixerGroups[0], null, 0);
            var ancestorStack = new Stack<AudioMixerGroupHierarchy>();
            // Iterate over all mixerGroups, resolving the hierarchy by 
            // testing results of mixer.FindMatchingGroups(searchPath)
            // against the mixerGroup we are iterating on.
            // Skip the first element which is the root. 
            for (var i = 1; i < depthFirstOrderedMixerGroups.Length; i++)
                var subMixer = depthFirstOrderedMixerGroups*;*

var parent = ancestorStack.Peek();
var searchPath = $“{parent.path}/{}”;
var searchPathResults = mixer.FindMatchingGroups(searchPath);

var index = Array.IndexOf(searchPathResults, subMixer);
if (index < 0)
// If the entry was not found in this searchPath, then search in the previous parent
// Debug.LogWarning($“Entry not at {searchPath}, back-track to previous parent {ancestorStack.Peek().Path} and re-iterate”);

var isProbableNode = searchPathResults.Length != 1;
// A LEAF may be falsely detected as a NODE:
// If the path of this node is a partial path of another deeper path
// there is no way to verify it is a LEAF before the whole tree has been resolved
// The only side-effect is an extra iteration, where we test the leaf-node
// for children before back-tracking.

var node = new AudioMixerGroupHierarchy(subMixer, parent, ancestorStack.Count);
if (isProbableNode)

return root;

IAudioMixerGroupHierarchy IAudioMixerGroupHierarchy.Parent => parent;

AudioMixerGroup IAudioMixerGroupHierarchy.Group => mixerGroup;

IReadOnlyList IAudioMixerGroupHierarchy.Children => children;

int IAudioMixerGroupHierarchy.Depth => depth;

string IAudioMixerGroupHierarchy.Path => path;

public interface IAudioMixerGroupHierarchy
public IAudioMixerGroupHierarchy Parent { get; }

public AudioMixerGroup Group { get; }

public IReadOnlyList Children { get; }

public int Depth { get; }

public string Path { get; }