diff --git a/geometry.go b/geometry.go
index ab7573e..17c574b 100644
--- a/geometry.go
+++ b/geometry.go
@@ -321,20 +321,20 @@ func (r Rect) IntersectsCircle(c Circle) bool {
 }
 
 // Circle is a 2D circle. It is defined by two properties:
-//  - Radius float64
 //  - Center vector
+//  - Radius float64
 type Circle struct {
-	Radius float64
 	Center Vec
+	Radius float64
 }
 
 // C returns a new Circle with the given radius and center coordinates.
 //
 // Note that a negative radius is valid.
-func C(radius float64, center Vec) Circle {
+func C(center Vec, radius float64) Circle {
 	return Circle{
-		Radius: radius,
 		Center: center,
+		Radius: radius,
 	}
 }
 
@@ -344,17 +344,17 @@ func C(radius float64, center Vec) Circle {
 //  c.String()     // returns "Circle(10.12, Vec(0, 0))"
 //  fmt.Println(c) // Circle(10.12, Vec(0, 0))
 func (c Circle) String() string {
-	return fmt.Sprintf("Circle(%.2f, %s)", c.Radius, c.Center)
+	return fmt.Sprintf("Circle(%s, %.2f)", c.Center, c.Radius)
 }
 
 // Norm returns the Circle in normalized form - this sets the radius to its absolute value.
 //
 // c := pixel.C(-10, pixel.ZV)
-// c.Norm() // returns pixel.Circle{10, pixel.Vec{0, 0}}
+// c.Norm() // returns pixel.Circle{pixel.Vec{0, 0}, 10}
 func (c Circle) Norm() Circle {
 	return Circle{
-		Radius: math.Abs(c.Radius),
 		Center: c.Center,
+		Radius: math.Abs(c.Radius),
 	}
 }
 
@@ -366,20 +366,20 @@ func (c Circle) Area() float64 {
 // Moved returns the Circle moved by the given vector delta.
 func (c Circle) Moved(delta Vec) Circle {
 	return Circle{
-		Radius: c.Radius,
 		Center: c.Center.Add(delta),
+		Radius: c.Radius,
 	}
 }
 
 // Resized returns the Circle resized by the given delta.  The Circles center is use as the anchor.
 //
-// c := pixel.C(10, pixel.ZV)
-// c.Resized(-5) // returns pixel.Circle{5, pixel.Vec{0, 0}}
-// c.Resized(25) // returns pixel.Circle{35, pixel.Vec{0, 0}}
+// c := pixel.C(pixel.ZV, 10)
+// c.Resized(-5) // returns pixel.Circle{pixel.Vec{0, 0}, 5}
+// c.Resized(25) // returns pixel.Circle{pixel.Vec{0, 0}, 35}
 func (c Circle) Resized(radiusDelta float64) Circle {
 	return Circle{
-		Radius: c.Radius + radiusDelta,
 		Center: c.Center,
+		Radius: c.Radius + radiusDelta,
 	}
 }
 
@@ -426,8 +426,8 @@ func (c Circle) Union(d Circle) Circle {
 	center := Lerp(smallerC.Center, biggerC.Center, theta)
 
 	return Circle{
-		Radius: r,
 		Center: center,
+		Radius: r,
 	}
 }
 
@@ -456,14 +456,14 @@ func (c Circle) Intersect(d Circle) Circle {
 
 	// No need to calculate radius if the circles do not overlap
 	if c.Center.To(d.Center).Len() >= c.Radius+d.Radius {
-		return C(0, center)
+		return C(center, 0)
 	}
 
 	radius := c.Center.To(d.Center).Len() - (c.Radius + d.Radius)
 
 	return Circle{
-		Radius: math.Abs(radius),
 		Center: center,
+		Radius: math.Abs(radius),
 	}
 }
 
diff --git a/geometry_test.go b/geometry_test.go
index 0ea1f1c..eec854d 100644
--- a/geometry_test.go
+++ b/geometry_test.go
@@ -107,7 +107,7 @@ func TestC(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := pixel.C(tt.args.radius, tt.args.center); !reflect.DeepEqual(got, tt.want) {
+			if got := pixel.C(tt.args.center, tt.args.radius); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("C() = %v, want %v", got, tt.want)
 			}
 		})
@@ -127,27 +127,27 @@ func TestCircle_String(t *testing.T) {
 		{
 			name:   "Circle.String(): positive radius",
 			fields: fields{radius: 10, center: pixel.ZV},
-			want:   "Circle(10.00, Vec(0, 0))",
+			want:   "Circle(Vec(0, 0), 10.00)",
 		},
 		{
 			name:   "Circle.String(): zero radius",
 			fields: fields{radius: 0, center: pixel.ZV},
-			want:   "Circle(0.00, Vec(0, 0))",
+			want:   "Circle(Vec(0, 0), 0.00)",
 		},
 		{
 			name:   "Circle.String(): negative radius",
 			fields: fields{radius: -5, center: pixel.ZV},
-			want:   "Circle(-5.00, Vec(0, 0))",
+			want:   "Circle(Vec(0, 0), -5.00)",
 		},
 		{
 			name:   "Circle.String(): irrational radius",
 			fields: fields{radius: math.Pi, center: pixel.ZV},
-			want:   "Circle(3.14, Vec(0, 0))",
+			want:   "Circle(Vec(0, 0), 3.14)",
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.String(); got != tt.want {
 				t.Errorf("Circle.String() = %v, want %v", got, tt.want)
 			}
@@ -168,22 +168,22 @@ func TestCircle_Norm(t *testing.T) {
 		{
 			name:   "Circle.Norm(): positive radius",
 			fields: fields{radius: 10, center: pixel.ZV},
-			want:   pixel.C(10, pixel.ZV),
+			want:   pixel.C(pixel.ZV, 10),
 		},
 		{
 			name:   "Circle.Norm(): zero radius",
 			fields: fields{radius: 0, center: pixel.ZV},
-			want:   pixel.C(0, pixel.ZV),
+			want:   pixel.C(pixel.ZV, 0),
 		},
 		{
 			name:   "Circle.Norm(): negative radius",
 			fields: fields{radius: -5, center: pixel.ZV},
-			want:   pixel.C(5, pixel.ZV),
+			want:   pixel.C(pixel.ZV, 5),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.Norm(); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Circle.Norm() = %v, want %v", got, tt.want)
 			}
@@ -219,7 +219,7 @@ func TestCircle_Area(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.Area(); got != tt.want {
 				t.Errorf("Circle.Area() = %v, want %v", got, tt.want)
 			}
@@ -245,24 +245,24 @@ func TestCircle_Moved(t *testing.T) {
 			name:   "Circle.Moved(): positive movement",
 			fields: fields{radius: 10, center: pixel.ZV},
 			args:   args{delta: pixel.V(10, 20)},
-			want:   pixel.C(10, pixel.V(10, 20)),
+			want:   pixel.C(pixel.V(10, 20), 10),
 		},
 		{
 			name:   "Circle.Moved(): zero movement",
 			fields: fields{radius: 10, center: pixel.ZV},
 			args:   args{delta: pixel.ZV},
-			want:   pixel.C(10, pixel.V(0, 0)),
+			want:   pixel.C(pixel.V(0, 0), 10),
 		},
 		{
 			name:   "Circle.Moved(): negative movement",
 			fields: fields{radius: 10, center: pixel.ZV},
 			args:   args{delta: pixel.V(-5, -10)},
-			want:   pixel.C(10, pixel.V(-5, -10)),
+			want:   pixel.C(pixel.V(-5, -10), 10),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.Moved(tt.args.delta); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Circle.Moved() = %v, want %v", got, tt.want)
 			}
@@ -288,24 +288,24 @@ func TestCircle_Resized(t *testing.T) {
 			name:   "Circle.Resized(): positive delta",
 			fields: fields{radius: 10, center: pixel.ZV},
 			args:   args{radiusDelta: 5},
-			want:   pixel.C(15, pixel.V(0, 0)),
+			want:   pixel.C(pixel.V(0, 0), 15),
 		},
 		{
 			name:   "Circle.Resized(): zero delta",
 			fields: fields{radius: 10, center: pixel.ZV},
 			args:   args{radiusDelta: 0},
-			want:   pixel.C(10, pixel.V(0, 0)),
+			want:   pixel.C(pixel.V(0, 0), 10),
 		},
 		{
 			name:   "Circle.Resized(): negative delta",
 			fields: fields{radius: 10, center: pixel.ZV},
 			args:   args{radiusDelta: -5},
-			want:   pixel.C(5, pixel.V(0, 0)),
+			want:   pixel.C(pixel.V(0, 0), 5),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.Resized(tt.args.radiusDelta); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Circle.Resized() = %v, want %v", got, tt.want)
 			}
@@ -354,7 +354,7 @@ func TestCircle_Contains(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.Contains(tt.args.u); got != tt.want {
 				t.Errorf("Circle.Contains() = %v, want %v", got, tt.want)
 			}
@@ -379,19 +379,19 @@ func TestCircle_Union(t *testing.T) {
 		{
 			name:   "Circle.Union(): overlapping circles",
 			fields: fields{radius: 5, center: pixel.ZV},
-			args:   args{d: pixel.C(5, pixel.ZV)},
-			want:   pixel.C(5, pixel.ZV),
+			args:   args{d: pixel.C(pixel.ZV, 5)},
+			want:   pixel.C(pixel.ZV, 5),
 		},
 		{
 			name:   "Circle.Union(): separate circles",
 			fields: fields{radius: 1, center: pixel.ZV},
-			args:   args{d: pixel.C(1, pixel.V(0, 2))},
-			want:   pixel.C(2, pixel.V(0, 1)),
+			args:   args{d: pixel.C(pixel.V(0, 2), 1)},
+			want:   pixel.C(pixel.V(0, 1), 2),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := pixel.C(tt.fields.radius, tt.fields.center)
+			c := pixel.C(tt.fields.center, tt.fields.radius)
 			if got := c.Union(tt.args.d); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Circle.Union() = %v, want %v", got, tt.want)
 			}
@@ -416,39 +416,39 @@ func TestCircle_Intersect(t *testing.T) {
 		{
 			name:   "Circle.Intersect(): intersecting circles",
 			fields: fields{radius: 1, center: pixel.ZV},
-			args:   args{d: pixel.C(1, pixel.V(1, 0))},
-			want:   pixel.C(1, pixel.V(0.5, 0)),
+			args:   args{d: pixel.C(pixel.V(1, 0), 1)},
+			want:   pixel.C(pixel.V(0.5, 0), 1),
 		},
 		{
 			name:   "Circle.Intersect(): non-intersecting circles",
 			fields: fields{radius: 1, center: pixel.ZV},
-			args:   args{d: pixel.C(1, pixel.V(3, 3))},
-			want:   pixel.C(0, pixel.V(1.5, 1.5)),
+			args:   args{d: pixel.C(pixel.V(3, 3), 1)},
+			want:   pixel.C(pixel.V(1.5, 1.5), 0),
 		},
 		{
 			name:   "Circle.Intersect(): first circle encompassing second",
 			fields: fields{radius: 10, center: pixel.ZV},
-			args:   args{d: pixel.C(1, pixel.V(3, 3))},
-			want:   pixel.C(10, pixel.ZV),
+			args:   args{d: pixel.C(pixel.V(3, 3), 1)},
+			want:   pixel.C(pixel.ZV, 10),
 		},
 		{
 			name:   "Circle.Intersect(): second circle encompassing first",
 			fields: fields{radius: 1, center: pixel.V(-1, -4)},
-			args:   args{d: pixel.C(10, pixel.ZV)},
-			want:   pixel.C(10, pixel.ZV),
+			args:   args{d: pixel.C(pixel.ZV, 10)},
+			want:   pixel.C(pixel.ZV, 10),
 		},
 		{
 			name:   "Circle.Intersect(): matching circles",
 			fields: fields{radius: 1, center: pixel.ZV},
-			args:   args{d: pixel.C(1, pixel.ZV)},
-			want:   pixel.C(1, pixel.ZV),
+			args:   args{d: pixel.C(pixel.ZV, 1)},
+			want:   pixel.C(pixel.ZV, 1),
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			c := pixel.C(
-				tt.fields.radius,
 				tt.fields.center,
+				tt.fields.radius,
 			)
 			if got := c.Intersect(tt.args.d); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("Circle.Intersect() = %v, want %v", got, tt.want)
@@ -474,49 +474,49 @@ func TestRect_IntersectsCircle(t *testing.T) {
 		{
 			name:   "Rect.IntersectsCircle(): no overlap",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(1, pixel.V(50, 50))},
+			args:   args{c: pixel.C(pixel.V(50, 50), 1)},
 			want:   false,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): circle contains rect",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(10, pixel.V(5, 5))},
+			args:   args{c: pixel.C(pixel.V(5, 5), 10)},
 			want:   true,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): rect contains circle",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(1, pixel.V(5, 5))},
+			args:   args{c: pixel.C(pixel.V(5, 5), 1)},
 			want:   true,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): circle overlaps bottom-left corner",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(1, pixel.V(-.5, -.5))},
+			args:   args{c: pixel.C(pixel.V(-.5, -.5), 1)},
 			want:   true,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): circle overlaps top-left corner",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(1, pixel.V(-.5, 10.5))},
+			args:   args{c: pixel.C(pixel.V(-.5, 10.5), 1)},
 			want:   true,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): circle overlaps two corners",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(6, pixel.V(0, 5))},
+			args:   args{c: pixel.C(pixel.V(0, 5), 6)},
 			want:   true,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): circle overlaps one edge",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(1, pixel.V(0, 5))},
+			args:   args{c: pixel.C(pixel.V(0, 5), 1)},
 			want:   true,
 		},
 		{
 			name:   "Rect.IntersectsCircle(): edge is tangent",
 			fields: fields{Min: pixel.ZV, Max: pixel.V(10, 10)},
-			args:   args{c: pixel.C(1, pixel.V(-1, 5))},
+			args:   args{c: pixel.C(pixel.V(-1, 5), 1)},
 			want:   true,
 		},
 	}