diff --git a/Mapbox.VectorTile.1.0.2-alpha1.nupkg b/Mapbox.VectorTile.1.0.2-alpha1.nupkg
new file mode 100644
index 0000000..52be64c
Binary files /dev/null and b/Mapbox.VectorTile.1.0.2-alpha1.nupkg differ
diff --git a/Mapbox.VectorTile.1.0.2-alpha2.nupkg b/Mapbox.VectorTile.1.0.2-alpha2.nupkg
new file mode 100644
index 0000000..08fc051
Binary files /dev/null and b/Mapbox.VectorTile.1.0.2-alpha2.nupkg differ
diff --git a/Mapbox.VectorTile.nuspec b/Mapbox.VectorTile.nuspec
index e91bc6f..ae3c341 100644
--- a/Mapbox.VectorTile.nuspec
+++ b/Mapbox.VectorTile.nuspec
@@ -2,16 +2,19 @@
 <package >
 	<metadata>
 		<id>Mapbox.VectorTile</id>
-		<version>1.0.1-alpha3</version>
+		<version>1.0.2-alpha2</version>
 		<authors>Mapbox</authors>
 		<owners>Mapbox</owners>
 		<licenseUrl>https://github.com/mapbox/vector-tile-cs</licenseUrl>
 		<projectUrl>https://github.com/mapbox/vector-tile-cs</projectUrl>
 		<requireLicenseAcceptance>false</requireLicenseAcceptance>
 		<description>Mapbox VectorTileReader CSharp</description>
-		<releaseNotes>Updates to VectorTileFeature.</releaseNotes>
+		<releaseNotes>Lazy loading.</releaseNotes>
 		<copyright>Copyright 2016</copyright>
 		<tags>vector tiles c# mapbox</tags>
+		<dependencies>
+			<dependency id="Mapbox.Geometry" version="[1.0.0-alpha1]" />
+		</dependencies>
 	</metadata>
 	<files>
 		<file src="bin\Mapbox.VectorTile.Geometry.dll" target="lib\net35\Mapbox.VectorTile.Geometry.dll"></file>
diff --git a/src/AssemblyInfoVersion.cs b/src/AssemblyInfoVersion.cs
new file mode 100644
index 0000000..0df494b
--- /dev/null
+++ b/src/AssemblyInfoVersion.cs
@@ -0,0 +1,5 @@
+using System.Reflection;
+
+[assembly: AssemblyVersion( "1.0.2" )]
+[assembly: AssemblyFileVersion( "1.0.2" )]
+[assembly: AssemblyInformationalVersion( "1.0.2" )]
diff --git a/src/Bench/Bench.csproj b/src/Bench/Bench.csproj
index fc38081..ba77ad6 100644
--- a/src/Bench/Bench.csproj
+++ b/src/Bench/Bench.csproj
@@ -43,6 +43,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/src/Bench/Program.cs b/src/Bench/Program.cs
index a96ccd5..96b2919 100644
--- a/src/Bench/Program.cs
+++ b/src/Bench/Program.cs
@@ -2,12 +2,13 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Net;
 using System.Text;
 
-namespace ProfileDecoding
+namespace Bench
 {
     class Program
     {
@@ -47,7 +48,8 @@ static int Main(string[] args)
                             return 1;
                         } else
                         {
-                            tiles.Add(new TileData() {
+                            tiles.Add(new TileData()
+                            {
                                 zoom = zoom,
                                 col = col,
                                 row = row,
@@ -67,7 +69,14 @@ static int Main(string[] args)
                 stopWatch.Start();
                 foreach (var tile in tiles)
                 {
-                    VectorTileReader.Decode(tile.zoom, tile.col, tile.row, tile.pbf);
+                    VectorTile vt = VectorTile.DecodeFully(tile.pbf);
+                    foreach (var lyr in vt.Layers)
+                    {
+                        foreach (var feat in lyr.Features)
+                        {
+                            var props = feat.GetProperties();
+                        }
+                    }
                 }
                 stopWatch.Stop();
                 //skip first run
@@ -76,6 +85,7 @@ static int Main(string[] args)
                     elapsed.Add(stopWatch.ElapsedMilliseconds);
                 }
                 stopWatch.Reset();
+                elapsed.Add(stopWatch.ElapsedMilliseconds);
             }
 
 
diff --git a/src/Bench/Properties/AssemblyInfo.cs b/src/Bench/Properties/AssemblyInfo.cs
index c5341ea..4f85afb 100644
--- a/src/Bench/Properties/AssemblyInfo.cs
+++ b/src/Bench/Properties/AssemblyInfo.cs
@@ -22,15 +22,3 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("5fa56c72-348a-4b52-980c-ea8287e66422")]
 
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/DemoConsoleApp/DemoConsoleApp.csproj b/src/DemoConsoleApp/DemoConsoleApp.csproj
index 2b9d1c8..54fe1f2 100644
--- a/src/DemoConsoleApp/DemoConsoleApp.csproj
+++ b/src/DemoConsoleApp/DemoConsoleApp.csproj
@@ -78,6 +78,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/src/DemoConsoleApp/Properties/AssemblyInfo.cs b/src/DemoConsoleApp/Properties/AssemblyInfo.cs
index e1b94c6..4fb8d0a 100644
--- a/src/DemoConsoleApp/Properties/AssemblyInfo.cs
+++ b/src/DemoConsoleApp/Properties/AssemblyInfo.cs
@@ -24,15 +24,3 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("d01ba6cb-9a2b-4aa5-95e1-085d9b569309")]
 
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/DemoConsoleApp/program.cs b/src/DemoConsoleApp/program.cs
index 02d348f..fb2ac01 100644
--- a/src/DemoConsoleApp/program.cs
+++ b/src/DemoConsoleApp/program.cs
@@ -22,6 +22,26 @@ public static int Main(string[] args)
                 return 1;
             }
 
+
+            var bufferedData = File.ReadAllBytes(vtIn);
+
+            VectorTileReader vtr = new VectorTileReader(bufferedData);
+            foreach (var lyrName in vtr.LayerNames())
+            {
+                Console.WriteLine(lyrName);
+                VectorTileLayer layer = vtr.GetLayer(lyrName);
+                Console.WriteLine("features: {0}", layer.FeatureCount());
+                for (int i = 0; i < layer.FeatureCount(); i++)
+                {
+                    VectorTileFeature feat = layer.GetFeature(i);
+                    Console.WriteLine(feat.Id);
+                    foreach (var prop in feat.GetProperties())
+                    {
+                        Console.WriteLine("{0}: {1}", prop.Key, prop.Value);
+                    }
+                }
+            }
+
             ulong zoom;
             ulong tileCol;
             ulong tileRow;
@@ -31,16 +51,10 @@ public static int Main(string[] args)
                 return 1;
             }
 
-            var bufferedData = File.ReadAllBytes(vtIn);
 
-            VectorTile tile = VectorTileReader.Decode(
-(ulong)zoom
-                , (ulong)tileCol
-                , (ulong)tileRow
-                , (byte[])bufferedData
-            );
+            VectorTile tile = VectorTile.DecodeFully(bufferedData);
 
-            Console.WriteLine(tile.ToGeoJson());
+            Console.WriteLine(tile.ToGeoJson(zoom, tileCol, tileRow));
 
             return 0;
         }
diff --git a/src/Geometry/DecodeGeometry.cs b/src/Geometry/DecodeGeometry.cs
index 3949907..599bfc9 100644
--- a/src/Geometry/DecodeGeometry.cs
+++ b/src/Geometry/DecodeGeometry.cs
@@ -1,7 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Collections.Generic;
+using Mapbox.Geometry;
 
 namespace Mapbox.VectorTile.Geometry
 {
@@ -25,19 +23,14 @@ public static class DecodeGeometry
         /// <para> Each child list contains the corrdinates of this part.</para>
         /// </summary>
         /// <param name="extent">Tile extent</param>
-        /// <param name="zoom">Zoom level</param>
-        /// <param name="tileColumn">Tile column</param>
-        /// <param name="tileRow">Tile row</param>
         /// <param name="geomType">Geometry type</param>
-        /// <param name="geometry"></param>
+        /// <param name="geometryCommands"></param>
         /// <returns>List<List<Point2d>></returns>
         public static List<List<Point2d>> GetGeometry(
             ulong extent
-            , ulong zoom
-            , ulong tileColumn
-            , ulong tileRow
             , GeomType geomType
-            , List<uint> geometry
+            , List<uint> geometryCommands
+            , float scale = 1.0f
         )
         {
 
@@ -46,10 +39,10 @@ ulong extent
             long cursorX = 0;
             long cursorY = 0;
 
-            for (int i = 0; i < geometry.Count; i++)
+            for (int i = 0; i < geometryCommands.Count; i++)
             {
 
-                uint g = geometry[i];
+                uint g = geometryCommands[i];
                 Commands cmd = (Commands)(g & 0x7);
                 uint cmdCount = g >> 3;
 
@@ -57,7 +50,7 @@ ulong extent
                 {
                     for (int j = 0; j < cmdCount; j++)
                     {
-                        Point2d delta = zigzagDecode(geometry[i + 1], geometry[i + 2]);
+                        Point2d delta = zigzagDecode(geometryCommands[i + 1], geometryCommands[i + 2]);
                         cursorX += delta.X;
                         cursorY += delta.Y;
                         i += 2;
@@ -85,6 +78,35 @@ ulong extent
                 geomOut.Add(geomTmp);
             }
 
+            //IGeometryBase geomOut2;
+            //switch (geomType)
+            //{
+            //    case GeomType.UNKNOWN:
+            //        throw new System.Exception("Geometry type unknown");
+            //    case GeomType.POINT:
+            //        if (geomOut.Count == 1)
+            //        {
+            //            geomOut2 = new Point<float>(geomOut[0][0].X, geomOut[0][0].Y);
+            //        } else
+            //        {
+            //            geomOut2 = new MultiPoint<float>();
+            //            foreach (var part in geomOut)
+            //            {
+            //                ((MultiPoint<float>)geomOut2).Add(new Point<float>(part[0].X, part[0].Y));
+            //            }
+            //        }
+            //        break;
+            //    case GeomType.LINESTRING:
+            //        geomOut2 = new LinearRing<float>();
+            //        break;
+            //    case GeomType.POLYGON:
+            //        geomOut2 = new Polygon<float>();
+            //        break;
+            //    default:
+            //        throw new System.Exception("Geometry type invalid");
+            //}
+
+            
             return geomOut;
         }
 
diff --git a/src/Geometry/Geometry.csproj b/src/Geometry/Geometry.csproj
index 9d39de1..1457991 100644
--- a/src/Geometry/Geometry.csproj
+++ b/src/Geometry/Geometry.csproj
@@ -54,6 +54,10 @@
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Mapbox.Geometry, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Mapbox.Geometry.1.0.0-alpha1\lib\net35\Mapbox.Geometry.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -62,6 +66,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="DecodeGeometry.cs" />
     <Compile Include="Geometry.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -76,6 +83,9 @@
       <Name>Util</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Geometry/Properties/AssemblyInfo.cs b/src/Geometry/Properties/AssemblyInfo.cs
index 5d4bdac..d925f8e 100644
--- a/src/Geometry/Properties/AssemblyInfo.cs
+++ b/src/Geometry/Properties/AssemblyInfo.cs
@@ -24,15 +24,3 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("f0967389-29c8-4d50-b397-9bb698f13ed6")]
 
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/Geometry/packages.config b/src/Geometry/packages.config
new file mode 100644
index 0000000..3d3a635
--- /dev/null
+++ b/src/Geometry/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Mapbox.Geometry" version="1.0.0-alpha1" targetFramework="net35" />
+</packages>
\ No newline at end of file
diff --git a/src/PbfReader/PbfReader.cs b/src/PbfReader/PbfReader.cs
index c6e5cee..84252aa 100644
--- a/src/PbfReader/PbfReader.cs
+++ b/src/PbfReader/PbfReader.cs
@@ -8,6 +8,12 @@
 namespace Mapbox.VectorTile
 {
 
+    public struct DataView
+    {
+        public ulong start;
+        public ulong end;
+    }
+
 
     public class PbfReader
     {
@@ -61,12 +67,14 @@ public byte[] View()
             {
                 throw new Exception("not of type string, bytes or message");
             }
+
             ulong tmpPos = Pos;
             ulong skipBytes = Varint();
             SkipBytes(skipBytes);
 
             byte[] buf = new byte[skipBytes];
             Array.Copy(_buffer, (int)Pos - (int)skipBytes, buf, 0, (int)skipBytes);
+
             return buf;
         }
 
@@ -135,19 +143,20 @@ public bool NextByte()
 
         public void SkipVarint()
         {
-            while (0 == (_buffer[Pos] & 0x80))
-            {
-                Pos++;
-                if (Pos >= _length)
-                {
-                    throw new Exception("Truncated message.");
-                }
-            }
-
-            if (Pos > _length)
-            {
-                throw new Exception("Truncated message.");
-            }
+            Varint();
+            //while (0 == (_buffer[Pos] & 0x80))
+            //{
+            //    Pos++;
+            //    if (Pos >= _length)
+            //    {
+            //        throw new Exception("Truncated message.");
+            //    }
+            //}
+
+            //if (Pos > _length)
+            //{
+            //    throw new Exception("Truncated message.");
+            //}
         }
 
 
diff --git a/src/PbfReader/PbfReader.csproj b/src/PbfReader/PbfReader.csproj
index 343b098..3c18789 100644
--- a/src/PbfReader/PbfReader.csproj
+++ b/src/PbfReader/PbfReader.csproj
@@ -62,6 +62,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="Constants.cs" />
     <Compile Include="PbfReader.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
diff --git a/src/PbfReader/Properties/AssemblyInfo.cs b/src/PbfReader/Properties/AssemblyInfo.cs
index 3fc28b9..0f05c7b 100644
--- a/src/PbfReader/Properties/AssemblyInfo.cs
+++ b/src/PbfReader/Properties/AssemblyInfo.cs
@@ -24,15 +24,3 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("4bce42ee-c33f-4fa4-bfdd-86f3d45c647c")]
 
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/Util/Properties/AssemblyInfo.cs b/src/Util/Properties/AssemblyInfo.cs
index aff95fe..3a12d5c 100644
--- a/src/Util/Properties/AssemblyInfo.cs
+++ b/src/Util/Properties/AssemblyInfo.cs
@@ -24,15 +24,3 @@
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("55503403-0083-4ed8-b618-f8377610b225")]
 
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/Util/Util.csproj b/src/Util/Util.csproj
index c770770..0e67f00 100644
--- a/src/Util/Util.csproj
+++ b/src/Util/Util.csproj
@@ -62,6 +62,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="Util.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/src/VectorTileReader/Properties/AssemblyInfo.cs b/src/VectorTileReader/Properties/AssemblyInfo.cs
index a62066f..91b08ab 100644
--- a/src/VectorTileReader/Properties/AssemblyInfo.cs
+++ b/src/VectorTileReader/Properties/AssemblyInfo.cs
@@ -23,16 +23,3 @@
 
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("4656b308-1492-4a22-a73e-06bf6aa858f2")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/VectorTileReader/VectorTile.cs b/src/VectorTileReader/VectorTile.cs
index e1e764a..1154398 100644
--- a/src/VectorTileReader/VectorTile.cs
+++ b/src/VectorTileReader/VectorTile.cs
@@ -3,32 +3,68 @@
 using Mapbox.VectorTile.Geometry;
 using System.Globalization;
 using System;
+using System.Diagnostics;
+using System.Collections.ObjectModel;
 
 namespace Mapbox.VectorTile
 {
 
+    [DebuggerDisplay("{Zoom}/{TileColumn}/{TileRow}")]
     public class VectorTile
     {
 
-        public VectorTile(
-            ulong zoom
-            , ulong tileColumn
-            , ulong tileRow
-        )
+        public VectorTile(byte[] data, bool lazyLoading = true)
+        {
+            _Layers = new List<VectorTileLayer>();
+            _Lazy = lazyLoading;
+            _VTR = new VectorTileReader(data);
+
+            if (!_Lazy)
+            {
+            }
+        }
+
+        private VectorTileReader _VTR;
+        private bool _Lazy;
+        private List<VectorTileLayer> _Layers;
+
+        [Obsolete("This method is likely to be removed.")]
+        public List<VectorTileLayer> Layers
         {
-            Zoom = zoom;
-            TileColumn = tileColumn;
-            TileRow = tileRow;
-            Layers = new List<VectorTileLayer>();
+            get {
+                if (!_Lazy)
+                {
+                    return _Layers;
+                }else
+                {
+                    return getLayers();
+                }
+            }
         }
 
-        public ulong Zoom { get; set; }
-        public ulong TileColumn { get; set; }
-        public ulong TileRow { get; set; }
+        public ReadOnlyCollection<string> LayerNames()
+        {
+            return _VTR.LayerNames();
+        }
+
+        public VectorTileLayer GetLayer(string layerName)
+        {
+            if (!_Lazy)
+            {
+                return _Layers.FirstOrDefault(l => l.Name.Equals(layerName));
+            }else
+            {
+                return _VTR.GetLayer(layerName);
+            }
+        }
 
-        public List<VectorTileLayer> Layers { get; set; }
 
-        public string ToGeoJson()
+        [Obsolete("This is a convenience method during early development and will be deprecated. Future clients will have to convert themselves.")]
+        public string ToGeoJson(
+            ulong zoom
+            , ulong tileColumn
+            , ulong tileRow
+        )
         {
 
             //to get '.' instead of ',' when using "string.format" with double/float and non-US system number format settings
@@ -73,7 +109,8 @@ public string ToGeoJson()
                     string geomType = feat.GeometryType.Description();
 
                     //multipart
-                    if (feat.Geometry.Count > 1)
+                    List<List<LatLng>> geomWgs84 = feat.GeometryAsWgs84(zoom, tileColumn, tileRow);
+                    if (geomWgs84.Count > 1)
                     {
                         switch (feat.GeometryType)
                         {
@@ -81,7 +118,7 @@ public string ToGeoJson()
                                 geomType = "MultiPoint";
                                 geojsonCoords = string.Join(
                                     ","
-                                    , feat.Geometry
+                                    , geomWgs84
                                         .SelectMany((List<LatLng> g) => g)
                                         .Select(g => string.Format(NumberFormatInfo.InvariantInfo, "[{0},{1}]", g.Lng, g.Lat)).ToArray()
                                 );
@@ -89,7 +126,7 @@ public string ToGeoJson()
                             case GeomType.LINESTRING:
                                 geomType = "MultiLineString";
                                 List<string> parts = new List<string>();
-                                foreach (var part in feat.Geometry)
+                                foreach (var part in geomWgs84)
                                 {
                                     parts.Add("[" + string.Join(
                                     ","
@@ -101,7 +138,7 @@ public string ToGeoJson()
                             case GeomType.POLYGON:
                                 geomType = "MultiPolygon";
                                 List<string> partsMP = new List<string>();
-                                foreach (var part in feat.Geometry)
+                                foreach (var part in geomWgs84)
                                 {
                                     partsMP.Add("[" + string.Join(
                                     ","
@@ -118,18 +155,18 @@ public string ToGeoJson()
                         switch (feat.GeometryType)
                         {
                             case GeomType.POINT:
-                                geojsonCoords = string.Format(NumberFormatInfo.InvariantInfo, "{0},{1}", feat.Geometry[0][0].Lng, feat.Geometry[0][0].Lat);
+                                geojsonCoords = string.Format(NumberFormatInfo.InvariantInfo, "{0},{1}", geomWgs84[0][0].Lng, geomWgs84[0][0].Lat);
                                 break;
                             case GeomType.LINESTRING:
                                 geojsonCoords = string.Join(
                                     ","
-                                    , feat.Geometry[0].Select(g => string.Format(NumberFormatInfo.InvariantInfo, "[{0},{1}]", g.Lng, g.Lat)).ToArray()
+                                    , geomWgs84[0].Select(g => string.Format(NumberFormatInfo.InvariantInfo, "[{0},{1}]", g.Lng, g.Lat)).ToArray()
                                 );
                                 break;
                             case GeomType.POLYGON:
                                 geojsonCoords = "[" + string.Join(
                                     ","
-                                    , feat.Geometry[0].Select(g => string.Format(NumberFormatInfo.InvariantInfo, "[{0},{1}]", g.Lng, g.Lat)).ToArray()
+                                    , geomWgs84[0].Select(g => string.Format(NumberFormatInfo.InvariantInfo, "[{0},{1}]", g.Lng, g.Lat)).ToArray()
                                 ) + "]";
                                 break;
                             default:
@@ -159,45 +196,25 @@ public string ToGeoJson()
         }
 
 
-        public bool Validate()
+        private List<VectorTileLayer> getLayers()
         {
 
-            List<string> layerNames = Layers.Select(l => l.Name).Distinct().ToList();
-            if (layerNames.Count() != Layers.Count())
-            {
-                throw new Exception("Duplicate layer names.");
-            }
-            if (0 < Layers.Where(l => l.Name.Length == 0).Count())
-            {
-                throw new Exception("Layer with no name");
-            }
-            if (0 < Layers.Where(l => l.Version != 2).Count())
-            {
-                throw new Exception("invalid layer version");
-            }
-            if (0 < Layers.Where(l => l.Extent == 0).Count())
-            {
-                throw new Exception("layer without extent");
-            }
-            if (0 < Layers.Where(l => l.Features.Count() == 0).Count())
-            {
-                throw new Exception("layer without features");
-            }
-            if (0 < Layers.SelectMany(l => l.Features).Where(f => null == f.GeometryOnTile).Count())
-            {
-                throw new Exception("features with no geometry");
-            }
-            //if (0 < Layers.SelectMany(l => l.Features).Where(f => f.GeometryType == GeomType.UNKNOWN).Count())
-            //{
-            //    throw new Exception("features with unknown geometry type");
-            //}
-
-            if (0 < Layers.Where(l => l.Keys.Count != l.Values.Count).Count())
+            List<VectorTileLayer> layers = new List<VectorTileLayer>();
+            foreach (var layerName in _VTR.LayerNames())
             {
-                throw new Exception("number of keys and values doesn't match");
+                VectorTileLayer layer = _VTR.GetLayer(layerName);
+                for (int i = 0; i < layer.FeatureCount(); i++)
+                {
+                    layer.Features.Add(_VTR.GetFeature(layer, i));
+                }
+                layers.Add(layer);
             }
+            return layers;
+        }
 
-            return true;
+        public static VectorTile DecodeFully(byte[] data)
+        {
+            return VectorTileReader.Decode(data);
         }
     }
 
diff --git a/src/VectorTileReader/VectorTileFeature.cs b/src/VectorTileReader/VectorTileFeature.cs
index 08385c9..1a106bf 100644
--- a/src/VectorTileReader/VectorTileFeature.cs
+++ b/src/VectorTileReader/VectorTileFeature.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using Mapbox.VectorTile.Geometry;
 using System.Linq;
+using System;
 
 namespace Mapbox.VectorTile
 {
@@ -11,10 +12,8 @@ public class VectorTileFeature
         /// <summary></summary>
         public ulong Id { get; set; }
         public GeomType GeometryType { get; set; }
-        /// <summary>Geometry in LatLng Coordinates</summary>
-        public List<List<LatLng>> Geometry { get; set; }
         /// <summary>Geometry in Tile Coordinates</summary>
-        public List<List<Point2d>> GeometryOnTile { get; set; }
+        public List<List<Point2d>> Geometry { get; set; }
         /// <summary>Tags to resolve Properties</summary>
         public List<int> Tags { get; set; }
 
@@ -25,7 +24,6 @@ public class VectorTileFeature
         public VectorTileFeature(VectorTileLayer layer)
         {
             _Layer = layer;
-            Geometry = new List<List<LatLng>>();
             Tags = new List<int>();
         }
 
@@ -48,10 +46,6 @@ public Dictionary<string, object> GetProperties()
 
         public object GetValue(string key)
         {
-            if (0 != Tags.Count % 2)
-            {
-                throw new System.Exception("uneven number of feature tag ids");
-            }
 
             var idxKey = _Layer.Keys.IndexOf(key);
             if (-1 == idxKey)
@@ -68,6 +62,30 @@ public object GetValue(string key)
             }
             return null;
         }
+
+
+        private List<List<LatLng>> _GeometryAsWgs84 = null;
+        [Obsolete("This is a convenience method during early development and will be deprecated. Future clients will have to convert themselves.")]
+        /// <summary>Geometry in LatLng Coordinates</summary>
+        public List<List<LatLng>> GeometryAsWgs84(ulong zoom, ulong tileColumn, ulong tileRow)
+        {
+
+            if (null != _GeometryAsWgs84)
+            {
+                return _GeometryAsWgs84;
+            }
+
+            _GeometryAsWgs84 = new List<List<LatLng>>();
+            foreach (var part in Geometry)
+            {
+                _GeometryAsWgs84.Add(
+                    part.Select(g => g.ToLngLat(zoom, tileColumn, tileRow, _Layer.Extent)).ToList()
+                );
+            }
+
+            return _GeometryAsWgs84;
+        }
+
     }
 
 
diff --git a/src/VectorTileReader/VectorTileLayer.cs b/src/VectorTileReader/VectorTileLayer.cs
index 079fe1e..bd1306b 100644
--- a/src/VectorTileReader/VectorTileLayer.cs
+++ b/src/VectorTileReader/VectorTileLayer.cs
@@ -1,25 +1,59 @@
 using System.Collections.Generic;
+using System.Diagnostics;
 
 namespace Mapbox.VectorTile
 {
 
 
+    [DebuggerDisplay("Layer {Name}")]
     public class VectorTileLayer
     {
 
         public VectorTileLayer()
         {
             Features = new List<VectorTileFeature>();
+            _FeaturesData = new List<byte[]>();
             Keys = new List<string>();
             Values = new List<object>();
         }
 
+        public VectorTileLayer(byte[] data) : this()
+        {
+            Data = data;
+        }
+
+        public byte[] Data { get; private set; }
+
+        public int FeatureCount()
+        {
+            return _FeaturesData.Count;
+        }
+
+        public VectorTileFeature GetFeature(int feature)
+        {
+            VectorTileReader vtr = new VectorTileReader();
+            return vtr.GetFeature(this, feature);
+        }
+
+        public void AddFeatureData(byte[] data)
+        {
+            _FeaturesData.Add(data);
+        }
+
+        public byte[] GetFeatureData(int idxFeature)
+        {
+            return _FeaturesData[idxFeature];
+        }
+
         public string Name { get; set; }
         public ulong Version { get; set; }
         public ulong Extent { get; set; }
         public List<VectorTileFeature> Features { get; set; }
+        private List<byte[]> _FeaturesData { get; set; }
         public List<object> Values { get; set; }
         public List<string> Keys { get; set; }
+
+
     }
 
 }
diff --git a/src/VectorTileReader/VectorTileReader.cs b/src/VectorTileReader/VectorTileReader.cs
index 18ccd1e..be50d67 100644
--- a/src/VectorTileReader/VectorTileReader.cs
+++ b/src/VectorTileReader/VectorTileReader.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using Mapbox.VectorTile.Geometry;
 using System.Globalization;
+using System.Collections.ObjectModel;
 
 namespace Mapbox.VectorTile
 {
@@ -12,180 +13,303 @@ namespace Mapbox.VectorTile
     public class VectorTileReader
     {
 
-        public static VectorTile Decode(
-            ulong zoom
-            , ulong tileCol
-            , ulong tileRow
-            , byte[] bufferedData
-        )
-        {
+        /// <summary>
+        /// DON'T use this constructor: it will be removed
+        /// </summary>
+        [Obsolete("DON'T use this constructor: it will be removed")]
+        public VectorTileReader() { }
 
-            if (bufferedData[0] == 0x1f && bufferedData[1] == 0x8b)
+        public VectorTileReader(byte[] data)
+        {
+            if (null == data)
+            {
+                throw new Exception("Tile data cannot be null");
+            }
+            if (data[0] == 0x1f && data[1] == 0x8b)
             {
-                throw new Exception("tile data is zipped");
+                throw new Exception("Tile data is zipped");
             }
 
-            var tileReader = new PbfReader(bufferedData);
-            VectorTile tile = new VectorTile(zoom, tileCol, tileRow);
+            layers(data);
+        }
+
 
+        private Dictionary<string, byte[]> _Layers = new Dictionary<string, byte[]>();
+
+        private void layers(byte[] data)
+        {
+            PbfReader tileReader = new PbfReader(data);
             while (tileReader.NextByte())
             {
-                if (tileReader.Tag != 3)
+                if (!Enum.IsDefined(typeof(TileType), tileReader.Tag))
                 {
-                    throw new Exception("unknown tile tag");
+                    throw new Exception("Unknown tile tag: " + tileReader.Tag);
                 }
                 if (tileReader.Tag == (int)TileType.Layers)
                 {
-                    VectorTileLayer layer = new VectorTileLayer();
-                    byte[] layerBuffer = tileReader.View();
-                    PbfReader layerReader = new PbfReader(layerBuffer);
-                    while (layerReader.NextByte())
+                    string name = null;
+                    byte[] layerMessage = tileReader.View();
+                    PbfReader layerView = new PbfReader(layerMessage);
+                    while (layerView.NextByte())
                     {
-                        switch ((LayerType)layerReader.Tag)
+                        if (layerView.Tag == (int)LayerType.Name)
+                        {
+                            ulong strLen = layerView.Varint();
+                            name = layerView.GetString(strLen);
+                        } else
                         {
-                            case LayerType.Version:
-                                ulong version = layerReader.Varint();
-                                layer.Version = version;
-                                break;
-                            case LayerType.Name:
-                                ulong strLength = layerReader.Varint();
-                                layer.Name = layerReader.GetString(strLength);
-                                break;
-                            case LayerType.Extent:
-                                layer.Extent = layerReader.Varint();
-                                break;
-                            case LayerType.Keys:
-                                byte[] keyBuffer = layerReader.View();
-                                string key = Encoding.UTF8.GetString(keyBuffer);
-                                layer.Keys.Add(key);
-                                break;
-                            case LayerType.Values:
-                                byte[] valueBuffer = layerReader.View();
-                                PbfReader valReader = new PbfReader(valueBuffer);
-                                while (valReader.NextByte())
-                                {
-                                    switch ((ValueType)valReader.Tag)
-                                    {
-                                        case ValueType.String:
-                                            byte[] stringBuffer = valReader.View();
-                                            string value = Encoding.UTF8.GetString(stringBuffer);
-                                            layer.Values.Add(value);
-                                            break;
-                                        case ValueType.Float:
-                                            float snglVal = valReader.GetFloat();
-                                            layer.Values.Add(snglVal);
-                                            break;
-                                        case ValueType.Double:
-                                            double dblVal = valReader.GetDouble();
-                                            layer.Values.Add(dblVal);
-                                            break;
-                                        case ValueType.Int:
-                                            ulong i64 = valReader.Varint();
-                                            layer.Values.Add(i64);
-                                            break;
-                                        case ValueType.UInt:
-                                            ulong u64 = valReader.Varint();
-                                            layer.Values.Add(u64);
-                                            break;
-                                        case ValueType.SInt:
-                                            ulong s64 = valReader.Varint();
-                                            layer.Values.Add(s64);
-                                            break;
-                                        case ValueType.Bool:
-                                            ulong b = valReader.Varint();
-                                            layer.Values.Add(b == 1);
-                                            break;
-                                        default:
-                                            throw new Exception(string.Format(
-                                                NumberFormatInfo.InvariantInfo
-                                                , "NOT IMPLEMENTED valueReader.Tag:{0} valueReader.WireType:{1}"
-                                                , valReader.Tag
-                                                , valReader.WireType
-                                            ));
-                                            //uncomment the following lines when not throwing!!
-                                            //valReader.Skip();
-                                            //break;
-                                    }
-                                }
-                                break;
-                            case LayerType.Features:
-                                byte[] featureBuffer = layerReader.View();
-                                PbfReader featureReader = new PbfReader(featureBuffer);
-                                VectorTileFeature feat = new VectorTileFeature(layer);
-                                bool geomTypeSet = false;
-                                while (featureReader.NextByte())
-                                {
-                                    switch ((FeatureType)featureReader.Tag)
-                                    {
-                                        case FeatureType.Id:
-                                            feat.Id = featureReader.Varint();
-                                            break;
-                                        case FeatureType.Tags:
-                                            List<int> tags = featureReader.GetPackedUnit32().Select(t => (int)t).ToList();
-                                            feat.Tags = tags;
-                                            break;
-                                        case FeatureType.Type:
-                                            int geomType = (int)featureReader.Varint();
-                                            if (!Enum.IsDefined(typeof(GeomType), geomType))
-                                            {
-                                                throw new Exception("Unknown geometry type tag");
-                                            }
-                                            feat.GeometryType = (GeomType)geomType;
-                                            geomTypeSet = true;
-                                            break;
-                                        case FeatureType.Geometry:
-                                            if (null != feat.GeometryOnTile)
-                                            {
-                                                throw new Exception("feature already has a geometry");
-                                            }
-                                            //get raw array of commands and coordinates
-                                            List<uint> geometry = featureReader.GetPackedUnit32();
-                                            //decode commands and coordinates
-                                            List<List<Point2d>> geom = DecodeGeometry.GetGeometry(
-                                                layer.Extent
-                                                , tile.Zoom
-                                                , tile.TileColumn
-                                                , tile.TileRow
-                                                , feat.GeometryType
-                                                , geometry
-                                            );
-                                            feat.GeometryOnTile = geom;
-                                            //convert tile coordinates to LatLnt
-                                            List<List<LatLng>> geomAsLatLng = new List<List<LatLng>>();
-                                            foreach (var part in geom)
-                                            {
-                                                geomAsLatLng.Add(
-                                                    part.Select(g => g.ToLngLat(zoom, tileCol, tileRow, layer.Extent)).ToList()
-                                                );
-                                            }
-                                            feat.Geometry.AddRange(geomAsLatLng);
-                                            break;
-                                        default:
-                                            featureReader.Skip();
-                                            break;
-                                    }
-                                }
-
-                                if (!geomTypeSet)
-                                {
-                                    throw new Exception("feature missing geometry type");
-                                }
-
-                                layer.Features.Add(feat);
-                                break;
-                            default:
-                                layerReader.Skip();
-                                break;
+                            layerView.Skip();
                         }
                     }
-
-                    tile.Layers.Add(layer);
+                    if (string.IsNullOrEmpty(name))
+                    {
+                        throw new Exception("Layer missing name");
+                    }
+                    if (_Layers.ContainsKey(name))
+                    {
+                        throw new Exception("Duplicate layer names: " + name);
+                    }
+                    _Layers.Add(name, layerMessage);
                 } else
                 {
                     tileReader.Skip();
                 }
             }
+        }
+
+
+        public ReadOnlyCollection<string> LayerNames()
+        {
+            return _Layers.Keys.ToList().AsReadOnly();
+        }
+
+        public VectorTileLayer GetLayer(string name)
+        {
+            if (!_Layers.ContainsKey(name))
+            {
+                return null;
+            }
 
+            return getLayer(_Layers[name]);
+        }
+
+
+        private VectorTileLayer getLayer(byte[] data)
+        {
+            VectorTileLayer layer = new VectorTileLayer(data);
+            PbfReader layerReader = new PbfReader(layer.Data);
+            while (layerReader.NextByte())
+            {
+                int layerType = layerReader.Tag;
+                if (!Enum.IsDefined(typeof(LayerType), layerType))
+                {
+                    throw new Exception("Unknown layer type: " + layerType);
+                }
+                switch ((LayerType)layerType)
+                {
+                    case LayerType.Version:
+                        ulong version = layerReader.Varint();
+                        layer.Version = version;
+                        break;
+                    case LayerType.Name:
+                        ulong strLength = layerReader.Varint();
+                        layer.Name = layerReader.GetString(strLength);
+                        break;
+                    case LayerType.Extent:
+                        layer.Extent = layerReader.Varint();
+                        break;
+                    case LayerType.Keys:
+                        byte[] keyBuffer = layerReader.View();
+                        string key = Encoding.UTF8.GetString(keyBuffer);
+                        layer.Keys.Add(key);
+                        break;
+                    case LayerType.Values:
+                        byte[] valueBuffer = layerReader.View();
+                        PbfReader valReader = new PbfReader(valueBuffer);
+                        while (valReader.NextByte())
+                        {
+                            switch ((ValueType)valReader.Tag)
+                            {
+                                case ValueType.String:
+                                    byte[] stringBuffer = valReader.View();
+                                    string value = Encoding.UTF8.GetString(stringBuffer);
+                                    layer.Values.Add(value);
+                                    break;
+                                case ValueType.Float:
+                                    float snglVal = valReader.GetFloat();
+                                    layer.Values.Add(snglVal);
+                                    break;
+                                case ValueType.Double:
+                                    double dblVal = valReader.GetDouble();
+                                    layer.Values.Add(dblVal);
+                                    break;
+                                case ValueType.Int:
+                                    ulong i64 = valReader.Varint();
+                                    layer.Values.Add(i64);
+                                    break;
+                                case ValueType.UInt:
+                                    ulong u64 = valReader.Varint();
+                                    layer.Values.Add(u64);
+                                    break;
+                                case ValueType.SInt:
+                                    ulong s64 = valReader.Varint();
+                                    layer.Values.Add(s64);
+                                    break;
+                                case ValueType.Bool:
+                                    ulong b = valReader.Varint();
+                                    layer.Values.Add(b == 1);
+                                    break;
+                                default:
+                                    throw new Exception(string.Format(
+                                        NumberFormatInfo.InvariantInfo
+                                        , "NOT IMPLEMENTED valueReader.Tag:{0} valueReader.WireType:{1}"
+                                        , valReader.Tag
+                                        , valReader.WireType
+                                    ));
+                                    //uncomment the following lines when not throwing!!
+                                    //valReader.Skip();
+                                    //break;
+                            }
+                        }
+                        break;
+                    case LayerType.Features:
+                        layer.AddFeatureData(layerReader.View());
+                        break;
+                    default:
+                        layerReader.Skip();
+                        break;
+                }
+            }
+
+            if (string.IsNullOrEmpty(layer.Name))
+            {
+                throw new Exception("Layer has no name");
+            }
+            if (0 == layer.Version)
+            {
+                throw new Exception("Layer has no version: " + layer.Name);
+            }
+            if (2 != layer.Version)
+            {
+                throw new Exception("Layer has invalid version: " + layer.Name);
+            }
+            if (0 == layer.Extent)
+            {
+                throw new Exception("Layer has no extent: " + layer.Name);
+            }
+            if (0 == layer.FeatureCount())
+            {
+                throw new Exception("Layer has no features: " + layer.Name);
+            }
+            if (layer.Values.Count != layer.Values.Distinct().Count())
+            {
+                throw new Exception("Duplicate values found");
+            }
+
+            return layer;
+        }
+
+
+        public VectorTileFeature GetFeature(VectorTileLayer layer, int idxFeature)
+        {
+
+            byte[] data = layer.GetFeatureData(idxFeature);
+
+            PbfReader featureReader = new PbfReader(data);
+            VectorTileFeature feat = new VectorTileFeature(layer);
+            bool geomTypeSet = false;
+            while (featureReader.NextByte())
+            {
+                int featureType = featureReader.Tag;
+                if (!Enum.IsDefined(typeof(FeatureType), featureType))
+                {
+                    throw new Exception(layer.Name + ", unknown feature type: " + featureType);
+                }
+                switch ((FeatureType)featureType)
+                {
+                    case FeatureType.Id:
+                        feat.Id = featureReader.Varint();
+                        break;
+                    case FeatureType.Tags:
+                        List<int> tags = featureReader.GetPackedUnit32().Select(t => (int)t).ToList();
+                        feat.Tags = tags;
+                        break;
+                    case FeatureType.Type:
+                        int geomType = (int)featureReader.Varint();
+                        if (!Enum.IsDefined(typeof(GeomType), geomType))
+                        {
+                            throw new Exception(layer.Name + ", unknown geometry type tag " + geomType);
+                        }
+                        feat.GeometryType = (GeomType)geomType;
+                        geomTypeSet = true;
+                        break;
+                    case FeatureType.Geometry:
+                        if (null != feat.Geometry)
+                        {
+                            throw new Exception(layer.Name + ", feature already has a geometry");
+                        }
+                        //get raw array of commands and coordinates
+                        List<uint> geometryCommands = featureReader.GetPackedUnit32();
+                        //decode commands and coordinates
+                        List<List<Point2d>> geom = DecodeGeometry.GetGeometry(
+                            layer.Extent
+                            , feat.GeometryType
+                            , geometryCommands
+                        );
+                        feat.Geometry = geom;
+                        break;
+                    default:
+                        featureReader.Skip();
+                        break;
+                }
+            }
+
+            if (!geomTypeSet)
+            {
+                throw new Exception(layer.Name + ", feature missing geometry type");
+            }
+            if (null == feat.Geometry)
+            {
+                throw new Exception(layer.Name + ", feature has no geometry");
+            }
+            if (0 != feat.Tags.Count % 2)
+            {
+                throw new Exception(layer.Name + ", uneven number of feature tag ids");
+            }
+            if (feat.Tags.Count > 0)
+            {
+                int maxKeyIndex = feat.Tags.Where((key, idx) => idx % 2 == 0).Max();
+                int maxValueIndex = feat.Tags.Where((key, idx) => (idx + 1) % 2 == 0).Max();
+                if (maxKeyIndex >= layer.Keys.Count)
+                {
+                    throw new Exception(layer.Name + ", maximum key index equal or greater number of key elements");
+                }
+                if (maxValueIndex >= layer.Values.Count)
+                {
+                    throw new Exception(layer.Name + ", maximum value index equal or greater number of value elements");
+                }
+            }
+
+            return feat;
+        }
+
+
+        public static VectorTile Decode(byte[] data)
+        {
+
+            VectorTileReader vtr = new VectorTileReader(data);
+            VectorTile tile = new VectorTile(data);
+
+            foreach (var layerName in vtr.LayerNames())
+            {
+                VectorTileLayer layer = vtr.GetLayer(layerName);
+                for (int i = 0; i < layer.FeatureCount(); i++)
+                {
+                    VectorTileFeature feature = vtr.GetFeature(layer, i);
+                    layer.Features.Add(feature);
+                }
+                tile.Layers.Add(layer);
+            }
             return tile;
         }
 
diff --git a/src/VectorTileReader/VectorTileReader.csproj b/src/VectorTileReader/VectorTileReader.csproj
index 4141a51..35d74da 100644
--- a/src/VectorTileReader/VectorTileReader.csproj
+++ b/src/VectorTileReader/VectorTileReader.csproj
@@ -54,6 +54,10 @@
     <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Mapbox.Geometry, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Mapbox.Geometry.1.0.0-alpha1\lib\net35\Mapbox.Geometry.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -62,6 +66,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="VectorTileFeature.cs" />
     <Compile Include="VectorTileLayer.cs" />
     <Compile Include="VectorTile.cs" />
@@ -82,6 +89,9 @@
       <Name>PbfReader</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/VectorTileReader/packages.config b/src/VectorTileReader/packages.config
new file mode 100644
index 0000000..3d3a635
--- /dev/null
+++ b/src/VectorTileReader/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Mapbox.Geometry" version="1.0.0-alpha1" targetFramework="net35" />
+</packages>
\ No newline at end of file
diff --git a/src/VectorTiles.Tests/Properties/AssemblyInfo.cs b/src/VectorTiles.Tests/Properties/AssemblyInfo.cs
index 47eeb76..a088980 100644
--- a/src/VectorTiles.Tests/Properties/AssemblyInfo.cs
+++ b/src/VectorTiles.Tests/Properties/AssemblyInfo.cs
@@ -11,7 +11,7 @@
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("VectorTiles.Tests")]
-[assembly: AssemblyCopyright("Copyright ©  2015")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 [assembly: NeutralResourcesLanguage("en-US")]
@@ -24,16 +24,3 @@
 
 // The following GUID is for the ID of the typelib if this project is exposed to COM
 [assembly: Guid("067456c0-086c-46a8-b37f-1405717b7bfc")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/src/VectorTiles.Tests/TestInvalidMvtInBulk.cs b/src/VectorTiles.Tests/TestInvalidMvtInBulk.cs
index 630db44..ee7efab 100644
--- a/src/VectorTiles.Tests/TestInvalidMvtInBulk.cs
+++ b/src/VectorTiles.Tests/TestInvalidMvtInBulk.cs
@@ -1,11 +1,8 @@
 using System;
 using NUnit.Framework;
 using System.IO;
-using System.Diagnostics;
-using System.Collections.Generic;
 using Mapbox.VectorTile;
 using System.Collections;
-using Mapbox.VectorTile.Geometry;
 
 namespace VectorTiles.Tests
 {
@@ -37,7 +34,7 @@ public void Validate(string fileName)
             byte[] data = File.ReadAllBytes(fullFileName);
             Assert.Throws(Is.InstanceOf<Exception>(), () =>
             {
-                VectorTile vt = VectorTileReader.Decode(0, 0, 0, data);
+                VectorTile vt = VectorTile.DecodeFully(data);
                 foreach (var lyr in vt.Layers)
                 {
                     foreach (var feat in lyr.Features)
@@ -45,7 +42,7 @@ public void Validate(string fileName)
                         feat.GetProperties();
                     }
                 }
-                vt.Validate();
+                //vt.Validate();
             });
         }
     }
diff --git a/src/VectorTiles.Tests/TestMvtInBulk.cs b/src/VectorTiles.Tests/TestMvtInBulk.cs
index fd047d3..8bec76a 100644
--- a/src/VectorTiles.Tests/TestMvtInBulk.cs
+++ b/src/VectorTiles.Tests/TestMvtInBulk.cs
@@ -29,15 +29,40 @@ public void FixturesPathExists()
         }
 
 
+        [Test, TestCaseSource(typeof(GetMVTs), "GetFixtureFileName")]
+        public void LazyDecoding(string fileName)
+        {
+            string fullFileName = Path.Combine(fixturesPath, fileName);
+            Assert.True(File.Exists(fullFileName), "Vector tile exists");
+            byte[] data = File.ReadAllBytes(fullFileName);
+            VectorTile vt = new VectorTile(data);
+            foreach (var layerName in vt.LayerNames())
+            {
+                VectorTileLayer layer = vt.GetLayer(layerName);
+                for (int i = 0; i < layer.FeatureCount(); i++)
+                {
+                    VectorTileFeature feat = layer.GetFeature(i);
+                    var properties = feat.GetProperties();
+                    foreach (var prop in properties)
+                    {
+                        Assert.AreEqual(prop.Value, feat.GetValue(prop.Key), "Property values match");
+                    }
+                }
+            }
+            string geojson = vt.ToGeoJson(0, 0, 0);
+            Assert.GreaterOrEqual(geojson.Length, 30, "geojson >= 30 chars");
+        }
+
+
         [Test, TestCaseSource(typeof(GetMVTs), "GetFixtureFileName")]
         public void AtLeastOneLayer(string fileName)
         {
             string fullFileName = Path.Combine(fixturesPath, fileName);
             Assert.True(File.Exists(fullFileName), "Vector tile exists");
             byte[] data = File.ReadAllBytes(fullFileName);
-            VectorTile vt = VectorTileReader.Decode(0, 0, 0, data);
+            VectorTile vt = VectorTile.DecodeFully(data);
             Assert.GreaterOrEqual(vt.Layers.Count, 1, "At least one layer");
-            string geojson = vt.ToGeoJson();
+            string geojson = vt.ToGeoJson(0, 0, 0);
             Assert.GreaterOrEqual(geojson.Length, 30, "geojson >= 30 chars");
         }
 
@@ -48,7 +73,7 @@ public void IterateAllProperties(string fileName)
             string fullFileName = Path.Combine(fixturesPath, fileName);
             Assert.True(File.Exists(fullFileName), "Vector tile exists");
             byte[] data = File.ReadAllBytes(fullFileName);
-            VectorTile vt = VectorTileReader.Decode(0, 0, 0, data);
+            VectorTile vt = VectorTile.DecodeFully(data);
             foreach (var lyr in vt.Layers)
             {
                 foreach (var feat in lyr.Features)
@@ -60,7 +85,6 @@ public void IterateAllProperties(string fileName)
                     }
                 }
             }
-            Assert.IsTrue(vt.Validate(), "VectorTile Validation");
         }
     }
 
diff --git a/src/VectorTiles.Tests/TestMvtSingle.cs b/src/VectorTiles.Tests/TestMvtSingle.cs
index 0fcd083..82910cf 100644
--- a/src/VectorTiles.Tests/TestMvtSingle.cs
+++ b/src/VectorTiles.Tests/TestMvtSingle.cs
@@ -25,7 +25,7 @@ public void FeatureSinglePoint()
         {
 
             byte[] data = File.ReadAllBytes(Path.Combine(fixturesPath, "Feature-single-point.mvt"));
-            VectorTile vt = VectorTileReader.Decode(0, 0, 0, data);
+            VectorTile vt = VectorTile.DecodeFully(data);
             Assert.AreEqual(1, vt.Layers.Count, "one layer");
             VectorTileLayer lyr = vt.Layers[0];
             Assert.AreEqual("layer_name", lyr.Name, "Layer name");
diff --git a/src/VectorTiles.Tests/VectorTiles.Tests.csproj b/src/VectorTiles.Tests/VectorTiles.Tests.csproj
index f380c59..137c462 100644
--- a/src/VectorTiles.Tests/VectorTiles.Tests.csproj
+++ b/src/VectorTiles.Tests/VectorTiles.Tests.csproj
@@ -59,6 +59,9 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\AssemblyInfoVersion.cs">
+      <Link>Properties\AssemblyInfoVersion.cs</Link>
+    </Compile>
     <Compile Include="TestInvalidMvtInBulk.cs" />
     <Compile Include="TestMvtSingle.cs" />
     <Compile Include="TestGeometry.cs" />