diff --git a/README.md b/README.md
index c349bd21..a31e2f18 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,6 @@ save the file as either R12 or the newest version possible (e.g., R2013 or R2010
 ## Status
 
 Support for DXF files is complete from versions R10 through R2014 _EXCEPT_ for the following entities:
-- HATCH
 - MESH
 - MLEADER
 - SURFACE
diff --git a/src/IxMilia.Dxf.Generator/GeneratorBase.cs b/src/IxMilia.Dxf.Generator/GeneratorBase.cs
index 86d6271e..cca2e57a 100644
--- a/src/IxMilia.Dxf.Generator/GeneratorBase.cs
+++ b/src/IxMilia.Dxf.Generator/GeneratorBase.cs
@@ -834,6 +834,12 @@ public string WriteConverter(XElement property)
             }
         }
 
+        public IEnumerable<string> WriteCustomCode(XElement spec)
+        {
+            var code = AttributeOrDefault(spec, "Code");
+            return new[] { code };
+        }
+
         public IEnumerable<string> WriteProperty(XElement spec, XElement entity)
         {
             var property = GetPropertiesAndPointers(entity).Single(p => Name(p) == spec.Attribute("Property").Value);
@@ -894,6 +900,8 @@ public IEnumerable<string> WriteSpecificValue(XElement spec)
             }
         }
 
+        private int _foreachLevel = 0;
+
         public IEnumerable<string> WriteValue(XElement spec, XElement entity)
         {
             switch (spec.Name.LocalName)
@@ -914,9 +922,12 @@ public IEnumerable<string> WriteValue(XElement spec, XElement entity)
                         lines.Add("{");
                     }
 
-                    lines.Add($"{indent}foreach (var item in {property})");
+                    var itemSuffix = _foreachLevel == 0 ? "" : _foreachLevel.ToString();
+                    lines.Add($"{indent}foreach (var item{itemSuffix} in {property})");
                     lines.Add($"{indent}{{");
+                    _foreachLevel++;
                     lines.AddRange(spec.Elements().SelectMany(e => WriteValue(e, entity)).Select(l => $"{indent}    {l}"));
+                    _foreachLevel--;
                     lines.Add($"{indent}}}");
                     if (condition != null)
                     {
@@ -927,6 +938,8 @@ public IEnumerable<string> WriteValue(XElement spec, XElement entity)
                     return lines;
                 case "WriteExtensionData":
                     return new[] { "AddExtensionValuePairs(pairs, version, outputHandles);" };
+                case "WriteCustomCode":
+                    return WriteCustomCode(spec);
                 default:
                     throw new NotSupportedException();
             }
diff --git a/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xml b/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xml
index 2a6ca57c..eb4b2a9c 100644
--- a/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xml
+++ b/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xml
@@ -519,7 +519,80 @@
     HATCH
 
     -->
-    <!-- TODO MinVersion="R14" -->
+    <Entity Name="DxfHatch" EntityType="Hatch" SubclassMarker="AcDbHatch" TypeString="HATCH" GenerateReaderFunction="false" MinVersion="R14">
+        <Property Name="ElevationPoint" Code="10" Type="DxfPoint" DefaultValue="DxfPoint.Origin" CodeOverrides="10,20,30" />
+        <Property Name="ExtrusionDirection" Code="210" Type="DxfVector" DefaultValue="DxfVector.ZAxis" CodeOverrides="210,220,230" />
+        <Property Name="PatternName" Code="2" Type="string" DefaultValue="null" />
+        <Property Name="FillMode" Code="70" Type="DxfHatchPatternFillMode" DefaultValue="DxfHatchPatternFillMode.PatternFill" ReadConverter="(DxfHatchPatternFillMode){0}" WriteConverter="(short){0}" />
+        <Property Name="FillColor" Code="63" Type="DxfColor" DefaultValue="DxfColor.ByLayer" ReadConverter="DxfColor.FromRawValue({0})" WriteConverter="DxfColor.GetRawValue({0})" MinVersion="R2004" />
+        <Property Name="IsAssociative" Code="71" Type="bool" DefaultValue="false" ReadConverter="BoolShort({0})" WriteConverter="BoolShort({0})" />
+        <Property Name="_boundaryPathCount" Code="91" Type="int" DefaultValue="0" />
+        <Property Name="BoundaryPaths" Code="92" Type="BoundaryPathBase" DefaultValue="" AllowMultiples="true" />
+        <Property Name="HatchStyle" Code="75" Type="DxfHatchStyle" DefaultValue="DxfHatchStyle.OddParity" ReadConverter="(DxfHatchStyle){0}" WriteConverter="(short){0}" />
+        <Property Name="PatternType" Code="76" Type="DxfHatchPatternType" DefaultValue="DxfHatchPatternType.UserDefined" ReadConverter="(DxfHatchPatternType){0}" WriteConverter="(short){0}" />
+        <Property Name="PatternAngle" Code="52" Type="double" DefaultValue="0.0" WriteCondition="FillMode == DxfHatchPatternFillMode.PatternFill" />
+        <Property Name="PatternScale" Code="41" Type="double" DefaultValue="1.0" WriteCondition="FillMode == DxfHatchPatternFillMode.PatternFill" />
+        <Property Name="IsPatternDoubled" Code="77" Type="bool" DefaultValue="false" ReadConverter="BoolShort({0})" WriteConverter="BoolShort({0})" WriteCondition="FillMode == DxfHatchPatternFillMode.PatternFill" />
+        <Property Name="_patternDefinitionLineCount" Code="78" Type="int" DefaultValue="0" WriteConverter="(short){0}" />
+        <Property Name="PatternDefinitionLines" Code="53" Type="PatternDefinitionLine" DefaultValue="" AllowMultiples="true" />
+        <Property Name="PixelSize" Code="47" Type="double" DefaultValue="1.0" />
+        <Property Name="_seedPointCount" Code="98" Type="int" Accessibility="private" DefaultValue="0" />
+        <Property Name="SeedPoints" Code="10" Type="DxfPoint" DefaultValue="DxfPoint.Origin" AllowMultiples="true" CodeOverrides="10,20" />
+        <Property Name="IsGradient" Code="450" Type="bool" DefaultValue="false" ReadConverter="BoolLong({0})" WriteConverter="BoolLong({0})" MinVersion="R2004" />
+        <Property Name="_zero" Code="451" Type="long" DefaultValue="0" Accessibility="private" MinVersion="R2004" Comment="Reserved for future use." />
+        <Property Name="GradientColorMode" Code="452" Type="DxfGradientColorMode" DefaultValue="DxfGradientColorMode.TwoColorGradient" ReadConverter="(DxfGradientColorMode){0}" WriteConverter="(long){0}" MinVersion="R2004" Comment="Only used by dialog code." />
+        <Property Name="NumberOfColors" Code="453" Type="long" DefaultValue="0" MinVersion="R2004" Comment="Unknown usage." />
+        <Property Name="GradientRotationAngle" Code="460" Type="double" DefaultValue="0.0" MinVersion="R2004" Comment="Rotation angle for gradients in radians." />
+        <Property Name="GradientDefinitionShift" Code="461" Type="double" DefaultValue="0.0" MinVersion="R2004" Comment="Unknown usage." />
+        <Property Name="ColorTint" Code="462" Type="double" DefaultValue="0.0" MinVersion="R2004" Comment="Range is [0.0, 1.0]." />
+        <Property Name="_reserved" Code="463" Type="double" DefaultValue="0.0" Accessibility="private" MinVersion="R2004" Comment="Reserved for future use." />
+        <Property Name="StringValue" Code="470" Type="string" DefaultValue="LINEAR" MinVersion="R2004" Comment="Unknown usage." />
+        <WriteOrder>
+            <WriteSpecificValue Code="100" Value="&quot;AcDbHatch&quot;" />
+            <WriteProperty Property="ElevationPoint" />
+            <WriteProperty Property="ExtrusionDirection" />
+            <WriteProperty Property="PatternName" />
+            <WriteProperty Property="FillMode" />
+            <WriteProperty Property="FillColor" />
+            <WriteProperty Property="IsAssociative" />
+            <WriteSpecificValue Code="91" Value="BoundaryPaths.Count" />
+            <Foreach Property="BoundaryPaths">
+                <WriteCustomCode Code="item.AddValuePairs(pairs, version, outputHandles);" />
+            </Foreach>
+            <WriteProperty Property="HatchStyle" />
+            <WriteProperty Property="PatternType" />
+            <WriteProperty Property="PatternAngle" />
+            <WriteProperty Property="PatternScale" />
+            <WriteProperty Property="IsPatternDoubled" />
+            <WriteSpecificValue Code="78" Value="(short)PatternDefinitionLines.Count" />
+            <Foreach Property="PatternDefinitionLines">
+                <WriteSpecificValue Code="53" Value="item.Angle" />
+                <WriteSpecificValue Code="43" Value="item.BasePoint.X" />
+                <WriteSpecificValue Code="44" Value="item.BasePoint.Y" />
+                <WriteSpecificValue Code="45" Value="item.Offset.X" />
+                <WriteSpecificValue Code="46" Value="item.Offset.Y" />
+                <WriteSpecificValue Code="79" Value="(short)item.DashLengths.Count" />
+                <Foreach Property="item.DashLengths">
+                    <WriteSpecificValue Code="49" Value="item1" />
+                </Foreach>
+            </Foreach>
+            <WriteProperty Property="PixelSize" />
+            <WriteSpecificValue Code="98" Value="SeedPoints.Count" />
+            <Foreach Property="SeedPoints">
+                <WriteSpecificValue Code="10" Value="item.X" />
+                <WriteSpecificValue Code="20" Value="item.Y" />
+            </Foreach>
+            <WriteProperty Property="IsGradient" />
+            <WriteProperty Property="_zero" />
+            <WriteProperty Property="GradientColorMode" />
+            <WriteProperty Property="NumberOfColors" />
+            <WriteProperty Property="GradientRotationAngle" />
+            <WriteProperty Property="GradientDefinitionShift" />
+            <WriteProperty Property="ColorTint" />
+            <WriteProperty Property="_reserved" />
+            <WriteProperty Property="StringValue" />
+        </WriteOrder>
+    </Entity>
     <!--
 
     HELIX
diff --git a/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xsd b/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xsd
index b5efaceb..6c95dc58 100644
--- a/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xsd
+++ b/src/IxMilia.Dxf.Generator/Specs/EntitiesSpec.xsd
@@ -121,12 +121,21 @@
         </xs:complexType>
     </xs:element>
 
+    <xs:element name="WriteCustomCode">
+        <xs:complexType>
+            <xs:attribute name="Code" type="xs:string" use="required" />
+        </xs:complexType>
+    </xs:element>
+
     <xs:element name="Foreach">
         <xs:complexType>
             <xs:sequence>
                 <xs:choice minOccurs="0" maxOccurs="unbounded">
                     <xs:element ref="WriteProperty" />
                     <xs:element ref="WriteSpecificValue" />
+                    <xs:element ref="Foreach" />
+                    <xs:element ref="WriteExtensionData" />
+                    <xs:element ref="WriteCustomCode" />
                 </xs:choice>
             </xs:sequence>
             <xs:attribute name="Property" type="xs:string" use="required" />
@@ -145,6 +154,7 @@
                     <xs:element ref="WriteSpecificValue" />
                     <xs:element ref="Foreach" />
                     <xs:element ref="WriteExtensionData" />
+                    <xs:element ref="WriteCustomCode" />
                 </xs:choice>
             </xs:sequence>
         </xs:complexType>
diff --git a/src/IxMilia.Dxf.Test/DxfCompatTests.cs b/src/IxMilia.Dxf.Test/DxfCompatTests.cs
index a16b4a0c..7de819c9 100644
--- a/src/IxMilia.Dxf.Test/DxfCompatTests.cs
+++ b/src/IxMilia.Dxf.Test/DxfCompatTests.cs
@@ -336,6 +336,7 @@ public void AutoCadReadAllEntitiesTest()
             var unsupportedTypes = new[]
             {
                 // unsupported because I need to write more information with them
+                typeof(DxfHatch), // need to fill in the data
                 typeof(DxfInsert), // need a block to insert
                 typeof(DxfLeader), // needs vertices
                 typeof(DxfMLine), // need to set MLINESTYLE and MLINESTYLE dictionary
diff --git a/src/IxMilia.Dxf.Test/DxfEntityTests.cs b/src/IxMilia.Dxf.Test/DxfEntityTests.cs
index 3035cdfc..e4722b0b 100644
--- a/src/IxMilia.Dxf.Test/DxfEntityTests.cs
+++ b/src/IxMilia.Dxf.Test/DxfEntityTests.cs
@@ -2019,6 +2019,577 @@ public void WriteOle2FrameTest()
 123456789A
   1
 OLE
+", DxfAcadVersion.R14);
+        }
+
+        [Fact]
+        public void ReadHatchPatternDefinitionTest()
+        {
+            var hatch = (DxfHatch)Entity("HATCH", @"
+ 77
+     1
+ 78
+     2
+ 53
+1.0
+ 43
+2.0
+ 44
+3.0
+ 45
+4.0
+ 46
+5.0
+ 79
+     2
+ 49
+6.0
+ 49
+7.0
+ 53
+8.0
+ 43
+9.0
+ 44
+10.0
+ 45
+11.0
+ 46
+12.0
+ 79
+     2
+ 49
+13.0
+ 49
+14.0
+ 47
+99.0
+");
+            Assert.True(hatch.IsPatternDoubled); // specified before pattern definition lines
+            Assert.Equal(99.0, hatch.PixelSize); // specified after pattern definition lines
+
+            Assert.Equal(2, hatch.PatternDefinitionLines.Count);
+            var line1 = hatch.PatternDefinitionLines[0];
+            Assert.Equal(1.0, line1.Angle);
+            Assert.Equal(2.0, line1.BasePoint.X);
+            Assert.Equal(3.0, line1.BasePoint.Y);
+            Assert.Equal(4.0, line1.Offset.X);
+            Assert.Equal(5.0, line1.Offset.Y);
+            AssertArrayEqual(new [] { 6.0, 7.0 }, line1.DashLengths.ToArray());
+
+            var line2 = hatch.PatternDefinitionLines[1];
+            Assert.Equal(8.0, line2.Angle);
+            Assert.Equal(9.0, line2.BasePoint.X);
+            Assert.Equal(10.0, line2.BasePoint.Y);
+            Assert.Equal(11.0, line2.Offset.X);
+            Assert.Equal(12.0, line2.Offset.Y);
+            AssertArrayEqual(new [] { 13.0, 14.0 }, line2.DashLengths.ToArray());
+        }
+
+        [Fact]
+        public void WriteHatchPatternDefinitionTest()
+        {
+            var hatch = new DxfHatch();
+            hatch.IsPatternDoubled = true; // written before pattern definition lines
+            hatch.PixelSize = 99.0; // written after pattern definition lines
+
+            var line1 = new DxfHatch.PatternDefinitionLine();
+            line1.Angle = 1.0;
+            line1.BasePoint = new DxfPoint(2.0, 3.0, 0.0);
+            line1.Offset = new DxfVector(4.0, 5.0, 0.0);
+            line1.DashLengths.Add(6.0);
+            line1.DashLengths.Add(7.0);
+
+            var line2 = new DxfHatch.PatternDefinitionLine();
+            line2.Angle = 8.0;
+            line2.BasePoint = new DxfPoint(9.0, 10.0, 0.0);
+            line2.Offset = new DxfVector(11.0, 12.0, 0.0);
+            line2.DashLengths.Add(13.0);
+            line2.DashLengths.Add(14.0);
+
+            hatch.PatternDefinitionLines.Add(line1);
+            hatch.PatternDefinitionLines.Add(line2);
+            EnsureFileContainsEntity(hatch, @"
+ 77
+     1
+ 78
+     2
+ 53
+1.0
+ 43
+2.0
+ 44
+3.0
+ 45
+4.0
+ 46
+5.0
+ 79
+     2
+ 49
+6.0
+ 49
+7.0
+ 53
+8.0
+ 43
+9.0
+ 44
+10.0
+ 45
+11.0
+ 46
+12.0
+ 79
+     2
+ 49
+13.0
+ 49
+14.0
+ 47
+99.0
+", DxfAcadVersion.R14);
+        }
+
+        [Fact]
+        public void ReadHatchSeedPointsTest()
+        {
+            var hatch = (DxfHatch)Entity("HATCH", @"
+ 47
+99.0
+ 98
+        2
+ 10
+1.0
+ 20
+2.0
+ 10
+3.0
+ 20
+4.0
+450
+        1
+");
+            Assert.Equal(99.0, hatch.PixelSize); // specified before seed points
+            Assert.True(hatch.IsGradient); // specified after seed points
+
+            Assert.Equal(2, hatch.SeedPoints.Count);
+            Assert.Equal(new DxfPoint(1.0, 2.0, 0.0), hatch.SeedPoints[0]);
+            Assert.Equal(new DxfPoint(3.0, 4.0, 0.0), hatch.SeedPoints[1]);
+        }
+
+        [Fact]
+        public void WriteHatchSeedPointsTest()
+        {
+            var hatch = new DxfHatch();
+            hatch.PixelSize = 99.0; // written before seed points
+            hatch.IsGradient = true; // written after seed points
+            hatch.SeedPoints.Add(new DxfPoint(1.0, 2.0, 0.0));
+            hatch.SeedPoints.Add(new DxfPoint(3.0, 4.0, 0.0));
+            EnsureFileContainsEntity(hatch, @"
+ 47
+99.0
+ 98
+        2
+ 10
+1.0
+ 20
+2.0
+ 10
+3.0
+ 20
+4.0
+450
+        1
+", DxfAcadVersion.R2004);
+        }
+
+        [Fact]
+        public void ReadHatchBoundaryPathDataTest()
+        {
+            var hatch = (DxfHatch)Entity("HATCH", @"
+ 10
+97.0
+ 20
+98.0
+ 30
+99.0
+ 71
+     1
+999
+======================================== boundary path count
+ 91
+        2
+999
+============================ start of polyline boundary path
+ 92
+        2
+ 72
+     1
+ 73
+     1
+ 93
+        2
+ 10
+1.0
+ 20
+2.0
+ 10
+3.0
+ 20
+4.0
+ 42
+5.0
+999
+==================================== source boundary objects
+ 97
+        2
+330
+ABC
+330
+DEF
+999
+============================== start of second boundary path
+ 92
+        8
+ 93
+        4
+999
+================================================ linear edge
+ 72
+     1
+ 10
+1.0
+ 20
+2.0
+ 11
+3.0
+ 21
+4.0
+999
+========================================== circular arc edge
+ 72
+     2
+ 10
+1.0
+ 20
+2.0
+ 40
+3.0
+ 50
+4.0
+ 51
+5.0
+ 73
+     1
+999
+========================================== elliptic arc edge
+ 72
+     3
+ 10
+1.0
+ 20
+2.0
+ 11
+3.0
+ 21
+4.0
+ 40
+5.0
+ 50
+6.0
+ 51
+7.0
+ 73
+     1
+999
+================================================ spline edge
+ 72
+     4
+ 94
+        2
+ 73
+     1
+ 74
+     1
+ 95
+        2
+ 96
+        2
+ 40
+1.0
+ 40
+2.0
+ 10
+3.0
+ 20
+4.0
+ 10
+5.0
+ 20
+6.0
+ 42
+7.0
+ 42
+8.0
+ 97
+        2
+ 11
+9.0
+ 21
+10.0
+ 11
+11.0
+ 21
+12.0
+ 12
+13.0
+ 22
+14.0
+ 13
+15.0
+ 23
+16.0
+ 97
+0
+999
+======================== back to HATCH (HatchStyle property)
+ 75
+     2
+");
+            Assert.Equal(new DxfPoint(97.0, 98.0, 99.0), hatch.ElevationPoint); // specified before boundary paths, shares codes with edge data
+            Assert.True(hatch.IsAssociative); // specified before boundary paths
+            Assert.Equal(DxfHatchStyle.EntireArea, hatch.HatchStyle); // specified after boundary paths
+
+            Assert.Equal(2, hatch.BoundaryPaths.Count);
+            var polyPath = (DxfHatch.PolylineBoundaryPath)hatch.BoundaryPaths[0];
+            Assert.True(polyPath.IsClosed);
+            Assert.Equal(2, polyPath.Vertices.Count);
+            Assert.Equal(new DxfPoint(1.0, 2.0, 0.0), polyPath.Vertices[0].Location);
+            Assert.Equal(0.0, polyPath.Vertices[0].Bulge);
+            Assert.Equal(new DxfPoint(3.0, 4.0, 0.0), polyPath.Vertices[1].Location);
+            Assert.Equal(5.0, polyPath.Vertices[1].Bulge);
+            AssertArrayEqual(new uint[] { 0xABC, 0xDEF }, polyPath.BoundaryHandles.ToArray());
+
+            var nonPolyPath = (DxfHatch.NonPolylineBoundaryPath)hatch.BoundaryPaths[1];
+            Assert.Equal(DxfHatch.BoundaryPathType.Textbox, nonPolyPath.PathType);
+            Assert.Equal(4, nonPolyPath.Edges.Count);
+
+            var linearEdge = (DxfHatch.LineBoundaryPathEdge)nonPolyPath.Edges[0];
+            Assert.Equal(new DxfPoint(1.0, 2.0, 0.0), linearEdge.StartPoint);
+            Assert.Equal(new DxfPoint(3.0, 4.0, 0.0), linearEdge.EndPoint);
+
+            var circularArcEdge = (DxfHatch.CircularArcBoundaryPathEdge)nonPolyPath.Edges[1];
+            Assert.Equal(new DxfPoint(1.0, 2.0, 0.0), circularArcEdge.Center);
+            Assert.Equal(3.0, circularArcEdge.Radius);
+            Assert.Equal(4.0, circularArcEdge.StartAngle);
+            Assert.Equal(5.0, circularArcEdge.EndAngle);
+            Assert.True(circularArcEdge.IsCounterClockwise);
+
+            var ellipticArcEdge = (DxfHatch.EllipticArcBoundaryPathEdge)nonPolyPath.Edges[2];
+            Assert.Equal(new DxfPoint(1.0, 2.0, 0.0), ellipticArcEdge.Center);
+            Assert.Equal(new DxfVector(3.0, 4.0, 0.0), ellipticArcEdge.MajorAxis);
+            Assert.Equal(5.0, ellipticArcEdge.MinorAxisRatio);
+            Assert.Equal(6.0, ellipticArcEdge.StartAngle);
+            Assert.Equal(7.0, ellipticArcEdge.EndAngle);
+            Assert.True(ellipticArcEdge.IsCounterClockwise);
+
+            var splineEdge = (DxfHatch.SplineBoundaryPathEdge)nonPolyPath.Edges[3];
+            Assert.Equal(2, splineEdge.Degree);
+            Assert.True(splineEdge.IsRational);
+            Assert.True(splineEdge.IsPeriodic);
+            AssertArrayEqual(new[] { 1.0, 2.0 }, splineEdge.Knots.ToArray());
+            AssertArrayEqual(new[]
+                {
+                    new DxfControlPoint(new DxfPoint(3.0, 4.0, 0.0), 7.0),
+                    new DxfControlPoint(new DxfPoint(5.0, 6.0, 0.0), 8.0)
+                },
+                splineEdge.ControlPoints.ToArray());
+            AssertArrayEqual(new[]
+                {
+                    new DxfPoint(9.0, 10.0, 0.0),
+                    new DxfPoint(11.0, 12.0, 0.0)
+                },
+                splineEdge.FitPoints.ToArray());
+            Assert.Equal(new DxfVector(13.0, 14.0, 0.0), splineEdge.StartTangent);
+            Assert.Equal(new DxfVector(15.0, 16.0, 0.0), splineEdge.EndTangent);
+        }
+
+        [Fact]
+        public void WriteHatchBoundaryPathDataTest()
+        {
+            var hatch = new DxfHatch();
+            hatch.IsAssociative = true; // written before boundary paths
+            hatch.HatchStyle = DxfHatchStyle.EntireArea; // written after boundary paths
+
+            var polyPath = new DxfHatch.PolylineBoundaryPath();
+            polyPath.IsClosed = true;
+            polyPath.Vertices.Add(new DxfVertex(new DxfPoint(1.0, 2.0, 0.0)));
+            polyPath.Vertices.Add(new DxfVertex(new DxfPoint(3.0, 4.0, 0.0)) { Bulge = 5.0 });
+            polyPath.BoundaryHandles.Add(0xABC);
+            polyPath.BoundaryHandles.Add(0xDEF);
+            hatch.BoundaryPaths.Add(polyPath);
+
+            var nonPolyPath = new DxfHatch.NonPolylineBoundaryPath(DxfHatch.BoundaryPathType.Textbox);
+            var linearEdge = new DxfHatch.LineBoundaryPathEdge();
+            linearEdge.StartPoint = new DxfPoint(1.0, 2.0, 0.0);
+            linearEdge.EndPoint = new DxfPoint(3.0, 4.0, 0.0);
+            nonPolyPath.Edges.Add(linearEdge);
+            var circularArcEdge = new DxfHatch.CircularArcBoundaryPathEdge();
+            circularArcEdge.Center = new DxfPoint(1.0, 2.0, 0.0);
+            circularArcEdge.Radius = 3.0;
+            circularArcEdge.StartAngle = 4.0;
+            circularArcEdge.EndAngle = 5.0;
+            circularArcEdge.IsCounterClockwise = true;
+            nonPolyPath.Edges.Add(circularArcEdge);
+            var ellipticArcEdge = new DxfHatch.EllipticArcBoundaryPathEdge();
+            ellipticArcEdge.Center = new DxfPoint(1.0, 2.0, 0.0);
+            ellipticArcEdge.MajorAxis = new DxfVector(3.0, 4.0, 0.0);
+            ellipticArcEdge.MinorAxisRatio = 5.0;
+            ellipticArcEdge.StartAngle = 6.0;
+            ellipticArcEdge.EndAngle = 7.0;
+            ellipticArcEdge.IsCounterClockwise = true;
+            nonPolyPath.Edges.Add(ellipticArcEdge);
+            var splineEdge = new DxfHatch.SplineBoundaryPathEdge();
+            splineEdge.Degree = 2;
+            splineEdge.IsRational = true;
+            splineEdge.IsPeriodic = true;
+            splineEdge.Knots.Add(1.0);
+            splineEdge.Knots.Add(2.0);
+            splineEdge.ControlPoints.Add(new DxfControlPoint(new DxfPoint(3.0, 4.0, 0.0), 7.0));
+            splineEdge.ControlPoints.Add(new DxfControlPoint(new DxfPoint(5.0, 6.0, 0.0), 8.0));
+            splineEdge.FitPoints.Add(new DxfPoint(9.0, 10.0, 0.0));
+            splineEdge.FitPoints.Add(new DxfPoint(11.0, 12.0, 0.0));
+            splineEdge.StartTangent = new DxfVector(13.0, 14.0, 0.0);
+            splineEdge.EndTangent = new DxfVector(15.0, 16.0, 0.0);
+            nonPolyPath.Edges.Add(splineEdge);
+            hatch.BoundaryPaths.Add(nonPolyPath);
+
+            EnsureFileContainsEntity(hatch, @"
+ 71
+     1
+ 91
+        2
+ 92
+        2
+ 72
+     1
+ 73
+     1
+ 93
+        2
+ 10
+1.0
+ 20
+2.0
+ 10
+3.0
+ 20
+4.0
+ 42
+5.0
+ 97
+        2
+330
+ABC
+330
+DEF
+ 92
+        8
+ 93
+        4
+ 72
+     1
+ 10
+1.0
+ 20
+2.0
+ 11
+3.0
+ 21
+4.0
+ 72
+     2
+ 10
+1.0
+ 20
+2.0
+ 40
+3.0
+ 50
+4.0
+ 51
+5.0
+ 73
+     1
+ 72
+     3
+ 10
+1.0
+ 20
+2.0
+ 11
+3.0
+ 21
+4.0
+ 40
+5.0
+ 50
+6.0
+ 51
+7.0
+ 73
+     1
+ 72
+     4
+ 94
+        2
+ 73
+     1
+ 74
+     1
+ 95
+        2
+ 96
+        2
+ 40
+1.0
+ 40
+2.0
+ 10
+3.0
+ 20
+4.0
+ 10
+5.0
+ 20
+6.0
+ 42
+7.0
+ 42
+8.0
+ 97
+        2
+ 11
+9.0
+ 21
+10.0
+ 11
+11.0
+ 21
+12.0
+ 12
+13.0
+ 22
+14.0
+ 13
+15.0
+ 23
+16.0
+ 97
+0
+ 75
+     2
 ", DxfAcadVersion.R14);
         }
     }
diff --git a/src/IxMilia.Dxf.Test/DxfReaderWriterTests.cs b/src/IxMilia.Dxf.Test/DxfReaderWriterTests.cs
index 2917cf51..59893f69 100644
--- a/src/IxMilia.Dxf.Test/DxfReaderWriterTests.cs
+++ b/src/IxMilia.Dxf.Test/DxfReaderWriterTests.cs
@@ -1452,11 +1452,11 @@ public void ReadBlockWithUnsupportedEntityTest()
 999
 ================================================================================
 999
-                       unsupported entity (HATCH) between two supported entities
+      unsupported entity (NOT_A_SUPPORTED_ENTITY) between two supported entities
 999
 ================================================================================
   0
-HATCH
+NOT_A_SUPPORTED_ENTITY
   0
 POINT
  10
diff --git a/src/IxMilia.Dxf/DxfCommonConverters.cs b/src/IxMilia.Dxf/DxfCommonConverters.cs
index 5b9b1b94..5025dfec 100644
--- a/src/IxMilia.Dxf/DxfCommonConverters.cs
+++ b/src/IxMilia.Dxf/DxfCommonConverters.cs
@@ -21,6 +21,16 @@ public static short StringShort(string s)
             return result;
         }
 
+        public static bool BoolLong(long l)
+        {
+            return l != 0;
+        }
+
+        public static long BoolLong(bool b)
+        {
+            return b ? 1 : 0;
+        }
+
         public static bool BoolShort(short s)
         {
             return s != 0;
diff --git a/src/IxMilia.Dxf/Entities/DxfControlPoint.cs b/src/IxMilia.Dxf/Entities/DxfControlPoint.cs
index 0233c58e..d0b3e065 100644
--- a/src/IxMilia.Dxf/Entities/DxfControlPoint.cs
+++ b/src/IxMilia.Dxf/Entities/DxfControlPoint.cs
@@ -12,5 +12,10 @@ public DxfControlPoint(DxfPoint point, double weight)
             Point = point;
             Weight = weight;
         }
+
+        public DxfControlPoint(DxfPoint point)
+            : this(point, 1.0)
+        {
+        }
     }
 }
diff --git a/src/IxMilia.Dxf/Entities/DxfEntity.cs b/src/IxMilia.Dxf/Entities/DxfEntity.cs
index edd37ca6..75d78577 100644
--- a/src/IxMilia.Dxf/Entities/DxfEntity.cs
+++ b/src/IxMilia.Dxf/Entities/DxfEntity.cs
@@ -54,6 +54,32 @@ public enum DxfPolylineType
         Outline = 2
     }
 
+    public enum DxfGradientColorMode
+    {
+        TwoColorGradient = 0,
+        SingleColorGradient = 1
+    }
+
+    public enum DxfHatchPatternFillMode
+    {
+        PatternFill = 0,
+        SolidFill = 1
+    }
+
+    public enum DxfHatchPatternType
+    {
+        UserDefined = 0,
+        Predefined = 1,
+        Custom = 2
+    }
+
+    public enum DxfHatchStyle
+    {
+        OddParity = 0,
+        OutermostAreaOnly = 1,
+        EntireArea = 2
+    }
+
     public enum DxfImageClippingBoundaryType
     {
         Rectangular = 1,
@@ -294,6 +320,16 @@ internal virtual DxfEntity PopulateFromBuffer(DxfCodePairBufferReader buffer)
             return PostParse();
         }
 
+        protected static bool BoolLong(long l)
+        {
+            return DxfCommonConverters.BoolLong(l);
+        }
+
+        protected static long BoolLong(bool b)
+        {
+            return DxfCommonConverters.BoolLong(b);
+        }
+
         protected static bool BoolShort(short s)
         {
             return DxfCommonConverters.BoolShort(s);
diff --git a/src/IxMilia.Dxf/Entities/DxfHatch.BoundaryPath.cs b/src/IxMilia.Dxf/Entities/DxfHatch.BoundaryPath.cs
new file mode 100644
index 00000000..84b8b2f0
--- /dev/null
+++ b/src/IxMilia.Dxf/Entities/DxfHatch.BoundaryPath.cs
@@ -0,0 +1,438 @@
+// Copyright (c) IxMilia.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using IxMilia.Dxf.Collections;
+
+namespace IxMilia.Dxf.Entities
+{
+    public partial class DxfHatch
+    {
+        public enum BoundaryPathType
+        {
+            Default = 0,
+            External = 1,
+            // Polyline = 2, // handled manually, not exposed
+            Derived = 4,
+            Textbox = 8,
+            Outermost = 16,
+        }
+
+        public abstract class BoundaryPathBase
+        {
+            public List<uint> BoundaryHandles { get; } = new List<uint>();
+
+            internal virtual void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(97, BoundaryHandles.Count));
+                foreach (var handle in BoundaryHandles)
+                {
+                    pairs.Add(new DxfCodePair(330, UIntHandle(handle)));
+                }
+            }
+
+            internal virtual bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 97:
+                        var _boundaryHandleCount = pair.IntegerValue;
+                        break;
+                    case 330:
+                        BoundaryHandles.Add(UIntHandle(pair.StringValue));
+                        break;
+                    default:
+                        return false;
+                }
+
+                return true;
+            }
+
+            internal static BoundaryPathBase CreateFromType(BoundaryPathType type)
+            {
+                if ((int)type == 2)
+                {
+                    // special polyline case
+                    return new PolylineBoundaryPath();
+                }
+
+                return new NonPolylineBoundaryPath(type);
+            }
+        }
+
+        public class NonPolylineBoundaryPath : BoundaryPathBase
+        {
+            public BoundaryPathType PathType { get; set; }
+            public IList<BoundaryPathEdgeBase> Edges { get; } = new ListNonNull<BoundaryPathEdgeBase>();
+
+            public NonPolylineBoundaryPath(BoundaryPathType pathType)
+            {
+                PathType = pathType;
+            }
+
+            internal override void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(92, (int)PathType));
+                pairs.Add(new DxfCodePair(93, Edges.Count));
+                foreach (var edge in Edges)
+                {
+                    edge.AddValuePairs(pairs, version, outputHandles);
+                }
+
+                base.AddValuePairs(pairs, version, outputHandles);
+            }
+
+            internal override bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 93:
+                        var _edgeCount = pair.IntegerValue;
+                        break;
+                    case 72:
+                        switch (pair.ShortValue)
+                        {
+                            case 1:
+                                Edges.Add(new LineBoundaryPathEdge());
+                                break;
+                            case 2:
+                                Edges.Add(new CircularArcBoundaryPathEdge());
+                                break;
+                            case 3:
+                                Edges.Add(new EllipticArcBoundaryPathEdge());
+                                break;
+                            case 4:
+                                Edges.Add(new SplineBoundaryPathEdge());
+                                break;
+                            default:
+                                return false;
+                        }
+                        break;
+                    default:
+                        return Edges.Last().TrySetPair(pair);
+                }
+
+                return true;
+            }
+        }
+
+        public abstract class BoundaryPathEdgeBase
+        {
+            internal abstract void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles);
+            internal abstract bool TrySetPair(DxfCodePair pair);
+        }
+
+        public class LineBoundaryPathEdge : BoundaryPathEdgeBase
+        {
+            public DxfPoint StartPoint { get; set; }
+            public DxfPoint EndPoint { get; set; }
+
+            internal override void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(72, (short)1));
+                pairs.Add(new DxfCodePair(10, StartPoint.X));
+                pairs.Add(new DxfCodePair(20, StartPoint.Y));
+                pairs.Add(new DxfCodePair(11, EndPoint.X));
+                pairs.Add(new DxfCodePair(21, EndPoint.Y));
+            }
+
+            internal override bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 10:
+                        StartPoint = StartPoint.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 20:
+                        StartPoint = StartPoint.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 11:
+                        EndPoint = EndPoint.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 21:
+                        EndPoint = EndPoint.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    default:
+                        return false;
+                }
+
+                return true;
+            }
+        }
+
+        public class CircularArcBoundaryPathEdge : BoundaryPathEdgeBase
+        {
+            public DxfPoint Center { get; set; }
+            public double Radius { get; set; }
+            public double StartAngle { get; set; }
+            public double EndAngle { get; set; }
+            public bool IsCounterClockwise { get; set; }
+
+            internal override void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(72, (short)2));
+                pairs.Add(new DxfCodePair(10, Center.X));
+                pairs.Add(new DxfCodePair(20, Center.Y));
+                pairs.Add(new DxfCodePair(40, Radius));
+                pairs.Add(new DxfCodePair(50, StartAngle));
+                pairs.Add(new DxfCodePair(51, EndAngle));
+                pairs.Add(new DxfCodePair(73, BoolShort(IsCounterClockwise)));
+            }
+
+            internal override bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 10:
+                        Center = Center.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 20:
+                        Center = Center.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 40:
+                        Radius = pair.DoubleValue;
+                        break;
+                    case 50:
+                        StartAngle = pair.DoubleValue;
+                        break;
+                    case 51:
+                        EndAngle = pair.DoubleValue;
+                        break;
+                    case 73:
+                        IsCounterClockwise = BoolShort(pair.ShortValue);
+                        break;
+                    default:
+                        return false;
+                }
+
+                return true;
+            }
+        }
+
+        public class EllipticArcBoundaryPathEdge : BoundaryPathEdgeBase
+        {
+            public DxfPoint Center { get; set; }
+            public DxfVector MajorAxis { get; set; }
+            public double MinorAxisRatio { get; set; }
+            public double StartAngle { get; set; }
+            public double EndAngle { get; set; }
+            public bool IsCounterClockwise { get; set; }
+
+            internal override void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(72, (short)3));
+                pairs.Add(new DxfCodePair(10, Center.X));
+                pairs.Add(new DxfCodePair(20, Center.Y));
+                pairs.Add(new DxfCodePair(11, MajorAxis.X));
+                pairs.Add(new DxfCodePair(21, MajorAxis.Y));
+                pairs.Add(new DxfCodePair(40, MinorAxisRatio));
+                pairs.Add(new DxfCodePair(50, StartAngle));
+                pairs.Add(new DxfCodePair(51, EndAngle));
+                pairs.Add(new DxfCodePair(73, BoolShort(IsCounterClockwise)));
+            }
+
+            internal override bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 10:
+                        Center = Center.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 20:
+                        Center = Center.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 11:
+                        MajorAxis = MajorAxis.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 21:
+                        MajorAxis = MajorAxis.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 40:
+                        MinorAxisRatio = pair.DoubleValue;
+                        break;
+                    case 50:
+                        StartAngle = pair.DoubleValue;
+                        break;
+                    case 51:
+                        EndAngle = pair.DoubleValue;
+                        break;
+                    case 73:
+                        IsCounterClockwise = BoolShort(pair.ShortValue);
+                        break;
+                    default:
+                        return false;
+                }
+
+                return true;
+            }
+        }
+
+        public class SplineBoundaryPathEdge : BoundaryPathEdgeBase
+        {
+            public int Degree { get; set; }
+            public bool IsRational { get; set; }
+            public bool IsPeriodic { get; set; }
+            public IList<double> Knots { get; } = new List<double>();
+            public IList<DxfControlPoint> ControlPoints { get; } = new List<DxfControlPoint>();
+            public IList<DxfPoint> FitPoints { get; } = new List<DxfPoint>();
+            public DxfVector StartTangent { get; set; }
+            public DxfVector EndTangent { get; set; }
+
+            private int _currentWeight = 0;
+
+            internal override void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(72, (short)4));
+                pairs.Add(new DxfCodePair(94, Degree));
+                pairs.Add(new DxfCodePair(73, BoolShort(IsRational)));
+                pairs.Add(new DxfCodePair(74, BoolShort(IsPeriodic)));
+                pairs.Add(new DxfCodePair(95, Knots.Count));
+                pairs.Add(new DxfCodePair(96, ControlPoints.Count));
+                foreach (var item in Knots)
+                {
+                    pairs.Add(new DxfCodePair(40, item));
+                }
+
+                foreach (var item in ControlPoints)
+                {
+                    pairs.Add(new DxfCodePair(10, item.Point.X));
+                    pairs.Add(new DxfCodePair(20, item.Point.Y));
+                }
+
+                if (ControlPoints.Any(cp => cp.Weight != 1.0))
+                {
+                    foreach (var item in ControlPoints)
+                    {
+                        pairs.Add(new DxfCodePair(42, item.Weight));
+                    }
+                }
+
+                pairs.Add(new DxfCodePair(97, FitPoints.Count));
+                foreach (var item in FitPoints)
+                {
+                    pairs.Add(new DxfCodePair(11, item.X));
+                    pairs.Add(new DxfCodePair(21, item.Y));
+                }
+
+                pairs.Add(new DxfCodePair(12, StartTangent.X));
+                pairs.Add(new DxfCodePair(22, StartTangent.Y));
+                pairs.Add(new DxfCodePair(13, EndTangent.X));
+                pairs.Add(new DxfCodePair(23, EndTangent.Y));
+            }
+
+            internal override bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 94:
+                        Degree = pair.IntegerValue;
+                        break;
+                    case 73:
+                        IsRational = BoolShort(pair.ShortValue);
+                        break;
+                    case 74:
+                        IsPeriodic = BoolShort(pair.ShortValue);
+                        break;
+                    case 95:
+                        var _knotCount = pair.IntegerValue;
+                        break;
+                    case 96:
+                        var _controlPointCount = pair.IntegerValue;
+                        break;
+                    case 40:
+                        Knots.Add(pair.DoubleValue);
+                        break;
+                    case 10:
+                        ControlPoints.Add(new DxfControlPoint(new DxfPoint(pair.DoubleValue, 0.0, 0.0)));
+                        break;
+                    case 20:
+                        ControlPoints[ControlPoints.Count - 1] = new DxfControlPoint(ControlPoints[ControlPoints.Count - 1].Point.WithUpdatedY(pair.DoubleValue));
+                        break;
+                    case 42:
+                        ControlPoints[_currentWeight] = new DxfControlPoint(ControlPoints[_currentWeight].Point, pair.DoubleValue);
+                        _currentWeight++;
+                        break;
+                    case 97:
+                        var _fitPointCount = pair.IntegerValue;
+                        break;
+                    case 11:
+                        FitPoints.Add(new DxfPoint(pair.DoubleValue, 0.0, 0.0));
+                        break;
+                    case 21:
+                        FitPoints[FitPoints.Count - 1] = FitPoints[FitPoints.Count - 1].WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 12:
+                        StartTangent = StartTangent.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 22:
+                        StartTangent = StartTangent.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 13:
+                        EndTangent = EndTangent.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 23:
+                        EndTangent = EndTangent.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    default:
+                        return false;
+                }
+
+                return true;
+            }
+        }
+
+        public class PolylineBoundaryPath : BoundaryPathBase
+        {
+            public bool IsClosed { get; set; }
+            public List<DxfVertex> Vertices { get; } = new List<DxfVertex>();
+
+            internal override void AddValuePairs(List<DxfCodePair> pairs, DxfAcadVersion version, bool outputHandles)
+            {
+                pairs.Add(new DxfCodePair(92, 2)); // polyline type
+                pairs.Add(new DxfCodePair(72, BoolShort(Vertices.Any(v => v.Bulge != 0.0))));
+                pairs.Add(new DxfCodePair(73, BoolShort(IsClosed)));
+                pairs.Add(new DxfCodePair(93, Vertices.Count));
+                foreach (var vertex in Vertices)
+                {
+                    pairs.Add(new DxfCodePair(10, vertex.Location.X));
+                    pairs.Add(new DxfCodePair(20, vertex.Location.Y));
+                    if (vertex.Bulge != 0.0)
+                    {
+                        pairs.Add(new DxfCodePair(42, vertex.Bulge));
+                    }
+                }
+
+                base.AddValuePairs(pairs, version, outputHandles);
+            }
+
+            internal override bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 72:
+                        var _hasBulge = BoolShort(pair.ShortValue);
+                        break;
+                    case 73:
+                        IsClosed = BoolShort(pair.ShortValue);
+                        break;
+                    case 93:
+                        var _vertexCount = pair.IntegerValue;
+                        break;
+                    case 10:
+                        Vertices.Add(new DxfVertex(new DxfPoint(pair.DoubleValue, 0.0, 0.0)));
+                        break;
+                    case 20:
+                        Vertices.Last().Location = Vertices.Last().Location.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 42:
+                        Vertices.Last().Bulge = pair.DoubleValue;
+                        break;
+                    default:
+                        return base.TrySetPair(pair);
+                }
+
+                return true;
+            }
+        }
+    }
+}
diff --git a/src/IxMilia.Dxf/Entities/DxfHatch.PatternDefinitionLine.cs b/src/IxMilia.Dxf/Entities/DxfHatch.PatternDefinitionLine.cs
new file mode 100644
index 00000000..d4178a36
--- /dev/null
+++ b/src/IxMilia.Dxf/Entities/DxfHatch.PatternDefinitionLine.cs
@@ -0,0 +1,49 @@
+// Copyright (c) IxMilia.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+
+namespace IxMilia.Dxf.Entities
+{
+    public partial class DxfHatch
+    {
+        public class PatternDefinitionLine
+        {
+            public double Angle { get; set; } = 0.0;
+            public DxfPoint BasePoint { get; set; } = DxfPoint.Origin;
+            public DxfVector Offset { get; set; } = DxfVector.Zero;
+            public List<double> DashLengths { get; } = new List<double>();
+
+            internal bool TrySetPair(DxfCodePair pair)
+            {
+                switch (pair.Code)
+                {
+                    case 53:
+                        Angle = pair.DoubleValue;
+                        break;
+                    case 43:
+                        BasePoint = BasePoint.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 44:
+                        BasePoint = BasePoint.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 45:
+                        Offset = Offset.WithUpdatedX(pair.DoubleValue);
+                        break;
+                    case 46:
+                        Offset = Offset.WithUpdatedY(pair.DoubleValue);
+                        break;
+                    case 79:
+                        var _dashLengthCount = pair.ShortValue;
+                        break;
+                    case 49:
+                        DashLengths.Add(pair.DoubleValue);
+                        break;
+                    default:
+                        return false;
+                }
+
+                return true;
+            }
+        }
+    }
+}
diff --git a/src/IxMilia.Dxf/Entities/DxfHatch.cs b/src/IxMilia.Dxf/Entities/DxfHatch.cs
new file mode 100644
index 00000000..20741064
--- /dev/null
+++ b/src/IxMilia.Dxf/Entities/DxfHatch.cs
@@ -0,0 +1,170 @@
+// Copyright (c) IxMilia.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Linq;
+
+namespace IxMilia.Dxf.Entities
+{
+    public partial class DxfHatch
+    {
+        private enum ReadMode
+        {
+            Entity,
+            BoundaryPath,
+            PatternData,
+            SeedPoints,
+        }
+
+        private ReadMode _readMode = ReadMode.Entity;
+
+        internal override bool TrySetPair(DxfCodePair pair)
+        {
+            switch (_readMode)
+            {
+                case ReadMode.BoundaryPath:
+                    if (pair.Code == 92)
+                    {
+                        // new boundary path
+                        var pathType = (BoundaryPathType)pair.IntegerValue;
+                        BoundaryPaths.Add(BoundaryPathBase.CreateFromType(pathType));
+                        return true;
+                    }
+
+                    if (BoundaryPaths.Last().TrySetPair(pair))
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        _readMode = ReadMode.Entity;
+                        break;
+                    }
+                case ReadMode.PatternData:
+                    if (pair.Code == 53)
+                    {
+                        // new pattern definition line
+                        PatternDefinitionLines.Add(new PatternDefinitionLine());
+                    }
+
+                    if (PatternDefinitionLines.Last().TrySetPair(pair))
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        _readMode = ReadMode.Entity;
+                        break;
+                    }
+                case ReadMode.SeedPoints:
+                    switch (pair.Code)
+                    {
+                        case 10:
+                            // new seed point
+                            SeedPoints.Add(new DxfPoint(pair.DoubleValue, 0.0, 0.0));
+                            return true;
+                        case 20:
+                            SeedPoints[SeedPoints.Count - 1] = SeedPoints.Last().WithUpdatedY(pair.DoubleValue);
+                            return true;
+                        default:
+                            _readMode = ReadMode.Entity;
+                            break;
+                    }
+                    break;
+            }
+
+            switch (pair.Code)
+            {
+                case 2:
+                    this.PatternName = pair.StringValue;
+                    break;
+                case 10:
+                    this.ElevationPoint = this.ElevationPoint.WithUpdatedX(pair.DoubleValue);
+                    break;
+                case 20:
+                    this.ElevationPoint = this.ElevationPoint.WithUpdatedY(pair.DoubleValue);
+                    break;
+                case 30:
+                    this.ElevationPoint = this.ElevationPoint.WithUpdatedZ(pair.DoubleValue);
+                    break;
+                case 41:
+                    this.PatternScale = pair.DoubleValue;
+                    break;
+                case 47:
+                    this.PixelSize = pair.DoubleValue;
+                    break;
+                case 52:
+                    this.PatternAngle = pair.DoubleValue;
+                    break;
+                case 63:
+                    this.FillColor = DxfColor.FromRawValue(pair.ShortValue);
+                    break;
+                case 70:
+                    this.FillMode = (DxfHatchPatternFillMode)pair.ShortValue;
+                    break;
+                case 71:
+                    this.IsAssociative = BoolShort(pair.ShortValue);
+                    break;
+                case 75:
+                    this.HatchStyle = (DxfHatchStyle)pair.ShortValue;
+                    break;
+                case 76:
+                    this.PatternType = (DxfHatchPatternType)pair.ShortValue;
+                    break;
+                case 77:
+                    this.IsPatternDoubled = BoolShort(pair.ShortValue);
+                    break;
+                case 78:
+                    this._patternDefinitionLineCount = pair.ShortValue;
+                    _readMode = ReadMode.PatternData;
+                    break;
+                case 91:
+                    this._boundaryPathCount = pair.IntegerValue;
+                    _readMode = ReadMode.BoundaryPath;
+                    break;
+                case 98:
+                    this._seedPointCount = pair.IntegerValue;
+                    _readMode = ReadMode.SeedPoints;
+                    break;
+                case 210:
+                    this.ExtrusionDirection = this.ExtrusionDirection.WithUpdatedX(pair.DoubleValue);
+                    break;
+                case 220:
+                    this.ExtrusionDirection = this.ExtrusionDirection.WithUpdatedY(pair.DoubleValue);
+                    break;
+                case 230:
+                    this.ExtrusionDirection = this.ExtrusionDirection.WithUpdatedZ(pair.DoubleValue);
+                    break;
+                case 450:
+                    this.IsGradient = BoolLong(pair.LongValue);
+                    break;
+                case 451:
+                    this._zero = pair.LongValue;
+                    break;
+                case 452:
+                    this.GradientColorMode = (DxfGradientColorMode)pair.LongValue;
+                    break;
+                case 453:
+                    this.NumberOfColors = pair.LongValue;
+                    break;
+                case 460:
+                    this.GradientRotationAngle = pair.DoubleValue;
+                    break;
+                case 461:
+                    this.GradientDefinitionShift = pair.DoubleValue;
+                    break;
+                case 462:
+                    this.ColorTint = pair.DoubleValue;
+                    break;
+                case 463:
+                    this._reserved = pair.DoubleValue;
+                    break;
+                case 470:
+                    this.StringValue = pair.StringValue;
+                    break;
+                default:
+                    return base.TrySetPair(pair);
+            }
+
+            return true;
+        }
+    }
+}