wip, lots to do...vkvg_backend

121 files changed, 1746 insertions, 48 deletions

diff --git a/Crow/Crow.csproj b/Crow/Crow.csproj
index 083b1989..4c40be81 100644
--- a/Crow/Crow.csproj
+++ b/Crow/Crow.csproj
@@ -43,13 +43,6 @@
 		<PackageReference Include="glfw-sharp" Version="$(GlfwSharpVersion)" />
 	</ItemGroup>
 
-	<PropertyGroup Condition=" '$(CrowVkvgBackend)' == 'true'">
-		<DefineConstants>$(DefineConstants);VKVG</DefineConstants>
-	</PropertyGroup>
-	<ItemGroup Condition=" '$(CrowVkvgBackend)' == 'true'">
-		<PackageReference Include="vkvg.net" Version="0.2.2-beta" />
-	</ItemGroup>
-
 	<PropertyGroup Condition=" '$(CrowStbSharp)' == 'true'">
 		<DefineConstants>$(DefineConstants);STB_SHARP</DefineConstants>
 	</PropertyGroup>
@@ -64,9 +57,21 @@
 		<ProjectReference Include="..\CrowDbgShared\CrowDbgShared.csproj" />
 	</ItemGroup>
 
+	<PropertyGroup Condition=" '$(CrowVkvgBackend)' == 'true'">
+		<DefineConstants>$(DefineConstants);VKVG</DefineConstants>
+	</PropertyGroup>
+	<ItemGroup Condition=" '$(CrowVkvgBackend)' == 'true'">
+		<Compile Include="src\GraphicBackends\vkvg\**\*.*" />
+	</ItemGroup>
+
+	<ItemGroup Condition=" '$(CrowVkvgBackend)' != 'true'">
+		<Compile Include="src\GraphicBackends\Mono.Cairo\**\*.*"
+			Exclude="src\GraphicBackends\Mono.Cairo\NativeMethods-internal.cs" />
+	</ItemGroup>
+
 	<ItemGroup>
 		<Content Include="..\Images\crow.png" Pack="true" PackagePath="" />
-		<Compile Include="src\**\*.cs" Exclude="src\Mono.Cairo\NativeMethods-internal.cs" />
+		<Compile Include="src\**\*.cs" Exclude="src\GraphicBackends\**\*.*" />
 		<EmbeddedResource Include="Templates\*.*">
 			<LogicalName>Crow.%(Filename).template</LogicalName>
 		</EmbeddedResource>
diff --git a/Crow/src/Cairo/CairoHelpers.cs b/Crow/src/Cairo/CairoHelpers.cs
index a2e036ac..129879a1 100644
--- a/Crow/src/Cairo/CairoHelpers.cs
+++ b/Crow/src/Cairo/CairoHelpers.cs
@@ -1,38 +1,22 @@
-//
-// CairoHelpers.cs
+// Copyright (c) 2013-2021  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
 //
-// Author:
-//       Jean-Philippe Bruyère <jp.bruyere@hotmail.com>
-//
-// Copyright (c) 2013-2017 Jean-Philippe Bruyère
-//
-// 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.
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+#if VKVG
+using vkvg;
+#else
+using Crow.Cairo;
+#endif
+
 namespace Crow
 {
     public static class CairoHelpers
-    {
+    {		
 		public static T Clamp<T>(this T val, T min, T max) where T : IComparable<T>
 		{
 		    if (val.CompareTo(min) < 0) return min;
@@ -57,18 +41,18 @@ namespace Crow
 
             return arr[minp];
         }
-		public static void CairoRectangle(Cairo.Context gr, RectangleD r, double radius, double stroke = 0.0)
+		public static void CairoRectangle(Context gr, RectangleD r, double radius, double stroke = 0.0)
 		{
 			if (radius > 0)
 				DrawRoundedRectangle (gr, r, radius, stroke);
 			else
 				gr.Rectangle (r, stroke);
 		}
-		public static void CairoCircle(Cairo.Context gr, RectangleD r)
+		public static void CairoCircle(Context gr, RectangleD r)
 		{
 			gr.Arc(r.X + r.Width/2.0, r.Y + r.Height/2.0, Math.Min(r.Width,r.Height)/2.0, 0, 2.0*Math.PI);
 		}
-		public static void DrawRoundedRectangle(Cairo.Context gr, RectangleD r, double radius, double stroke = 0.0)
+		public static void DrawRoundedRectangle(Context gr, RectangleD r, double radius, double stroke = 0.0)
         {
 			if (stroke>0.0) {
 				gr.LineWidth = stroke;
@@ -78,7 +62,7 @@ namespace Crow
 			}else
 				DrawRoundedRectangle(gr, r.X, r.Y, r.Width, r.Height, radius);
         }
-        public static void DrawRoundedRectangle(Cairo.Context gr, double x, double y, double width, double height, double radius)
+        public static void DrawRoundedRectangle(Context gr, double x, double y, double width, double height, double radius)
         {
             gr.Save();
 
@@ -96,7 +80,7 @@ namespace Crow
             gr.ClosePath();
             gr.Restore();
         }
-        public static void StrokeRaisedRectangle(Cairo.Context gr, Rectangle r, double width = 1)
+        public static void StrokeRaisedRectangle(Context gr, Rectangle r, double width = 1)
         {
             gr.Save();
             r.Inflate((int)-width / 2, (int)-width / 2);
@@ -115,7 +99,7 @@ namespace Crow
 
             gr.Restore();
         }
-        public static void StrokeLoweredRectangle(Cairo.Context gr, Rectangle r, double width = 1)
+        public static void StrokeLoweredRectangle(Context gr, Rectangle r, double width = 1)
         {
             gr.Save();
             r.Inflate((int)-width / 2, (int)-width / 2);
diff --git a/Crow/src/ExtensionsMethods.cs b/Crow/src/ExtensionsMethods.cs
index f8aefaf1..d7ebb3f2 100644
--- a/Crow/src/ExtensionsMethods.cs
+++ b/Crow/src/ExtensionsMethods.cs
@@ -8,13 +8,19 @@ using System.IO;
 using System.Linq;
 using System.Linq.Expressions;
 
+#if VKVG
+using vkvg;
+#else
+using Crow.Cairo;
+#endif
+
 namespace Crow
 {
 	public static class ExtensionsMethods
 	{
 		#region Cairo extensions
 
-		public static void Rectangle(this Cairo.Context ctx, Rectangle r, double stroke = 0.0)
+		public static void Rectangle(this Context ctx, Rectangle r, double stroke = 0.0)
 		{
 			if (stroke > 0.0) {
 				ctx.LineWidth = stroke;
@@ -48,7 +54,7 @@ namespace Crow
 		public static PointD Multiply(this PointD p1, double v){
 			return new PointD(p1.X * v, p1.Y * v);
 		}
-		public static void DrawCote(this Cairo.Context ctx, PointD p1, PointD p2,
+		public static void DrawCote(this Context ctx, PointD p1, PointD p2,
 			double stroke = 1.0, bool fill = false, double arrowWidth = 3.0, double arrowLength = 7.0)
 		{			
 			PointD vDir = p2.Substract(p1);
@@ -85,7 +91,7 @@ namespace Crow
 			ctx.LineWidth = stroke;
 			ctx.Stroke ();
 		}
-		public static void DrawCoteInverse(this Cairo.Context ctx, PointD p1, PointD p2,
+		public static void DrawCoteInverse(this Context ctx, PointD p1, PointD p2,
 			double stroke = 1.0, bool fill = false, double arrowWidth = 3.0, double arrowLength = 7.0)
 		{			
 			PointD vDir = p2.Substract(p1);
@@ -117,7 +123,7 @@ namespace Crow
 			ctx.LineWidth = stroke;
 			ctx.Stroke ();
 		}
-		public static void DrawCoteFixed(this Cairo.Context ctx, PointD p1, PointD p2,
+		public static void DrawCoteFixed(this Context ctx, PointD p1, PointD p2,
 			double stroke = 1.0, double coteWidth = 3.0)
 		{			
 			PointD vDir = p2.Substract(p1);
@@ -135,7 +141,7 @@ namespace Crow
 			ctx.Stroke ();
 		}
 
-		public static void AddColorStop(this Cairo.Gradient grad, double offset, Color c)
+		public static void AddColorStop(this Gradient grad, double offset, Color c)
 		{
 			grad.AddColorStop (offset, c);
 		}
diff --git a/Crow/src/Fill/BmpPicture.cs b/Crow/src/Fill/BmpPicture.cs
index 0f67323d..e8df7269 100644
--- a/Crow/src/Fill/BmpPicture.cs
+++ b/Crow/src/Fill/BmpPicture.cs
@@ -5,7 +5,11 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Fill/Fill.cs b/Crow/src/Fill/Fill.cs
index a11b666e..d9f3c69a 100644
--- a/Crow/src/Fill/Fill.cs
+++ b/Crow/src/Fill/Fill.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Fill/Gradient.cs b/Crow/src/Fill/Gradient.cs
index ac6a638e..680e1d0f 100644
--- a/Crow/src/Fill/Gradient.cs
+++ b/Crow/src/Fill/Gradient.cs
@@ -26,7 +26,11 @@
 
 using System;
 using System.Collections.Generic;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Fill/Picture.cs b/Crow/src/Fill/Picture.cs
index c9b23404..8c885bc8 100644
--- a/Crow/src/Fill/Picture.cs
+++ b/Crow/src/Fill/Picture.cs
@@ -26,7 +26,11 @@
 
 using System;
 using System.IO;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Collections.Generic;
 
 namespace Crow
diff --git a/Crow/src/Fill/SolidColor.cs b/Crow/src/Fill/SolidColor.cs
index 8ed77fbe..1c183d97 100644
--- a/Crow/src/Fill/SolidColor.cs
+++ b/Crow/src/Fill/SolidColor.cs
@@ -9,7 +9,11 @@ using System.Text;
 using System.Xml.Serialization;
 using System.Reflection;
 using System.Diagnostics;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 
 
diff --git a/Crow/src/Fill/SvgPicture.cs b/Crow/src/Fill/SvgPicture.cs
index fcd5c4d2..6ce11149 100644
--- a/Crow/src/Fill/SvgPicture.cs
+++ b/Crow/src/Fill/SvgPicture.cs
@@ -4,7 +4,11 @@
 
 using System;
 using System.IO;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Font.cs b/Crow/src/Font.cs
index f05c6fb1..9ad79450 100644
--- a/Crow/src/Font.cs
+++ b/Crow/src/Font.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using FastEnumUtility;
 
 namespace Crow
diff --git a/Crow/src/Mono.Cairo/Antialias.cs b/Crow/src/GraphicBackends/Mono.Cairo/Antialias.cs
index 64da6443..64da6443 100644
--- a/Crow/src/Mono.Cairo/Antialias.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Antialias.cs
diff --git a/Crow/src/Mono.Cairo/Cairo.cs b/Crow/src/GraphicBackends/Mono.Cairo/Cairo.cs
index c32c00d8..c32c00d8 100644
--- a/Crow/src/Mono.Cairo/Cairo.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Cairo.cs
diff --git a/Crow/src/Mono.Cairo/CairoDebug.cs b/Crow/src/GraphicBackends/Mono.Cairo/CairoDebug.cs
index a669d841..a669d841 100644
--- a/Crow/src/Mono.Cairo/CairoDebug.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/CairoDebug.cs
diff --git a/Crow/src/Mono.Cairo/Content.cs b/Crow/src/GraphicBackends/Mono.Cairo/Content.cs
index f14305a4..f14305a4 100644
--- a/Crow/src/Mono.Cairo/Content.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Content.cs
diff --git a/Crow/src/Mono.Cairo/Context.cs b/Crow/src/GraphicBackends/Mono.Cairo/Context.cs
index 5cd60dc1..5cd60dc1 100644
--- a/Crow/src/Mono.Cairo/Context.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Context.cs
diff --git a/Crow/src/Mono.Cairo/DRMDevice.cs b/Crow/src/GraphicBackends/Mono.Cairo/DRMDevice.cs
index 05e142cb..05e142cb 100644
--- a/Crow/src/Mono.Cairo/DRMDevice.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/DRMDevice.cs
diff --git a/Crow/src/Mono.Cairo/DRMSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/DRMSurface.cs
index f624967f..f624967f 100644
--- a/Crow/src/Mono.Cairo/DRMSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/DRMSurface.cs
diff --git a/Crow/src/Mono.Cairo/Device.cs b/Crow/src/GraphicBackends/Mono.Cairo/Device.cs
index 484264f0..484264f0 100644
--- a/Crow/src/Mono.Cairo/Device.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Device.cs
diff --git a/Crow/src/Mono.Cairo/DirectFBSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/DirectFBSurface.cs
index 64431574..64431574 100644
--- a/Crow/src/Mono.Cairo/DirectFBSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/DirectFBSurface.cs
diff --git a/Crow/src/Mono.Cairo/Distance.cs b/Crow/src/GraphicBackends/Mono.Cairo/Distance.cs
index d716ab1f..d716ab1f 100644
--- a/Crow/src/Mono.Cairo/Distance.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Distance.cs
diff --git a/Crow/src/Mono.Cairo/EGLDevice.cs b/Crow/src/GraphicBackends/Mono.Cairo/EGLDevice.cs
index 44590c70..44590c70 100644
--- a/Crow/src/Mono.Cairo/EGLDevice.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/EGLDevice.cs
diff --git a/Crow/src/Mono.Cairo/Extend.cs b/Crow/src/GraphicBackends/Mono.Cairo/Extend.cs
index 4af536dc..4af536dc 100644
--- a/Crow/src/Mono.Cairo/Extend.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Extend.cs
diff --git a/Crow/src/Mono.Cairo/FillRule.cs b/Crow/src/GraphicBackends/Mono.Cairo/FillRule.cs
index 80f61ed5..80f61ed5 100644
--- a/Crow/src/Mono.Cairo/FillRule.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FillRule.cs
diff --git a/Crow/src/Mono.Cairo/Filter.cs b/Crow/src/GraphicBackends/Mono.Cairo/Filter.cs
index a73ea58d..a73ea58d 100644
--- a/Crow/src/Mono.Cairo/Filter.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Filter.cs
diff --git a/Crow/src/Mono.Cairo/FontExtents.cs b/Crow/src/GraphicBackends/Mono.Cairo/FontExtents.cs
index ea26d9bb..ea26d9bb 100644
--- a/Crow/src/Mono.Cairo/FontExtents.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FontExtents.cs
diff --git a/Crow/src/Mono.Cairo/FontFace.cs b/Crow/src/GraphicBackends/Mono.Cairo/FontFace.cs
index 64c428e2..64c428e2 100644
--- a/Crow/src/Mono.Cairo/FontFace.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FontFace.cs
diff --git a/Crow/src/Mono.Cairo/FontOptions.cs b/Crow/src/GraphicBackends/Mono.Cairo/FontOptions.cs
index f90a3a4d..f90a3a4d 100644
--- a/Crow/src/Mono.Cairo/FontOptions.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FontOptions.cs
diff --git a/Crow/src/Mono.Cairo/FontSlant.cs b/Crow/src/GraphicBackends/Mono.Cairo/FontSlant.cs
index b3d8a1a2..b3d8a1a2 100644
--- a/Crow/src/Mono.Cairo/FontSlant.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FontSlant.cs
diff --git a/Crow/src/Mono.Cairo/FontType.cs b/Crow/src/GraphicBackends/Mono.Cairo/FontType.cs
index 5db44d4e..5db44d4e 100644
--- a/Crow/src/Mono.Cairo/FontType.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FontType.cs
diff --git a/Crow/src/Mono.Cairo/FontWeight.cs b/Crow/src/GraphicBackends/Mono.Cairo/FontWeight.cs
index 0b8fc6a8..0b8fc6a8 100644
--- a/Crow/src/Mono.Cairo/FontWeight.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/FontWeight.cs
diff --git a/Crow/src/Mono.Cairo/Format.cs b/Crow/src/GraphicBackends/Mono.Cairo/Format.cs
index 54c8be1e..54c8be1e 100644
--- a/Crow/src/Mono.Cairo/Format.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Format.cs
diff --git a/Crow/src/Mono.Cairo/GLSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/GLSurface.cs
index 60384b02..60384b02 100644
--- a/Crow/src/Mono.Cairo/GLSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/GLSurface.cs
diff --git a/Crow/src/Mono.Cairo/GLXDevice.cs b/Crow/src/GraphicBackends/Mono.Cairo/GLXDevice.cs
index 00cbce1f..00cbce1f 100644
--- a/Crow/src/Mono.Cairo/GLXDevice.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/GLXDevice.cs
diff --git a/Crow/src/Mono.Cairo/GlitzSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/GlitzSurface.cs
index 4aa24983..4aa24983 100644
--- a/Crow/src/Mono.Cairo/GlitzSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/GlitzSurface.cs
diff --git a/Crow/src/Mono.Cairo/Glyph.cs b/Crow/src/GraphicBackends/Mono.Cairo/Glyph.cs
index ad511562..ad511562 100644
--- a/Crow/src/Mono.Cairo/Glyph.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Glyph.cs
diff --git a/Crow/src/Mono.Cairo/Gradient.cs b/Crow/src/GraphicBackends/Mono.Cairo/Gradient.cs
index a1799e3f..a1799e3f 100644
--- a/Crow/src/Mono.Cairo/Gradient.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Gradient.cs
diff --git a/Crow/src/Mono.Cairo/HintMetrics.cs b/Crow/src/GraphicBackends/Mono.Cairo/HintMetrics.cs
index d830f3eb..d830f3eb 100644
--- a/Crow/src/Mono.Cairo/HintMetrics.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/HintMetrics.cs
diff --git a/Crow/src/Mono.Cairo/HintStyle.cs b/Crow/src/GraphicBackends/Mono.Cairo/HintStyle.cs
index 343daf3e..343daf3e 100644
--- a/Crow/src/Mono.Cairo/HintStyle.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/HintStyle.cs
diff --git a/Crow/src/Mono.Cairo/ImageSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/ImageSurface.cs
index 7c70569d..7c70569d 100644
--- a/Crow/src/Mono.Cairo/ImageSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/ImageSurface.cs
diff --git a/Crow/src/Mono.Cairo/LineCap.cs b/Crow/src/GraphicBackends/Mono.Cairo/LineCap.cs
index 1560cda4..1560cda4 100644
--- a/Crow/src/Mono.Cairo/LineCap.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/LineCap.cs
diff --git a/Crow/src/Mono.Cairo/LineJoin.cs b/Crow/src/GraphicBackends/Mono.Cairo/LineJoin.cs
index 1d5389b5..1d5389b5 100644
--- a/Crow/src/Mono.Cairo/LineJoin.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/LineJoin.cs
diff --git a/Crow/src/Mono.Cairo/LinearGradient.cs b/Crow/src/GraphicBackends/Mono.Cairo/LinearGradient.cs
index 100d1e6d..100d1e6d 100644
--- a/Crow/src/Mono.Cairo/LinearGradient.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/LinearGradient.cs
diff --git a/Crow/src/Mono.Cairo/Matrix.cs b/Crow/src/GraphicBackends/Mono.Cairo/Matrix.cs
index 7d5a6acd..7d5a6acd 100644
--- a/Crow/src/Mono.Cairo/Matrix.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Matrix.cs
diff --git a/Crow/src/Mono.Cairo/MeshPattern.cs b/Crow/src/GraphicBackends/Mono.Cairo/MeshPattern.cs
index 83da70b1..83da70b1 100644
--- a/Crow/src/Mono.Cairo/MeshPattern.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/MeshPattern.cs
diff --git a/Crow/src/Mono.Cairo/NativeMethods-internal.cs b/Crow/src/GraphicBackends/Mono.Cairo/NativeMethods-internal.cs
index 6e6d507c..6e6d507c 100644
--- a/Crow/src/Mono.Cairo/NativeMethods-internal.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/NativeMethods-internal.cs
diff --git a/Crow/src/Mono.Cairo/NativeMethods.cs b/Crow/src/GraphicBackends/Mono.Cairo/NativeMethods.cs
index 4f93c411..4f93c411 100644
--- a/Crow/src/Mono.Cairo/NativeMethods.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/NativeMethods.cs
diff --git a/Crow/src/Mono.Cairo/Operator.cs b/Crow/src/GraphicBackends/Mono.Cairo/Operator.cs
index 1c11cccc..1c11cccc 100644
--- a/Crow/src/Mono.Cairo/Operator.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Operator.cs
diff --git a/Crow/src/Mono.Cairo/PSSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/PSSurface.cs
index cf90794e..cf90794e 100644
--- a/Crow/src/Mono.Cairo/PSSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/PSSurface.cs
diff --git a/Crow/src/Mono.Cairo/Path.cs b/Crow/src/GraphicBackends/Mono.Cairo/Path.cs
index a55f03b0..881aa427 100644
--- a/Crow/src/Mono.Cairo/Path.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Path.cs
@@ -30,7 +30,11 @@
 
 using System;
 using System.Runtime.InteropServices;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow.Cairo {
 
diff --git a/Crow/src/Mono.Cairo/Pattern.cs b/Crow/src/GraphicBackends/Mono.Cairo/Pattern.cs
index 3e933a19..3e933a19 100644
--- a/Crow/src/Mono.Cairo/Pattern.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Pattern.cs
diff --git a/Crow/src/Mono.Cairo/PatternType.cs b/Crow/src/GraphicBackends/Mono.Cairo/PatternType.cs
index deac3ab7..deac3ab7 100644
--- a/Crow/src/Mono.Cairo/PatternType.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/PatternType.cs
diff --git a/Crow/src/Mono.Cairo/PdfSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/PdfSurface.cs
index 09a2d126..09a2d126 100644
--- a/Crow/src/Mono.Cairo/PdfSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/PdfSurface.cs
diff --git a/Crow/src/Mono.Cairo/RadialGradient.cs b/Crow/src/GraphicBackends/Mono.Cairo/RadialGradient.cs
index 6abe2671..6abe2671 100644
--- a/Crow/src/Mono.Cairo/RadialGradient.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/RadialGradient.cs
diff --git a/Crow/src/Mono.Cairo/Region.cs b/Crow/src/GraphicBackends/Mono.Cairo/Region.cs
index f2c111d7..f2c111d7 100644
--- a/Crow/src/Mono.Cairo/Region.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Region.cs
diff --git a/Crow/src/Mono.Cairo/ScaledFont.cs b/Crow/src/GraphicBackends/Mono.Cairo/ScaledFont.cs
index 594d1be9..594d1be9 100644
--- a/Crow/src/Mono.Cairo/ScaledFont.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/ScaledFont.cs
diff --git a/Crow/src/Mono.Cairo/SolidPattern.cs b/Crow/src/GraphicBackends/Mono.Cairo/SolidPattern.cs
index 6cd89f85..6cd89f85 100644
--- a/Crow/src/Mono.Cairo/SolidPattern.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/SolidPattern.cs
diff --git a/Crow/src/Mono.Cairo/Status.cs b/Crow/src/GraphicBackends/Mono.Cairo/Status.cs
index 2df15580..2df15580 100644
--- a/Crow/src/Mono.Cairo/Status.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Status.cs
diff --git a/Crow/src/Mono.Cairo/SubpixelOrder.cs b/Crow/src/GraphicBackends/Mono.Cairo/SubpixelOrder.cs
index 95f3cbee..95f3cbee 100644
--- a/Crow/src/Mono.Cairo/SubpixelOrder.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/SubpixelOrder.cs
diff --git a/Crow/src/Mono.Cairo/Surface.cs b/Crow/src/GraphicBackends/Mono.Cairo/Surface.cs
index 56c1553f..56c1553f 100644
--- a/Crow/src/Mono.Cairo/Surface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Surface.cs
diff --git a/Crow/src/Mono.Cairo/SurfacePattern.cs b/Crow/src/GraphicBackends/Mono.Cairo/SurfacePattern.cs
index 53a90d38..53a90d38 100644
--- a/Crow/src/Mono.Cairo/SurfacePattern.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/SurfacePattern.cs
diff --git a/Crow/src/Mono.Cairo/SurfaceType.cs b/Crow/src/GraphicBackends/Mono.Cairo/SurfaceType.cs
index bd992db0..bd992db0 100644
--- a/Crow/src/Mono.Cairo/SurfaceType.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/SurfaceType.cs
diff --git a/Crow/src/Mono.Cairo/SvgSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/SvgSurface.cs
index c7d72988..c7d72988 100644
--- a/Crow/src/Mono.Cairo/SvgSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/SvgSurface.cs
diff --git a/Crow/src/Mono.Cairo/SvgVersion.cs b/Crow/src/GraphicBackends/Mono.Cairo/SvgVersion.cs
index 916fb861..916fb861 100644
--- a/Crow/src/Mono.Cairo/SvgVersion.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/SvgVersion.cs
diff --git a/Crow/src/Mono.Cairo/TextExtents.cs b/Crow/src/GraphicBackends/Mono.Cairo/TextExtents.cs
index 965ca046..965ca046 100644
--- a/Crow/src/Mono.Cairo/TextExtents.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/TextExtents.cs
diff --git a/Crow/src/Mono.Cairo/WGLDevice.cs b/Crow/src/GraphicBackends/Mono.Cairo/WGLDevice.cs
index 308cfadd..308cfadd 100644
--- a/Crow/src/Mono.Cairo/WGLDevice.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/WGLDevice.cs
diff --git a/Crow/src/Mono.Cairo/Win32Surface.cs b/Crow/src/GraphicBackends/Mono.Cairo/Win32Surface.cs
index 4776a19b..4776a19b 100644
--- a/Crow/src/Mono.Cairo/Win32Surface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/Win32Surface.cs
diff --git a/Crow/src/Mono.Cairo/XcbSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/XcbSurface.cs
index 32a67848..32a67848 100644
--- a/Crow/src/Mono.Cairo/XcbSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/XcbSurface.cs
diff --git a/Crow/src/Mono.Cairo/XlibSurface.cs b/Crow/src/GraphicBackends/Mono.Cairo/XlibSurface.cs
index 18e810bd..18e810bd 100644
--- a/Crow/src/Mono.Cairo/XlibSurface.cs
+++ b/Crow/src/GraphicBackends/Mono.Cairo/XlibSurface.cs
diff --git a/Crow/src/GraphicBackends/vkvg/Context.cs b/Crow/src/GraphicBackends/vkvg/Context.cs
new file mode 100644
index 00000000..482dfe12
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/Context.cs
@@ -0,0 +1,347 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+using System.Text;
+using Crow;
+
+namespace vkvg
+{
+	public class Context : IDisposable
+	{
+
+		IntPtr handle = IntPtr.Zero;
+
+		public Context(Surface surf)
+		{
+			handle = NativeMethods.vkvg_create(surf.Handle);
+		}
+		~Context()
+		{
+			Dispose(false);
+		}
+
+		public IntPtr Handle => handle;
+
+		public void AddReference()
+		{
+			NativeMethods.vkvg_reference(handle);
+		}
+		public uint References() => NativeMethods.vkvg_get_reference_count(handle);
+
+		public double LineWidth
+		{
+			get => NativeMethods.vkvg_get_line_width(handle);
+			set { NativeMethods.vkvg_set_line_width(handle, (float)value); }
+		}
+		public LineJoin LineJoin
+		{
+			get => NativeMethods.vkvg_get_line_join(handle);
+			set { NativeMethods.vkvg_set_line_join(handle, value); }
+		}
+		public LineCap LineCap
+		{
+			get => NativeMethods.vkvg_get_line_cap(handle);
+			set { NativeMethods.vkvg_set_line_cap(handle, value); }
+		}
+		public uint FontSize
+		{
+			set { NativeMethods.vkvg_set_font_size(handle, value); }
+		}
+		public string FontFace
+		{
+			set { NativeMethods.vkvg_select_font_face(handle, value); }
+		}
+		public Operator Operator
+		{
+			set { NativeMethods.vkvg_set_operator(handle, value); }
+			get { return NativeMethods.vkvg_get_operator(handle); }
+		}
+		public FillRule FillRule
+		{
+			set { NativeMethods.vkvg_set_fill_rule(handle, value); }
+			get { return NativeMethods.vkvg_get_fill_rule(handle); }
+		}
+		public FontExtents FontExtents
+		{
+			get
+			{
+				FontExtents f_extents;
+				NativeMethods.vkvg_font_extents(handle, out f_extents);
+				return f_extents;
+			}
+		}
+		public TextExtents TextExtents(string s)
+		{
+			TextExtents extents = default(TextExtents);
+			if (!string.IsNullOrEmpty(s))
+				NativeMethods.vkvg_text_extents(handle, TerminateUtf8(s), out extents);
+			return extents;
+		}
+		public Matrix Matrix
+		{
+			get
+			{
+				Matrix m;
+				NativeMethods.vkvg_get_matrix(handle, out m);
+				return m;
+			}
+			set
+			{
+				NativeMethods.vkvg_set_matrix(handle, ref value);
+			}
+		}
+		public void ShowText(string txt)
+		{
+			NativeMethods.vkvg_show_text(handle, TerminateUtf8(txt));
+		}
+		public void ShowText(TextRun textRun)
+		{
+			NativeMethods.vkvg_show_text_run(handle, textRun.Handle);
+		}
+		public void Save()
+		{
+			NativeMethods.vkvg_save(handle);
+		}
+		public void Restore()
+		{
+			NativeMethods.vkvg_restore(handle);
+		}
+		public void Flush()
+		{
+			NativeMethods.vkvg_flush(handle);
+		}
+		public void Clear()
+		{
+			NativeMethods.vkvg_clear(handle);
+		}
+		public void Paint()
+		{
+			NativeMethods.vkvg_paint(handle);
+		}
+		public void Arc(float xc, float yc, float radius, float a1, float a2)
+		{
+			NativeMethods.vkvg_arc(handle, xc, yc, radius, a1, a2);
+		}
+		public void Arc(double xc, double yc, double radius, double a1, double a2)
+		{
+			NativeMethods.vkvg_arc(handle, (float)xc, (float)yc, (float)radius, (float)a1, (float)a2);
+		}
+		public void ArcNegative(float xc, float yc, float radius, float a1, float a2)
+		{
+			NativeMethods.vkvg_arc_negative(handle, xc, yc, radius, a1, a2);
+		}
+		public void Rectangle(float x, float y, float width, float height)
+		{
+			NativeMethods.vkvg_rectangle(handle, x, y, width, height);
+		}
+		public void Scale(float sx, float sy)
+		{
+			NativeMethods.vkvg_scale(handle, sx, sy);
+		}
+		public void Translate(float dx, float dy)
+		{
+			NativeMethods.vkvg_translate(handle, dx, dy);
+		}
+		public void Rotate(float alpha)
+		{
+			NativeMethods.vkvg_rotate(handle, alpha);
+		}
+		public void ArcNegative(double xc, double yc, double radius, double a1, double a2)
+		{
+			NativeMethods.vkvg_arc_negative(handle, (float)xc, (float)yc, (float)radius, (float)a1, (float)a2);
+		}
+		public void Rectangle(double x, double y, double width, double height)
+		{
+			NativeMethods.vkvg_rectangle(handle, (float)x, (float)y, (float)width, (float)height);
+		}
+		public void Scale(double sx, double sy)
+		{
+			NativeMethods.vkvg_scale(handle, (float)sx, (float)sy);
+		}
+		public void Translate(double dx, double dy)
+		{
+			NativeMethods.vkvg_translate(handle, (float)dx, (float)dy);
+		}
+		public void Translate(PointD p)
+		{
+			NativeMethods.vkvg_translate(handle, (float)p.X, (float)p.Y);
+		}
+		public void Rotate(double alpha)
+		{
+			NativeMethods.vkvg_rotate(handle, (float)alpha);
+		}
+
+		public void Fill()
+		{
+			NativeMethods.vkvg_fill(handle);
+		}
+		public void FillPreserve()
+		{
+			NativeMethods.vkvg_fill_preserve(handle);
+		}
+		public void Stroke()
+		{
+			NativeMethods.vkvg_stroke(handle);
+		}
+		public void StrokePreserve()
+		{
+			NativeMethods.vkvg_stroke_preserve(handle);
+		}
+		public void Clip()
+		{
+			NativeMethods.vkvg_clip(handle);
+		}
+		public void ClipPreserve()
+		{
+			NativeMethods.vkvg_clip_preserve(handle);
+		}
+		public void ResetClip()
+		{
+			NativeMethods.vkvg_reset_clip(handle);
+		}
+		public void NewPath()
+		{
+			NativeMethods.vkvg_new_path(handle);
+		}
+		public void NewSubPath()
+		{
+			NativeMethods.vkvg_new_sub_path(handle);
+		}
+		public void ClosePath()
+		{
+			NativeMethods.vkvg_close_path(handle);
+		}
+		public void MoveTo(PointD p)
+		{
+			NativeMethods.vkvg_move_to(handle, (float)p.X, (float)p.Y);
+		}
+		public void MoveTo(Point p)
+		{
+			NativeMethods.vkvg_move_to(handle, p.X, p.Y);
+		}
+		public void MoveTo(float x, float y)
+		{
+			NativeMethods.vkvg_move_to(handle, x, y);
+		}
+		public void RelMoveTo(float x, float y)
+		{
+			NativeMethods.vkvg_rel_move_to(handle, x, y);
+		}
+		public void LineTo(float x, float y)
+		{
+			NativeMethods.vkvg_line_to(handle, x, y);
+		}
+		public void LineTo(Point p)
+		{
+			NativeMethods.vkvg_line_to(handle, p.X, p.Y);
+		}
+		public void LineTo(PointD p)
+		{
+			NativeMethods.vkvg_line_to(handle, (float)p.X, (float)p.Y);
+		}
+		public void RelLineTo(float x, float y)
+		{
+			NativeMethods.vkvg_rel_line_to(handle, x, y);
+		}
+		public void CurveTo(float x1, float y1, float x2, float y2, float x3, float y3)
+		{
+			NativeMethods.vkvg_curve_to(handle, x1, y1, x2, y2, x3, y3);
+		}
+		public void RelCurveTo(float x1, float y1, float x2, float y2, float x3, float y3)
+		{
+			NativeMethods.vkvg_rel_curve_to(handle, x1, y1, x2, y2, x3, y3);
+		}
+
+		public void MoveTo(double x, double y)
+		{
+			NativeMethods.vkvg_move_to(handle, (float)x, (float)y);
+		}
+		public void RelMoveTo(double x, double y)
+		{
+			NativeMethods.vkvg_rel_move_to(handle, (float)x, (float)y);
+		}
+		public void LineTo(double x, double y)
+		{
+			NativeMethods.vkvg_line_to(handle, (float)x, (float)y);
+		}
+		public void RelLineTo(double x, double y)
+		{
+			NativeMethods.vkvg_rel_line_to(handle, (float)x, (float)y);
+		}
+		public void CurveTo(double x1, double y1, double x2, double y2, double x3, double y3)
+		{
+			NativeMethods.vkvg_curve_to(handle, (float)x1, (float)y1, (float)x2, (float)y2, (float)x3, (float)y3);
+		}
+		public void RelCurveTo(double x1, double y1, double x2, double y2, double x3, double y3)
+		{
+			NativeMethods.vkvg_rel_curve_to(handle, (float)x1, (float)y1, (float)x2, (float)y2, (float)x3, (float)y3);
+		}
+
+		public void SetSource(Pattern pat)
+		{
+			NativeMethods.vkvg_set_source(handle, pat.Handle);
+		}
+		public void SetSource (Color color)
+		{
+			NativeMethods.vkvg_set_source_rgba (handle, (float)(color.R / 255.0), (float)(color.G / 255.0), (float)(color.B / 255.0), (float)(color.A / 255.0));
+		}
+		public void SetSource(float r, float g, float b, float a = 1f)
+		{
+			NativeMethods.vkvg_set_source_rgba(handle, r, g, b, a);
+		}
+		public void SetSource(double r, double g, double b, double a = 1.0)
+		{
+			NativeMethods.vkvg_set_source_rgba(handle, (float)r, (float)g, (float)b, (float)a);
+		}
+		public void SetSource(Surface surf, float x = 0f, float y = 0f)
+		{
+			NativeMethods.vkvg_set_source_surface(handle, surf.Handle, x, y);
+		}
+		public void SetSourceSurface(Surface surf, float x = 0f, float y = 0f)
+		{
+			NativeMethods.vkvg_set_source_surface(handle, surf.Handle, x, y);
+		}
+		public void RenderSvg(IntPtr nsvgImage, string subId = null)
+		{
+			NativeMethods.vkvg_render_svg(handle, nsvgImage, subId);
+		}
+		internal static byte[] TerminateUtf8(string s)
+		{
+			// compute the byte count including the trailing \0
+			var byteCount = Encoding.UTF8.GetMaxByteCount(s.Length + 1);
+			var bytes = new byte[byteCount];
+			Encoding.UTF8.GetBytes(s, 0, s.Length, bytes, 0);
+			return bytes;
+		}
+
+		public float[] Dashes
+		{
+			set
+			{
+				if (value == null)
+					NativeMethods.vkvg_set_dash(handle, null, 0, 0);
+				else
+					NativeMethods.vkvg_set_dash(handle, value, (uint)value.Length, 0);
+			}
+		}
+		#region IDisposable implementation
+		public void Dispose()
+		{
+			Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if (!disposing || handle == IntPtr.Zero)
+				return;
+
+			NativeMethods.vkvg_destroy(handle);
+			handle = IntPtr.Zero;
+		}
+		#endregion
+	}
+}
+
diff --git a/Crow/src/GraphicBackends/vkvg/Device.cs b/Crow/src/GraphicBackends/vkvg/Device.cs
new file mode 100644
index 00000000..84eea519
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/Device.cs
@@ -0,0 +1,56 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+
+namespace vkvg
+{
+	public class Device: IDisposable
+	{
+
+		IntPtr handle = IntPtr.Zero;
+
+		#region CTORS & DTOR
+		public Device (IntPtr instance, IntPtr phy, IntPtr dev, uint qFamIdx, SampleCount samples = SampleCount.Sample_1, uint qIndex = 0)
+		{
+			handle = NativeMethods.vkvg_device_create_multisample (instance, phy, dev, qFamIdx, qIndex, samples, false);
+		}
+		~Device ()
+		{
+			Dispose (false);
+		}
+		#endregion
+
+		public void GetDpy (out int hdpy, out int vdpy) {
+			NativeMethods.vkvg_device_get_dpy (handle, out hdpy, out vdpy);
+		}
+		public void SetDpy (int hdpy, int vdpy) {
+			NativeMethods.vkvg_device_set_dpy (handle, hdpy, vdpy);
+		}
+		public void AddReference () {
+			NativeMethods.vkvg_device_reference (handle);
+		}
+		public uint References () => NativeMethods.vkvg_device_get_reference_count (handle);
+
+		public IntPtr Handle { get { return handle; }}
+
+		#region IDisposable implementation
+		public void Dispose ()
+		{
+			Dispose (true);
+			GC.SuppressFinalize (this);
+		}
+
+		protected virtual void Dispose (bool disposing)
+		{
+			if (!disposing || handle == IntPtr.Zero)
+				return;
+
+			NativeMethods.vkvg_device_destroy (handle);
+			handle = IntPtr.Zero;
+		}
+		#endregion
+	}
+}
+
diff --git a/Crow/src/GraphicBackends/vkvg/Enums.cs b/Crow/src/GraphicBackends/vkvg/Enums.cs
new file mode 100644
index 00000000..41c5eb9c
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/Enums.cs
@@ -0,0 +1,143 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+
+namespace vkvg
+{
+    public enum Status
+    {
+        Success = 0,
+        NoMemory,
+        InvalidRestore,
+        InvalidPopGroup,
+        NoCurrentPoint,
+        InvalidMatrix,
+        InvalidStatus,
+        NullPointer,
+        InvalidString,
+        InvalidPathData,
+        ReadError,
+        WriteError,
+        SurfaceFinished,
+        SurfaceTypeMismatch,
+        PatternTypeMismatch,
+        InvalidContent,
+        InvalidFormat,
+        InvalidVisual,
+        FileNotFound,
+        InvalidDash
+    }
+
+    public enum Direction
+    {
+        Horizontal = 0,
+        Vertical = 1
+    }
+
+    public enum Format
+    {
+        ARGB32,
+        RGB24,
+        A8,
+        A1
+    }
+
+    public enum Extend
+    {
+        None,
+        Repeat,
+        Reflect,
+        Pad
+    }
+
+    public enum Filter
+    {
+        Fast,
+        Good,
+        Best,
+        Nearest,
+        Bilinear,
+        Gaussian,
+    }
+
+    public enum PatternType
+    {
+        Solid,
+        Surface,
+        Linear,
+        Radial,
+        Mesh,
+        RasterSource,
+    }
+
+    public enum Operator
+    {
+        Clear,
+        Source,
+        Over,
+        In,
+        Out,
+        Atop,
+
+        Dest,
+        DestOver,
+        DestIn,
+        DestOut,
+        DestAtop,
+
+        Xor,
+        Add,
+        Saturate,
+    }
+
+    public enum FontSlant
+    {
+        Normal,
+        Italic,
+        Oblique
+    }
+    public enum FontWeight
+    {
+        Normal,
+        Bold,
+    }
+
+    public enum SampleCount
+    {
+        Sample_1 = 0x00000001,
+        Sample_2 = 0x00000002,
+        Sample_4 = 0x00000004,
+        Sample_8 = 0x00000008,
+        Sample_16 = 0x00000010,
+        Sample_32 = 0x00000020,
+        Sample_64 = 0x00000040
+    }
+
+    public enum LineCap
+    {
+        Butt,
+        Round,
+        Square
+    }
+
+    public enum LineJoin
+    {
+        Miter,
+        Round,
+        Bevel
+    }
+    public enum FillRule
+    {
+        EvenOdd,
+        NonZero,
+    }
+	public enum Antialias
+	{
+		Default,
+		None,
+		Grey,
+		Subpixel,
+	}
+}
\ No newline at end of file
diff --git a/Crow/src/GraphicBackends/vkvg/FontExtents.cs b/Crow/src/GraphicBackends/vkvg/FontExtents.cs
new file mode 100644
index 00000000..41b025de
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/FontExtents.cs
@@ -0,0 +1,106 @@
+//
+// from Mono.Cairo.FontExtents.cs
+//
+// Authors: Duncan Mak (duncan@ximian.com)
+//          Hisham Mardam Bey (hisham.mardambey@gmail.com)
+//
+// (C) Ximian, Inc. 2003
+//
+// This is a simplistic binding of the Cairo API to C#. All functions
+// in cairo.h are transcribed into their C# equivelants
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// 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.
+//
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+using System;
+using System.Runtime.InteropServices;
+
+namespace vkvg
+{
+	[StructLayout (LayoutKind.Sequential)]
+	public struct FontExtents
+	{
+		float ascent;
+		float descent;
+		float height;
+		float maxXAdvance;
+		float maxYAdvance;
+		
+		public float Ascent {
+			get { return ascent; }
+			set { ascent = value; }
+		}
+		
+		public float Descent {
+			get { return descent; }
+			set { descent = value; }
+		}
+		
+		public float Height {
+			get { return height; }
+			set { height = value; }
+		}
+		
+		public float MaxXAdvance {
+			get { return maxXAdvance; }
+			set { maxXAdvance = value; }
+		}
+		
+		public float MaxYAdvance {
+			get { return maxYAdvance; }
+			set { maxYAdvance = value; }
+		}
+
+		public FontExtents (float ascent, float descent, float height, float maxXAdvance, float maxYAdvance)
+		{
+			this.ascent = ascent;
+			this.descent = descent;
+			this.height = height;
+			this.maxXAdvance = maxXAdvance;
+			this.maxYAdvance = maxYAdvance;
+		}
+
+		public override bool Equals (object obj)
+		{
+			if (obj is FontExtents)
+				return this == (FontExtents) obj;
+			return false;
+		}
+
+		public override int GetHashCode ()
+		{
+			return (int) Ascent ^ (int) Descent ^ (int) Height ^ (int) MaxXAdvance ^ (int) MaxYAdvance;
+		}
+
+		public static bool operator == (FontExtents extents, FontExtents other)
+		{
+			return extents.Ascent == other.Ascent && extents.Descent == other.Descent && extents.Height == other.Height && extents.MaxXAdvance == other.MaxXAdvance && extents.MaxYAdvance == other.MaxYAdvance;
+		}
+
+		public static bool operator != (FontExtents extents, FontExtents other)
+		{
+			return !(extents == other);
+		}
+	}
+}
diff --git a/Crow/src/GraphicBackends/vkvg/Matrix.cs b/Crow/src/GraphicBackends/vkvg/Matrix.cs
new file mode 100644
index 00000000..12e9e382
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/Matrix.cs
@@ -0,0 +1,92 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+namespace vkvg {
+	public struct Matrix {
+		float xx; float yx;
+		float xy; float yy;
+		float x0; float y0;
+
+		public float XX { get { return xx; } set { xx = value; } }
+		public float YX { get { return yx; } set { yx = value; } }
+		public float XY { get { return xy; } set { xy = value; } }
+		public float YY { get { return yy; } set { yy = value; } }
+		public float X0 { get { return x0; } set { x0 = value; } }
+		public float Y0 { get { return y0; } set { y0 = value; } }
+
+		public static Matrix Create (float xx, float yx, float xy, float yy, float x0, float y0) {
+			Matrix tmp;
+			NativeMethods.vkvg_matrix_init (out tmp, xx, yx, xy, yy, x0, y0);
+			return tmp;
+		}
+		public static Matrix CreateTranslation (float tx, float ty) {
+			Matrix tmp;
+			NativeMethods.vkvg_matrix_init_translate (out tmp, tx, ty);
+			return tmp;
+		}
+		public static Matrix CreateRotation (float radian) {
+			Matrix tmp;
+			NativeMethods.vkvg_matrix_init_rotate (out tmp, radian);
+			return tmp;
+		}
+		public static Matrix CreateScale (float sx, float sy) {
+			Matrix tmp;
+			NativeMethods.vkvg_matrix_init_scale (out tmp, sx, sy);
+			return tmp;
+		}
+		public static Matrix Identity {
+			get {
+				Matrix tmp;
+				NativeMethods.vkvg_matrix_init_identity (out tmp);
+				return tmp;
+			}
+		}
+
+		public void Translate (float tx, float ty) {
+			Matrix tmp = this;
+			NativeMethods.vkvg_matrix_translate (ref tmp, tx, ty);
+			xx = tmp.xx; yx = tmp.yx;
+			xy = tmp.xy; yy = tmp.yy;
+			x0 = tmp.x0; y0 = tmp.y0;
+		}
+		public void Rotate (float radian) {
+			Matrix tmp = this;
+			NativeMethods.vkvg_matrix_rotate (ref tmp, radian);
+			xx = tmp.xx; yx = tmp.yx;
+			xy = tmp.xy; yy = tmp.yy;
+			x0 = tmp.x0; y0 = tmp.y0;
+		}
+		public void Scale (float sx, float sy) {
+			Matrix tmp = this;
+			NativeMethods.vkvg_matrix_scale (ref tmp, sx, sy);
+			xx = tmp.xx; yx = tmp.yx;
+			xy = tmp.xy; yy = tmp.yy;
+			x0 = tmp.x0; y0 = tmp.y0;
+		}
+		public void Invert () {
+			Matrix tmp = this;
+			NativeMethods.vkvg_matrix_invert (ref tmp);
+			xx = tmp.xx; yx = tmp.yx;
+			xy = tmp.xy; yy = tmp.yy;
+			x0 = tmp.x0; y0 = tmp.y0;
+		}
+		public void TransformDistance (ref float dx, ref float dy) {
+			NativeMethods.vkvg_matrix_transform_distance (ref this, ref dx, ref dy);
+		}
+		public void TransformPoint (ref float px, ref float py) {
+			NativeMethods.vkvg_matrix_transform_distance (ref this, ref px, ref py);
+		}
+
+		public static Matrix operator *(Matrix a, Matrix b) {
+			Matrix tmp;
+			NativeMethods.vkvg_matrix_multiply (out tmp, ref a, ref b);
+			return tmp;
+		}
+
+		public override string ToString () {
+			return string.Format ($"({xx};{yx};{xy};{yy};{x0};{y0})");
+		}
+	}
+}
diff --git a/Crow/src/GraphicBackends/vkvg/NativeMethods.cs b/Crow/src/GraphicBackends/vkvg/NativeMethods.cs
new file mode 100644
index 00000000..48f2eb6b
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/NativeMethods.cs
@@ -0,0 +1,272 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace vkvg
+{
+    internal static class NativeMethods
+    {
+        const string libvkvg = "vkvg";
+
+        #region Device
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_device_create(IntPtr instance, IntPtr phy, IntPtr dev, uint qFamIdx, uint qIndex);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_device_destroy(IntPtr device);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_device_create_multisample(IntPtr inst, IntPtr phy, IntPtr vkdev, uint qFamIdx, uint qIndex, SampleCount samples, bool deferredResolve);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_device_reference(IntPtr dev);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern uint vkvg_device_get_reference_count(IntPtr dev);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_device_set_dpy(IntPtr dev, int hdpy, int vdpy);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_device_get_dpy(IntPtr dev, out int hdpy, out int vdpy);
+        #endregion
+
+        #region Context
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_create(IntPtr surface);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_destroy(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_flush(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_new_path(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_new_sub_path(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_close_path(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_line_to(IntPtr ctx, float x, float y);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_rel_line_to(IntPtr ctx, float x, float y);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_move_to(IntPtr ctx, float x, float y);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_rel_move_to(IntPtr ctx, float x, float y);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_arc(IntPtr ctx, float xc, float yc, float radius, float a1, float a2);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_arc_negative(IntPtr ctx, float xc, float yc, float radius, float a1, float a2);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_curve_to(IntPtr ctx, float x1, float y1, float x2, float y2, float x3, float y3);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_rel_curve_to(IntPtr ctx, float x1, float y1, float x2, float y2, float x3, float y3);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_rectangle(IntPtr ctx, float x, float y, float width, float height);
+
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_scale(IntPtr ctx, float sx, float sy);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_translate(IntPtr ctx, float dx, float dy);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_rotate(IntPtr ctx, float alpha);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_transform(IntPtr ctx, ref Matrix matrix);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_matrix(IntPtr ctx, ref Matrix matrix);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_get_matrix(IntPtr ctx, out Matrix matrix);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_identity_matrix(IntPtr ctx);
+
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_stroke(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_stroke_preserve(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_clip(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_clip_preserve(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_reset_clip(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_fill(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_fill_preserve(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_paint(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_source_rgba(IntPtr ctx, float r, float g, float b, float a);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_line_width(IntPtr ctx, float width);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_line_cap(IntPtr ctx, LineCap cap);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_line_join(IntPtr ctx, LineJoin join);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_operator(IntPtr ctx, Operator op);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern FillRule vkvg_get_fill_rule(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_fill_rule(IntPtr ctx, FillRule fr);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern Operator vkvg_get_operator(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_source_surface(IntPtr ctx, IntPtr surf, float x, float y);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_source(IntPtr ctx, IntPtr pattern);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_font_extents(IntPtr ctx, out FontExtents extents);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_text_extents(IntPtr ctx, byte[] utf8, out TextExtents extents);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_select_font_face(IntPtr ctx, string name);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_set_font_size(IntPtr ctx, uint size);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_show_text(IntPtr ctx, byte [] utf8);
+
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_save(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_restore(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_clear(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern float vkvg_get_line_width(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern LineCap vkvg_get_line_cap(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern LineJoin vkvg_get_line_join(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_get_source(IntPtr ctx);
+
+		[DllImport (libvkvg, CallingConvention = CallingConvention.Cdecl)]
+		internal static extern void vkvg_set_dash (IntPtr ctx, float[] dashes, uint dashCount, float offset);
+
+		//void vkvg_set_dash (VkvgContext ctx, const float* dashes, uint32_t num_dashes, float offset);
+		//void vkvg_get_dash (VkvgContext ctx, const float* dashes, uint32_t* num_dashes, float* offset
+
+	   [DllImport (libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_reference(IntPtr ctx);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern uint vkvg_get_reference_count(IntPtr ctx);
+        #endregion
+
+        #region TextRun
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_text_run_create(IntPtr ctx, byte[] utf8);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_text_run_destroy(IntPtr textRun);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_show_text_run(IntPtr ctx, IntPtr textRun);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_text_run_get_extents(IntPtr textRun, out TextExtents extents);
+        #endregion
+
+        #region Pattern
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_create();
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_reference(IntPtr pat);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern uint vkvg_pattern_get_reference_count(IntPtr pat);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_create_rgba(float r, float g, float b, float a);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_create_rgb(float r, float g, float b);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_create_for_surface(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_create_linear(float x0, float y0, float x1, float y1);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_pattern_create_radial(float cx0, float cy0, float radius0,
+                                             float cx1, float cy1, float radius1);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_pattern_destroy(IntPtr pat);
+
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_pattern_add_color_stop(IntPtr pat, float offset, float r, float g, float b, float a);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_pattern_set_extend(IntPtr pat, Extend extend);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_pattern_set_filter(IntPtr pat, Filter filter);
+
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern Extend vkvg_pattern_get_extend(IntPtr pat);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern Filter vkvg_pattern_get_filter(IntPtr pat);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern PatternType vkvg_pattern_get_type(IntPtr pat);
+        #endregion
+
+        #region Matrices
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_init_identity(out Matrix matrix);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_init(out Matrix matrix,
+           float xx, float yx,
+           float xy, float yy,
+           float x0, float y0);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_init_translate(out Matrix matrix, float tx, float ty);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_init_scale(out Matrix matrix, float sx, float sy);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_init_rotate(out Matrix matrix, float radians);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_translate(ref Matrix matrix, float tx, float ty);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_scale(ref Matrix matrix, float sx, float sy);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_rotate(ref Matrix matrix, float radians);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_multiply(out Matrix result, ref Matrix a, ref Matrix b);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_transform_distance(ref Matrix matrix, ref float dx, ref float dy);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_transform_point(ref Matrix matrix, ref float x, ref float y);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_matrix_invert(ref Matrix matrix);
+        #endregion
+
+        #region Surface
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_create(IntPtr device, uint width, uint height);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_create_from_image(IntPtr dev, string filePath);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_create_from_svg(IntPtr dev, string filePath);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_create_from_svg_fragment(IntPtr dev, byte[] filePath);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_create_from_bitmap(IntPtr dev, ref byte[] data, uint width, uint height);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_surface_destroy(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_get_vk_image(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int vkvg_surface_get_width(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int vkvg_surface_get_height(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_surface_clear(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr vkvg_surface_reference(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern uint vkvg_surface_get_reference_count(IntPtr surf);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_surface_write_to_png(IntPtr surf, [MarshalAs(UnmanagedType.LPStr)]string path);
+        #endregion
+
+        #region NSVG
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr nsvg_load_file(IntPtr dev, string filePath);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern IntPtr nsvg_load(IntPtr dev, byte[] fragment);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void nsvg_destroy(IntPtr nsvgImage);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void nsvg_get_size(IntPtr nsvgImage, out int width, out int height);
+        [DllImport(libvkvg, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void vkvg_render_svg(IntPtr ctx, IntPtr nsvgImage, string subId);
+        #endregion
+    }
+}
+
diff --git a/Crow/src/GraphicBackends/vkvg/Pattern.cs b/Crow/src/GraphicBackends/vkvg/Pattern.cs
new file mode 100644
index 00000000..a66ffdcc
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/Pattern.cs
@@ -0,0 +1,92 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+namespace vkvg
+{
+    public class Pattern : IDisposable
+    {
+
+        IntPtr handle = IntPtr.Zero;
+
+        #region CTORS & DTOR
+        protected Pattern(IntPtr handle)
+        {
+            this.handle = handle;
+        }
+        public Pattern()
+        {
+            handle = NativeMethods.vkvg_pattern_create();
+        }
+        public Pattern(float r, float g, float b)
+        {
+            handle = NativeMethods.vkvg_pattern_create_rgb(r, g, b);
+        }
+        public Pattern(float r, float g, float b, float a)
+        {
+            handle = NativeMethods.vkvg_pattern_create_rgba(r, g, b, a);
+        }
+        public Pattern(Surface surf)
+        {
+            handle = NativeMethods.vkvg_pattern_create_for_surface(surf.Handle);
+        }
+
+        ~Pattern()
+        {
+            Dispose(false);
+        }
+        #endregion
+
+        public static Pattern CreateLinearGradient(float x0, float y0, float x1, float y1)
+        {
+            return new Pattern(NativeMethods.vkvg_pattern_create_linear(x0, y0, x1, y1));
+        }
+        public static Pattern CreateRadialGradient(float cx0, float cy0, float radius0,
+                                                     float cx1, float cy1, float radius1)
+        {
+            return new Pattern(NativeMethods.vkvg_pattern_create_radial(cx0, cy0, radius0, cx1, cy1, radius1));
+        }
+
+        public void AddReference()
+        {
+            NativeMethods.vkvg_pattern_reference(handle);
+        }
+        public uint References() => NativeMethods.vkvg_pattern_get_reference_count(handle);
+
+        public IntPtr Handle { get { return handle; } }
+
+        public Extend Extend
+        {
+            set { NativeMethods.vkvg_pattern_set_extend(handle, value); }
+            get { return NativeMethods.vkvg_pattern_get_extend(handle); }
+        }
+        public Filter Filter
+        {
+            set { NativeMethods.vkvg_pattern_set_filter(handle, value); }
+            get { return NativeMethods.vkvg_pattern_get_filter(handle); }
+        }
+
+        public void AddColorStop(float offset, float r, float g, float b, float a = 1f)
+        {
+            NativeMethods.vkvg_pattern_add_color_stop(handle, offset, r, g, b, a);
+        }
+
+        #region IDisposable implementation
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposing || handle == IntPtr.Zero)
+                return;
+
+            NativeMethods.vkvg_pattern_destroy(handle);
+            handle = IntPtr.Zero;
+        }
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/Crow/src/GraphicBackends/vkvg/Surface.cs b/Crow/src/GraphicBackends/vkvg/Surface.cs
new file mode 100644
index 00000000..79f92dcd
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/Surface.cs
@@ -0,0 +1,85 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+
+namespace vkvg
+{
+	public class Surface: IDisposable
+	{		
+		IntPtr handle = IntPtr.Zero;
+		Device vkvgDev;
+
+		public Surface (Device device, int width, int heigth)
+		{
+			vkvgDev = device;
+			handle = NativeMethods.vkvg_surface_create (device.Handle, (uint)width, (uint)heigth);
+		}
+		public Surface (Device device, ref byte[] data, int width, int heigth)
+		{
+			vkvgDev = device;
+			handle = NativeMethods.vkvg_surface_create (device.Handle, (uint)width, (uint)heigth);
+		}
+		public Surface (Device device, string imgPath) {
+			vkvgDev = device;
+			handle = NativeMethods.vkvg_surface_create_from_image (device.Handle, imgPath);
+		}
+
+
+		Surface (IntPtr devHandle, int width, int heigth)
+		{
+			handle = NativeMethods.vkvg_surface_create (devHandle, (uint)width, (uint)heigth);
+		}
+		~Surface ()
+		{
+			Dispose (false);
+		}
+
+		public IntPtr Handle { get { return handle; }}
+		public IntPtr VkImage { get { return NativeMethods.vkvg_surface_get_vk_image (handle); }}
+		public int Width { get { return NativeMethods.vkvg_surface_get_width (handle); }}
+		public int Height { get { return NativeMethods.vkvg_surface_get_height (handle); }}
+
+		public void AddReference () {
+			NativeMethods.vkvg_surface_reference (handle);
+		}
+		public uint References () => NativeMethods.vkvg_surface_get_reference_count (handle);
+
+//		public Surface CreateSimilar (uint width, uint height) {
+//			return new Surface (handle, width, height);
+//		}
+//		public Surface CreateSimilar (int width, int height) {
+//			return new Surface (handle, (uint)width, (uint)height);
+//		}
+
+		public void Flush () {
+			throw new NotImplementedException ();
+		}
+
+		public void WriteToPng (string path) {
+			NativeMethods.vkvg_surface_write_to_png (handle, path);
+		}
+		public void Clear () {
+			NativeMethods.vkvg_surface_clear (handle);
+		}
+
+		#region IDisposable implementation
+		public void Dispose ()
+		{
+			Dispose (true);
+			GC.SuppressFinalize (this);
+		}
+
+		protected virtual void Dispose (bool disposing)
+		{
+			if (!disposing || handle == IntPtr.Zero)
+				return;
+
+			NativeMethods.vkvg_surface_destroy (handle);
+			handle = IntPtr.Zero;
+		}
+		#endregion
+	}
+}
+
diff --git a/Crow/src/GraphicBackends/vkvg/TextExtents.cs b/Crow/src/GraphicBackends/vkvg/TextExtents.cs
new file mode 100644
index 00000000..becca773
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/TextExtents.cs
@@ -0,0 +1,72 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace vkvg
+{
+	[StructLayout (LayoutKind.Sequential)]
+	public struct TextExtents
+	{
+		float xbearing;
+		float ybearing;
+		float width;
+		float height;
+		float xadvance;
+		float yadvance;
+		
+		public float XBearing {
+			get { return xbearing; }
+			set { xbearing = value; }
+		}
+		
+		public float YBearing {
+			get { return ybearing; }
+			set { ybearing = value; }
+		}
+		
+		public float Width {
+			get { return width; }
+			set { width = value; }
+		}
+		
+		public float Height {
+			get { return height; }
+			set { height = value; }
+		}
+		
+		public float XAdvance {
+			get { return xadvance; }
+			set { xadvance = value; }
+		}
+		
+		public float YAdvance {
+			get { return yadvance; }
+			set { yadvance = value; }
+		}
+
+		public override bool Equals (object obj)
+		{
+			if (obj is TextExtents)
+				return this == (TextExtents)obj;
+			return false;
+		}
+
+		public override int GetHashCode ()
+		{
+			return (int)XBearing ^ (int)YBearing ^ (int)Width ^ (int)Height ^ (int)XAdvance ^ (int)YAdvance;
+		}
+
+		public static bool operator == (TextExtents extents, TextExtents other)
+		{
+			return extents.XBearing == other.XBearing && extents.YBearing == other.YBearing && extents.Width == other.Width && extents.Height == other.Height && extents.XAdvance == other.XAdvance && extents.YAdvance == other.YAdvance;
+		}
+
+		public static bool operator != (TextExtents extents, TextExtents other)
+		{
+			return !(extents == other);
+		}
+	}
+}
diff --git a/Crow/src/GraphicBackends/vkvg/TextRun.cs b/Crow/src/GraphicBackends/vkvg/TextRun.cs
new file mode 100644
index 00000000..95cdf7f3
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/TextRun.cs
@@ -0,0 +1,54 @@
+// Copyright (c) 2018-2020  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System;
+namespace vkvg {
+	public class TextRun : IDisposable {
+
+		IntPtr handle = IntPtr.Zero;
+
+		#region CTORS & DTOR
+		protected TextRun(IntPtr handle) {
+			this.handle = handle;
+		}
+		public TextRun(string text) {
+			handle = NativeMethods.vkvg_text_run_create (handle, Context.TerminateUtf8(text));
+		}
+
+		~TextRun() {
+			Dispose (false);
+		}
+		#endregion
+
+		//public void AddReference () {
+		//	NativeMethods.vkvg_pattern_reference (handle);
+		//}
+		//public uint References () => NativeMethods.vkvg_pattern_get_reference_count (handle);
+
+		public IntPtr Handle { get { return handle; } }
+
+		public TextExtents Extents {
+			get {
+				TextExtents extents;
+				NativeMethods.vkvg_text_run_get_extents (handle, out extents);
+				return extents;
+			}
+		}
+
+		#region IDisposable implementation
+		public void Dispose () {
+			Dispose (true);
+			GC.SuppressFinalize (this);
+		}
+
+		protected virtual void Dispose (bool disposing) {
+			if (!disposing || handle == IntPtr.Zero)
+				return;
+
+			NativeMethods.vkvg_text_run_destroy (handle);
+			handle = IntPtr.Zero;
+		}
+		#endregion
+	}
+}
\ No newline at end of file
diff --git a/Crow/src/GraphicBackends/vkvg/tmp/FontOptions.cs b/Crow/src/GraphicBackends/vkvg/tmp/FontOptions.cs
new file mode 100644
index 00000000..690f2145
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/tmp/FontOptions.cs
@@ -0,0 +1,74 @@
+//from Mono.Cairo
+//fake FontOptions
+
+using System;
+
+namespace vkvg
+{
+	public enum SubpixelOrder
+	{
+		Default,
+		Rgb,
+		Bgr,
+		Vrgb,
+		Vbgr,
+	}
+	public enum HintMetrics
+	{
+		Default,
+		Off,
+		On,
+	}
+	public enum HintStyle
+	{
+		Default,
+		None,
+		Slight,
+		Medium,
+		Full,
+	}		
+	public class FontOptions : IDisposable
+	{
+		public FontOptions () {	}
+
+
+		public FontOptions Copy () => default;
+
+
+		public IntPtr Handle {
+			get ;
+		}
+
+	
+		public void Merge (FontOptions other)
+		{
+		}
+
+		public void Dispose() {}
+
+		public Antialias Antialias {
+			get ;
+			set ;
+		}
+
+		public HintMetrics HintMetrics {
+			get ;
+			set ;
+		}
+
+		public HintStyle HintStyle {
+			get ;
+			set ;
+		}
+
+		public Status Status {
+			get ;
+		}
+
+		public SubpixelOrder SubpixelOrder {
+			get ;
+			set ;
+		}
+	}
+}
+
diff --git a/Crow/src/GraphicBackends/vkvg/tmp/Rectangles.cs b/Crow/src/GraphicBackends/vkvg/tmp/Rectangles.cs
new file mode 100644
index 00000000..c50236ce
--- /dev/null
+++ b/Crow/src/GraphicBackends/vkvg/tmp/Rectangles.cs
@@ -0,0 +1,116 @@
+// Copyright (c) 2021  Jean-Philippe Bruyère <jp_bruyere@hotmail.com>
+//
+// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
+
+using System.Collections.Generic;
+using vkvg;
+
+namespace Crow {
+	public enum RegionOverlap {
+		In,
+		Out,
+		Part,
+	}	
+	public class Region
+    {
+        public List<Rectangle> list = new List<Rectangle>();
+        public int count
+        {
+            get { return list.Count; }
+        }
+		public bool IsEmpty => list.Count == 0;
+
+        public void AddRectangle(Rectangle r)
+        {
+			if (doesNotContain (r)) {
+				list.Add (r);
+				boundsUpToDate = false;
+			}
+        }
+        public void Reset()
+        {
+            list = new List<Rectangle>();
+			_bounds = default;
+			boundsUpToDate = true;
+        }
+        bool doesNotContain(Rectangle r)
+        {
+            foreach (Rectangle rInList in list)
+                if (rInList.ContainsOrIsEqual(r))
+                    return false;
+            return true;
+        }
+
+        public bool intersect(Rectangle r)
+        {
+            foreach (Rectangle rInList in list)
+                if (rInList.Intersect(r))
+                    return true;
+            return false;
+        }
+		public void stroke(Context ctx, Color c)
+		{
+			foreach (Rectangle r in list)
+				ctx.Rectangle(r);
+
+			ctx.SetSource(c);
+
+			ctx.LineWidth = 2;
+			ctx.Stroke ();
+		}
+        public void clearAndClip(Context ctx)
+        {
+			if (list.Count == 0)
+				return;
+            foreach (Rectangle r in list)
+                ctx.Rectangle(r);
+
+			ctx.ClipPreserve();
+			ctx.Operator = Operator.Clear;
+            ctx.Fill();
+            ctx.Operator = Operator.Over;
+        }
+
+        public void clip(Context ctx)
+        {
+            foreach (Rectangle r in list)
+            	ctx.Rectangle(r);
+
+            ctx.Clip();
+        }
+
+		Rectangle _bounds;
+		bool boundsUpToDate = true;
+		public Rectangle Bounds {
+			get {
+				if (!boundsUpToDate) {
+					if (list.Count > 0) {
+						_bounds = list [0];
+						for (int i = 1; i < list.Count; i++) {
+							_bounds += list [i];
+						}
+					} else
+						_bounds = default;
+					boundsUpToDate = true;
+				}
+				return _bounds;
+			}
+		}
+		public void clear(Context ctx)
+        {
+            foreach (Rectangle r in list)
+                ctx.Rectangle(r);
+            ctx.Operator = Operator.Clear;
+            ctx.Fill();
+            ctx.Operator = Operator.Over;
+        }
+		public override string ToString ()
+		{
+			string tmp = "";
+			foreach (Rectangle r in list) {
+				tmp += r.ToString ();
+			}
+			return tmp;
+		}
+    }
+}
diff --git a/Crow/src/Interface.cs b/Crow/src/Interface.cs
index 60f0e221..ff2caff4 100644
--- a/Crow/src/Interface.cs
+++ b/Crow/src/Interface.cs
@@ -13,7 +13,11 @@ using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Crow.IML;
 using Glfw;
 using Path = System.IO.Path;
diff --git a/Crow/src/Text/IEditableTextWidget.cs b/Crow/src/Text/IEditableTextWidget.cs
index 19f3ebd0..28ca1d07 100644
--- a/Crow/src/Text/IEditableTextWidget.cs
+++ b/Crow/src/Text/IEditableTextWidget.cs
@@ -2,7 +2,11 @@
 //
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Border.cs b/Crow/src/Widgets/Border.cs
index c702d9ac..0dc156f2 100644
--- a/Crow/src/Widgets/Border.cs
+++ b/Crow/src/Widgets/Border.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 using System;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/ColorSlider.cs b/Crow/src/Widgets/ColorSlider.cs
index 9ac4b8a0..18be2120 100644
--- a/Crow/src/Widgets/ColorSlider.cs
+++ b/Crow/src/Widgets/ColorSlider.cs
@@ -4,7 +4,11 @@
 
 using System;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Glfw;
 
 namespace Crow
diff --git a/Crow/src/Widgets/DockWindow.cs b/Crow/src/Widgets/DockWindow.cs
index af47ce3a..f111c458 100644
--- a/Crow/src/Widgets/DockWindow.cs
+++ b/Crow/src/Widgets/DockWindow.cs
@@ -4,7 +4,11 @@
 
 using System;
 using System.Xml.Serialization;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Glfw;
 
 namespace Crow
diff --git a/Crow/src/Widgets/Gauge.cs b/Crow/src/Widgets/Gauge.cs
index 5964da02..635ace58 100644
--- a/Crow/src/Widgets/Gauge.cs
+++ b/Crow/src/Widgets/Gauge.cs
@@ -5,7 +5,11 @@
 
 using System;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow {
 	public class Gauge : Widget
diff --git a/Crow/src/Widgets/GraduatedSlider.cs b/Crow/src/Widgets/GraduatedSlider.cs
index 01b8b4cb..8d286a9f 100644
--- a/Crow/src/Widgets/GraduatedSlider.cs
+++ b/Crow/src/Widgets/GraduatedSlider.cs
@@ -2,7 +2,11 @@
 //
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Group.cs b/Crow/src/Widgets/Group.cs
index 55cc6353..936d5e4a 100644
--- a/Crow/src/Widgets/Group.cs
+++ b/Crow/src/Widgets/Group.cs
@@ -5,7 +5,11 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Threading;
 
 using static Crow.Logger;
diff --git a/Crow/src/Widgets/GroupBase.cs b/Crow/src/Widgets/GroupBase.cs
index 4c0267f8..69829a6f 100644
--- a/Crow/src/Widgets/GroupBase.cs
+++ b/Crow/src/Widgets/GroupBase.cs
@@ -5,7 +5,11 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Threading;
 
 using static Crow.Logger;
diff --git a/Crow/src/Widgets/HueSelector.cs b/Crow/src/Widgets/HueSelector.cs
index 64f8217e..11f4ac5a 100644
--- a/Crow/src/Widgets/HueSelector.cs
+++ b/Crow/src/Widgets/HueSelector.cs
@@ -27,7 +27,11 @@
 using System;
 using System.Xml.Serialization;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Image.cs b/Crow/src/Widgets/Image.cs
index 5f8ed06e..c3551d08 100644
--- a/Crow/src/Widgets/Image.cs
+++ b/Crow/src/Widgets/Image.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Xml.Serialization;
 using System.ComponentModel;
 using System.Diagnostics;
diff --git a/Crow/src/Widgets/Label.cs b/Crow/src/Widgets/Label.cs
index c8b4b238..1ec42957 100644
--- a/Crow/src/Widgets/Label.cs
+++ b/Crow/src/Widgets/Label.cs
@@ -4,7 +4,11 @@
 
 using System;
 using System.Linq;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.ComponentModel;
 using Glfw;
 using Crow.Text;
diff --git a/Crow/src/Widgets/OldLabel.cs b/Crow/src/Widgets/OldLabel.cs
index 17179ae3..c0c94703 100644
--- a/Crow/src/Widgets/OldLabel.cs
+++ b/Crow/src/Widgets/OldLabel.cs
@@ -5,7 +5,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Text.RegularExpressions;
 using System.ComponentModel;
 
diff --git a/Crow/src/Widgets/OldTextBox.cs b/Crow/src/Widgets/OldTextBox.cs
index c236bf4b..01ef5ac0 100644
--- a/Crow/src/Widgets/OldTextBox.cs
+++ b/Crow/src/Widgets/OldTextBox.cs
@@ -2,7 +2,11 @@
 //
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Glfw;
 using System;
 
diff --git a/Crow/src/Widgets/PrivateContainer.cs b/Crow/src/Widgets/PrivateContainer.cs
index 22a34f1c..0c35306a 100644
--- a/Crow/src/Widgets/PrivateContainer.cs
+++ b/Crow/src/Widgets/PrivateContainer.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using static Crow.Logger;
 namespace Crow
 {
diff --git a/Crow/src/Widgets/ProgressBar.cs b/Crow/src/Widgets/ProgressBar.cs
index ca9a1a3d..53f90017 100644
--- a/Crow/src/Widgets/ProgressBar.cs
+++ b/Crow/src/Widgets/ProgressBar.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/SaturationValueSelector.cs b/Crow/src/Widgets/SaturationValueSelector.cs
index c56dd30c..386a0ce0 100644
--- a/Crow/src/Widgets/SaturationValueSelector.cs
+++ b/Crow/src/Widgets/SaturationValueSelector.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Scroller.cs b/Crow/src/Widgets/Scroller.cs
index 314a7503..8a8f640d 100644
--- a/Crow/src/Widgets/Scroller.cs
+++ b/Crow/src/Widgets/Scroller.cs
@@ -4,7 +4,11 @@
 
 using System;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Glfw;
 
 namespace Crow
diff --git a/Crow/src/Widgets/Shape.cs b/Crow/src/Widgets/Shape.cs
index dd8fefdf..da00ae37 100644
--- a/Crow/src/Widgets/Shape.cs
+++ b/Crow/src/Widgets/Shape.cs
@@ -6,7 +6,11 @@ using System;
 using System.ComponentModel;
 using System.IO;
 using System.Text;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Slider.cs b/Crow/src/Widgets/Slider.cs
index dd977128..9ac69f8e 100644
--- a/Crow/src/Widgets/Slider.cs
+++ b/Crow/src/Widgets/Slider.cs
@@ -2,7 +2,11 @@
 //
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System;
 using System.ComponentModel;
 
diff --git a/Crow/src/Widgets/TabView.cs b/Crow/src/Widgets/TabView.cs
index 8872b92b..c5a7ad3b 100644
--- a/Crow/src/Widgets/TabView.cs
+++ b/Crow/src/Widgets/TabView.cs
@@ -4,7 +4,11 @@
 
 using System;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Linq;
 
 namespace Crow
diff --git a/Crow/src/Widgets/Table copy.cs b/Crow/src/Widgets/Table copy.cs
index 5aeaede8..14349c6d 100644
--- a/Crow/src/Widgets/Table copy.cs
+++ b/Crow/src/Widgets/Table copy.cs
@@ -4,7 +4,11 @@
 using System;
 using System.ComponentModel;
 using System.Linq;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Table.cs b/Crow/src/Widgets/Table.cs
index 27cfb963..9fb8e1ad 100644
--- a/Crow/src/Widgets/Table.cs
+++ b/Crow/src/Widgets/Table.cs
@@ -4,7 +4,11 @@
 using System;
 using System.ComponentModel;
 using System.Linq;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/TableRow copy.cs b/Crow/src/Widgets/TableRow copy.cs
index 2184d486..0387c38f 100644
--- a/Crow/src/Widgets/TableRow copy.cs
+++ b/Crow/src/Widgets/TableRow copy.cs
@@ -4,7 +4,11 @@
 using System;
 using System.ComponentModel;
 using System.Linq;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Glfw;
 
 namespace Crow
diff --git a/Crow/src/Widgets/TableRow.cs b/Crow/src/Widgets/TableRow.cs
index 1ce02c15..1155ba8c 100644
--- a/Crow/src/Widgets/TableRow.cs
+++ b/Crow/src/Widgets/TableRow.cs
@@ -4,7 +4,11 @@
 using System;
 using System.ComponentModel;
 using System.Linq;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Glfw;
 
 namespace Crow
diff --git a/Crow/src/Widgets/TemplatedControl.cs b/Crow/src/Widgets/TemplatedControl.cs
index 5110d941..2c147dc1 100644
--- a/Crow/src/Widgets/TemplatedControl.cs
+++ b/Crow/src/Widgets/TemplatedControl.cs
@@ -7,7 +7,11 @@ using System.ComponentModel;
 using System.IO;
 using System.Reflection;
 using System.Xml;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/TemplatedGroup.cs b/Crow/src/Widgets/TemplatedGroup.cs
index a1ac759c..5a3fadf2 100644
--- a/Crow/src/Widgets/TemplatedGroup.cs
+++ b/Crow/src/Widgets/TemplatedGroup.cs
@@ -8,7 +8,11 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using System.Threading;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Crow.IML;
 
 namespace Crow {
diff --git a/Crow/src/Widgets/TestCairoPatch.cs b/Crow/src/Widgets/TestCairoPatch.cs
index 99230a05..ba598959 100644
--- a/Crow/src/Widgets/TestCairoPatch.cs
+++ b/Crow/src/Widgets/TestCairoPatch.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/TextBox.cs b/Crow/src/Widgets/TextBox.cs
index ece9adc0..84085298 100644
--- a/Crow/src/Widgets/TextBox.cs
+++ b/Crow/src/Widgets/TextBox.cs
@@ -2,7 +2,11 @@
 //
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Crow.Text;
 using Glfw;
 using System;
diff --git a/Crow/src/Widgets/TextRun.cs b/Crow/src/Widgets/TextRun.cs
index d118974f..9efa5cbf 100644
--- a/Crow/src/Widgets/TextRun.cs
+++ b/Crow/src/Widgets/TextRun.cs
@@ -7,7 +7,11 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using System.Text.RegularExpressions;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Trend.cs b/Crow/src/Widgets/Trend.cs
index 1a2d1375..808cd769 100644
--- a/Crow/src/Widgets/Trend.cs
+++ b/Crow/src/Widgets/Trend.cs
@@ -4,7 +4,11 @@
 
 using System.Collections.Generic;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 namespace Crow
 {
diff --git a/Crow/src/Widgets/Widget.cs b/Crow/src/Widgets/Widget.cs
index c38f373b..08cc52d0 100644
--- a/Crow/src/Widgets/Widget.cs
+++ b/Crow/src/Widgets/Widget.cs
@@ -8,7 +8,11 @@ using System.ComponentModel;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Runtime.CompilerServices;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Diagnostics;
 using Crow.IML;
 using System.Threading;
diff --git a/Crow/src/rsvg/Handle.cs b/Crow/src/rsvg/Handle.cs
index ca06ad25..bd0e725e 100644
--- a/Crow/src/rsvg/Handle.cs
+++ b/Crow/src/rsvg/Handle.cs
@@ -1,5 +1,9 @@
 //Copyright GPL2
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 
 
 namespace Rsvg {
diff --git a/Directory.Build.props b/Directory.Build.props
index 41e78201..faca4414 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -10,6 +10,7 @@
 		<CrowPackageVersion>$(CrowVersion)-beta</CrowPackageVersion>
 		<CrowStbSharp>true</CrowStbSharp>
 		<CrowDebugLogEnabled>false</CrowDebugLogEnabled>
+		<CrowVkvgBackend>true</CrowVkvgBackend>
 		<GlfwSharpVersion>0.2.11-beta</GlfwSharpVersion>
 	</PropertyGroup>
 </Project>
diff --git a/Samples/DebugLogAnalyzer/src/DbgEventWidget.cs b/Samples/DebugLogAnalyzer/src/DbgEventWidget.cs
index 6af3f6df..51ce140e 100644
--- a/Samples/DebugLogAnalyzer/src/DbgEventWidget.cs
+++ b/Samples/DebugLogAnalyzer/src/DbgEventWidget.cs
@@ -4,7 +4,11 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Crow.DebugLogger;
 using DebugLogAnalyzer;
 
diff --git a/Samples/DebugLogAnalyzer/src/DbgLogViewer.cs b/Samples/DebugLogAnalyzer/src/DbgLogViewer.cs
index d39cc62a..ddbb9183 100644
--- a/Samples/DebugLogAnalyzer/src/DbgLogViewer.cs
+++ b/Samples/DebugLogAnalyzer/src/DbgLogViewer.cs
@@ -10,7 +10,11 @@ using System.ComponentModel;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using Crow.DebugLogger;
 using DebugLogAnalyzer;
 
diff --git a/Samples/DebugLogAnalyzer/src/DebugInterface.cs b/Samples/DebugLogAnalyzer/src/DebugInterface.cs
index 26a1eddf..f29da259 100644
--- a/Samples/DebugLogAnalyzer/src/DebugInterface.cs
+++ b/Samples/DebugLogAnalyzer/src/DebugInterface.cs
@@ -3,7 +3,11 @@
 // This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
 
 using System;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Threading;
 
 namespace Crow
diff --git a/Samples/DebugLogAnalyzer/src/DebugInterfaceWidget.cs b/Samples/DebugLogAnalyzer/src/DebugInterfaceWidget.cs
index c8b27d7d..9ac6a63c 100644
--- a/Samples/DebugLogAnalyzer/src/DebugInterfaceWidget.cs
+++ b/Samples/DebugLogAnalyzer/src/DebugInterfaceWidget.cs
@@ -7,7 +7,11 @@ using Glfw;
 using System.Reflection;
 using System.Runtime.Loader;
 using System.IO;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Diagnostics;
 using System.Collections.Generic;
 using Crow.DebugLogger;
diff --git a/Samples/PathPainter/Painter.cs b/Samples/PathPainter/Painter.cs
index 7e3c97bb..2f7f4c81 100644
--- a/Samples/PathPainter/Painter.cs
+++ b/Samples/PathPainter/Painter.cs
@@ -1,4 +1,8 @@
-using Crow.Cairo;
+#if VKVG
+using vkvg;
+#else
+using Crow.Cairo;
+#endif
 using System;
 using System.Collections;
 using System.Collections.Generic;
diff --git a/Samples/common/Editor.cs b/Samples/common/Editor.cs
index 95de4569..be8dfcdb 100644
--- a/Samples/common/Editor.cs
+++ b/Samples/common/Editor.cs
@@ -8,7 +8,11 @@ using System;
 using Glfw;
 using Crow.Text;
 using System.Collections.Generic;
+#if VKVG
+using vkvg;
+#else
 using Crow.Cairo;
+#endif
 using System.Threading.Tasks;
 using System.Linq;
 
diff --git a/Samples/dragNdrop/dragNdrop.cs b/Samples/dragNdrop/dragNdrop.cs
index 2ca41357..9f62ec7f 100644
--- a/Samples/dragNdrop/dragNdrop.cs
+++ b/Samples/dragNdrop/dragNdrop.cs
@@ -1,4 +1,9 @@
-using Crow;
+#if VKVG
+using vkvg;
+#else
+using Crow.Cairo;
+#endif
+
 
 namespace tests
 {
@@ -28,9 +33,9 @@ namespace tests
 			Rectangle r = e.DragSource.LastPaintedSlot;
             startGroup = e.DragSource.Parent as Group;
 
-            Crow.Cairo.Surface dragImg = surf.CreateSimilar (Crow.Cairo.Content.ColorAlpha,
+            Surface dragImg = surf.CreateSimilar (Content.ColorAlpha,
 				r.Width, r.Height);
-            using (Crow.Cairo.Context gr = new Crow.Cairo.Context(dragImg)) {
+            using (Context gr = new Context(dragImg)) {
                 gr.SetSource (e.DragSource.bmp, 0, 0);
                 gr.Paint ();
             }