                 stackViewConstraints += [bottomConstraint, leftConstraint, rightConstraint, topConstraint]
             }
             
+            if axis == .Horizontal {
+                switch distribution {
+                case .Fill, .EqualSpacing, .EqualCentering:
+                    let totalVisible = visibleArrangedSubviews.count
+                    let multilineLabels = arrangedSubviews.filter { view in
+                        isMultilineLabel(view)
+                    }
+                    
+                    if  totalVisible > 0 {
+                        let totalSpacing = spacing * CGFloat(totalVisible - 1)
+                        
+                        let ratio = CGFloat(1) / CGFloat(totalVisible)
+                        let decrease = totalSpacing / CGFloat(totalVisible)
+                        
+                        let edgeItem = layoutMarginsView ?? self
+                        
+                        for label in multilineLabels {
+                            stackViewConstraints.append(constraint(item: label, attribute: .Width, relatedBy: .Equal, toItem: edgeItem, attribute: .Width, multiplier: ratio, constant: -decrease, priority: 760, identifier: "TZSV-text-width-disambiguation"))
+                        }
+                    } else {
+                        for label in multilineLabels {
+                            let aConstraint = constraint(item: label, attribute: .Width, relatedBy: .Equal, toItem: nil, attribute: .NotAnAttribute, constant: 0, priority: 760, identifier: "TZSV-text-width-disambiguation")
+                            subviewConstraints.append(aConstraint)
+                            label.addConstraint(aConstraint)
+                        }
+                    }
+                case .FillEqually, .FillProportionally:
+                    break
+                }
+            }
+            
             addConstraints(stackViewConstraints)
         }
 

                    stackViewConstraints += createFillEquallyConstraints(arrangedSubviews, identifier: "TZSV-fill-equally")
                }
                if distribution == .FillProportionally {
                    stackViewConstraints += createFillProportionallyConstraints(arrangedSubviews)
                }
                
                stackViewConstraints += createFillConstraints(arrangedSubviews, constant: spacing, identifier: "TZSV-spacing")

        return constraints
    }
    
    private func createFillProportionallyConstraints(views: [UIView]) -> (stackViewConstraints: [NSLayoutConstraint], subviewConstraints: [(owningView: UIView, [NSLayoutConstraint])]) {
        func intrinsicContentLengthOf(view: UIView) -> CGFloat {
            let size = view.intrinsicContentSize()
            switch axis {
            case .Horizontal:
                if let label = view as? UILabel where label.numberOfLines != 1 { // multiline label
                    return 0
                } else {
                    return size.width != UIViewNoIntrinsicMetric ? size.width : 0
                }
            case .Vertical:
                return size.height != UIViewNoIntrinsicMetric ? size.height : 0
            }
        }
        
        let nonHiddenViews = views.filter { view in
            return !isHidden(view)
        }
        
        if nonHiddenViews.count == 0 {
            return ([], [])
        }
        
        let numberOfHiddenViews = views.count - nonHiddenViews.count
        
        let totalViewLength = nonHiddenViews
            .map { view in
                intrinsicContentLengthOf(view)
            }
            .reduce(CGFloat(0), combine: +)
        
        let showingTotalIsSmall: Bool
        if  numberOfHiddenViews == 0 {
            switch nonHiddenViews.count {
            case 0: // not possible
                showingTotalIsSmall = false
            case 1:
                let view = nonHiddenViews[0]
                showingTotalIsSmall = intrinsicContentLengthOf(view) <= 1
            default:
                showingTotalIsSmall = totalViewLength == 0
            }
        } else {
            showingTotalIsSmall = totalViewLength <= spacing * CGFloat(numberOfHiddenViews)
        }
        
        if showingTotalIsSmall {
            return (stackViewConstraints: createFillEquallyConstraints(nonHiddenViews, identifier: "TZSV-fill-equally"), subviewConstraints: [])
        }
        
        var stackViewConstraints = [NSLayoutConstraint]()
        var subviewConstraints = [(owningView: UIView, [NSLayoutConstraint])]()

        let totalSpacing = CGFloat(nonHiddenViews.count - 1) * spacing
        let totalSize = totalViewLength + totalSpacing

        var priority: UILayoutPriority = 1000
        let countDownPriority = nonHiddenViews.count > 1
        for arrangedSubview in views {
            if countDownPriority {
                priority--
