How to draw a heart with basic graphics commands in C#

Heart drawing is the process of creating a heart-shaped figure using graphics commands, mathematical formulas, vector paths, lines, curves, and drawing libraries. The heart shape is one of the most recognizable symbols in user interfaces and graphic applications.

Unlike simple geometric shapes such as rectangles or circles, a heart typically requires curve-based rendering to achieve a natural appearance.

Why Do We Need Heart Drawing?

Many applications require heart-shaped graphics for user interactions, social features, notifications, badges, and visual indicators. Creating the shape programmatically allows developers to customize its size, color, and appearance dynamically.

Vector-based heart rendering also scales better than image assets and remains sharp on high-resolution displays.

Are There Libraries to Draw a Heart in C#?

Several graphics libraries can be used to render heart shapes in C#. Most solutions rely on path-based drawing capabilities and curve support.

For most desktop applications, System.Drawing provides enough functionality to create smooth heart shapes using Bezier curves and path commands.

How Can I Draw a Heart with a Graphics Library?

One of the most common approaches is creating a GraphicsPath and combining multiple Bezier curves into a closed heart shape.

using System.Drawing;
using System.Drawing.Drawing2D;

GraphicsPath path = new GraphicsPath();

path.AddBezier(
  new Point(100, 70),
  new Point(40, 20),
  new Point(0, 120),
  new Point(100, 180));

path.AddBezier(
  new Point(100, 180),
  new Point(200, 120),
  new Point(160, 20),
  new Point(100, 70));

graphics.FillPath(Brushes.Red, path);
graphics.DrawPath(Pens.DarkRed, path);

This method produces a smooth heart shape suitable for most graphical applications.

How Can I Draw a Heart with Basic Graphics Commands (Line, Path, Bezier, and More)?

The heart shape can also be constructed directly using basic path and Bezier commands without relying on helper methods or external geometry libraries.

Bezier curves are particularly useful because the heart consists primarily of smooth curved segments.

GraphicsPath path = new GraphicsPath();

path.StartFigure();

path.AddBezier(
  new PointF(100, 60),
  new PointF(40, 0),
  new PointF(-10, 90),
  new PointF(100, 180));

path.AddBezier(
  new PointF(100, 180),
  new PointF(210, 90),
  new PointF(160, 0),
  new PointF(100, 60));

path.CloseFigure();

graphics.FillPath(Brushes.HotPink, path);
graphics.DrawPath(Pens.Black, path);

The same concept can be applied to other graphics frameworks because Bezier and path operations are common drawing primitives.

An Alternative Heart Implementation: Mathematical Heart Formula

A mathematical heart curve can be generated using a well-known parametric equation. This approach is useful when highly scalable and accurate vector rendering is required.

for (double t = 0; t < Math.PI * 2; t += 0.05)
{
  double x = 16 * Math.Pow(Math.Sin(t), 3);
  double y = 13 * Math.Cos(t)
    - 5 * Math.Cos(2 * t)
    - 2 * Math.Cos(3 * t)
    - Math.Cos(4 * t);

  // Convert mathematical coordinates to screen coordinates
}

This formula generates a classic heart curve and can be scaled to any size.

An Alternative Heart Implementation: Rounded Heart Icon

Modern user interfaces often use softer heart designs with additional curve smoothing. This style is frequently seen in mobile applications and social media platforms.

GraphicsPath path = new GraphicsPath();

path.AddArc(50, 30, 50, 50, 0, 180);
path.AddArc(100, 30, 50, 50, 0, 180);
path.AddLine(150, 55, 100, 160);
path.AddLine(100, 160, 50, 55);
path.CloseFigure();

graphics.FillPath(Brushes.Crimson, path);

This implementation creates a more icon-like appearance while maintaining the recognizable heart silhouette.

How to Use This Method Correctly?

Heart rendering is generally straightforward, but several factors can influence visual quality.

For smoother rendering, enable anti-aliasing before drawing.

graphics.SmoothingMode = SmoothingMode.AntiAlias;

Heart Drawing Performance Considerations

Most heart rendering operations are lightweight, but applications displaying large numbers of vector shapes should minimize allocations and reuse drawing resources whenever possible.

Conclusion

Drawing a heart in C# can be accomplished using GraphicsPath, Bezier curves, mathematical equations, or custom path definitions. The best method depends on the desired appearance and level of control.

For most applications, GraphicsPath combined with Bezier curves offers the best balance of simpity, flexibility, scalability, and visual quality.