diff --git a/libs/ui/include/psemek/ui/element.hpp b/libs/ui/include/psemek/ui/element.hpp
index 7433b5fc..9acfae49 100644
--- a/libs/ui/include/psemek/ui/element.hpp
+++ b/libs/ui/include/psemek/ui/element.hpp
@@ -44,8 +44,15 @@ namespace psemek::ui
 		virtual void reshape(geom::box<float, 2> const & bbox) = 0;
 		virtual void reshape();
 
+		// Constraints on the element's width & height, assuming unlimited available space
 		virtual geom::box<float, 2> size_constraints() const;
 
+		// Constraints on the element's width, assuming fixed height
+		virtual geom::interval<float> width_constraints(float height) const;
+
+		// Constraints on the element's height, assuming fixed width
+		virtual geom::interval<float> height_constraints(float width) const;
+
 		virtual bool enabled() const { return enabled_; }
 		virtual void set_enabled(bool value) { enabled_ = value; }
 		virtual void enable() { set_enabled(true); }
diff --git a/libs/ui/include/psemek/ui/grid_layout.hpp b/libs/ui/include/psemek/ui/grid_layout.hpp
index 37e24ade..3e194c14 100644
--- a/libs/ui/include/psemek/ui/grid_layout.hpp
+++ b/libs/ui/include/psemek/ui/grid_layout.hpp
@@ -40,8 +40,15 @@ namespace psemek::ui
 		virtual void set_outer_margin(bool value);
 		virtual bool outer_margin() const { return outer_margin_; }
 
+		virtual void set_width_first(bool value);
+		virtual bool width_first() const { return width_first_; }
+
 		geom::box<float, 2> size_constraints() const override;
 
+		geom::interval<float> width_constraints(float height) const override;
+
+		geom::interval<float> height_constraints(float width) const override;
+
 		struct shape const & shape() const override { return shape_; }
 		void reshape(geom::box<float, 2> const & bbox) override;
 
@@ -61,6 +68,7 @@ namespace psemek::ui
 		std::vector<float> column_weight_;
 
 		bool outer_margin_ = true;
+		bool width_first_ = true;
 
 		box_shape shape_;
 	};
diff --git a/libs/ui/include/psemek/ui/label.hpp b/libs/ui/include/psemek/ui/label.hpp
index 66c8bf52..8bc5616d 100644
--- a/libs/ui/include/psemek/ui/label.hpp
+++ b/libs/ui/include/psemek/ui/label.hpp
@@ -69,6 +69,9 @@ namespace psemek::ui
 
 		geom::box<float, 2> size_constraints() const override;
 
+		geom::interval<float> width_constraints(float height) const override;
+		geom::interval<float> height_constraints(float width) const override;
+
 		void style_updated() override;
 		void own_style_updated() override;
 
diff --git a/libs/ui/source/element.cpp b/libs/ui/source/element.cpp
index 6a9aa1a0..22e862fa 100644
--- a/libs/ui/source/element.cpp
+++ b/libs/ui/source/element.cpp
@@ -61,6 +61,16 @@ namespace psemek::ui
 		return {{{0.f, inf}, {0.f, inf}}};
 	}
 
+	geom::interval<float> element::width_constraints(float) const
+	{
+		return size_constraints()[0];
+	}
+
+	geom::interval<float> element::height_constraints(float) const
+	{
+		return size_constraints()[1];
+	}
+
 	std::shared_ptr<style const> element::set_style(std::shared_ptr<struct style const> st)
 	{
 		if (style_)
diff --git a/libs/ui/source/grid_layout.cpp b/libs/ui/source/grid_layout.cpp
index fc683cef..0734e3d8 100644
--- a/libs/ui/source/grid_layout.cpp
+++ b/libs/ui/source/grid_layout.cpp
@@ -149,86 +149,167 @@ namespace psemek::ui
 		post_reshape();
 	}
 
-	static std::pair<std::vector<geom::interval<float>>, std::vector<geom::interval<float>>> row_column_sizes(util::array<std::shared_ptr<element>, 2> const & children)
+	void grid_layout::set_width_first(bool value)
 	{
-		std::vector<geom::interval<float>> row_size(children.width(), {0.f, inf});
-		std::vector<geom::interval<float>> column_size(children.height(), {0.f, inf});
+		width_first_ = value;
+		post_reshape();
+	}
 
-		for (std::size_t i = 0; i < children.width(); ++i)
+	template <int Dimension>
+	static std::vector<geom::interval<float>> cell_sizes(util::array<std::shared_ptr<element>, 2> const & children)
+	{
+		std::vector<geom::interval<float>> result(children.dim(Dimension), {0.f, inf});
+
+		for (auto idx : children.indices())
 		{
-			for (std::size_t j = 0; j < children.height(); ++j)
-			{
-				auto c = children(i, j);
-				if (!c) continue;
+			auto c = children(idx);
+			if (!c) continue;
 
-				auto sc = c->size_constraints();
-				row_size[i] &= sc[1];
-				column_size[j] &= sc[0];
+			result[idx[Dimension]] &= c->size_constraints()[1 - Dimension];
+		}
+
+		return result;
+	}
+
+	template <int Dimension>
+	static std::vector<geom::interval<float>> cell_sizes_constrained(util::array<std::shared_ptr<element>, 2> const & children, std::vector<geom::interval<float>> const & other_dimension_shapes)
+	{
+		std::vector<geom::interval<float>> result(children.dim(Dimension), {0.f, inf});
+
+		for (auto idx : children.indices())
+		{
+			auto c = children(idx);
+			if (!c) continue;
+
+			geom::interval<float> constraint;
+
+			if constexpr (Dimension == 0)
+			{
+				constraint = c->height_constraints(other_dimension_shapes[idx[1]].length());
+			}
+			else if constexpr (Dimension == 1)
+			{
+				constraint = c->width_constraints(other_dimension_shapes[idx[0]].length());
+			}
+
+			result[idx[Dimension]] &= constraint;
+		}
+
+		return result;
+	}
+
+	static geom::interval<float> combine(std::vector<geom::interval<float>> const & sizes, std::vector<float> const & weights, float margin, bool outer)
+	{
+		geom::interval<float> result{0.f, 0.f};
+		geom::interval<float> unit{0.f, inf};
+
+		float sum_weights = 0.f;
+
+		for (std::size_t i = 0; i < sizes.size(); ++i)
+		{
+			bool const minimized = (weights[i] == 0.f);
+
+			if (minimized)
+				result += sizes[i].min;
+			else
+				unit &= geom::interval<float>{sizes[i].min / weights[i], sizes[i].max / weights[i]};
+
+			sum_weights += weights[i];
+		}
+
+		// prevent (inf * 0.f)
+		if (sum_weights > 0.f)
+		{
+			result.min += unit.min * sum_weights;
+			result.max += unit.max * sum_weights;
+		}
+
+		int const margin_count = (std::max<int>(1, sizes.size()) + (outer ? 1 : -1));
+
+		result += margin_count * margin;
+
+		return result;
+	}
+
+	static std::vector<geom::interval<float>> allocate(std::vector<geom::interval<float>> const & sizes, std::vector<float> const & weights, float available, float margin, bool outer)
+	{
+		available -= margin * (static_cast<int>(sizes.size()) + (outer ? 1 : -1));
+
+		float const sum_weights = std::accumulate(weights.begin(), weights.end(), 0.f);
+
+		std::vector<geom::interval<float>> result(sizes.size());
+
+		// Allocate minimized
+		for (std::size_t i = 0; i < sizes.size(); ++i)
+		{
+			if (weights[i] == 0.f)
+			{
+				result[i] = {0.f, sizes[i].min};
+				available -= sizes[i].min;
 			}
 		}
 
-		return {std::move(row_size), std::move(column_size)};
+		available = std::max(available, 0.f);
+
+		// Allocate scalable
+		for (std::size_t i = 0; i < sizes.size(); ++i)
+		{
+			if (weights[i] == 0.f)
+				continue;
+
+			float const column_width = available * weights[i] / sum_weights;
+			result[i] = {0.f, column_width};
+		}
+
+		return result;
+	}
+
+	static void move(std::vector<geom::interval<float>> & shapes, geom::interval<float> const & available, float margin, bool outer)
+	{
+		// Move cells one after another
+		for (std::size_t i = 0; i < shapes.size(); ++i)
+		{
+			if (i == 0)
+				shapes[i] += available.min + (outer ? margin : 0.f);
+			else
+				shapes[i] += shapes[i - 1].max + margin;
+		}
 	}
 
 	geom::box<float, 2> grid_layout::size_constraints() const
 	{
 		auto st = merged_own_style();
-		if (!st) return element::size_constraints();
 
-		auto row_column_size = row_column_sizes(children_);
-		auto const & row_size = row_column_size.first;
-		auto const & column_size = row_column_size.second;
+		auto row_sizes = cell_sizes<0>(children_);
+		auto column_sizes = cell_sizes<1>(children_);
 
-		geom::box<float, 2> result{{{0.f, 0.f}, {0.f, 0.f}}};
-		geom::box<float, 2> unit{{{0.f, inf}, {0.f, inf}}};
+		auto height = combine(row_sizes, row_weight_, *st->outer_margin, outer_margin_);
+		auto width = combine(column_sizes, column_weight_, *st->outer_margin, outer_margin_);
+		return {{width, height}};
+	}
 
-		float sum_row_weights = 0.f;
-		float sum_column_weights = 0.f;
+	geom::interval<float> grid_layout::width_constraints(float height) const
+	{
+		auto st = merged_own_style();
 
-		for (std::size_t i = 0; i < row_count(); ++i)
-		{
-			bool const minimized = (row_weight_[i] == 0.f);
+		auto row_sizes = cell_sizes<0>(children_);
+		auto row_shapes = allocate(row_sizes, row_weight_, height, *st->outer_margin, outer_margin_);
 
-			if (minimized)
-				result[1] += row_size[i].min;
-			else
-				unit[1] &= geom::interval<float>{row_size[i].min / row_weight_[i], row_size[i].max / row_weight_[i]};
+		auto column_sizes = cell_sizes_constrained<1>(children_, row_shapes);
 
-			sum_row_weights += row_weight_[i];
-		}
+		return combine(column_sizes, column_weight_, *st->outer_margin, outer_margin_);
+	}
 
-		for (std::size_t i = 0; i < column_count(); ++i)
-		{
-			bool const minimized = (column_weight_[i] == 0.f);
+	geom::interval<float> grid_layout::height_constraints(float width) const
+	{
+		auto st = merged_own_style();
 
-			if (minimized)
-				result[0] += column_size[i].min;
-			else
-				unit[0] &= geom::interval<float>{column_size[i].min / column_weight_[i], column_size[i].max / column_weight_[i]};
+		auto column_sizes = cell_sizes<1>(children_);
+		auto column_shapes = allocate(column_sizes, column_weight_, width, *st->outer_margin, outer_margin_);
 
-			sum_column_weights += column_weight_[i];
-		}
+		auto row_sizes = cell_sizes_constrained<0>(children_, column_shapes);
 
-		// prevent (inf * 0.f)
-		if (sum_row_weights > 0.f)
-		{
-			result[1].min += unit[1].min * sum_row_weights;
-			result[1].max += unit[1].max * sum_row_weights;
-		}
-
-		if (sum_column_weights > 0.f)
-		{
-			result[0].min += unit[0].min * sum_column_weights;
-			result[0].max += unit[0].max * sum_column_weights;
-		}
-
-		int const margin_row_count = (std::max<int>(1, row_count()) + (outer_margin_ ? 1 : -1));
-		int const margin_column_count = (std::max<int>(1, column_count()) + (outer_margin_ ? 1 : -1));
-
-		result[1] += margin_row_count * (*st->outer_margin);
-		result[0] += margin_column_count * (*st->outer_margin);
-
-		return result;
+		return combine(row_sizes, row_weight_, *st->outer_margin, outer_margin_);
 	}
 
 	void grid_layout::reshape(geom::box<float, 2> const & bbox)
@@ -236,87 +317,30 @@ namespace psemek::ui
 		shape_.box = bbox;
 
 		auto st = merged_own_style();
-		if (!st) return;
 
-		float const margin = *st->outer_margin;
-
-		auto row_column_size = row_column_sizes(children_);
-		auto const & row_size = row_column_size.first;
-		auto const & column_size = row_column_size.second;
-
-		int const margin_row_count = (std::max<int>(1, row_count()) + (outer_margin_ ? 1 : -1));
-		int const margin_column_count = (std::max<int>(1, column_count()) + (outer_margin_ ? 1 : -1));
-
-		float available_height = std::max(0.f, bbox[1].length() - margin * margin_row_count);
-		float available_width = std::max(0.f, bbox[0].length() - margin * margin_column_count);
-
-		float const row_weight_sum = std::accumulate(row_weight_.begin(), row_weight_.end(), 0.f);
-		float const column_weight_sum = std::accumulate(column_weight_.begin(), column_weight_.end(), 0.f);
-
-		row_shape_.resize(row_count());
-		column_shape_.resize(column_count());
-
-		// First, allocate minimized rows
-		for (std::size_t i = 0; i < row_count(); ++i)
+		if (width_first_)
 		{
-			if (row_weight_[i] == 0.f)
-			{
-				row_shape_[i] = {0.f, row_size[i].min};
-				available_height -= row_size[i].min;
-			}
+			auto column_sizes = cell_sizes<1>(children_);
+
+			column_shape_ = allocate(column_sizes, column_weight_, bbox[0].length(), *st->outer_margin, outer_margin_);
+
+			auto row_sizes = cell_sizes_constrained<0>(children_, column_shape_);
+
+			row_shape_ = allocate(row_sizes, row_weight_, bbox[1].length(), *st->outer_margin, outer_margin_);
+		}
+		else
+		{
+			auto row_sizes = cell_sizes<0>(children_);
+
+			row_shape_ = allocate(row_sizes, row_weight_, bbox[1].length(), *st->outer_margin, outer_margin_);
+
+			auto column_sizes = cell_sizes_constrained<1>(children_, row_shape_);
+
+			column_shape_ = allocate(column_sizes, column_weight_, bbox[0].length(), *st->outer_margin, outer_margin_);
 		}
 
-		available_height = std::max(available_height, 0.f);
-
-		// Next, allocate scalable rows
-		for (std::size_t i = 0; i < row_count(); ++i)
-		{
-			if (row_weight_[i] == 0.f)
-				continue;
-
-			float const row_height = available_height * row_weight_[i] / row_weight_sum;
-			row_shape_[i] = {0.f, row_height};
-		}
-
-		// Finally, move rows one after another
-		for (std::size_t i = 0; i < row_count(); ++i)
-		{
-			if (i == 0)
-				row_shape_[i] += bbox[1].min + (outer_margin_ ? margin : 0.f);
-			else
-				row_shape_[i] += row_shape_[i - 1].max + margin;
-		}
-
-		// First, allocate minimized columns
-		for (std::size_t i = 0; i < column_count(); ++i)
-		{
-			if (column_weight_[i] == 0.f)
-			{
-				column_shape_[i] = {0.f, column_size[i].min};
-				available_width -= column_size[i].min;
-			}
-		}
-
-		available_width = std::max(available_width, 0.f);
-
-		// Next, allocate scalable columns
-		for (std::size_t i = 0; i < column_count(); ++i)
-		{
-			if (column_weight_[i] == 0.f)
-				continue;
-
-			float const column_width = available_width * column_weight_[i] / column_weight_sum;
-			column_shape_[i] = {0.f, column_width};
-		}
-
-		// Finally, move rows one after another
-		for (std::size_t i = 0; i < column_count(); ++i)
-		{
-			if (i == 0)
-				column_shape_[i] += bbox[0].min + (outer_margin_ ? margin : 0.f);
-			else
-				column_shape_[i] += column_shape_[i - 1].max + margin;
-		}
+		move(row_shape_, bbox[1], *st->outer_margin, outer_margin_);
+		move(column_shape_, bbox[0], *st->outer_margin, outer_margin_);
 
 		// Apply calculated shapes
 		for (std::size_t i = 0; i < row_count(); ++i)
diff --git a/libs/ui/source/label.cpp b/libs/ui/source/label.cpp
index a0ff88c9..6a2b41ae 100644
--- a/libs/ui/source/label.cpp
+++ b/libs/ui/source/label.cpp
@@ -68,6 +68,22 @@ namespace psemek::ui
 		return {{{cached_state_inf_->size[0], inf}, {cached_state_inf_->size[1], inf}}};
 	}
 
+	geom::interval<float> label::width_constraints(float height) const
+	{
+		static float const inf = std::numeric_limits<float>::infinity();
+
+		auto state = cached_state_for({{{0.f, inf}, {0.f, height}}});
+		return {state.size[0], inf};
+	}
+
+	geom::interval<float> label::height_constraints(float width) const
+	{
+		static float const inf = std::numeric_limits<float>::infinity();
+
+		auto state = cached_state_for({{{0.f, width}, {0.f, inf}}});
+		return {state.size[1], inf};
+	}
+
 	void label::style_updated()
 	{
 		element::style_updated();