         return constraints
     }
     
-    private func createFillProportionallyConstraints(views: [UIView]) -> [NSLayoutConstraint] {
-        var constraints = [NSLayoutConstraint]()
-
-        var totalSize: CGFloat = 0
-        var totalCount = 0
-        for arrangedSubview in views {
-            if isHidden(arrangedSubview) {
-                continue
-            }
+    private func createFillProportionallyConstraints(views: [UIView]) -> (stackViewConstraints: [NSLayoutConstraint], subviewConstraints: [(owningView: UIView, [NSLayoutConstraint])]) {
+        func intrinsicContentLengthOf(view: UIView) -> CGFloat {
+            let size = view.intrinsicContentSize()
             switch axis {
             case .Horizontal:
-                totalSize += arrangedSubview.intrinsicContentSize().width
+                if let label = view as? UILabel where label.numberOfLines != 1 { // multiline label
+                    return 0
+                } else {
+                    return size.width != UIViewNoIntrinsicMetric ? size.width : 0
+                }
             case .Vertical:
-                totalSize += arrangedSubview.intrinsicContentSize().height
-            }
-            totalCount++
-        }
-        totalSize += (CGFloat(totalCount - 1) * spacing)
-        
+                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 = (views.filter({!self.isHidden($0)}).count > 1)
+        let countDownPriority = nonHiddenViews.count > 1
         for arrangedSubview in views {
             if countDownPriority {
                 priority--

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

                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)
        }

