Chart with UIBezierPath at one below one – Ios swift

This solution is for SwiftUI using Path.

struct DonutElement: Shape{
    
    var width: CGFloat = 50
    var startAngle: Angle
    var endAngle: Angle
    
    func path(in rect: CGRect) -> Path {
        // define commonly used vars
        // the extend of the shape
        let outerRadius = min(rect.width, rect.height) / 2
        // the middle of the shape
        let midRadius = outerRadius - width / 2
        // the inner radius
        let innerRadius = outerRadius - width
        // centerpoint used to move coordinate system in to center
        let center = CGPoint(x: rect.width / 2, y: rect.height / 2)
        
        return Path{ path in
            // calculate the startpoint from the startAngle. startAngle is allready normalized
            let startPoint = startAngle.polarCoordinates(center: center, radius: outerRadius)

            // move the path without drawing to the starting position
            path.move(to: startPoint)
            
            // add the starting concav arc
            // the center point for this arc are the polar coordinates relative to midradius of the donut
            path.addArc(center: startAngle.polarCoordinates(center: center, radius: midRadius), radius: width / 2, startAngle: startAngle.normalizing(), endAngle: (.init(degrees: 180) - startAngle), clockwise: true)
            
            // add the arc that presents the inner donut line
            // center point is the center of the drawing rect with normalized angles
            path.addArc(center: center, radius: innerRadius, startAngle: startAngle.normalizing(), endAngle: endAngle.normalizing(), clockwise: true)
            
            // add the convex arc at the end of the donut element
            // switch clockwise to false and swap end and start angle
            // replace startAngle with endAngle
            path.addArc(center: endAngle.polarCoordinates(center: center, radius: midRadius), radius: width / 2, startAngle: (.init(degrees: 180) - endAngle), endAngle:  endAngle.normalizing(), clockwise: false)
            
            // add the outer stroke to close the shape
            path.addArc(center: center, radius: outerRadius, startAngle: endAngle.normalizing(), endAngle: startAngle.normalizing(), clockwise: false)
            
            // just in case
            path.closeSubpath()
        }
    }
}

extension Shape {
    func fillWithStroke<Fill: ShapeStyle, Stroke: ShapeStyle>(_ fillStyle: Fill, strokeBorder strokeStyle: Stroke, lineWidth: Double = 1) -> some View {
        self
            .stroke(strokeStyle, lineWidth: lineWidth)
            .background(self.fill(fillStyle))
    }
}

struct AngleContainer: Identifiable, Hashable{
    let id = UUID()
    var startAngle: Angle
    var endAngle: Angle
    var color: Color
}



struct Donut: View{
    // each element ends here and starts at the previous or 0. Values in percent
    var elementStops: [(CGFloat , Color)] = [(0.4 , .blue), (45 , .red), (55 , .green), (78 , .gray), (100 , .white)]
    var width: CGFloat = 50.0
    private var angles: [AngleContainer] {
        var angles = [AngleContainer]()
        
        for (index, stop) in elementStops.enumerated(){
            if index == 0{
                let startAngle = Angle(degrees: 0)
                let endAngle = Angle(degrees: stop.0/100 * 360)
                
                angles.append(AngleContainer(startAngle: startAngle,endAngle: endAngle,color: stop.1))
            } else{
                let startAngle = Angle(degrees: elementStops[index - 1].0 / 100 * 360)
                let endAngle = Angle(degrees: stop.0/100 * 360)
                
                angles.append(AngleContainer(startAngle: startAngle,endAngle: endAngle,color: stop.1))
            }
        }
        
        return angles
    }
    var body: some View{
        ZStack{
            ForEach(angles){ angleContainer in
                DonutElement(width: width, startAngle: angleContainer.startAngle, endAngle: angleContainer.endAngle)
                    .fillWithStroke(angleContainer.color, strokeBorder: .black.opacity(0.2))
            }
        }
        .background(.white)
    }
}

// used for transfering coordinate system
extension CGPoint{
    mutating func transfered(to center: CGPoint){
        x = center.x + x
        y = center.y - y
    }
    
    func transfering(to center: CGPoint) -> CGPoint{
        .init(x:  center.x + x, y: center.y - y)
    }

}

I am normalizing angles to behave more like in math with 90 degrees at the top and not at the bottom.

// convenience so angle feels more natural
extension Angle{
    func normalizing() -> Angle {
        Angle(degrees: 0) - self
    }
    
    func polarCoordinates(center: CGPoint, radius: CGFloat) -> CGPoint{
        CGPoint(x: cos(self.radians) * radius, y: sin(self.radians) * radius )
            .transfering(to: center)
    }
}

Result: