diff --git a/src/azure-c.cpp b/src/azure-c.cpp
index 9f2a42f..6da7f0b 100644
--- a/src/azure-c.cpp
+++ b/src/azure-c.cpp
@@ -607,6 +607,24 @@ extern "C" void AzPathBuilderArc(AzPathBuilderRef aPathBuilder,
     gfxPathBuilder->Arc(*gfxOrigin, aRadius, aStartAngle, aEndAngle, aAntiClockwise);
 }
 
+extern "C" void
+AzPathBuilderBezierTo(AzPathBuilderRef aPathBuilder,
+                      const AzPoint *aControlPoint1,
+                      const AzPoint *aControlPoint2,
+                      const AzPoint *aControlPoint3) {
+    gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder);
+    const gfx::Point *gfxControlPoint1 = reinterpret_cast<const gfx::Point*>(aControlPoint1);
+    const gfx::Point *gfxControlPoint2 = reinterpret_cast<const gfx::Point*>(aControlPoint2);
+    const gfx::Point *gfxControlPoint3 = reinterpret_cast<const gfx::Point*>(aControlPoint3);
+    gfxPathBuilder->BezierTo(*gfxControlPoint1, *gfxControlPoint2, *gfxControlPoint3);
+}
+
+extern "C" void
+AzPathBuilderClose(AzPathBuilderRef aPathBuilder) {
+    gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder);
+    gfxPathBuilder->Close();
+}
+
 extern "C" AzPathRef
 AzPathBuilderFinish(AzPathBuilderRef aPathBuilder) {
     gfx::PathBuilder *gfxPathBuilder = static_cast<gfx::PathBuilder*>(aPathBuilder);
diff --git a/src/azure-c.h b/src/azure-c.h
index 9f732cd..92229af 100644
--- a/src/azure-c.h
+++ b/src/azure-c.h
@@ -436,6 +436,11 @@ void AzPathBuilderArc(AzPathBuilderRef aPathBuilder,
                       AzFloat aStartAngle,
                       AzFloat aEndAngle,
                       bool aAntiClockwise);
+void AzPathBuilderBezierTo(AzPathBuilderRef aPathBuilder,
+                           const AzPoint *aControlPoint1,
+                           const AzPoint *aControlPoint2,
+                           const AzPoint *aControlPoint3);
+void AzPathBuilderClose(AzPathBuilderRef aPathBuilder);
 AzPathRef AzPathBuilderFinish(AzPathBuilderRef aPathBuilder);
 
 AzLinearGradientPatternRef AzCreateLinearGradientPattern(const AzPoint *aBegin,
diff --git a/src/azure.rs b/src/azure.rs
index de3005a..2eafa72 100644
--- a/src/azure.rs
+++ b/src/azure.rs
@@ -569,6 +569,13 @@ pub fn AzPathBuilderArc(aPathBuilder: AzPathBuilderRef,
                         aEndAngle: AzFloat,
                         aAntiClockwise: bool);
 
+pub fn AzPathBuilderBezierTo(aPathBuilder: AzPathBuilderRef,
+                             aControlPoint1: *const AzPoint,
+                             aControlPoint2: *const AzPoint,
+                             aControlPoint3: *const AzPoint);
+
+pub fn AzPathBuilderClose(aPathBuilder: AzPathBuilderRef);
+
 pub fn AzPathBuilderFinish(aPathBuilder: AzPathBuilderRef) -> AzPathRef;
 
 pub fn AzReleasePath(aPath: AzPathRef);
diff --git a/src/azure_hl.rs b/src/azure_hl.rs
index 739b434..a14c227 100644
--- a/src/azure_hl.rs
+++ b/src/azure_hl.rs
@@ -50,7 +50,8 @@ use azure::{AzFilterNodeSetSourceSurfaceInput, AzReleaseFilterNode, AzDrawTarget
 use azure::{AzFilterNodeSetColorAttribute, AzFilterNodeSetFloatAttribute};
 use azure::{AzFilterNodeSetMatrix5x4Attribute, AzFilterNodeSetFilterNodeInput};
 use azure::{AzFilterNodeSetFloatArrayAttribute, AzFilterNodeSetBoolAttribute};
-use azure::{AzDrawTargetDrawFilter, AzFilterNodeRef, AzFilterType};
+use azure::{AzDrawTargetDrawFilter, AzFilterNodeRef, AzFilterType, AzPathBuilderBezierTo};
+use azure::{AzPathBuilderClose};
 
 use geom::matrix2d::Matrix2D;
 use geom::point::Point2D;
@@ -983,6 +984,26 @@ impl PathBuilder {
         }
     }
 
+    /// Adds a cubic Bézier curve to the current figure.
+    pub fn bezier_curve_to(&self,
+                           control_point_1: &Point2D<AzFloat>,
+                           control_point_2: &Point2D<AzFloat>,
+                           control_point_3: &Point2D<AzFloat>) {
+        unsafe {
+            AzPathBuilderBezierTo(self.azure_path_builder,
+                                  &control_point_1.as_azure_point(),
+                                  &control_point_2.as_azure_point(),
+                                  &control_point_3.as_azure_point())
+        }
+    }
+
+    /// Closes the current path.
+    pub fn close(&self) {
+        unsafe {
+            AzPathBuilderClose(self.azure_path_builder)
+        }
+    }
+
     pub fn finish(&self) -> Path {
         let az_path = unsafe { AzPathBuilderFinish(self.azure_path_builder) };
         Path {
@@ -1047,6 +1068,22 @@ impl<'a> PatternRef<'a> {
     }
 }
 
+pub enum Pattern {
+    Color(ColorPattern),
+    LinearGradient(LinearGradientPattern),
+}
+
+impl Pattern {
+    pub fn to_pattern_ref(&self) -> PatternRef {
+        match *self {
+            Pattern::Color(ref color_pattern) => PatternRef::Color(color_pattern),
+            Pattern::LinearGradient(ref linear_gradient_pattern) => {
+                PatternRef::LinearGradient(linear_gradient_pattern)
+            }
+        }
+    }
+}
+
 pub struct FilterNode {
     pub azure_filter_node: AzFilterNodeRef,
 }