diff --git a/Common/UnitDefinitions/Force.json b/Common/UnitDefinitions/Force.json
index aebf6a9ed9..9b8314350a 100644
--- a/Common/UnitDefinitions/Force.json
+++ b/Common/UnitDefinitions/Force.json
@@ -147,6 +147,22 @@
           "Abbreviations": [ "ozf" ]
         }
       ]
+    },
+    {
+      "SingularName": "KilopoundForce",
+      "PluralName": "KilopoundsForce",
+      "FromUnitToBaseFunc": "x*4448.2216152605095551842641431421",
+      "FromBaseToUnitFunc": "x/4448.2216152605095551842641431421",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "kipf" ]
+        },
+        {
+          "Culture": "ru-RU",
+          "Abbreviations": [ "кипф" ]
+        }
+      ]
     }
   ]
 }
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index 34b620ffb7..abc8968f9d 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -12,6 +12,7 @@ public class ForceTests : ForceTestsBase
 
         protected override double KilogramsForceInOneNewton => 0.101972;
 
+        protected override double KilopoundsForceInOneNewton => 0.22481e-3;
         protected override double MeganewtonsInOneNewton => 1E-6;
         protected override double KilonewtonsInOneNewton => 1E-3;
 
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
index e960c9f468..bcf25ac1de 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/ForceTestsBase.g.cs
@@ -41,6 +41,7 @@ public abstract partial class ForceTestsBase
         protected abstract double KilogramsForceInOneNewton { get; }
         protected abstract double KilonewtonsInOneNewton { get; }
         protected abstract double KiloPondsInOneNewton { get; }
+        protected abstract double KilopoundsForceInOneNewton { get; }
         protected abstract double MeganewtonsInOneNewton { get; }
         protected abstract double MicronewtonsInOneNewton { get; }
         protected abstract double MillinewtonsInOneNewton { get; }
@@ -56,6 +57,7 @@ public abstract partial class ForceTestsBase
         protected virtual double KilogramsForceTolerance { get { return 1e-5; } }
         protected virtual double KilonewtonsTolerance { get { return 1e-5; } }
         protected virtual double KiloPondsTolerance { get { return 1e-5; } }
+        protected virtual double KilopoundsForceTolerance { get { return 1e-5; } }
         protected virtual double MeganewtonsTolerance { get { return 1e-5; } }
         protected virtual double MicronewtonsTolerance { get { return 1e-5; } }
         protected virtual double MillinewtonsTolerance { get { return 1e-5; } }
@@ -130,6 +132,7 @@ public void NewtonToForceUnits()
             AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.KilogramsForce, KilogramsForceTolerance);
             AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.Kilonewtons, KilonewtonsTolerance);
             AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.KiloPonds, KiloPondsTolerance);
+            AssertEx.EqualTolerance(KilopoundsForceInOneNewton, newton.KilopoundsForce, KilopoundsForceTolerance);
             AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.Meganewtons, MeganewtonsTolerance);
             AssertEx.EqualTolerance(MicronewtonsInOneNewton, newton.Micronewtons, MicronewtonsTolerance);
             AssertEx.EqualTolerance(MillinewtonsInOneNewton, newton.Millinewtons, MillinewtonsTolerance);
@@ -163,37 +166,41 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
             AssertEx.EqualTolerance(1, quantity04.KiloPonds, KiloPondsTolerance);
             Assert.Equal(ForceUnit.KiloPond, quantity04.Unit);
 
-            var quantity05 = Force.From(1, ForceUnit.Meganewton);
-            AssertEx.EqualTolerance(1, quantity05.Meganewtons, MeganewtonsTolerance);
-            Assert.Equal(ForceUnit.Meganewton, quantity05.Unit);
+            var quantity05 = Force.From(1, ForceUnit.KilopoundForce);
+            AssertEx.EqualTolerance(1, quantity05.KilopoundsForce, KilopoundsForceTolerance);
+            Assert.Equal(ForceUnit.KilopoundForce, quantity05.Unit);
 
-            var quantity06 = Force.From(1, ForceUnit.Micronewton);
-            AssertEx.EqualTolerance(1, quantity06.Micronewtons, MicronewtonsTolerance);
-            Assert.Equal(ForceUnit.Micronewton, quantity06.Unit);
+            var quantity06 = Force.From(1, ForceUnit.Meganewton);
+            AssertEx.EqualTolerance(1, quantity06.Meganewtons, MeganewtonsTolerance);
+            Assert.Equal(ForceUnit.Meganewton, quantity06.Unit);
 
-            var quantity07 = Force.From(1, ForceUnit.Millinewton);
-            AssertEx.EqualTolerance(1, quantity07.Millinewtons, MillinewtonsTolerance);
-            Assert.Equal(ForceUnit.Millinewton, quantity07.Unit);
+            var quantity07 = Force.From(1, ForceUnit.Micronewton);
+            AssertEx.EqualTolerance(1, quantity07.Micronewtons, MicronewtonsTolerance);
+            Assert.Equal(ForceUnit.Micronewton, quantity07.Unit);
 
-            var quantity08 = Force.From(1, ForceUnit.Newton);
-            AssertEx.EqualTolerance(1, quantity08.Newtons, NewtonsTolerance);
-            Assert.Equal(ForceUnit.Newton, quantity08.Unit);
+            var quantity08 = Force.From(1, ForceUnit.Millinewton);
+            AssertEx.EqualTolerance(1, quantity08.Millinewtons, MillinewtonsTolerance);
+            Assert.Equal(ForceUnit.Millinewton, quantity08.Unit);
 
-            var quantity09 = Force.From(1, ForceUnit.OunceForce);
-            AssertEx.EqualTolerance(1, quantity09.OunceForce, OunceForceTolerance);
-            Assert.Equal(ForceUnit.OunceForce, quantity09.Unit);
+            var quantity09 = Force.From(1, ForceUnit.Newton);
+            AssertEx.EqualTolerance(1, quantity09.Newtons, NewtonsTolerance);
+            Assert.Equal(ForceUnit.Newton, quantity09.Unit);
 
-            var quantity10 = Force.From(1, ForceUnit.Poundal);
-            AssertEx.EqualTolerance(1, quantity10.Poundals, PoundalsTolerance);
-            Assert.Equal(ForceUnit.Poundal, quantity10.Unit);
+            var quantity10 = Force.From(1, ForceUnit.OunceForce);
+            AssertEx.EqualTolerance(1, quantity10.OunceForce, OunceForceTolerance);
+            Assert.Equal(ForceUnit.OunceForce, quantity10.Unit);
 
-            var quantity11 = Force.From(1, ForceUnit.PoundForce);
-            AssertEx.EqualTolerance(1, quantity11.PoundsForce, PoundsForceTolerance);
-            Assert.Equal(ForceUnit.PoundForce, quantity11.Unit);
+            var quantity11 = Force.From(1, ForceUnit.Poundal);
+            AssertEx.EqualTolerance(1, quantity11.Poundals, PoundalsTolerance);
+            Assert.Equal(ForceUnit.Poundal, quantity11.Unit);
 
-            var quantity12 = Force.From(1, ForceUnit.TonneForce);
-            AssertEx.EqualTolerance(1, quantity12.TonnesForce, TonnesForceTolerance);
-            Assert.Equal(ForceUnit.TonneForce, quantity12.Unit);
+            var quantity12 = Force.From(1, ForceUnit.PoundForce);
+            AssertEx.EqualTolerance(1, quantity12.PoundsForce, PoundsForceTolerance);
+            Assert.Equal(ForceUnit.PoundForce, quantity12.Unit);
+
+            var quantity13 = Force.From(1, ForceUnit.TonneForce);
+            AssertEx.EqualTolerance(1, quantity13.TonnesForce, TonnesForceTolerance);
+            Assert.Equal(ForceUnit.TonneForce, quantity13.Unit);
 
         }
 
@@ -219,6 +226,7 @@ public void As()
             AssertEx.EqualTolerance(KilogramsForceInOneNewton, newton.As(ForceUnit.KilogramForce), KilogramsForceTolerance);
             AssertEx.EqualTolerance(KilonewtonsInOneNewton, newton.As(ForceUnit.Kilonewton), KilonewtonsTolerance);
             AssertEx.EqualTolerance(KiloPondsInOneNewton, newton.As(ForceUnit.KiloPond), KiloPondsTolerance);
+            AssertEx.EqualTolerance(KilopoundsForceInOneNewton, newton.As(ForceUnit.KilopoundForce), KilopoundsForceTolerance);
             AssertEx.EqualTolerance(MeganewtonsInOneNewton, newton.As(ForceUnit.Meganewton), MeganewtonsTolerance);
             AssertEx.EqualTolerance(MicronewtonsInOneNewton, newton.As(ForceUnit.Micronewton), MicronewtonsTolerance);
             AssertEx.EqualTolerance(MillinewtonsInOneNewton, newton.As(ForceUnit.Millinewton), MillinewtonsTolerance);
@@ -254,6 +262,10 @@ public void ToUnit()
             AssertEx.EqualTolerance(KiloPondsInOneNewton, (double)kilopondQuantity.Value, KiloPondsTolerance);
             Assert.Equal(ForceUnit.KiloPond, kilopondQuantity.Unit);
 
+            var kilopoundforceQuantity = newton.ToUnit(ForceUnit.KilopoundForce);
+            AssertEx.EqualTolerance(KilopoundsForceInOneNewton, (double)kilopoundforceQuantity.Value, KilopoundsForceTolerance);
+            Assert.Equal(ForceUnit.KilopoundForce, kilopoundforceQuantity.Unit);
+
             var meganewtonQuantity = newton.ToUnit(ForceUnit.Meganewton);
             AssertEx.EqualTolerance(MeganewtonsInOneNewton, (double)meganewtonQuantity.Value, MeganewtonsTolerance);
             Assert.Equal(ForceUnit.Meganewton, meganewtonQuantity.Unit);
@@ -296,6 +308,7 @@ public void ConversionRoundTrip()
             AssertEx.EqualTolerance(1, Force.FromKilogramsForce(newton.KilogramsForce).Newtons, KilogramsForceTolerance);
             AssertEx.EqualTolerance(1, Force.FromKilonewtons(newton.Kilonewtons).Newtons, KilonewtonsTolerance);
             AssertEx.EqualTolerance(1, Force.FromKiloPonds(newton.KiloPonds).Newtons, KiloPondsTolerance);
+            AssertEx.EqualTolerance(1, Force.FromKilopoundsForce(newton.KilopoundsForce).Newtons, KilopoundsForceTolerance);
             AssertEx.EqualTolerance(1, Force.FromMeganewtons(newton.Meganewtons).Newtons, MeganewtonsTolerance);
             AssertEx.EqualTolerance(1, Force.FromMicronewtons(newton.Micronewtons).Newtons, MicronewtonsTolerance);
             AssertEx.EqualTolerance(1, Force.FromMillinewtons(newton.Millinewtons).Newtons, MillinewtonsTolerance);
@@ -448,6 +461,7 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
                 Assert.Equal("1 kgf", new Force(1, ForceUnit.KilogramForce).ToString());
                 Assert.Equal("1 kN", new Force(1, ForceUnit.Kilonewton).ToString());
                 Assert.Equal("1 kp", new Force(1, ForceUnit.KiloPond).ToString());
+                Assert.Equal("1 kipf", new Force(1, ForceUnit.KilopoundForce).ToString());
                 Assert.Equal("1 MN", new Force(1, ForceUnit.Meganewton).ToString());
                 Assert.Equal("1 µN", new Force(1, ForceUnit.Micronewton).ToString());
                 Assert.Equal("1 mN", new Force(1, ForceUnit.Millinewton).ToString());
@@ -474,6 +488,7 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 kgf", new Force(1, ForceUnit.KilogramForce).ToString(swedishCulture));
             Assert.Equal("1 kN", new Force(1, ForceUnit.Kilonewton).ToString(swedishCulture));
             Assert.Equal("1 kp", new Force(1, ForceUnit.KiloPond).ToString(swedishCulture));
+            Assert.Equal("1 kipf", new Force(1, ForceUnit.KilopoundForce).ToString(swedishCulture));
             Assert.Equal("1 MN", new Force(1, ForceUnit.Meganewton).ToString(swedishCulture));
             Assert.Equal("1 µN", new Force(1, ForceUnit.Micronewton).ToString(swedishCulture));
             Assert.Equal("1 mN", new Force(1, ForceUnit.Millinewton).ToString(swedishCulture));
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs
index fa1e543a55..e2be885186 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/Force.g.cs
@@ -180,6 +180,11 @@ private Force(double value, ForceUnit unit)
         /// </summary>
         public double KiloPonds => As(ForceUnit.KiloPond);
 
+        /// <summary>
+        ///     Get Force in KilopoundsForce.
+        /// </summary>
+        public double KilopoundsForce => As(ForceUnit.KilopoundForce);
+
         /// <summary>
         ///     Get Force in Meganewtons.
         /// </summary>
@@ -301,6 +306,16 @@ public static Force FromKiloPonds(double kiloponds)
             return new Force(value, ForceUnit.KiloPond);
         }
         /// <summary>
+        ///     Get Force from KilopoundsForce.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static Force FromKilopoundsForce(double kilopoundsforce)
+        {
+            double value = (double) kilopoundsforce;
+            return new Force(value, ForceUnit.KilopoundForce);
+        }
+        /// <summary>
         ///     Get Force from Meganewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -676,6 +691,7 @@ private double AsBaseUnit()
                 case ForceUnit.KilogramForce: return _value*9.80665002864;
                 case ForceUnit.Kilonewton: return (_value) * 1e3d;
                 case ForceUnit.KiloPond: return _value*9.80665002864;
+                case ForceUnit.KilopoundForce: return _value*4448.2216152605095551842641431421;
                 case ForceUnit.Meganewton: return (_value) * 1e6d;
                 case ForceUnit.Micronewton: return (_value) * 1e-6d;
                 case ForceUnit.Millinewton: return (_value) * 1e-3d;
@@ -703,6 +719,7 @@ private double AsBaseNumericType(ForceUnit unit)
                 case ForceUnit.KilogramForce: return baseUnitValue/9.80665002864;
                 case ForceUnit.Kilonewton: return (baseUnitValue) / 1e3d;
                 case ForceUnit.KiloPond: return baseUnitValue/9.80665002864;
+                case ForceUnit.KilopoundForce: return baseUnitValue/4448.2216152605095551842641431421;
                 case ForceUnit.Meganewton: return (baseUnitValue) / 1e6d;
                 case ForceUnit.Micronewton: return (baseUnitValue) / 1e-6d;
                 case ForceUnit.Millinewton: return (baseUnitValue) / 1e-3d;
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
index c69a6aad28..b55767980a 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -366,6 +366,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("ru-RU", typeof(ForceUnit), (int)ForceUnit.Kilonewton, new string[]{"кН"}),
                 ("en-US", typeof(ForceUnit), (int)ForceUnit.KiloPond, new string[]{"kp"}),
                 ("ru-RU", typeof(ForceUnit), (int)ForceUnit.KiloPond, new string[]{"кгс"}),
+                ("en-US", typeof(ForceUnit), (int)ForceUnit.KilopoundForce, new string[]{"kipf"}),
+                ("ru-RU", typeof(ForceUnit), (int)ForceUnit.KilopoundForce, new string[]{"кипф"}),
                 ("en-US", typeof(ForceUnit), (int)ForceUnit.Meganewton, new string[]{"MN"}),
                 ("ru-RU", typeof(ForceUnit), (int)ForceUnit.Meganewton, new string[]{"МН"}),
                 ("en-US", typeof(ForceUnit), (int)ForceUnit.Micronewton, new string[]{"µN"}),
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceUnit.g.cs
index 2e131dcb60..4658e160bf 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceUnit.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/ForceUnit.g.cs
@@ -31,6 +31,7 @@ public enum ForceUnit
         KilogramForce,
         Kilonewton,
         KiloPond,
+        KilopoundForce,
         Meganewton,
         Micronewton,
         Millinewton,
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index b3b6a0bd3d..98be579b24 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -55,6 +55,7 @@ static Force()
                     new UnitInfo<ForceUnit>(ForceUnit.KilogramForce, BaseUnits.Undefined),
                     new UnitInfo<ForceUnit>(ForceUnit.Kilonewton, BaseUnits.Undefined),
                     new UnitInfo<ForceUnit>(ForceUnit.KiloPond, BaseUnits.Undefined),
+                    new UnitInfo<ForceUnit>(ForceUnit.KilopoundForce, BaseUnits.Undefined),
                     new UnitInfo<ForceUnit>(ForceUnit.Meganewton, BaseUnits.Undefined),
                     new UnitInfo<ForceUnit>(ForceUnit.Micronewton, BaseUnits.Undefined),
                     new UnitInfo<ForceUnit>(ForceUnit.Millinewton, BaseUnits.Undefined),
@@ -200,6 +201,11 @@ public Force(double value, UnitSystem unitSystem)
         /// </summary>
         public double KiloPonds => As(ForceUnit.KiloPond);
 
+        /// <summary>
+        ///     Get Force in KilopoundsForce.
+        /// </summary>
+        public double KilopoundsForce => As(ForceUnit.KilopoundForce);
+
         /// <summary>
         ///     Get Force in Meganewtons.
         /// </summary>
@@ -315,6 +321,15 @@ public static Force FromKiloPonds(QuantityValue kiloponds)
             return new Force(value, ForceUnit.KiloPond);
         }
         /// <summary>
+        ///     Get Force from KilopoundsForce.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static Force FromKilopoundsForce(QuantityValue kilopoundsforce)
+        {
+            double value = (double) kilopoundsforce;
+            return new Force(value, ForceUnit.KilopoundForce);
+        }
+        /// <summary>
         ///     Get Force from Meganewtons.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -820,6 +835,7 @@ private double GetValueInBaseUnit()
                 case ForceUnit.KilogramForce: return _value*9.80665002864;
                 case ForceUnit.Kilonewton: return (_value) * 1e3d;
                 case ForceUnit.KiloPond: return _value*9.80665002864;
+                case ForceUnit.KilopoundForce: return _value*4448.2216152605095551842641431421;
                 case ForceUnit.Meganewton: return (_value) * 1e6d;
                 case ForceUnit.Micronewton: return (_value) * 1e-6d;
                 case ForceUnit.Millinewton: return (_value) * 1e-3d;
@@ -858,6 +874,7 @@ private double GetValueAs(ForceUnit unit)
                 case ForceUnit.KilogramForce: return baseUnitValue/9.80665002864;
                 case ForceUnit.Kilonewton: return (baseUnitValue) / 1e3d;
                 case ForceUnit.KiloPond: return baseUnitValue/9.80665002864;
+                case ForceUnit.KilopoundForce: return baseUnitValue/4448.2216152605095551842641431421;
                 case ForceUnit.Meganewton: return (baseUnitValue) / 1e6d;
                 case ForceUnit.Micronewton: return (baseUnitValue) / 1e-6d;
                 case ForceUnit.Millinewton: return (baseUnitValue) / 1e-3d;
diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
index efb2b4eba8..d6e63ea444 100644
--- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -366,6 +366,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("ru-RU", typeof(ForceUnit), (int)ForceUnit.Kilonewton, new string[]{"кН"}),
                 ("en-US", typeof(ForceUnit), (int)ForceUnit.KiloPond, new string[]{"kp"}),
                 ("ru-RU", typeof(ForceUnit), (int)ForceUnit.KiloPond, new string[]{"кгс"}),
+                ("en-US", typeof(ForceUnit), (int)ForceUnit.KilopoundForce, new string[]{"kipf"}),
+                ("ru-RU", typeof(ForceUnit), (int)ForceUnit.KilopoundForce, new string[]{"кипф"}),
                 ("en-US", typeof(ForceUnit), (int)ForceUnit.Meganewton, new string[]{"MN"}),
                 ("ru-RU", typeof(ForceUnit), (int)ForceUnit.Meganewton, new string[]{"МН"}),
                 ("en-US", typeof(ForceUnit), (int)ForceUnit.Micronewton, new string[]{"µN"}),
diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs
index 217f59c0f4..c82b3feaa3 100644
--- a/UnitsNet/GeneratedCode/UnitConverter.g.cs
+++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs
@@ -558,6 +558,8 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter)
             unitConverter.SetConversionFunction<Force>(ForceUnit.Kilonewton, Force.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.KiloPond, q => q.ToUnit(ForceUnit.KiloPond));
             unitConverter.SetConversionFunction<Force>(ForceUnit.KiloPond, Force.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.KilopoundForce, q => q.ToUnit(ForceUnit.KilopoundForce));
+            unitConverter.SetConversionFunction<Force>(ForceUnit.KilopoundForce, Force.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Meganewton, q => q.ToUnit(ForceUnit.Meganewton));
             unitConverter.SetConversionFunction<Force>(ForceUnit.Meganewton, Force.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<Force>(Force.BaseUnit, ForceUnit.Micronewton, q => q.ToUnit(ForceUnit.Micronewton));
diff --git a/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs b/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs
index 2e131dcb60..4658e160bf 100644
--- a/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/ForceUnit.g.cs
@@ -31,6 +31,7 @@ public enum ForceUnit
         KilogramForce,
         Kilonewton,
         KiloPond,
+        KilopoundForce,
         Meganewton,
         Micronewton,
         Millinewton,