Consider the following XAML:

```xml
<Grid>
  <Grid.ColumnDefinitions>
    <ColumnDefinition/>
    <ColumnDefinition Width="Auto"/>
  </Grid.ColumnDefinitions>
  <Button Content="Button" HorizontalAlignment="Left"/>
  <Grid Grid.Column="1">
    <Grid.ColumnDefinitions>
      <ColumnDefinition/>
      <ColumnDefinition/>
    </Grid.ColumnDefinitions>
    <Button Content="B" Margin="5"/>
    <Button Content="Button" Grid.Column="1" Margin="5"/>
  </Grid>
</Grid>

```

In the above, all `ColumnDefinition` values except one use the default value for `Width`, which is `"*"`, i.e. "star sizing". The one exception is the column containing the nested `Grid` control, which is set to `"Auto"`.

The way I expect this to work is as follows:

* The outer `Grid` sizes the second column according to the needs of its content, and then assigns the remaining width of the control to the first column.
* The inner `Grid` distributes its available space *evenly* to the two columns. After all, they both are set to use star sizing, and star sizing is supposed to set the `GridLength` property (width, in this case) to a weighted distribution of available space. The minimum layout size for this inner `Grid` (needed for the outer `Grid` to compute the width of its second column) is the sum of evenly-distributed-width, star-sized columns (i.e. in this case, two times the width of the column with the widest content).

But instead, the column widths for the nested grid are set according to the computed minimum size of each button, with no apparent weighted relationship between the two star-sized columns (gridlines are shown for clarity):

![incorrectly distributed column widths](https://i.stack.imgur.com/TDNYB.png)

It works as expected if I don't have the outer grid, i.e. just make the inner grid the only grid in the window:

![correctly distributed column widths](https://i.stack.imgur.com/9jUOz.png)

The two columns are forced to be the same size, and then of course the left-hand button is stretched to fit the size of its containing cell (which is what I want…the end goal is for those two buttons to have the same width, with the grid columns providing the layout to accomplish that).

In this particular example, I can use `UniformGrid` as a work-around, to force even distribution of column widths. This is how I want it actually to look (`UniformGrid` doesn't have a `ShowGridLines` property, so you just have to imagine the imaginary line between the two right-most buttons):

![enter image description here](https://i.stack.imgur.com/vXboi.png)

But I really would like to understand more generally how to accomplish this, so that in more complex scenarios I would be able to use star-sizing in a nested `Grid` control.

It seems that somehow, being contained within the cell of another `Grid` control is changing the way that star sizing is computed for the inner `Grid` control (or preventing star sizing from having any effect at all). But why should this be? Am I missing (yet again) some esoteric layout rule of WPF that explains this as "by design" behavior? Or is this simply a bug in the framework?

**Update:**

I understand Ben's answer to mean that star-sizing should be distributing only the left-over space *after* the minimum sizes for each column has been accounted for. But that is not what one sees in other scenarios.

For example, if the column containing the inner grid has been sized explicitly, then using star-sizing for the inner grid's columns results in the columns being sized evenly, just as I'd expect.

I.e. this XAML:

```xml
<Grid ShowGridLines="True">
  <Grid.ColumnDefinitions>
    <ColumnDefinition/>
    <!--
    <ColumnDefinition Width="Auto"/>
    -->
    <ColumnDefinition Width="60"/>
  </Grid.ColumnDefinitions>
  <Button Content="Button" HorizontalAlignment="Left"/>
  <Grid Grid.Column="1" ShowGridLines="True">
    <Grid.ColumnDefinitions>
      <ColumnDefinition/>
      <ColumnDefinition/>
    </Grid.ColumnDefinitions>
    <Button Content="B" Margin="5"/>
    <Button Content="Button" Grid.Column="1" Margin="5"/>
  </Grid>
</Grid>

```

produces this output:

![enter image description here](https://i.stack.imgur.com/ipJdX.png)

In other words, at worst, I'd expect WPF to first calculate the minimum size of the inner grid without considering the star-sizing (e.g. if the short button takes 10 pixels and the long button takes 70, then the total width would be 80), and then *still* distribute evenly the column widths (i.e. in the 10/70 example, each column would wind up with 40 pixels, truncated the longer button, similar to the above image).

Why should star-sizing sometimes evenly distribute the widths across columns and sometimes not?

**Update #2:**

Here is a simple example that shows clearly and dramatically how WPF treats star-sizing differently depending on whether it's the one to compute the `Grid` width or you are:

```xml
<Window x:Class="TestGridLayout2.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        SizeToContent="WidthAndHeight"
        Title="MainWindow">
  <Window.Resources>
    <Style TargetType="Border">
      <Setter Property="BorderBrush" Value="Black"/>
      <Setter Property="BorderThickness" Value="1"/>
    </Style>
    <Style TargetType="TextBlock">
      <Setter Property="FontSize" Value="24"/>
    </Style>
  </Window.Resources>
  <Grid>
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="*"/>
      <ColumnDefinition Width="3*"/>
    </Grid.ColumnDefinitions>

    <Border Grid.Column="0"/>
    <Border Grid.Column="1"/>

    <StackPanel>
      <TextBlock Text="Some text -- one"/>
      <TextBlock Text="Some text -- two"/>
      <TextBlock Text="Some text -- three"/>
    </StackPanel>
    <StackPanel Grid.Column="1">
      <TextBlock Text="one"/>
      <TextBlock Text="two"/>
      <TextBlock Text="three"/>
    </StackPanel>
  </Grid>
</Window>

```

When you run the program, you see this:

[![enter image description here](https://i.stack.imgur.com/nkAUq.png)](https://i.stack.imgur.com/nkAUq.png)

WPF has ignored star-sizing, setting each column width to its minimum. If you simply click on the window border, as if to resize the window (you don't even have to actually drag the border anywhere), the `Grid` layout gets redone, and you get this:

[![enter image description here](https://i.stack.imgur.com/nGnYy.png)](https://i.stack.imgur.com/nGnYy.png)

At this point, the star-sizing gets applied (as I'd expect) and the columns are proportioned according to the XAML declarations.