diff --git a/README.md b/README.md
index 023c94f529..ce1fa30a32 100644
--- a/README.md
+++ b/README.md
@@ -1,126 +1,126 @@
-Units.NET
-========
-
-Data structures and methods in C# .NET that make life working with units just a little bit better.
-
-Everyone have written their share of trivial conversions between meters and centimeters, or less obvious conversions to units like Pascal and PSI where most mortals need a quick Google to find that magic constant.
-
-Stop littering your code with unnecessary calculations. Units.NET gives you all the common units and conversions. It is light-weight, unit tested and supports [PCL](http://msdn.microsoft.com/en-us/library/gg597391.aspx "MSDN PCL").
-
-
-Install
-=======
-To install Units.NET, run the following command in the [Package Manager Console](http://docs.nuget.org/docs/start-here/using-the-package-manager-console) or go to the [NuGet site](https://www.nuget.org/packages/UnitsNet/ "NuGet site").
-
-![Install-Package UnitsNet](Docs/Images/install_package_unitsnet.png "Install-Package UnitsNet")
-
-Build Targets:
-* .NET 3.5 Client
-* Silverlight 4
-* WinRT / .NET Core 4.5
-* Portable Class Library (.NET 4.0 + Silverlight 4 + Windows Phone 7 + Xbox 360)
-
-Features
-========
-
-* Immutable structs for units of measurement, such as Length, Mass, Force and Pressure. See full list [here](https://github.com/InitialForce/UnitsNet/blob/master/Src/UnitsNet/ "Data structures").
-* Convert between most popular units in the metric and imperial systems. See full list [here](https://github.com/InitialForce/UnitsNet/blob/master/Src/UnitsNet/Unit.cs "Unit.cs").
-* Choose between static (struct) or dynamic (UnitValue) representations for units of measurement.
-* Parse abbreviations to unit.
-* Get abbreviations for units in different cultures.
-
-Static Representation and Explicit Conversion
------------------------------------------------
-```C#
-// Stop postfixing your variables and method names with the unit...
-double weightKg = GetPersonWeightInKg();
-double weightGrams = weightKg * 1000;
-double weightTonnes = weightKg / 1000;
-
-// ...and start using a static representation for the measurement then 
-// explicitly convert to the unit of choice - when you need it.
-Mass weight = GetPersonWeight();
-double weightGrams = weight.Grams;
-double weightTonnes = weight.Tonnes;
-
-// Convert between compatible units of measurement...
-Force scaleMeasurement = Force.FromNewtons(850);
-Mass personWeight = Mass.FromGravitationalForce(scaleMeasurement);
-double weightKg = personWeight.Kilograms;
-
-// ...while avoiding confusing conversions, such as between weight and mass.
-Mass weight = GetPersonWeight();
-double weightNewtons = weight.Newtons; // No such thing.
-
-// Some popular conversions.
-Length meter = Length.FromMeters(1);
-double cm = meter.Centimeters; // 100
-double yards = meter.Yards; // 1.09361
-double feet = meter.Feet; // 3.28084
-double inches = meter.Inches; // 39.3701
-
-Pressure p = Pressure.FromPascal(1);
-double kpa = p.KiloPascals; // 1000
-double bar = p.Bars; // 1 × 10-5
-double atm = p.Atmosphere; // 9.86923267 × 10-6
-double psi = p.Psi; // 1.45037738 × 10-4
-```
-
-Dynamic Representation and Conversion
-------------------
-```C#
-// Explicitly
-double m = UnitConverter.Convert(1, Unit.Kilometer, Unit.Meter); // 1000
-double mi = UnitConverter.Convert(1, Unit.Kilometer, Unit.Mile); // 0.621371
-double yds = UnitConverter.Convert(1, Unit.Meter, Unit.Yard); // 1.09361
-
-// Or dynamically.
-UnitValue val = GetUnknownValueAndUnit();
-
-// Returns false if conversion was not possible.
-double cm;
-val.TryConvert(LengthUnit.Centimeter, out cm);
-```
-
-Helper Methods to Construct Measurements
-----------------------------------------
-```C#
-var f = Force.FromPressureByArea(Pressure p, Length2d area);
-var f = Force.FromMassAcceleration(Mass mass, double metersPerSecondSquared);
-```
-
-Parse and Get Culture-Specific Abbreviations
--------------------------------------------------
-```C#
-  var us = new CultureInfo("en-US");
-  var norwegian = new CultureInfo("nb-NO");
-  
-  Unit.Tablespoon == UnitSystem.Create(us).Parse("tbsp")
-  Unit.Tablespoon == UnitSystem.Create(norwegian).Parse("ss")  
-
-  "T" == UnitSystem.GetDefaultAbbreviation(Unit.Tablespoon, us)
-  "ss" == UnitSystem.GetDefaultAbbreviation(Unit.Tablespoon, norwegian)
-```
-
-What It Is Not
-==============
-
-* It is not an equation solver. 
-* It does not figure out the units after a calculation.
-
-Work In Progress
-================
-This project is still early and many units and conversions are not yet covered. If you are missing something, please help by contributing.
-
-* Add more units.
-* Not all conversions are unit tested yet.
-* Parsing and getting textual representations not complete.
-* Document all the data structures, units and conversions.
-
-Want To Contribute?
-===================
-Please read the wiki on [Adding a New Unit](https://github.com/InitialForce/UnitsNet/wiki/Adding-a-New-Unit).<br>
-For other things to do, see Work In Progress.
-
-
-[Contact me](https://github.com/anjdreas) if you have any questions.
+Units.NET
+========
+
+Data structures and methods in C# .NET that make life working with units just a little bit better.
+
+Everyone have written their share of trivial conversions between meters and centimeters, or less obvious conversions to units like Pascal and PSI where most mortals need a quick Google to find that magic constant.
+
+Stop littering your code with unnecessary calculations. Units.NET gives you all the common units and conversions. It is light-weight, unit tested and supports [PCL](http://msdn.microsoft.com/en-us/library/gg597391.aspx "MSDN PCL").
+
+
+Install
+=======
+To install Units.NET, run the following command in the [Package Manager Console](http://docs.nuget.org/docs/start-here/using-the-package-manager-console) or go to the [NuGet site](https://www.nuget.org/packages/UnitsNet/ "NuGet site").
+
+![Install-Package UnitsNet](Docs/Images/install_package_unitsnet.png "Install-Package UnitsNet")
+
+Build Targets:
+* .NET 3.5 Client
+* Silverlight 4
+* WinRT / .NET Core 4.5
+* Portable Class Library (.NET 4.0 + Silverlight 4 + Windows Phone 7 + Xbox 360)
+
+Features
+========
+
+* Immutable structs for units of measurement, such as Length, Mass, Force and Pressure. See full list [here](https://github.com/InitialForce/UnitsNet/blob/master/Src/UnitsNet/ "Data structures").
+* Convert between most popular units in the metric and imperial systems. See full list [here](https://github.com/InitialForce/UnitsNet/blob/master/Src/UnitsNet/Unit.cs "Unit.cs").
+* Choose between static (struct) or dynamic (UnitValue) representations for units of measurement.
+* Parse abbreviations to unit.
+* Get abbreviations for units in different cultures.
+
+Static Representation and Explicit Conversion
+-----------------------------------------------
+```C#
+// Stop postfixing your variables and method names with the unit...
+double weightKg = GetPersonWeightInKg();
+double weightGrams = weightKg * 1000;
+double weightTonnes = weightKg / 1000;
+
+// ...and start using a static representation for the measurement then 
+// explicitly convert to the unit of choice - when you need it.
+Mass weight = GetPersonWeight();
+double weightGrams = weight.Grams;
+double weightTonnes = weight.Tonnes;
+
+// Convert between compatible units of measurement...
+Force scaleMeasurement = Force.FromNewtons(850);
+Mass personWeight = Mass.FromGravitationalForce(scaleMeasurement);
+double weightKg = personWeight.Kilograms;
+
+// ...while avoiding confusing conversions, such as between weight and mass.
+Mass weight = GetPersonWeight();
+double weightNewtons = weight.Newtons; // No such thing.
+
+// Some popular conversions.
+Length meter = Length.FromMeters(1);
+double cm = meter.Centimeters; // 100
+double yards = meter.Yards; // 1.09361
+double feet = meter.Feet; // 3.28084
+double inches = meter.Inches; // 39.3701
+
+Pressure p = Pressure.FromPascal(1);
+double kpa = p.KiloPascals; // 1000
+double bar = p.Bars; // 1 × 10-5
+double atm = p.Atmosphere; // 9.86923267 × 10-6
+double psi = p.Psi; // 1.45037738 × 10-4
+```
+
+Dynamic Representation and Conversion
+------------------
+```C#
+// Explicitly
+double m = UnitConverter.Convert(1, Unit.Kilometer, Unit.Meter); // 1000
+double mi = UnitConverter.Convert(1, Unit.Kilometer, Unit.Mile); // 0.621371
+double yds = UnitConverter.Convert(1, Unit.Meter, Unit.Yard); // 1.09361
+
+// Or dynamically.
+UnitValue val = GetUnknownValueAndUnit();
+
+// Returns false if conversion was not possible.
+double cm;
+val.TryConvert(LengthUnit.Centimeter, out cm);
+```
+
+Helper Methods to Construct Measurements
+----------------------------------------
+```C#
+var f = Force.FromPressureByArea(Pressure p, Length2d area);
+var f = Force.FromMassAcceleration(Mass mass, double metersPerSecondSquared);
+```
+
+Parse and Get Culture-Specific Abbreviations
+-------------------------------------------------
+```C#
+  var us = new CultureInfo("en-US");
+  var norwegian = new CultureInfo("nb-NO");
+  
+  Unit.Tablespoon == UnitSystem.Create(us).Parse("tbsp")
+  Unit.Tablespoon == UnitSystem.Create(norwegian).Parse("ss")  
+
+  "T" == UnitSystem.GetDefaultAbbreviation(Unit.Tablespoon, us)
+  "ss" == UnitSystem.GetDefaultAbbreviation(Unit.Tablespoon, norwegian)
+```
+
+What It Is Not
+==============
+
+* It is not an equation solver. 
+* It does not figure out the units after a calculation.
+
+Work In Progress
+================
+This project is still early and many units and conversions are not yet covered. If you are missing something, please help by contributing.
+
+* Add more units.
+* Not all conversions are unit tested yet.
+* Parsing and getting textual representations not complete.
+* Document all the data structures, units and conversions.
+
+Want To Contribute?
+===================
+Please read the wiki on [Adding a New Unit](https://github.com/InitialForce/UnitsNet/wiki/Adding-a-New-Unit).<br>
+For other things to do, see Work In Progress.
+
+
+[Contact me](https://github.com/anjdreas) if you have any questions.
diff --git a/Src/UnitsNet/Unit.cs b/Src/UnitsNet/Unit.cs
index ea86a363ee..53b3a018a4 100644
--- a/Src/UnitsNet/Unit.cs
+++ b/Src/UnitsNet/Unit.cs
@@ -90,10 +90,12 @@ public enum Unit
         Poundal,
 
         // Volume
+        CubicKilometer,
         CubicMeter,
         CubicDecimeter,
         CubicCentimeter,
-        CubicMillimeter,
+        CubicMilimeter,
+        Hectoliter,
         Liter,
         Deciliter,
         Centiliter,
diff --git a/Src/UnitsNet/UnitConverter.cs b/Src/UnitsNet/UnitConverter.cs
index 5b8e7fa8f3..981b9ad233 100644
--- a/Src/UnitsNet/UnitConverter.cs
+++ b/Src/UnitsNet/UnitConverter.cs
@@ -43,6 +43,7 @@ public static double Convert(double value, Unit fromUnit, Unit toUnit)
 
             double newValue;
             if (TryConvertLength(value, fromUnit, toUnit, out newValue)) return newValue;
+            if (TryConvertVolume(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertMass(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertPressure(value, fromUnit, toUnit, out newValue)) return newValue;
             if (TryConvertForce(value, fromUnit, toUnit, out newValue)) return newValue;
@@ -72,6 +73,7 @@ public static bool TryConvert(double value, Unit fromUnit, Unit toUnit, out doub
             }
 
             if (TryConvertLength(value, fromUnit, toUnit, out newValue)) return true;
+            if (TryConvertVolume(value, fromUnit, toUnit, out newValue)) return true;
             if (TryConvertMass(value, fromUnit, toUnit, out newValue)) return true;
             if (TryConvertPressure(value, fromUnit, toUnit, out newValue)) return true;
             if (TryConvertForce(value, fromUnit, toUnit, out newValue)) return true;
@@ -211,6 +213,37 @@ private static bool TryConvertLength(double value, Unit fromUnit, Unit toUnit, o
             }
         }
 
+        private static bool TryConvertVolume(double value, Unit fromUnit, Unit toUnit, out double newValue)
+        {
+            switch (fromUnit)
+            {
+                case Unit.CubicKilometer:
+                    return TryConvert(Volume.FromCubicKilometers(value), toUnit, out newValue);
+                case Unit.CubicMeter:
+                    return TryConvert(Volume.FromCubicMeters(value), toUnit, out newValue);
+                case Unit.CubicDecimeter:
+                    return TryConvert(Volume.FromCubicDecimeters(value), toUnit, out newValue);
+                case Unit.CubicCentimeter:
+                    return TryConvert(Volume.FromCubicCentimeters(value), toUnit, out newValue);
+                case Unit.CubicMilimeter:
+                    return TryConvert(Volume.FromCubicMilimeters(value), toUnit, out newValue);
+                case Unit.Hectoliter:
+                    return TryConvert(Volume.FromHectoliters(value), toUnit, out newValue);
+                case Unit.Liter:
+                    return TryConvert(Volume.FromLiters(value), toUnit, out newValue);
+                case Unit.Deciliter:
+                    return TryConvert(Volume.FromDeciliters(value), toUnit, out newValue);
+                case Unit.Centiliter:
+                    return TryConvert(Volume.FromCentiliters(value), toUnit, out newValue);
+                case Unit.Milliliter:
+                    return TryConvert(Volume.FromMililiters(value), toUnit, out newValue);
+
+                default:
+                    newValue = 0;
+                    return false;
+            }
+        }
+
         private static bool TryConvertMass(double value, Unit fromUnit, Unit toUnit, out double newValue)
         {
             switch (fromUnit)
@@ -293,6 +326,48 @@ public static bool TryConvert(Length l, Unit toUnit, out double newValue)
             }
         }
 
+        public static bool TryConvert(Volume volume, Unit toUnit, out double newValue)
+        {
+            switch (toUnit)
+            {
+                case Unit.CubicKilometer:
+                    newValue = volume.CubicKilometers;
+                    return true;
+                case Unit.CubicMeter:
+                    newValue = volume.CubicMeters;
+                    return true;
+                case Unit.CubicDecimeter:
+                    newValue = volume.CubicDecimeters;
+                    return true;
+                case Unit.CubicCentimeter:
+                    newValue = volume.CubicCentimeters;
+                    return true;
+                case Unit.CubicMilimeter:
+                    newValue = volume.CubicMilimeters;
+                    return true;
+                case Unit.Hectoliter:
+                    newValue = volume.Hectoliters;
+                    return true;
+                case Unit.Liter:
+                    newValue = volume.Liters;
+                    return true;
+                case Unit.Deciliter:
+                    newValue = volume.Deciliters;
+                    return true;
+                case Unit.Centiliter:
+                    newValue = volume.Centiliters;
+                    return true;
+                case Unit.Milliliter:
+                    newValue = volume.Mililiters;
+                    return true;
+
+                default:
+                    throw new Exception(
+                        string.Format(
+                            "Conversion from volume to unit [{0}] is either not valid or not yet implemented.", toUnit));
+            }
+        }
+
         public static bool TryConvert(Mass m, Unit toUnit, out double newValue)
         {
             switch (toUnit)
@@ -420,28 +495,6 @@ public static bool TryConvert(Force f, Unit toUnit, out double newValue)
             }
         }
 
-        // public static double TryConvert(Volume v, Unit toUnit)
-        // {
-        //     switch (toUnit)
-        //     {
-        //case Unit.CubicMeter:
-        //             retunr
-        //case Unit.CubicDecimeter:
-        //case Unit.CubicCentimeter:
-        //case Unit.CubicMillimeter:
-        //case Unit.Liter:
-        //case Unit.Deciliter:
-        //case Unit.Centiliter:
-        //case Unit.Milliliter:
-        ////case Unit.Gallon:
-
-        //         default:
-        //             throw new Exception(
-        //                 string.Format(
-        //                     "Conversion from volume to unit [{0}] is either not valid or not yet implemented.", toUnit));
-        //     }
-        // }
-
         public static bool TryConvert(Torque t, Unit toUnit, out double newValue)
         {
             switch (toUnit)
diff --git a/Src/UnitsNet/UnitsNet.net35.csproj b/Src/UnitsNet/UnitsNet.net35.csproj
index fdd3a10dc1..c4a453c705 100644
--- a/Src/UnitsNet/UnitsNet.net35.csproj
+++ b/Src/UnitsNet/UnitsNet.net35.csproj
@@ -53,6 +53,7 @@
     <Compile Include="Torque.cs" />
     <Compile Include="Vector2.cs" />
     <Compile Include="Vector3.cs" />
+    <Compile Include="Volume.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Src/UnitsNet/UnitsNet.pcl.csproj b/Src/UnitsNet/UnitsNet.pcl.csproj
index 6fb9ea4961..373302677d 100644
--- a/Src/UnitsNet/UnitsNet.pcl.csproj
+++ b/Src/UnitsNet/UnitsNet.pcl.csproj
@@ -51,6 +51,7 @@
     <Compile Include="UnitValue.cs" />
     <Compile Include="Vector2.cs" />
     <Compile Include="Vector3.cs" />
+    <Compile Include="Volume.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Src/UnitsNet/UnitsNet.sl4.csproj b/Src/UnitsNet/UnitsNet.sl4.csproj
index cda6f6f988..c94503f0db 100644
--- a/Src/UnitsNet/UnitsNet.sl4.csproj
+++ b/Src/UnitsNet/UnitsNet.sl4.csproj
@@ -72,6 +72,7 @@
     <Compile Include="UnitValue.cs" />
     <Compile Include="Vector2.cs" />
     <Compile Include="Vector3.cs" />
+    <Compile Include="Volume.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Silverlight\$(SilverlightVersion)\Microsoft.Silverlight.CSharp.targets" />
   <ProjectExtensions>
diff --git a/Src/UnitsNet/Volume.cs b/Src/UnitsNet/Volume.cs
new file mode 100644
index 0000000000..345abcb924
--- /dev/null
+++ b/Src/UnitsNet/Volume.cs
@@ -0,0 +1,265 @@
+// Copyright © 2007 by Initial Force AS.  All rights reserved.
+// https://github.com/InitialForce/SIUnits
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+
+namespace UnitsNet
+{
+    /// <summary>
+    ///     A class for representing units of volume.
+    /// </summary>
+    public struct Volume : IComparable, IComparable<Volume>
+    {
+        private const double CubicKilometersToCubicMetersRatio = 1E9;
+        private const double CubicDecimetersToCubicMetersRatio = 1E-3; 
+        private const double CubicCentimetersToCubicMetersRatio = 1E-6;
+        private const double CubicMilimetersToCubicMetersRatio = 1E-9; 
+        private const double HectolitersToCubicMetersRatio = 1E-1; 
+        private const double LitersToCubicMetersRatio = 1E-3; 
+        private const double DecilitersToCubicMetersRatio = 1E-4; 
+        private const double CentilitersToCubicMetersRatio = 1E-5;
+        private const double MililitersToCubicMetersRatio = 1E-6;
+
+        public readonly double CubicMeters;
+
+        /// <summary>
+        ///     Enforce static methods for creation.
+        /// </summary>
+        private Volume(double cubicMeters)
+            : this()
+        {
+            CubicMeters = cubicMeters;
+        }
+
+        #region Unit Properties
+
+        public double CubicKilometers
+        {
+            get { return CubicMeters / CubicKilometersToCubicMetersRatio; }
+        }
+
+        public double CubicDecimeters
+        {
+            get { return CubicMeters / CubicDecimetersToCubicMetersRatio; }
+        }
+
+        public double CubicCentimeters
+        {
+            get { return CubicMeters / CubicCentimetersToCubicMetersRatio; }
+        }
+
+        public double CubicMilimeters
+        {
+            get { return CubicMeters / CubicMilimetersToCubicMetersRatio; }
+        }
+
+        public double Hectoliters
+        {
+            get { return CubicMeters / HectolitersToCubicMetersRatio; }
+        }
+
+        public double Liters
+        {
+            get { return CubicMeters / LitersToCubicMetersRatio; }
+        }
+
+        public double Deciliters
+        {
+            get { return CubicMeters / DecilitersToCubicMetersRatio; }
+        }
+
+        public double Centiliters
+        {
+            get { return CubicMeters / CentilitersToCubicMetersRatio; }
+        }
+
+        public double Mililiters
+        {
+            get { return CubicMeters / MililitersToCubicMetersRatio; }
+        }
+
+        #endregion
+
+        #region Static
+
+        /// <summary>
+        ///     The maximum representable volume in cubic meters.
+        /// </summary>
+        public static Volume Max
+        {
+            get { return new Volume(double.MaxValue); }
+        }
+
+        /// <summary>
+        ///     The smallest representable volume in cubic meters.
+        /// </summary>
+        public static Volume Min
+        {
+            get { return new Volume(double.MinValue); }
+        }
+
+        public static Volume Zero
+        {
+            get { return new Volume(); }
+        }
+
+        public static Volume FromCubicKilometers(double cubicKilometers)
+        {
+            return new Volume(cubicKilometers * CubicKilometersToCubicMetersRatio);
+        }
+
+        public static Volume FromCubicMeters(double cubicMeters)
+        {
+            return new Volume(cubicMeters);
+        }
+
+        public static Volume FromCubicDecimeters(double cubicDecimeters)
+        {
+            return new Volume(cubicDecimeters * CubicDecimetersToCubicMetersRatio);
+        }
+
+        public static Volume FromCubicCentimeters(double cubicCentimeters)
+        {
+            return new Volume(cubicCentimeters * CubicCentimetersToCubicMetersRatio);
+        }
+
+        public static Volume FromCubicMilimeters(double cubicMilimeters)
+        {
+            return new Volume(cubicMilimeters * CubicMilimetersToCubicMetersRatio);
+        }
+
+        public static Volume FromHectoliters(double hectoliters)
+        {
+            return new Volume(hectoliters * HectolitersToCubicMetersRatio);
+        }
+
+        public static Volume FromLiters(double liters)
+        {
+            return new Volume(liters * LitersToCubicMetersRatio);
+        }
+
+        public static Volume FromDeciliters(double deciliters)
+        {
+            return new Volume(deciliters * DecilitersToCubicMetersRatio);
+        }
+
+        public static Volume FromCentiliters(double centiliters)
+        {
+            return new Volume(centiliters * CentilitersToCubicMetersRatio);
+        }
+
+        public static Volume FromMililiters(double mililiters)
+        {
+            return new Volume(mililiters * MililitersToCubicMetersRatio);
+        }
+
+        #endregion
+
+        #region Arithmetic operators
+
+        public static Volume operator -(Volume right)
+        {
+            return FromCubicMeters(-right.CubicMeters);
+        }
+
+        public static Volume operator -(Volume left, Volume right)
+        {
+            return FromCubicMeters(left.CubicMeters - right.CubicMeters);
+        }
+
+        public static Volume operator +(Volume left, Volume right)
+        {
+            return FromCubicMeters(left.CubicMeters + right.CubicMeters);
+        }
+
+        #endregion
+
+        #region Comparable operators
+
+        public static bool operator <=(Volume left, Volume right)
+        {
+            return left.CubicMeters <= right.CubicMeters;
+        }
+
+        public static bool operator >=(Volume left, Volume right)
+        {
+            return left.CubicMeters >= right.CubicMeters;
+        }
+
+        public static bool operator <(Volume left, Volume right)
+        {
+            return left.CubicMeters < right.CubicMeters;
+        }
+
+        public static bool operator >(Volume left, Volume right)
+        {
+            return left.CubicMeters > right.CubicMeters;
+        }
+
+        public static bool operator ==(Volume left, Volume right)
+        {
+            return left.CubicMeters == right.CubicMeters;
+        }
+
+        public static bool operator !=(Volume left, Volume right)
+        {
+            return !(left.CubicMeters == right.CubicMeters);
+        }
+
+        #endregion
+
+        #region Equality / IComparable
+
+        public int CompareTo(object obj)
+        {
+            if (obj == null) throw new ArgumentNullException("obj");
+            if (!(obj is Volume)) throw new ArgumentException("Expected type Volume.", "obj");
+            return CompareTo((Volume)obj);
+        }
+
+        public int CompareTo(Volume other)
+        {
+            return CubicMeters.CompareTo(other.CubicMeters);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || !(obj is Volume))
+            {
+                return false;
+            }
+
+            return CubicMeters.CompareTo(((Volume)obj).CubicMeters) == 0;
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        #endregion
+
+        public override string ToString()
+        {
+            return CubicMeters + " m3";
+        }
+    }
+}
diff --git a/Tests/UnitConverterTests.cs b/Tests/UnitConverterTests.cs
index 20656ba0fe..0730fabb1e 100644
--- a/Tests/UnitConverterTests.cs
+++ b/Tests/UnitConverterTests.cs
@@ -8,7 +8,7 @@ public class UnitConverterTests
     {
         private const double Delta = 1E-5;
 
-        // TODO Test Force, Length2d, Mass, Pressure and Volume units.
+        // TODO Test Force, Length2d, Mass, Pressure units.
 
         [Test]
         public void MeterToLengthUnits()
@@ -28,6 +28,21 @@ public void MeterToLengthUnits()
         }
 
         [Test]
+        public void CubicMeterToVolumeUnits()
+        {
+            Assert.AreEqual(1E-9, UnitConverter.Convert(1, Unit.CubicMeter, Unit.CubicKilometer), Delta);
+            Assert.AreEqual(1E0, UnitConverter.Convert(1, Unit.CubicMeter, Unit.CubicMeter), Delta);
+            Assert.AreEqual(1E3, UnitConverter.Convert(1, Unit.CubicMeter, Unit.CubicDecimeter), Delta);
+            Assert.AreEqual(1E6, UnitConverter.Convert(1, Unit.CubicMeter, Unit.CubicCentimeter), Delta);
+            Assert.AreEqual(1E9, UnitConverter.Convert(1, Unit.CubicMeter, Unit.CubicMilimeter), Delta);
+            Assert.AreEqual(1E1, UnitConverter.Convert(1, Unit.CubicMeter, Unit.Hectoliter), Delta);
+            Assert.AreEqual(1E3, UnitConverter.Convert(1, Unit.CubicMeter, Unit.Liter), Delta);
+            Assert.AreEqual(1E4, UnitConverter.Convert(1, Unit.CubicMeter, Unit.Deciliter), Delta);
+            Assert.AreEqual(1E5, UnitConverter.Convert(1, Unit.CubicMeter, Unit.Centiliter), Delta);
+            Assert.AreEqual(1E6, UnitConverter.Convert(1, Unit.CubicMeter, Unit.Milliliter), Delta);
+        }
+
+        [Test]
         public void ThrowsOnIncompatibleUnits()
         {
             Assert.Throws<Exception>(() => UnitConverter.Convert(1, Unit.Meter, Unit.Second));
diff --git a/Tests/UnitValueTests.cs b/Tests/UnitValueTests.cs
index 0b9345d02f..8929573726 100644
--- a/Tests/UnitValueTests.cs
+++ b/Tests/UnitValueTests.cs
@@ -1,21 +1,21 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using NUnit.Framework;
-
-namespace UnitsNet.Tests.net35
-{
-    [TestFixture]
-    public class UnitValueTests
-    {
-        [Test]
-        public void TryConvertReturnsFalseOnIncompatibleUnits()
-        {
-            var val = new UnitValue(1, Unit.Meter);
-            double newValue;
-            Assert.False(val.TryConvert(Unit.Second, out newValue));
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace UnitsNet.Tests.net35
+{
+    [TestFixture]
+    public class UnitValueTests
+    {
+        [Test]
+        public void TryConvertReturnsFalseOnIncompatibleUnits()
+        {
+            var val = new UnitValue(1, Unit.Meter);
+            double newValue;
+            Assert.False(val.TryConvert(Unit.Second, out newValue));
+        }
+    }
+}
diff --git a/Tests/UnitsNet.Tests.net35.csproj b/Tests/UnitsNet.Tests.net35.csproj
index d45e775fd7..3290346114 100644
--- a/Tests/UnitsNet.Tests.net35.csproj
+++ b/Tests/UnitsNet.Tests.net35.csproj
@@ -44,6 +44,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="VolumeTests.cs" />
     <Compile Include="Length2dTests.cs" />
     <Compile Include="LengthTests.cs" />
     <Compile Include="ForceTests.cs" />
diff --git a/Tests/VolumeTests.cs b/Tests/VolumeTests.cs
new file mode 100644
index 0000000000..aed225b0ea
--- /dev/null
+++ b/Tests/VolumeTests.cs
@@ -0,0 +1,128 @@
+using System;
+using NUnit.Framework;
+
+namespace UnitsNet.Tests.net35
+{
+    [TestFixture]
+    public class VolumeTests
+    {
+        private const double Delta = 1E-5;
+        private Volume cubicMeter;
+        private Volume liter;
+        private Volume otherLiter;
+
+        [SetUp]
+        public void Setup()
+        {
+            cubicMeter = Volume.FromCubicMeters(1);
+            liter = Volume.FromLiters(1);
+            otherLiter = Volume.FromLiters(1);
+        }
+
+        [Test]
+        public void CubicMetersToVolumeUnits()
+        {
+            Assert.AreEqual(1E-9, cubicMeter.CubicKilometers, Delta);
+            Assert.AreEqual(1, cubicMeter.CubicMeters, Delta);
+            Assert.AreEqual(1E3, cubicMeter.CubicDecimeters, Delta);
+            Assert.AreEqual(1E6, cubicMeter.CubicCentimeters, Delta);
+            Assert.AreEqual(1E9, cubicMeter.CubicMilimeters, Delta);
+
+            Assert.AreEqual(1E1, cubicMeter.Hectoliters, Delta);
+            Assert.AreEqual(1E3, cubicMeter.Liters, Delta);
+            Assert.AreEqual(1E4, cubicMeter.Deciliters, Delta);
+            Assert.AreEqual(1E5, cubicMeter.Centiliters, Delta);
+            Assert.AreEqual(1E6, cubicMeter.Mililiters, Delta);
+        }
+
+        [Test]
+        public void VolumeUnitsRoundTrip()
+        {
+            Assert.AreEqual(1, Volume.FromCubicKilometers(cubicMeter.CubicKilometers).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicMeters(cubicMeter.CubicMeters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicDecimeters(cubicMeter.CubicDecimeters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicCentimeters(cubicMeter.CubicCentimeters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCubicMilimeters(cubicMeter.CubicMilimeters).CubicMeters, Delta);
+
+            Assert.AreEqual(1, Volume.FromHectoliters(cubicMeter.Hectoliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromLiters(cubicMeter.Liters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromDeciliters(cubicMeter.Deciliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromCentiliters(cubicMeter.Centiliters).CubicMeters, Delta);
+            Assert.AreEqual(1, Volume.FromMililiters(cubicMeter.Mililiters).CubicMeters, Delta);
+        }
+
+        [Test]
+        public void ArithmeticOperatorsRoundtrip()
+        {
+            Assert.AreEqual(Volume.FromLiters(-1000).CubicMeters, (-cubicMeter).CubicMeters, Delta);
+            Assert.AreEqual(Volume.FromLiters(1000 - 1).CubicMeters, (cubicMeter - liter).CubicMeters, Delta);
+            Assert.AreEqual(Volume.FromLiters(1000 + 1).CubicMeters, (cubicMeter + liter).CubicMeters, Delta);
+        }
+
+        [Test]
+        public void ComparableOperatorsRoundtrip()
+        {
+            Assert.IsTrue(liter < cubicMeter);
+            Assert.IsFalse(cubicMeter < liter);
+
+            Assert.IsTrue(liter <= cubicMeter);
+            Assert.IsFalse(cubicMeter <= liter);
+            Assert.IsTrue(liter <= Volume.FromLiters(1));
+
+            Assert.IsTrue(cubicMeter > liter);
+            Assert.IsFalse(liter > cubicMeter);
+
+            Assert.IsTrue(cubicMeter >= liter);
+            Assert.IsFalse(liter >= cubicMeter);
+            Assert.IsTrue(liter >= Volume.FromLiters(1));
+
+            Assert.IsTrue(liter == otherLiter);
+            Assert.IsFalse(liter == cubicMeter);
+
+            Assert.IsTrue(liter != cubicMeter);
+            Assert.IsFalse(liter != otherLiter);
+        }
+
+        [Test]
+        public void CompareToIsImplemented()
+        {
+            Assert.AreEqual(0, cubicMeter.CompareTo(cubicMeter));
+            Assert.IsTrue(cubicMeter.CompareTo(Volume.Zero) > 0);
+            Assert.IsTrue(Volume.Zero.CompareTo(cubicMeter) < 0);
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentException))]
+        public void CompareToCanHandleTypeMismatch()
+        {
+            cubicMeter.CompareTo(new object());
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentNullException))]
+        public void CompareToCanHandleNullInstance()
+        {
+            cubicMeter.CompareTo((object)null);
+        }
+
+        [Test]
+        public void EqualsIsImplemented()
+        {
+            Assert.IsTrue(cubicMeter.Equals(Volume.FromCubicMeters(1)));
+            Assert.IsTrue(cubicMeter.Equals(cubicMeter));
+            Assert.IsFalse(cubicMeter.Equals(liter));
+        }
+
+        [Test]
+        public void EqualsCanHandleTypeMismatch()
+        {
+            Assert.IsFalse(cubicMeter.Equals(new object()));
+        }
+
+        [Test]
+        public void EqualsCanHandleNullInstance()
+        {
+            Assert.IsFalse(cubicMeter.Equals(null));
+        }
+    }
+}
\ No newline at end of file