working c# backend

111 files changed, 11549 insertions, 64 deletions

diff --git a/ddl/Generate.hs b/ddl/Generate.hs
index 532a012..9f9b7b8 100644
--- a/ddl/Generate.hs
+++ b/ddl/Generate.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE OverloadedStrings, FlexibleInstances #-}
+{-# LANGUAGE OverloadedStrings, FlexibleInstances, LambdaCase #-}
 import qualified Data.Text.Lazy as LText
 import           Text.EDE
 import           Text.EDE.Filters
@@ -7,8 +7,10 @@ import           Data.HashMap.Strict          (HashMap)
 import qualified Data.HashMap.Strict          as HashMap
 import           Data.Text                    (Text)
 import qualified Data.Map as Map
+import qualified Data.Set as Set
 
 import System.Directory
+import System.FilePath
 
 import Data.Time.Clock
 import Control.Monad.Writer
@@ -32,7 +34,7 @@ main = do
   dataCs <- eitherParseFile "templates/data.cs.ede"
   dataHs <- eitherParseFile "templates/data.hs.ede"
   dataPs <- eitherParseFile "templates/data.purs.ede"
-  let generate (ModuleDef name imports def) = do
+  let generate mod@(ModuleDef name imports def) = do
         dt <- getCurrentTime
         let env = fromPairs
               [ "dataAndType" .= def
@@ -40,6 +42,8 @@ main = do
               , "moduleName"  .= name
               , "dateTime"    .= dt
               , "imports"     .= imports
+              , "usedTypes"   .= collectTypes aliasMap mod
+              , "usedCSTypes" .= (Set.fromList $ Map.elems $ Map.fromList [ (csType name aliasMap t,t) | t <- Set.toList $ collectTypes aliasMap mod])
               ]
             aliasMap = Map.fromList [(n,t) | TypeAlias n t <- def]
             mylib :: HashMap Text Term
@@ -50,7 +54,8 @@ main = do
                 , "hsType"          @: hsType aliasMap
                 , "psType"          @: psType aliasMap
                 , "cppType"         @: cppType aliasMap
-                , "csType"          @: csType aliasMap
+                , "csType"          @: csType name aliasMap
+                , "csTypeEnum"      @: csTypeEnum aliasMap
                 , "javaType"        @: javaType aliasMap
                 , "swiftType"       @: swiftType aliasMap
                 ]
@@ -63,12 +68,23 @@ main = do
         either error (\x -> writeFile ("out/" ++ name ++ "2.hpp") $ LText.unpack x) $ dataHpp2 >>= (\t -> eitherRenderWith mylib t env)
         either error (\x -> writeFile ("out/" ++ name ++ ".hpp") $ LText.unpack x) $ dataHpp >>= (\t -> eitherRenderWith mylib t env)
         either error (\x -> writeFile ("out/" ++ name ++ ".cpp") $ LText.unpack x) $ dataCpp >>= (\t -> eitherRenderWith mylib t env)
-        {-
         -- Java
-        either error (\x -> writeFile ("out/" ++ name ++ ".java") $ LText.unpack x) $ dataJava >>= (\t -> eitherRenderWith mylib t env)
+        forM_ [a | a@DataDef{} <- def {-TODO-}] $ \d -> do
+          let env = fromPairs
+                [ "def"         .= d
+                , "moduleName"  .= name
+                , "dateTime"    .= dt
+                , "imports"     .= imports
+                ]
+              toPath a = flip map a $ \case
+                '.' -> '/'
+                c -> c
+              fname = "out/java/" ++ toPath name ++ "/" ++ dataName d ++ ".java"
+              dir = takeDirectory fname
+          createDirectoryIfMissing True dir
+          either error (\x -> writeFile fname $ LText.unpack x) $ dataJava >>= (\t -> eitherRenderWith mylib t env)
         -- C#
         either error (\x -> writeFile ("out/" ++ name ++ ".cs") $ LText.unpack x) $ dataCs >>= (\t -> eitherRenderWith mylib t env)
-        -}
         -- Swift
         either error (\x -> writeFile ("out/" ++ name ++ ".swift") $ LText.unpack x) $ dataSwift >>= (\t -> eitherRenderWith mylib t env)
   mapM_ generate $ execWriter modules
diff --git a/ddl/Language.hs b/ddl/Language.hs
index 79c3056..989314a 100644
--- a/ddl/Language.hs
+++ b/ddl/Language.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE RankNTypes, OverloadedStrings, DeriveGeneric, LambdaCase #-}
+{-# LANGUAGE RankNTypes, OverloadedStrings, DeriveGeneric, LambdaCase, RecordWildCards #-}
 module Language where
 
 import GHC.Generics
@@ -8,6 +8,8 @@ import Data.String
 import Data.List
 import Data.Map (Map)
 import qualified Data.Map as Map
+import Data.Set (Set)
+import qualified Data.Set as Set
 
 instance IsString Type where
   fromString a = Data a
@@ -67,17 +69,21 @@ data Type
   | Float
   | Bool
   | String
-  | V2 Type
-  | V3 Type
-  | V4 Type
   -- higher order types
-  | Array Type
-  | List Type
-  | Maybe Type
-  | Map Type Type
+  | V2 { type_ :: Type }
+  | V3 { type_ :: Type }
+  | V4 { type_ :: Type }
+  | Array { type_ :: Type }
+  | List { type_ :: Type }
+  | Maybe { type_ :: Type }
+  | Map { key_ :: Type, value_ :: Type }
   -- user defined
-  | Data String
-  deriving (Show,Generic)
+  | Data { name_ :: String }
+  deriving (Show,Generic,Eq,Ord)
+
+collectTypes :: AliasMap -> ModuleDef -> Set Type
+collectTypes aliasMap ModuleDef{..} = Set.fromList $ map (normalize aliasMap) $ concat
+  [Data dataName : [fieldType | ConstructorDef{..} <- constructors, Field{..} <- fields] | DataDef{..} <- definitions]
 
 parens :: String -> String
 parens a
@@ -88,6 +94,13 @@ type AliasMap = Map String Type
 
 normalize :: AliasMap -> Type -> Type
 normalize aliasMap t@(Data n) = Map.findWithDefault t n aliasMap
+normalize aliasMap (V2 t) = V2 $ normalize aliasMap t
+normalize aliasMap (V3 t) = V3 $ normalize aliasMap t
+normalize aliasMap (V4 t) = V4 $ normalize aliasMap t
+normalize aliasMap (Array t) = Array $ normalize aliasMap t
+normalize aliasMap (List t) = List $ normalize aliasMap t
+normalize aliasMap (Maybe t) = Maybe $ normalize aliasMap t
+normalize aliasMap (Map k v) = Map (normalize aliasMap k) (normalize aliasMap v)
 normalize _ t = t
 
 psType :: AliasMap -> Type -> String
@@ -222,21 +235,41 @@ swiftType aliasMap = \case
 javaType :: AliasMap -> Type -> String -- TODO
 javaType aliasMap a = case normalize aliasMap a of
   Data t        -> t
-  Int           -> "int"
-  Int32         -> "int"
-  Word          -> "int"
-  Word32        -> "int"
-  Float         -> "float"
-  Bool          -> "boolean"
+  Int           -> "Integer"
+  Int32         -> "Integer"
+  Word          -> "Integer"
+  Word32        -> "Integer"
+  Float         -> "Float"
+  Bool          -> "Boolean"
   String        -> "String"
   Array t       -> "ArrayList<" ++ javaType aliasMap t ++ ">"
   List t        -> "ArrayList<" ++ javaType aliasMap t ++ ">"
   Map k v       -> "HashMap<" ++ javaType aliasMap k ++ ", " ++ javaType aliasMap v ++ ">"
-  _ -> "int"
+  _ -> "Integer"
+  --x -> error $ "javaType: " ++ show x
 
-csType :: AliasMap -> Type -> String -- TODO
-csType aliasMap a = case normalize aliasMap a of
+csTypeEnum :: AliasMap -> Type -> String
+csTypeEnum aliasMap a = case normalize aliasMap a of
   Data t        -> t
+  Int           -> "Int"
+  Int32         -> "Int32"
+  Word          -> "Word"
+  Word32        -> "Word32"
+  Float         -> "Float"
+  Bool          -> "Bool"
+  String        -> "String"
+  Array t       -> "Array_" ++ csTypeEnum aliasMap t
+  List t        -> "List_" ++ csTypeEnum aliasMap t
+  Map k v       -> "Map_" ++ csTypeEnum aliasMap k ++ "_" ++ csTypeEnum aliasMap v
+  V2 t          -> "V2_" ++ csTypeEnum aliasMap t
+  V3 t          -> "V3_" ++ csTypeEnum aliasMap t
+  V4 t          -> "V4_" ++ csTypeEnum aliasMap t
+  Maybe t       -> "Maybe_" ++ csTypeEnum aliasMap t
+  x -> error $ "unknown type: " ++ show x
+
+csType :: String -> AliasMap -> Type -> String -- TODO
+csType moduleName aliasMap a = case normalize aliasMap a of
+  Data t        -> "global::" ++ moduleName ++ "." ++ t
   Int           -> "int"
   Int32         -> "int"
   Word          -> "uint"
@@ -244,10 +277,14 @@ csType aliasMap a = case normalize aliasMap a of
   Float         -> "float"
   Bool          -> "bool"
   String        -> "string"
-  Array t       -> "List<" ++ csType aliasMap t ++ ">"
-  List t        -> "List<" ++ csType aliasMap t ++ ">"
-  Map k v       -> "Dictionary<" ++ csType aliasMap k ++ ", " ++ csType aliasMap v ++ ">"
-  _ -> "int"
+  Array t       -> "List<" ++ csType moduleName aliasMap t ++ ">"
+  List t        -> "List<" ++ csType moduleName aliasMap t ++ ">"
+  Map k v       -> "Dictionary<" ++ csType moduleName aliasMap k ++ ", " ++ csType moduleName aliasMap v ++ ">"
+  V2 t          -> "V2<" ++ csType moduleName aliasMap t ++ ">"
+  V3 t          -> "V3<" ++ csType moduleName aliasMap t ++ ">"
+  V4 t          -> "V4<" ++ csType moduleName aliasMap t ++ ">"
+  Maybe t       -> "Maybe<" ++ parens (csType moduleName aliasMap t) ++ ">"
+  x -> error $ "unknown type: " ++ show x
 
 cppType :: AliasMap -> Type -> String
 cppType aliasMap = \case
diff --git a/ddl/out/LambdaCube.IR.cpp b/ddl/out/LambdaCube.IR.cpp
index 75a26eb..fcbcebb 100644
--- a/ddl/out/LambdaCube.IR.cpp
+++ b/ddl/out/LambdaCube.IR.cpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.426854000000Z
+=======
+// 2016-03-20T21:42:12.172652000000Z
+>>>>>>> working c# backend
 
 #include "LambdaCube.IR.hpp"
 template<> json toJSON<std::shared_ptr<ArrayValue>>(std::shared_ptr<ArrayValue> &v) {
diff --git a/ddl/out/LambdaCube.IR.cs b/ddl/out/LambdaCube.IR.cs
new file mode 100644
index 0000000..3c603ca
--- /dev/null
+++ b/ddl/out/LambdaCube.IR.cs
@@ -0,0 +1,4444 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+
+namespace LambdaCube.IR {
+  class ArrayValue {
+      public enum Tag { 
+        VBoolArray,
+        VIntArray,
+        VWordArray,
+        VFloatArray
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class VBoolArray : LambdaCube.IR.ArrayValue { 
+      public List<bool> _0;
+      public VBoolArray() { tag = LambdaCube.IR.ArrayValue.Tag.VBoolArray; }
+    };
+    class VIntArray : LambdaCube.IR.ArrayValue { 
+      public List<int> _0;
+      public VIntArray() { tag = LambdaCube.IR.ArrayValue.Tag.VIntArray; }
+    };
+    class VWordArray : LambdaCube.IR.ArrayValue { 
+      public List<uint> _0;
+      public VWordArray() { tag = LambdaCube.IR.ArrayValue.Tag.VWordArray; }
+    };
+    class VFloatArray : LambdaCube.IR.ArrayValue { 
+      public List<float> _0;
+      public VFloatArray() { tag = LambdaCube.IR.ArrayValue.Tag.VFloatArray; }
+    };
+  }
+  class Value {
+      public enum Tag { 
+        VBool,
+        VV2B,
+        VV3B,
+        VV4B,
+        VWord,
+        VV2U,
+        VV3U,
+        VV4U,
+        VInt,
+        VV2I,
+        VV3I,
+        VV4I,
+        VFloat,
+        VV2F,
+        VV3F,
+        VV4F,
+        VM22F,
+        VM23F,
+        VM24F,
+        VM32F,
+        VM33F,
+        VM34F,
+        VM42F,
+        VM43F,
+        VM44F
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class VBool : LambdaCube.IR.Value { 
+      public bool _0;
+      public VBool() { tag = LambdaCube.IR.Value.Tag.VBool; }
+    };
+    class VV2B : LambdaCube.IR.Value { 
+      public V2<bool> _0;
+      public VV2B() { tag = LambdaCube.IR.Value.Tag.VV2B; }
+    };
+    class VV3B : LambdaCube.IR.Value { 
+      public V3<bool> _0;
+      public VV3B() { tag = LambdaCube.IR.Value.Tag.VV3B; }
+    };
+    class VV4B : LambdaCube.IR.Value { 
+      public V4<bool> _0;
+      public VV4B() { tag = LambdaCube.IR.Value.Tag.VV4B; }
+    };
+    class VWord : LambdaCube.IR.Value { 
+      public uint _0;
+      public VWord() { tag = LambdaCube.IR.Value.Tag.VWord; }
+    };
+    class VV2U : LambdaCube.IR.Value { 
+      public V2<uint> _0;
+      public VV2U() { tag = LambdaCube.IR.Value.Tag.VV2U; }
+    };
+    class VV3U : LambdaCube.IR.Value { 
+      public V3<uint> _0;
+      public VV3U() { tag = LambdaCube.IR.Value.Tag.VV3U; }
+    };
+    class VV4U : LambdaCube.IR.Value { 
+      public V4<uint> _0;
+      public VV4U() { tag = LambdaCube.IR.Value.Tag.VV4U; }
+    };
+    class VInt : LambdaCube.IR.Value { 
+      public int _0;
+      public VInt() { tag = LambdaCube.IR.Value.Tag.VInt; }
+    };
+    class VV2I : LambdaCube.IR.Value { 
+      public V2<int> _0;
+      public VV2I() { tag = LambdaCube.IR.Value.Tag.VV2I; }
+    };
+    class VV3I : LambdaCube.IR.Value { 
+      public V3<int> _0;
+      public VV3I() { tag = LambdaCube.IR.Value.Tag.VV3I; }
+    };
+    class VV4I : LambdaCube.IR.Value { 
+      public V4<int> _0;
+      public VV4I() { tag = LambdaCube.IR.Value.Tag.VV4I; }
+    };
+    class VFloat : LambdaCube.IR.Value { 
+      public float _0;
+      public VFloat() { tag = LambdaCube.IR.Value.Tag.VFloat; }
+    };
+    class VV2F : LambdaCube.IR.Value { 
+      public V2<float> _0;
+      public VV2F() { tag = LambdaCube.IR.Value.Tag.VV2F; }
+    };
+    class VV3F : LambdaCube.IR.Value { 
+      public V3<float> _0;
+      public VV3F() { tag = LambdaCube.IR.Value.Tag.VV3F; }
+    };
+    class VV4F : LambdaCube.IR.Value { 
+      public V4<float> _0;
+      public VV4F() { tag = LambdaCube.IR.Value.Tag.VV4F; }
+    };
+    class VM22F : LambdaCube.IR.Value { 
+      public V2<V2<float>> _0;
+      public VM22F() { tag = LambdaCube.IR.Value.Tag.VM22F; }
+    };
+    class VM23F : LambdaCube.IR.Value { 
+      public V3<V2<float>> _0;
+      public VM23F() { tag = LambdaCube.IR.Value.Tag.VM23F; }
+    };
+    class VM24F : LambdaCube.IR.Value { 
+      public V4<V2<float>> _0;
+      public VM24F() { tag = LambdaCube.IR.Value.Tag.VM24F; }
+    };
+    class VM32F : LambdaCube.IR.Value { 
+      public V2<V3<float>> _0;
+      public VM32F() { tag = LambdaCube.IR.Value.Tag.VM32F; }
+    };
+    class VM33F : LambdaCube.IR.Value { 
+      public V3<V3<float>> _0;
+      public VM33F() { tag = LambdaCube.IR.Value.Tag.VM33F; }
+    };
+    class VM34F : LambdaCube.IR.Value { 
+      public V4<V3<float>> _0;
+      public VM34F() { tag = LambdaCube.IR.Value.Tag.VM34F; }
+    };
+    class VM42F : LambdaCube.IR.Value { 
+      public V2<V4<float>> _0;
+      public VM42F() { tag = LambdaCube.IR.Value.Tag.VM42F; }
+    };
+    class VM43F : LambdaCube.IR.Value { 
+      public V3<V4<float>> _0;
+      public VM43F() { tag = LambdaCube.IR.Value.Tag.VM43F; }
+    };
+    class VM44F : LambdaCube.IR.Value { 
+      public V4<V4<float>> _0;
+      public VM44F() { tag = LambdaCube.IR.Value.Tag.VM44F; }
+    };
+  }
+  class InputType {
+      public enum Tag { 
+        Bool,
+        V2B,
+        V3B,
+        V4B,
+        Word,
+        V2U,
+        V3U,
+        V4U,
+        Int,
+        V2I,
+        V3I,
+        V4I,
+        Float,
+        V2F,
+        V3F,
+        V4F,
+        M22F,
+        M23F,
+        M24F,
+        M32F,
+        M33F,
+        M34F,
+        M42F,
+        M43F,
+        M44F,
+        STexture1D,
+        STexture2D,
+        STextureCube,
+        STexture1DArray,
+        STexture2DArray,
+        STexture2DRect,
+        FTexture1D,
+        FTexture2D,
+        FTexture3D,
+        FTextureCube,
+        FTexture1DArray,
+        FTexture2DArray,
+        FTexture2DMS,
+        FTexture2DMSArray,
+        FTextureBuffer,
+        FTexture2DRect,
+        ITexture1D,
+        ITexture2D,
+        ITexture3D,
+        ITextureCube,
+        ITexture1DArray,
+        ITexture2DArray,
+        ITexture2DMS,
+        ITexture2DMSArray,
+        ITextureBuffer,
+        ITexture2DRect,
+        UTexture1D,
+        UTexture2D,
+        UTexture3D,
+        UTextureCube,
+        UTexture1DArray,
+        UTexture2DArray,
+        UTexture2DMS,
+        UTexture2DMSArray,
+        UTextureBuffer,
+        UTexture2DRect
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class PointSpriteCoordOrigin {
+      public enum Tag { 
+        LowerLeft,
+        UpperLeft
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class PointSize {
+      public enum Tag { 
+        PointSize,
+        ProgramPointSize
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class PointSize : LambdaCube.IR.PointSize { 
+      public float _0;
+      public PointSize() { tag = LambdaCube.IR.PointSize.Tag.PointSize; }
+    };
+  }
+  class PolygonOffset {
+      public enum Tag { 
+        NoOffset,
+        Offset
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Offset : LambdaCube.IR.PolygonOffset { 
+      public float _0;
+      public float _1;
+      public Offset() { tag = LambdaCube.IR.PolygonOffset.Tag.Offset; }
+    };
+  }
+  class FrontFace {
+      public enum Tag { 
+        CCW,
+        CW
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class PolygonMode {
+      public enum Tag { 
+        PolygonPoint,
+        PolygonLine,
+        PolygonFill
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class PolygonPoint : LambdaCube.IR.PolygonMode { 
+      public global::LambdaCube.IR.PointSize _0;
+      public PolygonPoint() { tag = LambdaCube.IR.PolygonMode.Tag.PolygonPoint; }
+    };
+    class PolygonLine : LambdaCube.IR.PolygonMode { 
+      public float _0;
+      public PolygonLine() { tag = LambdaCube.IR.PolygonMode.Tag.PolygonLine; }
+    };
+  }
+  class ProvokingVertex {
+      public enum Tag { 
+        FirstVertex,
+        LastVertex
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class CullMode {
+      public enum Tag { 
+        CullNone,
+        CullFront,
+        CullBack
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class CullFront : LambdaCube.IR.CullMode { 
+      public global::LambdaCube.IR.FrontFace _0;
+      public CullFront() { tag = LambdaCube.IR.CullMode.Tag.CullFront; }
+    };
+    class CullBack : LambdaCube.IR.CullMode { 
+      public global::LambdaCube.IR.FrontFace _0;
+      public CullBack() { tag = LambdaCube.IR.CullMode.Tag.CullBack; }
+    };
+  }
+  class ComparisonFunction {
+      public enum Tag { 
+        Never,
+        Less,
+        Equal,
+        Lequal,
+        Greater,
+        Notequal,
+        Gequal,
+        Always
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class StencilOperation {
+      public enum Tag { 
+        OpZero,
+        OpKeep,
+        OpReplace,
+        OpIncr,
+        OpIncrWrap,
+        OpDecr,
+        OpDecrWrap,
+        OpInvert
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class BlendEquation {
+      public enum Tag { 
+        FuncAdd,
+        FuncSubtract,
+        FuncReverseSubtract,
+        Min,
+        Max
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class BlendingFactor {
+      public enum Tag { 
+        Zero,
+        One,
+        SrcColor,
+        OneMinusSrcColor,
+        DstColor,
+        OneMinusDstColor,
+        SrcAlpha,
+        OneMinusSrcAlpha,
+        DstAlpha,
+        OneMinusDstAlpha,
+        ConstantColor,
+        OneMinusConstantColor,
+        ConstantAlpha,
+        OneMinusConstantAlpha,
+        SrcAlphaSaturate
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class LogicOperation {
+      public enum Tag { 
+        Clear,
+        And,
+        AndReverse,
+        Copy,
+        AndInverted,
+        Noop,
+        Xor,
+        Or,
+        Nor,
+        Equiv,
+        Invert,
+        OrReverse,
+        CopyInverted,
+        OrInverted,
+        Nand,
+        Set
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class StencilOps {
+      public enum Tag { 
+        StencilOps
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class StencilOps : LambdaCube.IR.StencilOps { 
+      public global::LambdaCube.IR.StencilOperation frontStencilOp;
+      public global::LambdaCube.IR.StencilOperation backStencilOp;
+      public StencilOps() { tag = LambdaCube.IR.StencilOps.Tag.StencilOps; }
+    };
+  }
+  class StencilTest {
+      public enum Tag { 
+        StencilTest
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class StencilTest : LambdaCube.IR.StencilTest { 
+      public global::LambdaCube.IR.ComparisonFunction stencilComparision;
+      public int stencilReference;
+      public uint stencilMask;
+      public StencilTest() { tag = LambdaCube.IR.StencilTest.Tag.StencilTest; }
+    };
+  }
+  class StencilTests {
+      public enum Tag { 
+        StencilTests
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class StencilTests : LambdaCube.IR.StencilTests { 
+      public global::LambdaCube.IR.StencilTest _0;
+      public global::LambdaCube.IR.StencilTest _1;
+      public StencilTests() { tag = LambdaCube.IR.StencilTests.Tag.StencilTests; }
+    };
+  }
+  class FetchPrimitive {
+      public enum Tag { 
+        Points,
+        Lines,
+        Triangles,
+        LinesAdjacency,
+        TrianglesAdjacency
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class OutputPrimitive {
+      public enum Tag { 
+        TrianglesOutput,
+        LinesOutput,
+        PointsOutput
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class ColorArity {
+      public enum Tag { 
+        Red,
+        RG,
+        RGB,
+        RGBA
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class Blending {
+      public enum Tag { 
+        NoBlending,
+        BlendLogicOp,
+        Blend
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class BlendLogicOp : LambdaCube.IR.Blending { 
+      public global::LambdaCube.IR.LogicOperation _0;
+      public BlendLogicOp() { tag = LambdaCube.IR.Blending.Tag.BlendLogicOp; }
+    };
+    class Blend : LambdaCube.IR.Blending { 
+      public global::LambdaCube.IR.BlendEquation colorEqSrc;
+      public global::LambdaCube.IR.BlendEquation alphaEqSrc;
+      public global::LambdaCube.IR.BlendingFactor colorFSrc;
+      public global::LambdaCube.IR.BlendingFactor colorFDst;
+      public global::LambdaCube.IR.BlendingFactor alphaFSrc;
+      public global::LambdaCube.IR.BlendingFactor alphaFDst;
+      public V4<float> color;
+      public Blend() { tag = LambdaCube.IR.Blending.Tag.Blend; }
+    };
+  }
+  class RasterContext {
+      public enum Tag { 
+        PointCtx,
+        LineCtx,
+        TriangleCtx
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class PointCtx : LambdaCube.IR.RasterContext { 
+      public global::LambdaCube.IR.PointSize _0;
+      public float _1;
+      public global::LambdaCube.IR.PointSpriteCoordOrigin _2;
+      public PointCtx() { tag = LambdaCube.IR.RasterContext.Tag.PointCtx; }
+    };
+    class LineCtx : LambdaCube.IR.RasterContext { 
+      public float _0;
+      public global::LambdaCube.IR.ProvokingVertex _1;
+      public LineCtx() { tag = LambdaCube.IR.RasterContext.Tag.LineCtx; }
+    };
+    class TriangleCtx : LambdaCube.IR.RasterContext { 
+      public global::LambdaCube.IR.CullMode _0;
+      public global::LambdaCube.IR.PolygonMode _1;
+      public global::LambdaCube.IR.PolygonOffset _2;
+      public global::LambdaCube.IR.ProvokingVertex _3;
+      public TriangleCtx() { tag = LambdaCube.IR.RasterContext.Tag.TriangleCtx; }
+    };
+  }
+  class FragmentOperation {
+      public enum Tag { 
+        DepthOp,
+        StencilOp,
+        ColorOp
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class DepthOp : LambdaCube.IR.FragmentOperation { 
+      public global::LambdaCube.IR.ComparisonFunction _0;
+      public bool _1;
+      public DepthOp() { tag = LambdaCube.IR.FragmentOperation.Tag.DepthOp; }
+    };
+    class StencilOp : LambdaCube.IR.FragmentOperation { 
+      public global::LambdaCube.IR.StencilTests _0;
+      public global::LambdaCube.IR.StencilOps _1;
+      public global::LambdaCube.IR.StencilOps _2;
+      public StencilOp() { tag = LambdaCube.IR.FragmentOperation.Tag.StencilOp; }
+    };
+    class ColorOp : LambdaCube.IR.FragmentOperation { 
+      public global::LambdaCube.IR.Blending _0;
+      public global::LambdaCube.IR.Value _1;
+      public ColorOp() { tag = LambdaCube.IR.FragmentOperation.Tag.ColorOp; }
+    };
+  }
+  class AccumulationContext {
+      public enum Tag { 
+        AccumulationContext
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class AccumulationContext : LambdaCube.IR.AccumulationContext { 
+      public Maybe<string> accViewportName;
+      public List<global::LambdaCube.IR.FragmentOperation> accOperations;
+      public AccumulationContext() { tag = LambdaCube.IR.AccumulationContext.Tag.AccumulationContext; }
+    };
+  }
+  class TextureDataType {
+      public enum Tag { 
+        FloatT,
+        IntT,
+        WordT,
+        ShadowT
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class FloatT : LambdaCube.IR.TextureDataType { 
+      public global::LambdaCube.IR.ColorArity _0;
+      public FloatT() { tag = LambdaCube.IR.TextureDataType.Tag.FloatT; }
+    };
+    class IntT : LambdaCube.IR.TextureDataType { 
+      public global::LambdaCube.IR.ColorArity _0;
+      public IntT() { tag = LambdaCube.IR.TextureDataType.Tag.IntT; }
+    };
+    class WordT : LambdaCube.IR.TextureDataType { 
+      public global::LambdaCube.IR.ColorArity _0;
+      public WordT() { tag = LambdaCube.IR.TextureDataType.Tag.WordT; }
+    };
+  }
+  class TextureType {
+      public enum Tag { 
+        Texture1D,
+        Texture2D,
+        Texture3D,
+        TextureCube,
+        TextureRect,
+        Texture2DMS,
+        TextureBuffer
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Texture1D : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public int _1;
+      public Texture1D() { tag = LambdaCube.IR.TextureType.Tag.Texture1D; }
+    };
+    class Texture2D : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public int _1;
+      public Texture2D() { tag = LambdaCube.IR.TextureType.Tag.Texture2D; }
+    };
+    class Texture3D : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public Texture3D() { tag = LambdaCube.IR.TextureType.Tag.Texture3D; }
+    };
+    class TextureCube : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public TextureCube() { tag = LambdaCube.IR.TextureType.Tag.TextureCube; }
+    };
+    class TextureRect : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public TextureRect() { tag = LambdaCube.IR.TextureType.Tag.TextureRect; }
+    };
+    class Texture2DMS : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public int _1;
+      public int _2;
+      public bool _3;
+      public Texture2DMS() { tag = LambdaCube.IR.TextureType.Tag.Texture2DMS; }
+    };
+    class TextureBuffer : LambdaCube.IR.TextureType { 
+      public global::LambdaCube.IR.TextureDataType _0;
+      public TextureBuffer() { tag = LambdaCube.IR.TextureType.Tag.TextureBuffer; }
+    };
+  }
+  class MipMap {
+      public enum Tag { 
+        Mip,
+        NoMip,
+        AutoMip
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Mip : LambdaCube.IR.MipMap { 
+      public int _0;
+      public int _1;
+      public Mip() { tag = LambdaCube.IR.MipMap.Tag.Mip; }
+    };
+    class AutoMip : LambdaCube.IR.MipMap { 
+      public int _0;
+      public int _1;
+      public AutoMip() { tag = LambdaCube.IR.MipMap.Tag.AutoMip; }
+    };
+  }
+  class Filter {
+      public enum Tag { 
+        Nearest,
+        Linear,
+        NearestMipmapNearest,
+        NearestMipmapLinear,
+        LinearMipmapNearest,
+        LinearMipmapLinear
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class EdgeMode {
+      public enum Tag { 
+        Repeat,
+        MirroredRepeat,
+        ClampToEdge,
+        ClampToBorder
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class ImageSemantic {
+      public enum Tag { 
+        Depth,
+        Stencil,
+        Color
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class ImageRef {
+      public enum Tag { 
+        TextureImage,
+        Framebuffer
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class TextureImage : LambdaCube.IR.ImageRef { 
+      public int _0;
+      public int _1;
+      public Maybe<int> _2;
+      public TextureImage() { tag = LambdaCube.IR.ImageRef.Tag.TextureImage; }
+    };
+    class Framebuffer : LambdaCube.IR.ImageRef { 
+      public global::LambdaCube.IR.ImageSemantic _0;
+      public Framebuffer() { tag = LambdaCube.IR.ImageRef.Tag.Framebuffer; }
+    };
+  }
+  class ClearImage {
+      public enum Tag { 
+        ClearImage
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class ClearImage : LambdaCube.IR.ClearImage { 
+      public global::LambdaCube.IR.ImageSemantic imageSemantic;
+      public global::LambdaCube.IR.Value clearValue;
+      public ClearImage() { tag = LambdaCube.IR.ClearImage.Tag.ClearImage; }
+    };
+  }
+  class Command {
+      public enum Tag { 
+        SetRasterContext,
+        SetAccumulationContext,
+        SetRenderTarget,
+        SetProgram,
+        SetSamplerUniform,
+        SetTexture,
+        SetSampler,
+        RenderSlot,
+        RenderStream,
+        ClearRenderTarget,
+        GenerateMipMap,
+        SaveImage,
+        LoadImage
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class SetRasterContext : LambdaCube.IR.Command { 
+      public global::LambdaCube.IR.RasterContext _0;
+      public SetRasterContext() { tag = LambdaCube.IR.Command.Tag.SetRasterContext; }
+    };
+    class SetAccumulationContext : LambdaCube.IR.Command { 
+      public global::LambdaCube.IR.AccumulationContext _0;
+      public SetAccumulationContext() { tag = LambdaCube.IR.Command.Tag.SetAccumulationContext; }
+    };
+    class SetRenderTarget : LambdaCube.IR.Command { 
+      public int _0;
+      public SetRenderTarget() { tag = LambdaCube.IR.Command.Tag.SetRenderTarget; }
+    };
+    class SetProgram : LambdaCube.IR.Command { 
+      public int _0;
+      public SetProgram() { tag = LambdaCube.IR.Command.Tag.SetProgram; }
+    };
+    class SetSamplerUniform : LambdaCube.IR.Command { 
+      public string _0;
+      public int _1;
+      public SetSamplerUniform() { tag = LambdaCube.IR.Command.Tag.SetSamplerUniform; }
+    };
+    class SetTexture : LambdaCube.IR.Command { 
+      public int _0;
+      public int _1;
+      public SetTexture() { tag = LambdaCube.IR.Command.Tag.SetTexture; }
+    };
+    class SetSampler : LambdaCube.IR.Command { 
+      public int _0;
+      public Maybe<int> _1;
+      public SetSampler() { tag = LambdaCube.IR.Command.Tag.SetSampler; }
+    };
+    class RenderSlot : LambdaCube.IR.Command { 
+      public int _0;
+      public RenderSlot() { tag = LambdaCube.IR.Command.Tag.RenderSlot; }
+    };
+    class RenderStream : LambdaCube.IR.Command { 
+      public int _0;
+      public RenderStream() { tag = LambdaCube.IR.Command.Tag.RenderStream; }
+    };
+    class ClearRenderTarget : LambdaCube.IR.Command { 
+      public List<global::LambdaCube.IR.ClearImage> _0;
+      public ClearRenderTarget() { tag = LambdaCube.IR.Command.Tag.ClearRenderTarget; }
+    };
+    class GenerateMipMap : LambdaCube.IR.Command { 
+      public int _0;
+      public GenerateMipMap() { tag = LambdaCube.IR.Command.Tag.GenerateMipMap; }
+    };
+    class SaveImage : LambdaCube.IR.Command { 
+      public int _0;
+      public global::LambdaCube.IR.ImageRef _1;
+      public SaveImage() { tag = LambdaCube.IR.Command.Tag.SaveImage; }
+    };
+    class LoadImage : LambdaCube.IR.Command { 
+      public global::LambdaCube.IR.ImageRef _0;
+      public int _1;
+      public LoadImage() { tag = LambdaCube.IR.Command.Tag.LoadImage; }
+    };
+  }
+  class SamplerDescriptor {
+      public enum Tag { 
+        SamplerDescriptor
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class SamplerDescriptor : LambdaCube.IR.SamplerDescriptor { 
+      public global::LambdaCube.IR.EdgeMode samplerWrapS;
+      public Maybe<global::LambdaCube.IR.EdgeMode> samplerWrapT;
+      public Maybe<global::LambdaCube.IR.EdgeMode> samplerWrapR;
+      public global::LambdaCube.IR.Filter samplerMinFilter;
+      public global::LambdaCube.IR.Filter samplerMagFilter;
+      public global::LambdaCube.IR.Value samplerBorderColor;
+      public Maybe<float> samplerMinLod;
+      public Maybe<float> samplerMaxLod;
+      public float samplerLodBias;
+      public Maybe<global::LambdaCube.IR.ComparisonFunction> samplerCompareFunc;
+      public SamplerDescriptor() { tag = LambdaCube.IR.SamplerDescriptor.Tag.SamplerDescriptor; }
+    };
+  }
+  class TextureDescriptor {
+      public enum Tag { 
+        TextureDescriptor
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class TextureDescriptor : LambdaCube.IR.TextureDescriptor { 
+      public global::LambdaCube.IR.TextureType textureType;
+      public global::LambdaCube.IR.Value textureSize;
+      public global::LambdaCube.IR.ImageSemantic textureSemantic;
+      public global::LambdaCube.IR.SamplerDescriptor textureSampler;
+      public int textureBaseLevel;
+      public int textureMaxLevel;
+      public TextureDescriptor() { tag = LambdaCube.IR.TextureDescriptor.Tag.TextureDescriptor; }
+    };
+  }
+  class Parameter {
+      public enum Tag { 
+        Parameter
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Parameter : LambdaCube.IR.Parameter { 
+      public string name;
+      public global::LambdaCube.IR.InputType ty;
+      public Parameter() { tag = LambdaCube.IR.Parameter.Tag.Parameter; }
+    };
+  }
+  class Program {
+      public enum Tag { 
+        Program
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Program : LambdaCube.IR.Program { 
+      public Dictionary<string, global::LambdaCube.IR.InputType> programUniforms;
+      public Dictionary<string, global::LambdaCube.IR.Parameter> programStreams;
+      public Dictionary<string, global::LambdaCube.IR.InputType> programInTextures;
+      public List<global::LambdaCube.IR.Parameter> programOutput;
+      public string vertexShader;
+      public Maybe<string> geometryShader;
+      public string fragmentShader;
+      public Program() { tag = LambdaCube.IR.Program.Tag.Program; }
+    };
+  }
+  class Slot {
+      public enum Tag { 
+        Slot
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Slot : LambdaCube.IR.Slot { 
+      public string slotName;
+      public Dictionary<string, global::LambdaCube.IR.InputType> slotStreams;
+      public Dictionary<string, global::LambdaCube.IR.InputType> slotUniforms;
+      public global::LambdaCube.IR.FetchPrimitive slotPrimitive;
+      public List<int> slotPrograms;
+      public Slot() { tag = LambdaCube.IR.Slot.Tag.Slot; }
+    };
+  }
+  class StreamData {
+      public enum Tag { 
+        StreamData
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class StreamData : LambdaCube.IR.StreamData { 
+      public Dictionary<string, global::LambdaCube.IR.ArrayValue> streamData;
+      public Dictionary<string, global::LambdaCube.IR.InputType> streamType;
+      public global::LambdaCube.IR.FetchPrimitive streamPrimitive;
+      public List<int> streamPrograms;
+      public StreamData() { tag = LambdaCube.IR.StreamData.Tag.StreamData; }
+    };
+  }
+  class TargetItem {
+      public enum Tag { 
+        TargetItem
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class TargetItem : LambdaCube.IR.TargetItem { 
+      public global::LambdaCube.IR.ImageSemantic targetSemantic;
+      public Maybe<global::LambdaCube.IR.ImageRef> targetRef;
+      public TargetItem() { tag = LambdaCube.IR.TargetItem.Tag.TargetItem; }
+    };
+  }
+  class RenderTarget {
+      public enum Tag { 
+        RenderTarget
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class RenderTarget : LambdaCube.IR.RenderTarget { 
+      public List<global::LambdaCube.IR.TargetItem> renderTargets;
+      public RenderTarget() { tag = LambdaCube.IR.RenderTarget.Tag.RenderTarget; }
+    };
+  }
+  class Backend {
+      public enum Tag { 
+        WebGL1,
+        OpenGL33
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class Pipeline {
+      public enum Tag { 
+        Pipeline
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Pipeline : LambdaCube.IR.Pipeline { 
+      public string info;
+      public global::LambdaCube.IR.Backend backend;
+      public List<global::LambdaCube.IR.TextureDescriptor> textures;
+      public List<global::LambdaCube.IR.SamplerDescriptor> samplers;
+      public List<global::LambdaCube.IR.RenderTarget> targets;
+      public List<global::LambdaCube.IR.Program> programs;
+      public List<global::LambdaCube.IR.Slot> slots;
+      public List<global::LambdaCube.IR.StreamData> streams;
+      public List<global::LambdaCube.IR.Command> commands;
+      public Pipeline() { tag = LambdaCube.IR.Pipeline.Tag.Pipeline; }
+    };
+  }
+
+  // JSON deserializer
+  enum Type { 
+    Int,
+    Int32,
+    Word,
+    Word32,
+    Float,
+    Bool,
+    String,
+    V2_Int,
+    V2_Word,
+    V2_Float,
+    V2_Bool,
+    V2_V2_Float,
+    V2_V3_Float,
+    V2_V4_Float,
+    V3_Int,
+    V3_Word,
+    V3_Float,
+    V3_Bool,
+    V3_V2_Float,
+    V3_V3_Float,
+    V3_V4_Float,
+    V4_Int,
+    V4_Word,
+    V4_Float,
+    V4_Bool,
+    V4_V2_Float,
+    V4_V3_Float,
+    V4_V4_Float,
+    Array_Int,
+    Array_Int32,
+    Array_Word32,
+    Array_Float,
+    Array_Bool,
+    Array_ClearImage,
+    Array_Command,
+    Array_Parameter,
+    Array_Program,
+    Array_RenderTarget,
+    Array_SamplerDescriptor,
+    Array_Slot,
+    Array_StreamData,
+    Array_TargetItem,
+    Array_TextureDescriptor,
+    List_FragmentOperation,
+    Maybe_Int,
+    Maybe_Float,
+    Maybe_String,
+    Maybe_ComparisonFunction,
+    Maybe_EdgeMode,
+    Maybe_ImageRef,
+    Map_String_ArrayValue,
+    Map_String_InputType,
+    Map_String_Parameter,
+    AccumulationContext,
+    ArrayValue,
+    Backend,
+    BlendEquation,
+    Blending,
+    BlendingFactor,
+    ClearImage,
+    ColorArity,
+    Command,
+    ComparisonFunction,
+    CullMode,
+    EdgeMode,
+    FetchPrimitive,
+    Filter,
+    FragmentOperation,
+    FrontFace,
+    ImageRef,
+    ImageSemantic,
+    InputType,
+    LogicOperation,
+    MipMap,
+    OutputPrimitive,
+    Parameter,
+    Pipeline,
+    PointSize,
+    PointSpriteCoordOrigin,
+    PolygonMode,
+    PolygonOffset,
+    Program,
+    ProvokingVertex,
+    RasterContext,
+    RenderTarget,
+    SamplerDescriptor,
+    Slot,
+    StencilOperation,
+    StencilOps,
+    StencilTest,
+    StencilTests,
+    StreamData,
+    TargetItem,
+    TextureDataType,
+    TextureDescriptor,
+    TextureType,
+    Value
+  }
+
+  class Loader {
+    public static object fromJSON(Type type, JToken obj) {
+      switch (type) {
+        case Type.Int: return (int)obj;
+        case Type.Int32: return (int)obj;
+        case Type.Word: return (uint)obj;
+        case Type.Word32: return (uint)obj;
+        case Type.Float: return (float)obj;
+        case Type.Bool: return (bool)obj;
+        case Type.String: return (string)obj;
+        case Type.V2_Int:
+          return new V2<int>
+            { x = (int)fromJSON(Type.Int,obj["x"])
+            , y = (int)fromJSON(Type.Int,obj["y"])
+            };
+        case Type.V2_Word:
+          return new V2<uint>
+            { x = (uint)fromJSON(Type.Word,obj["x"])
+            , y = (uint)fromJSON(Type.Word,obj["y"])
+            };
+        case Type.V2_Float:
+          return new V2<float>
+            { x = (float)fromJSON(Type.Float,obj["x"])
+            , y = (float)fromJSON(Type.Float,obj["y"])
+            };
+        case Type.V2_Bool:
+          return new V2<bool>
+            { x = (bool)fromJSON(Type.Bool,obj["x"])
+            , y = (bool)fromJSON(Type.Bool,obj["y"])
+            };
+        case Type.V2_V2_Float:
+          return new V2<V2<float>>
+            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
+            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
+            };
+        case Type.V2_V3_Float:
+          return new V2<V3<float>>
+            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
+            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
+            };
+        case Type.V2_V4_Float:
+          return new V2<V4<float>>
+            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
+            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
+            };
+        case Type.V3_Int:
+          return new V3<int>
+            { x = (int)fromJSON(Type.Int,obj["x"])
+            , y = (int)fromJSON(Type.Int,obj["y"])
+            , z = (int)fromJSON(Type.Int,obj["z"])
+            };
+        case Type.V3_Word:
+          return new V3<uint>
+            { x = (uint)fromJSON(Type.Word,obj["x"])
+            , y = (uint)fromJSON(Type.Word,obj["y"])
+            , z = (uint)fromJSON(Type.Word,obj["z"])
+            };
+        case Type.V3_Float:
+          return new V3<float>
+            { x = (float)fromJSON(Type.Float,obj["x"])
+            , y = (float)fromJSON(Type.Float,obj["y"])
+            , z = (float)fromJSON(Type.Float,obj["z"])
+            };
+        case Type.V3_Bool:
+          return new V3<bool>
+            { x = (bool)fromJSON(Type.Bool,obj["x"])
+            , y = (bool)fromJSON(Type.Bool,obj["y"])
+            , z = (bool)fromJSON(Type.Bool,obj["z"])
+            };
+        case Type.V3_V2_Float:
+          return new V3<V2<float>>
+            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
+            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
+            , z = (V2<float>)fromJSON(Type.V2_Float,obj["z"])
+            };
+        case Type.V3_V3_Float:
+          return new V3<V3<float>>
+            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
+            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
+            , z = (V3<float>)fromJSON(Type.V3_Float,obj["z"])
+            };
+        case Type.V3_V4_Float:
+          return new V3<V4<float>>
+            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
+            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
+            , z = (V4<float>)fromJSON(Type.V4_Float,obj["z"])
+            };
+        case Type.V4_Int:
+          return new V4<int>
+            { x = (int)fromJSON(Type.Int,obj["x"])
+            , y = (int)fromJSON(Type.Int,obj["y"])
+            , z = (int)fromJSON(Type.Int,obj["z"])
+            , w = (int)fromJSON(Type.Int,obj["w"])
+            };
+        case Type.V4_Word:
+          return new V4<uint>
+            { x = (uint)fromJSON(Type.Word,obj["x"])
+            , y = (uint)fromJSON(Type.Word,obj["y"])
+            , z = (uint)fromJSON(Type.Word,obj["z"])
+            , w = (uint)fromJSON(Type.Word,obj["w"])
+            };
+        case Type.V4_Float:
+          return new V4<float>
+            { x = (float)fromJSON(Type.Float,obj["x"])
+            , y = (float)fromJSON(Type.Float,obj["y"])
+            , z = (float)fromJSON(Type.Float,obj["z"])
+            , w = (float)fromJSON(Type.Float,obj["w"])
+            };
+        case Type.V4_Bool:
+          return new V4<bool>
+            { x = (bool)fromJSON(Type.Bool,obj["x"])
+            , y = (bool)fromJSON(Type.Bool,obj["y"])
+            , z = (bool)fromJSON(Type.Bool,obj["z"])
+            , w = (bool)fromJSON(Type.Bool,obj["w"])
+            };
+        case Type.V4_V2_Float:
+          return new V4<V2<float>>
+            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
+            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
+            , z = (V2<float>)fromJSON(Type.V2_Float,obj["z"])
+            , w = (V2<float>)fromJSON(Type.V2_Float,obj["w"])
+            };
+        case Type.V4_V3_Float:
+          return new V4<V3<float>>
+            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
+            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
+            , z = (V3<float>)fromJSON(Type.V3_Float,obj["z"])
+            , w = (V3<float>)fromJSON(Type.V3_Float,obj["w"])
+            };
+        case Type.V4_V4_Float:
+          return new V4<V4<float>>
+            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
+            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
+            , z = (V4<float>)fromJSON(Type.V4_Float,obj["z"])
+            , w = (V4<float>)fromJSON(Type.V4_Float,obj["w"])
+            };
+        case Type.Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList();
+        case Type.Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList();
+        case Type.Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList();
+        case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
+        case Type.Array_Bool: return ((JArray)obj).Select(x => fromJSON (Type.Bool, x)).ToList();
+        case Type.Array_ClearImage: return ((JArray)obj).Select(x => fromJSON (Type.ClearImage, x)).ToList();
+        case Type.Array_Command: return ((JArray)obj).Select(x => fromJSON (Type.Command, x)).ToList();
+        case Type.Array_Parameter: return ((JArray)obj).Select(x => fromJSON (Type.Parameter, x)).ToList();
+        case Type.Array_Program: return ((JArray)obj).Select(x => fromJSON (Type.Program, x)).ToList();
+        case Type.Array_RenderTarget: return ((JArray)obj).Select(x => fromJSON (Type.RenderTarget, x)).ToList();
+        case Type.Array_SamplerDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.SamplerDescriptor, x)).ToList();
+        case Type.Array_Slot: return ((JArray)obj).Select(x => fromJSON (Type.Slot, x)).ToList();
+        case Type.Array_StreamData: return ((JArray)obj).Select(x => fromJSON (Type.StreamData, x)).ToList();
+        case Type.Array_TargetItem: return ((JArray)obj).Select(x => fromJSON (Type.TargetItem, x)).ToList();
+        case Type.Array_TextureDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.TextureDescriptor, x)).ToList();
+        case Type.List_FragmentOperation: return ((JArray)obj).Select(x => fromJSON (Type.FragmentOperation, x)).ToList();
+        case Type.Maybe_Int: {
+          var m = new Maybe<int> ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = (int)fromJSON (Type.Int,obj);
+          }
+          return m;
+        }
+        case Type.Maybe_Float: {
+          var m = new Maybe<float> ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = (float)fromJSON (Type.Float,obj);
+          }
+          return m;
+        }
+        case Type.Maybe_String: {
+          var m = new Maybe<string> ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = (string)fromJSON (Type.String,obj);
+          }
+          return m;
+        }
+        case Type.Maybe_ComparisonFunction: {
+          var m = new Maybe<global::LambdaCube.IR.ComparisonFunction> ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = (global::LambdaCube.IR.ComparisonFunction)fromJSON (Type.ComparisonFunction,obj);
+          }
+          return m;
+        }
+        case Type.Maybe_EdgeMode: {
+          var m = new Maybe<global::LambdaCube.IR.EdgeMode> ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = (global::LambdaCube.IR.EdgeMode)fromJSON (Type.EdgeMode,obj);
+          }
+          return m;
+        }
+        case Type.Maybe_ImageRef: {
+          var m = new Maybe<global::LambdaCube.IR.ImageRef> ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = (global::LambdaCube.IR.ImageRef)fromJSON (Type.ImageRef,obj);
+          }
+          return m;
+        }
+        case Type.Map_String_ArrayValue: {
+          var map = new Dictionary<string, global::LambdaCube.IR.ArrayValue> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.IR.ArrayValue)fromJSON(Type.ArrayValue,i.Value));
+          }
+          return map;
+        }
+        case Type.Map_String_InputType: {
+          var map = new Dictionary<string, global::LambdaCube.IR.InputType> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.IR.InputType)fromJSON(Type.InputType,i.Value));
+          }
+          return map;
+        }
+        case Type.Map_String_Parameter: {
+          var map = new Dictionary<string, global::LambdaCube.IR.Parameter> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.IR.Parameter)fromJSON(Type.Parameter,i.Value));
+          }
+          return map;
+        }
+
+        case Type.ArrayValue: {
+          string tag = (string)obj["tag"];
+          ArrayValue.Tag tagType;
+          if (tag == "VBoolArray") {
+            tagType = ArrayValue.Tag.VBoolArray;
+            data.VBoolArray tv = new data.VBoolArray();
+            tv._0 = (List<bool>)fromJSON(Type.Array_Bool,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VIntArray") {
+            tagType = ArrayValue.Tag.VIntArray;
+            data.VIntArray tv = new data.VIntArray();
+            tv._0 = (List<int>)fromJSON(Type.Array_Int32,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VWordArray") {
+            tagType = ArrayValue.Tag.VWordArray;
+            data.VWordArray tv = new data.VWordArray();
+            tv._0 = (List<uint>)fromJSON(Type.Array_Word32,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VFloatArray") {
+            tagType = ArrayValue.Tag.VFloatArray;
+            data.VFloatArray tv = new data.VFloatArray();
+            tv._0 = (List<float>)fromJSON(Type.Array_Float,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ArrayValue o = new ArrayValue();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Value: {
+          string tag = (string)obj["tag"];
+          Value.Tag tagType;
+          if (tag == "VBool") {
+            tagType = Value.Tag.VBool;
+            data.VBool tv = new data.VBool();
+            tv._0 = (bool)fromJSON(Type.Bool,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV2B") {
+            tagType = Value.Tag.VV2B;
+            data.VV2B tv = new data.VV2B();
+            tv._0 = (V2<bool>)fromJSON(Type.V2_Bool,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV3B") {
+            tagType = Value.Tag.VV3B;
+            data.VV3B tv = new data.VV3B();
+            tv._0 = (V3<bool>)fromJSON(Type.V3_Bool,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV4B") {
+            tagType = Value.Tag.VV4B;
+            data.VV4B tv = new data.VV4B();
+            tv._0 = (V4<bool>)fromJSON(Type.V4_Bool,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VWord") {
+            tagType = Value.Tag.VWord;
+            data.VWord tv = new data.VWord();
+            tv._0 = (uint)fromJSON(Type.Word32,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV2U") {
+            tagType = Value.Tag.VV2U;
+            data.VV2U tv = new data.VV2U();
+            tv._0 = (V2<uint>)fromJSON(Type.V2_Word,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV3U") {
+            tagType = Value.Tag.VV3U;
+            data.VV3U tv = new data.VV3U();
+            tv._0 = (V3<uint>)fromJSON(Type.V3_Word,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV4U") {
+            tagType = Value.Tag.VV4U;
+            data.VV4U tv = new data.VV4U();
+            tv._0 = (V4<uint>)fromJSON(Type.V4_Word,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VInt") {
+            tagType = Value.Tag.VInt;
+            data.VInt tv = new data.VInt();
+            tv._0 = (int)fromJSON(Type.Int32,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV2I") {
+            tagType = Value.Tag.VV2I;
+            data.VV2I tv = new data.VV2I();
+            tv._0 = (V2<int>)fromJSON(Type.V2_Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV3I") {
+            tagType = Value.Tag.VV3I;
+            data.VV3I tv = new data.VV3I();
+            tv._0 = (V3<int>)fromJSON(Type.V3_Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV4I") {
+            tagType = Value.Tag.VV4I;
+            data.VV4I tv = new data.VV4I();
+            tv._0 = (V4<int>)fromJSON(Type.V4_Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VFloat") {
+            tagType = Value.Tag.VFloat;
+            data.VFloat tv = new data.VFloat();
+            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV2F") {
+            tagType = Value.Tag.VV2F;
+            data.VV2F tv = new data.VV2F();
+            tv._0 = (V2<float>)fromJSON(Type.V2_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV3F") {
+            tagType = Value.Tag.VV3F;
+            data.VV3F tv = new data.VV3F();
+            tv._0 = (V3<float>)fromJSON(Type.V3_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VV4F") {
+            tagType = Value.Tag.VV4F;
+            data.VV4F tv = new data.VV4F();
+            tv._0 = (V4<float>)fromJSON(Type.V4_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM22F") {
+            tagType = Value.Tag.VM22F;
+            data.VM22F tv = new data.VM22F();
+            tv._0 = (V2<V2<float>>)fromJSON(Type.V2_V2_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM23F") {
+            tagType = Value.Tag.VM23F;
+            data.VM23F tv = new data.VM23F();
+            tv._0 = (V3<V2<float>>)fromJSON(Type.V3_V2_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM24F") {
+            tagType = Value.Tag.VM24F;
+            data.VM24F tv = new data.VM24F();
+            tv._0 = (V4<V2<float>>)fromJSON(Type.V4_V2_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM32F") {
+            tagType = Value.Tag.VM32F;
+            data.VM32F tv = new data.VM32F();
+            tv._0 = (V2<V3<float>>)fromJSON(Type.V2_V3_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM33F") {
+            tagType = Value.Tag.VM33F;
+            data.VM33F tv = new data.VM33F();
+            tv._0 = (V3<V3<float>>)fromJSON(Type.V3_V3_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM34F") {
+            tagType = Value.Tag.VM34F;
+            data.VM34F tv = new data.VM34F();
+            tv._0 = (V4<V3<float>>)fromJSON(Type.V4_V3_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM42F") {
+            tagType = Value.Tag.VM42F;
+            data.VM42F tv = new data.VM42F();
+            tv._0 = (V2<V4<float>>)fromJSON(Type.V2_V4_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM43F") {
+            tagType = Value.Tag.VM43F;
+            data.VM43F tv = new data.VM43F();
+            tv._0 = (V3<V4<float>>)fromJSON(Type.V3_V4_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "VM44F") {
+            tagType = Value.Tag.VM44F;
+            data.VM44F tv = new data.VM44F();
+            tv._0 = (V4<V4<float>>)fromJSON(Type.V4_V4_Float,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Value o = new Value();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.InputType: {
+          string tag = (string)obj["tag"];
+          InputType.Tag tagType;
+          if (tag == "Bool") {
+            tagType = InputType.Tag.Bool;
+          }
+          else if (tag == "V2B") {
+            tagType = InputType.Tag.V2B;
+          }
+          else if (tag == "V3B") {
+            tagType = InputType.Tag.V3B;
+          }
+          else if (tag == "V4B") {
+            tagType = InputType.Tag.V4B;
+          }
+          else if (tag == "Word") {
+            tagType = InputType.Tag.Word;
+          }
+          else if (tag == "V2U") {
+            tagType = InputType.Tag.V2U;
+          }
+          else if (tag == "V3U") {
+            tagType = InputType.Tag.V3U;
+          }
+          else if (tag == "V4U") {
+            tagType = InputType.Tag.V4U;
+          }
+          else if (tag == "Int") {
+            tagType = InputType.Tag.Int;
+          }
+          else if (tag == "V2I") {
+            tagType = InputType.Tag.V2I;
+          }
+          else if (tag == "V3I") {
+            tagType = InputType.Tag.V3I;
+          }
+          else if (tag == "V4I") {
+            tagType = InputType.Tag.V4I;
+          }
+          else if (tag == "Float") {
+            tagType = InputType.Tag.Float;
+          }
+          else if (tag == "V2F") {
+            tagType = InputType.Tag.V2F;
+          }
+          else if (tag == "V3F") {
+            tagType = InputType.Tag.V3F;
+          }
+          else if (tag == "V4F") {
+            tagType = InputType.Tag.V4F;
+          }
+          else if (tag == "M22F") {
+            tagType = InputType.Tag.M22F;
+          }
+          else if (tag == "M23F") {
+            tagType = InputType.Tag.M23F;
+          }
+          else if (tag == "M24F") {
+            tagType = InputType.Tag.M24F;
+          }
+          else if (tag == "M32F") {
+            tagType = InputType.Tag.M32F;
+          }
+          else if (tag == "M33F") {
+            tagType = InputType.Tag.M33F;
+          }
+          else if (tag == "M34F") {
+            tagType = InputType.Tag.M34F;
+          }
+          else if (tag == "M42F") {
+            tagType = InputType.Tag.M42F;
+          }
+          else if (tag == "M43F") {
+            tagType = InputType.Tag.M43F;
+          }
+          else if (tag == "M44F") {
+            tagType = InputType.Tag.M44F;
+          }
+          else if (tag == "STexture1D") {
+            tagType = InputType.Tag.STexture1D;
+          }
+          else if (tag == "STexture2D") {
+            tagType = InputType.Tag.STexture2D;
+          }
+          else if (tag == "STextureCube") {
+            tagType = InputType.Tag.STextureCube;
+          }
+          else if (tag == "STexture1DArray") {
+            tagType = InputType.Tag.STexture1DArray;
+          }
+          else if (tag == "STexture2DArray") {
+            tagType = InputType.Tag.STexture2DArray;
+          }
+          else if (tag == "STexture2DRect") {
+            tagType = InputType.Tag.STexture2DRect;
+          }
+          else if (tag == "FTexture1D") {
+            tagType = InputType.Tag.FTexture1D;
+          }
+          else if (tag == "FTexture2D") {
+            tagType = InputType.Tag.FTexture2D;
+          }
+          else if (tag == "FTexture3D") {
+            tagType = InputType.Tag.FTexture3D;
+          }
+          else if (tag == "FTextureCube") {
+            tagType = InputType.Tag.FTextureCube;
+          }
+          else if (tag == "FTexture1DArray") {
+            tagType = InputType.Tag.FTexture1DArray;
+          }
+          else if (tag == "FTexture2DArray") {
+            tagType = InputType.Tag.FTexture2DArray;
+          }
+          else if (tag == "FTexture2DMS") {
+            tagType = InputType.Tag.FTexture2DMS;
+          }
+          else if (tag == "FTexture2DMSArray") {
+            tagType = InputType.Tag.FTexture2DMSArray;
+          }
+          else if (tag == "FTextureBuffer") {
+            tagType = InputType.Tag.FTextureBuffer;
+          }
+          else if (tag == "FTexture2DRect") {
+            tagType = InputType.Tag.FTexture2DRect;
+          }
+          else if (tag == "ITexture1D") {
+            tagType = InputType.Tag.ITexture1D;
+          }
+          else if (tag == "ITexture2D") {
+            tagType = InputType.Tag.ITexture2D;
+          }
+          else if (tag == "ITexture3D") {
+            tagType = InputType.Tag.ITexture3D;
+          }
+          else if (tag == "ITextureCube") {
+            tagType = InputType.Tag.ITextureCube;
+          }
+          else if (tag == "ITexture1DArray") {
+            tagType = InputType.Tag.ITexture1DArray;
+          }
+          else if (tag == "ITexture2DArray") {
+            tagType = InputType.Tag.ITexture2DArray;
+          }
+          else if (tag == "ITexture2DMS") {
+            tagType = InputType.Tag.ITexture2DMS;
+          }
+          else if (tag == "ITexture2DMSArray") {
+            tagType = InputType.Tag.ITexture2DMSArray;
+          }
+          else if (tag == "ITextureBuffer") {
+            tagType = InputType.Tag.ITextureBuffer;
+          }
+          else if (tag == "ITexture2DRect") {
+            tagType = InputType.Tag.ITexture2DRect;
+          }
+          else if (tag == "UTexture1D") {
+            tagType = InputType.Tag.UTexture1D;
+          }
+          else if (tag == "UTexture2D") {
+            tagType = InputType.Tag.UTexture2D;
+          }
+          else if (tag == "UTexture3D") {
+            tagType = InputType.Tag.UTexture3D;
+          }
+          else if (tag == "UTextureCube") {
+            tagType = InputType.Tag.UTextureCube;
+          }
+          else if (tag == "UTexture1DArray") {
+            tagType = InputType.Tag.UTexture1DArray;
+          }
+          else if (tag == "UTexture2DArray") {
+            tagType = InputType.Tag.UTexture2DArray;
+          }
+          else if (tag == "UTexture2DMS") {
+            tagType = InputType.Tag.UTexture2DMS;
+          }
+          else if (tag == "UTexture2DMSArray") {
+            tagType = InputType.Tag.UTexture2DMSArray;
+          }
+          else if (tag == "UTextureBuffer") {
+            tagType = InputType.Tag.UTextureBuffer;
+          }
+          else if (tag == "UTexture2DRect") {
+            tagType = InputType.Tag.UTexture2DRect;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          InputType o = new InputType();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.PointSpriteCoordOrigin: {
+          string tag = (string)obj["tag"];
+          PointSpriteCoordOrigin.Tag tagType;
+          if (tag == "LowerLeft") {
+            tagType = PointSpriteCoordOrigin.Tag.LowerLeft;
+          }
+          else if (tag == "UpperLeft") {
+            tagType = PointSpriteCoordOrigin.Tag.UpperLeft;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          PointSpriteCoordOrigin o = new PointSpriteCoordOrigin();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.PointSize: {
+          string tag = (string)obj["tag"];
+          PointSize.Tag tagType;
+          if (tag == "PointSize") {
+            tagType = PointSize.Tag.PointSize;
+            data.PointSize tv = new data.PointSize();
+            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "ProgramPointSize") {
+            tagType = PointSize.Tag.ProgramPointSize;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          PointSize o = new PointSize();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.PolygonOffset: {
+          string tag = (string)obj["tag"];
+          PolygonOffset.Tag tagType;
+          if (tag == "NoOffset") {
+            tagType = PolygonOffset.Tag.NoOffset;
+          }
+          else if (tag == "Offset") {
+            tagType = PolygonOffset.Tag.Offset;
+            data.Offset tv = new data.Offset();
+            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
+            tv._1 = (float)fromJSON(Type.Float,obj["arg1"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          PolygonOffset o = new PolygonOffset();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.FrontFace: {
+          string tag = (string)obj["tag"];
+          FrontFace.Tag tagType;
+          if (tag == "CCW") {
+            tagType = FrontFace.Tag.CCW;
+          }
+          else if (tag == "CW") {
+            tagType = FrontFace.Tag.CW;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          FrontFace o = new FrontFace();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.PolygonMode: {
+          string tag = (string)obj["tag"];
+          PolygonMode.Tag tagType;
+          if (tag == "PolygonPoint") {
+            tagType = PolygonMode.Tag.PolygonPoint;
+            data.PolygonPoint tv = new data.PolygonPoint();
+            tv._0 = (global::LambdaCube.IR.PointSize)fromJSON(Type.PointSize,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "PolygonLine") {
+            tagType = PolygonMode.Tag.PolygonLine;
+            data.PolygonLine tv = new data.PolygonLine();
+            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "PolygonFill") {
+            tagType = PolygonMode.Tag.PolygonFill;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          PolygonMode o = new PolygonMode();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ProvokingVertex: {
+          string tag = (string)obj["tag"];
+          ProvokingVertex.Tag tagType;
+          if (tag == "FirstVertex") {
+            tagType = ProvokingVertex.Tag.FirstVertex;
+          }
+          else if (tag == "LastVertex") {
+            tagType = ProvokingVertex.Tag.LastVertex;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ProvokingVertex o = new ProvokingVertex();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.CullMode: {
+          string tag = (string)obj["tag"];
+          CullMode.Tag tagType;
+          if (tag == "CullNone") {
+            tagType = CullMode.Tag.CullNone;
+          }
+          else if (tag == "CullFront") {
+            tagType = CullMode.Tag.CullFront;
+            data.CullFront tv = new data.CullFront();
+            tv._0 = (global::LambdaCube.IR.FrontFace)fromJSON(Type.FrontFace,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "CullBack") {
+            tagType = CullMode.Tag.CullBack;
+            data.CullBack tv = new data.CullBack();
+            tv._0 = (global::LambdaCube.IR.FrontFace)fromJSON(Type.FrontFace,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          CullMode o = new CullMode();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ComparisonFunction: {
+          string tag = (string)obj["tag"];
+          ComparisonFunction.Tag tagType;
+          if (tag == "Never") {
+            tagType = ComparisonFunction.Tag.Never;
+          }
+          else if (tag == "Less") {
+            tagType = ComparisonFunction.Tag.Less;
+          }
+          else if (tag == "Equal") {
+            tagType = ComparisonFunction.Tag.Equal;
+          }
+          else if (tag == "Lequal") {
+            tagType = ComparisonFunction.Tag.Lequal;
+          }
+          else if (tag == "Greater") {
+            tagType = ComparisonFunction.Tag.Greater;
+          }
+          else if (tag == "Notequal") {
+            tagType = ComparisonFunction.Tag.Notequal;
+          }
+          else if (tag == "Gequal") {
+            tagType = ComparisonFunction.Tag.Gequal;
+          }
+          else if (tag == "Always") {
+            tagType = ComparisonFunction.Tag.Always;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ComparisonFunction o = new ComparisonFunction();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.StencilOperation: {
+          string tag = (string)obj["tag"];
+          StencilOperation.Tag tagType;
+          if (tag == "OpZero") {
+            tagType = StencilOperation.Tag.OpZero;
+          }
+          else if (tag == "OpKeep") {
+            tagType = StencilOperation.Tag.OpKeep;
+          }
+          else if (tag == "OpReplace") {
+            tagType = StencilOperation.Tag.OpReplace;
+          }
+          else if (tag == "OpIncr") {
+            tagType = StencilOperation.Tag.OpIncr;
+          }
+          else if (tag == "OpIncrWrap") {
+            tagType = StencilOperation.Tag.OpIncrWrap;
+          }
+          else if (tag == "OpDecr") {
+            tagType = StencilOperation.Tag.OpDecr;
+          }
+          else if (tag == "OpDecrWrap") {
+            tagType = StencilOperation.Tag.OpDecrWrap;
+          }
+          else if (tag == "OpInvert") {
+            tagType = StencilOperation.Tag.OpInvert;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          StencilOperation o = new StencilOperation();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.BlendEquation: {
+          string tag = (string)obj["tag"];
+          BlendEquation.Tag tagType;
+          if (tag == "FuncAdd") {
+            tagType = BlendEquation.Tag.FuncAdd;
+          }
+          else if (tag == "FuncSubtract") {
+            tagType = BlendEquation.Tag.FuncSubtract;
+          }
+          else if (tag == "FuncReverseSubtract") {
+            tagType = BlendEquation.Tag.FuncReverseSubtract;
+          }
+          else if (tag == "Min") {
+            tagType = BlendEquation.Tag.Min;
+          }
+          else if (tag == "Max") {
+            tagType = BlendEquation.Tag.Max;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          BlendEquation o = new BlendEquation();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.BlendingFactor: {
+          string tag = (string)obj["tag"];
+          BlendingFactor.Tag tagType;
+          if (tag == "Zero") {
+            tagType = BlendingFactor.Tag.Zero;
+          }
+          else if (tag == "One") {
+            tagType = BlendingFactor.Tag.One;
+          }
+          else if (tag == "SrcColor") {
+            tagType = BlendingFactor.Tag.SrcColor;
+          }
+          else if (tag == "OneMinusSrcColor") {
+            tagType = BlendingFactor.Tag.OneMinusSrcColor;
+          }
+          else if (tag == "DstColor") {
+            tagType = BlendingFactor.Tag.DstColor;
+          }
+          else if (tag == "OneMinusDstColor") {
+            tagType = BlendingFactor.Tag.OneMinusDstColor;
+          }
+          else if (tag == "SrcAlpha") {
+            tagType = BlendingFactor.Tag.SrcAlpha;
+          }
+          else if (tag == "OneMinusSrcAlpha") {
+            tagType = BlendingFactor.Tag.OneMinusSrcAlpha;
+          }
+          else if (tag == "DstAlpha") {
+            tagType = BlendingFactor.Tag.DstAlpha;
+          }
+          else if (tag == "OneMinusDstAlpha") {
+            tagType = BlendingFactor.Tag.OneMinusDstAlpha;
+          }
+          else if (tag == "ConstantColor") {
+            tagType = BlendingFactor.Tag.ConstantColor;
+          }
+          else if (tag == "OneMinusConstantColor") {
+            tagType = BlendingFactor.Tag.OneMinusConstantColor;
+          }
+          else if (tag == "ConstantAlpha") {
+            tagType = BlendingFactor.Tag.ConstantAlpha;
+          }
+          else if (tag == "OneMinusConstantAlpha") {
+            tagType = BlendingFactor.Tag.OneMinusConstantAlpha;
+          }
+          else if (tag == "SrcAlphaSaturate") {
+            tagType = BlendingFactor.Tag.SrcAlphaSaturate;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          BlendingFactor o = new BlendingFactor();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.LogicOperation: {
+          string tag = (string)obj["tag"];
+          LogicOperation.Tag tagType;
+          if (tag == "Clear") {
+            tagType = LogicOperation.Tag.Clear;
+          }
+          else if (tag == "And") {
+            tagType = LogicOperation.Tag.And;
+          }
+          else if (tag == "AndReverse") {
+            tagType = LogicOperation.Tag.AndReverse;
+          }
+          else if (tag == "Copy") {
+            tagType = LogicOperation.Tag.Copy;
+          }
+          else if (tag == "AndInverted") {
+            tagType = LogicOperation.Tag.AndInverted;
+          }
+          else if (tag == "Noop") {
+            tagType = LogicOperation.Tag.Noop;
+          }
+          else if (tag == "Xor") {
+            tagType = LogicOperation.Tag.Xor;
+          }
+          else if (tag == "Or") {
+            tagType = LogicOperation.Tag.Or;
+          }
+          else if (tag == "Nor") {
+            tagType = LogicOperation.Tag.Nor;
+          }
+          else if (tag == "Equiv") {
+            tagType = LogicOperation.Tag.Equiv;
+          }
+          else if (tag == "Invert") {
+            tagType = LogicOperation.Tag.Invert;
+          }
+          else if (tag == "OrReverse") {
+            tagType = LogicOperation.Tag.OrReverse;
+          }
+          else if (tag == "CopyInverted") {
+            tagType = LogicOperation.Tag.CopyInverted;
+          }
+          else if (tag == "OrInverted") {
+            tagType = LogicOperation.Tag.OrInverted;
+          }
+          else if (tag == "Nand") {
+            tagType = LogicOperation.Tag.Nand;
+          }
+          else if (tag == "Set") {
+            tagType = LogicOperation.Tag.Set;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          LogicOperation o = new LogicOperation();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.StencilOps: {
+          string tag = (string)obj["tag"];
+          StencilOps.Tag tagType;
+          if (tag == "StencilOps") {
+            tagType = StencilOps.Tag.StencilOps;
+            data.StencilOps tv = new data.StencilOps();
+            tv.frontStencilOp = (global::LambdaCube.IR.StencilOperation)fromJSON(Type.StencilOperation,obj["frontStencilOp"]);
+            tv.backStencilOp = (global::LambdaCube.IR.StencilOperation)fromJSON(Type.StencilOperation,obj["backStencilOp"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          StencilOps o = new StencilOps();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.StencilTest: {
+          string tag = (string)obj["tag"];
+          StencilTest.Tag tagType;
+          if (tag == "StencilTest") {
+            tagType = StencilTest.Tag.StencilTest;
+            data.StencilTest tv = new data.StencilTest();
+            tv.stencilComparision = (global::LambdaCube.IR.ComparisonFunction)fromJSON(Type.ComparisonFunction,obj["stencilComparision"]);
+            tv.stencilReference = (int)fromJSON(Type.Int32,obj["stencilReference"]);
+            tv.stencilMask = (uint)fromJSON(Type.Word32,obj["stencilMask"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          StencilTest o = new StencilTest();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.StencilTests: {
+          string tag = (string)obj["tag"];
+          StencilTests.Tag tagType;
+          if (tag == "StencilTests") {
+            tagType = StencilTests.Tag.StencilTests;
+            data.StencilTests tv = new data.StencilTests();
+            tv._0 = (global::LambdaCube.IR.StencilTest)fromJSON(Type.StencilTest,obj["arg0"]);
+            tv._1 = (global::LambdaCube.IR.StencilTest)fromJSON(Type.StencilTest,obj["arg1"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          StencilTests o = new StencilTests();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.FetchPrimitive: {
+          string tag = (string)obj["tag"];
+          FetchPrimitive.Tag tagType;
+          if (tag == "Points") {
+            tagType = FetchPrimitive.Tag.Points;
+          }
+          else if (tag == "Lines") {
+            tagType = FetchPrimitive.Tag.Lines;
+          }
+          else if (tag == "Triangles") {
+            tagType = FetchPrimitive.Tag.Triangles;
+          }
+          else if (tag == "LinesAdjacency") {
+            tagType = FetchPrimitive.Tag.LinesAdjacency;
+          }
+          else if (tag == "TrianglesAdjacency") {
+            tagType = FetchPrimitive.Tag.TrianglesAdjacency;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          FetchPrimitive o = new FetchPrimitive();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.OutputPrimitive: {
+          string tag = (string)obj["tag"];
+          OutputPrimitive.Tag tagType;
+          if (tag == "TrianglesOutput") {
+            tagType = OutputPrimitive.Tag.TrianglesOutput;
+          }
+          else if (tag == "LinesOutput") {
+            tagType = OutputPrimitive.Tag.LinesOutput;
+          }
+          else if (tag == "PointsOutput") {
+            tagType = OutputPrimitive.Tag.PointsOutput;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          OutputPrimitive o = new OutputPrimitive();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ColorArity: {
+          string tag = (string)obj["tag"];
+          ColorArity.Tag tagType;
+          if (tag == "Red") {
+            tagType = ColorArity.Tag.Red;
+          }
+          else if (tag == "RG") {
+            tagType = ColorArity.Tag.RG;
+          }
+          else if (tag == "RGB") {
+            tagType = ColorArity.Tag.RGB;
+          }
+          else if (tag == "RGBA") {
+            tagType = ColorArity.Tag.RGBA;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ColorArity o = new ColorArity();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Blending: {
+          string tag = (string)obj["tag"];
+          Blending.Tag tagType;
+          if (tag == "NoBlending") {
+            tagType = Blending.Tag.NoBlending;
+          }
+          else if (tag == "BlendLogicOp") {
+            tagType = Blending.Tag.BlendLogicOp;
+            data.BlendLogicOp tv = new data.BlendLogicOp();
+            tv._0 = (global::LambdaCube.IR.LogicOperation)fromJSON(Type.LogicOperation,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "Blend") {
+            tagType = Blending.Tag.Blend;
+            data.Blend tv = new data.Blend();
+            tv.colorEqSrc = (global::LambdaCube.IR.BlendEquation)fromJSON(Type.BlendEquation,obj["colorEqSrc"]);
+            tv.alphaEqSrc = (global::LambdaCube.IR.BlendEquation)fromJSON(Type.BlendEquation,obj["alphaEqSrc"]);
+            tv.colorFSrc = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["colorFSrc"]);
+            tv.colorFDst = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["colorFDst"]);
+            tv.alphaFSrc = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["alphaFSrc"]);
+            tv.alphaFDst = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["alphaFDst"]);
+            tv.color = (V4<float>)fromJSON(Type.V4_Float,obj["color"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Blending o = new Blending();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.RasterContext: {
+          string tag = (string)obj["tag"];
+          RasterContext.Tag tagType;
+          if (tag == "PointCtx") {
+            tagType = RasterContext.Tag.PointCtx;
+            data.PointCtx tv = new data.PointCtx();
+            tv._0 = (global::LambdaCube.IR.PointSize)fromJSON(Type.PointSize,obj["arg0"]);
+            tv._1 = (float)fromJSON(Type.Float,obj["arg1"]);
+            tv._2 = (global::LambdaCube.IR.PointSpriteCoordOrigin)fromJSON(Type.PointSpriteCoordOrigin,obj["arg2"]);
+            return tv;
+          }
+          else if (tag == "LineCtx") {
+            tagType = RasterContext.Tag.LineCtx;
+            data.LineCtx tv = new data.LineCtx();
+            tv._0 = (float)fromJSON(Type.Float,obj["arg0"]);
+            tv._1 = (global::LambdaCube.IR.ProvokingVertex)fromJSON(Type.ProvokingVertex,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "TriangleCtx") {
+            tagType = RasterContext.Tag.TriangleCtx;
+            data.TriangleCtx tv = new data.TriangleCtx();
+            tv._0 = (global::LambdaCube.IR.CullMode)fromJSON(Type.CullMode,obj["arg0"]);
+            tv._1 = (global::LambdaCube.IR.PolygonMode)fromJSON(Type.PolygonMode,obj["arg1"]);
+            tv._2 = (global::LambdaCube.IR.PolygonOffset)fromJSON(Type.PolygonOffset,obj["arg2"]);
+            tv._3 = (global::LambdaCube.IR.ProvokingVertex)fromJSON(Type.ProvokingVertex,obj["arg3"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          RasterContext o = new RasterContext();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.FragmentOperation: {
+          string tag = (string)obj["tag"];
+          FragmentOperation.Tag tagType;
+          if (tag == "DepthOp") {
+            tagType = FragmentOperation.Tag.DepthOp;
+            data.DepthOp tv = new data.DepthOp();
+            tv._0 = (global::LambdaCube.IR.ComparisonFunction)fromJSON(Type.ComparisonFunction,obj["arg0"]);
+            tv._1 = (bool)fromJSON(Type.Bool,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "StencilOp") {
+            tagType = FragmentOperation.Tag.StencilOp;
+            data.StencilOp tv = new data.StencilOp();
+            tv._0 = (global::LambdaCube.IR.StencilTests)fromJSON(Type.StencilTests,obj["arg0"]);
+            tv._1 = (global::LambdaCube.IR.StencilOps)fromJSON(Type.StencilOps,obj["arg1"]);
+            tv._2 = (global::LambdaCube.IR.StencilOps)fromJSON(Type.StencilOps,obj["arg2"]);
+            return tv;
+          }
+          else if (tag == "ColorOp") {
+            tagType = FragmentOperation.Tag.ColorOp;
+            data.ColorOp tv = new data.ColorOp();
+            tv._0 = (global::LambdaCube.IR.Blending)fromJSON(Type.Blending,obj["arg0"]);
+            tv._1 = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["arg1"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          FragmentOperation o = new FragmentOperation();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.AccumulationContext: {
+          string tag = (string)obj["tag"];
+          AccumulationContext.Tag tagType;
+          if (tag == "AccumulationContext") {
+            tagType = AccumulationContext.Tag.AccumulationContext;
+            data.AccumulationContext tv = new data.AccumulationContext();
+            tv.accViewportName = (Maybe<string>)fromJSON(Type.Maybe_String,obj["accViewportName"]);
+            tv.accOperations = (List<global::LambdaCube.IR.FragmentOperation>)fromJSON(Type.List_FragmentOperation,obj["accOperations"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          AccumulationContext o = new AccumulationContext();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.TextureDataType: {
+          string tag = (string)obj["tag"];
+          TextureDataType.Tag tagType;
+          if (tag == "FloatT") {
+            tagType = TextureDataType.Tag.FloatT;
+            data.FloatT tv = new data.FloatT();
+            tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "IntT") {
+            tagType = TextureDataType.Tag.IntT;
+            data.IntT tv = new data.IntT();
+            tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "WordT") {
+            tagType = TextureDataType.Tag.WordT;
+            data.WordT tv = new data.WordT();
+            tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "ShadowT") {
+            tagType = TextureDataType.Tag.ShadowT;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          TextureDataType o = new TextureDataType();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.TextureType: {
+          string tag = (string)obj["tag"];
+          TextureType.Tag tagType;
+          if (tag == "Texture1D") {
+            tagType = TextureType.Tag.Texture1D;
+            data.Texture1D tv = new data.Texture1D();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "Texture2D") {
+            tagType = TextureType.Tag.Texture2D;
+            data.Texture2D tv = new data.Texture2D();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "Texture3D") {
+            tagType = TextureType.Tag.Texture3D;
+            data.Texture3D tv = new data.Texture3D();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "TextureCube") {
+            tagType = TextureType.Tag.TextureCube;
+            data.TextureCube tv = new data.TextureCube();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "TextureRect") {
+            tagType = TextureType.Tag.TextureRect;
+            data.TextureRect tv = new data.TextureRect();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "Texture2DMS") {
+            tagType = TextureType.Tag.Texture2DMS;
+            data.Texture2DMS tv = new data.Texture2DMS();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            tv._2 = (int)fromJSON(Type.Int,obj["arg2"]);
+            tv._3 = (bool)fromJSON(Type.Bool,obj["arg3"]);
+            return tv;
+          }
+          else if (tag == "TextureBuffer") {
+            tagType = TextureType.Tag.TextureBuffer;
+            data.TextureBuffer tv = new data.TextureBuffer();
+            tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          TextureType o = new TextureType();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.MipMap: {
+          string tag = (string)obj["tag"];
+          MipMap.Tag tagType;
+          if (tag == "Mip") {
+            tagType = MipMap.Tag.Mip;
+            data.Mip tv = new data.Mip();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "NoMip") {
+            tagType = MipMap.Tag.NoMip;
+          }
+          else if (tag == "AutoMip") {
+            tagType = MipMap.Tag.AutoMip;
+            data.AutoMip tv = new data.AutoMip();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          MipMap o = new MipMap();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Filter: {
+          string tag = (string)obj["tag"];
+          Filter.Tag tagType;
+          if (tag == "Nearest") {
+            tagType = Filter.Tag.Nearest;
+          }
+          else if (tag == "Linear") {
+            tagType = Filter.Tag.Linear;
+          }
+          else if (tag == "NearestMipmapNearest") {
+            tagType = Filter.Tag.NearestMipmapNearest;
+          }
+          else if (tag == "NearestMipmapLinear") {
+            tagType = Filter.Tag.NearestMipmapLinear;
+          }
+          else if (tag == "LinearMipmapNearest") {
+            tagType = Filter.Tag.LinearMipmapNearest;
+          }
+          else if (tag == "LinearMipmapLinear") {
+            tagType = Filter.Tag.LinearMipmapLinear;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Filter o = new Filter();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.EdgeMode: {
+          string tag = (string)obj["tag"];
+          EdgeMode.Tag tagType;
+          if (tag == "Repeat") {
+            tagType = EdgeMode.Tag.Repeat;
+          }
+          else if (tag == "MirroredRepeat") {
+            tagType = EdgeMode.Tag.MirroredRepeat;
+          }
+          else if (tag == "ClampToEdge") {
+            tagType = EdgeMode.Tag.ClampToEdge;
+          }
+          else if (tag == "ClampToBorder") {
+            tagType = EdgeMode.Tag.ClampToBorder;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          EdgeMode o = new EdgeMode();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ImageSemantic: {
+          string tag = (string)obj["tag"];
+          ImageSemantic.Tag tagType;
+          if (tag == "Depth") {
+            tagType = ImageSemantic.Tag.Depth;
+          }
+          else if (tag == "Stencil") {
+            tagType = ImageSemantic.Tag.Stencil;
+          }
+          else if (tag == "Color") {
+            tagType = ImageSemantic.Tag.Color;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ImageSemantic o = new ImageSemantic();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ImageRef: {
+          string tag = (string)obj["tag"];
+          ImageRef.Tag tagType;
+          if (tag == "TextureImage") {
+            tagType = ImageRef.Tag.TextureImage;
+            data.TextureImage tv = new data.TextureImage();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            tv._2 = (Maybe<int>)fromJSON(Type.Maybe_Int,obj["arg2"]);
+            return tv;
+          }
+          else if (tag == "Framebuffer") {
+            tagType = ImageRef.Tag.Framebuffer;
+            data.Framebuffer tv = new data.Framebuffer();
+            tv._0 = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ImageRef o = new ImageRef();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ClearImage: {
+          string tag = (string)obj["tag"];
+          ClearImage.Tag tagType;
+          if (tag == "ClearImage") {
+            tagType = ClearImage.Tag.ClearImage;
+            data.ClearImage tv = new data.ClearImage();
+            tv.imageSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["imageSemantic"]);
+            tv.clearValue = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["clearValue"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ClearImage o = new ClearImage();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Command: {
+          string tag = (string)obj["tag"];
+          Command.Tag tagType;
+          if (tag == "SetRasterContext") {
+            tagType = Command.Tag.SetRasterContext;
+            data.SetRasterContext tv = new data.SetRasterContext();
+            tv._0 = (global::LambdaCube.IR.RasterContext)fromJSON(Type.RasterContext,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "SetAccumulationContext") {
+            tagType = Command.Tag.SetAccumulationContext;
+            data.SetAccumulationContext tv = new data.SetAccumulationContext();
+            tv._0 = (global::LambdaCube.IR.AccumulationContext)fromJSON(Type.AccumulationContext,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "SetRenderTarget") {
+            tagType = Command.Tag.SetRenderTarget;
+            data.SetRenderTarget tv = new data.SetRenderTarget();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "SetProgram") {
+            tagType = Command.Tag.SetProgram;
+            data.SetProgram tv = new data.SetProgram();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "SetSamplerUniform") {
+            tagType = Command.Tag.SetSamplerUniform;
+            data.SetSamplerUniform tv = new data.SetSamplerUniform();
+            tv._0 = (string)fromJSON(Type.String,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "SetTexture") {
+            tagType = Command.Tag.SetTexture;
+            data.SetTexture tv = new data.SetTexture();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "SetSampler") {
+            tagType = Command.Tag.SetSampler;
+            data.SetSampler tv = new data.SetSampler();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            tv._1 = (Maybe<int>)fromJSON(Type.Maybe_Int,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "RenderSlot") {
+            tagType = Command.Tag.RenderSlot;
+            data.RenderSlot tv = new data.RenderSlot();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "RenderStream") {
+            tagType = Command.Tag.RenderStream;
+            data.RenderStream tv = new data.RenderStream();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "ClearRenderTarget") {
+            tagType = Command.Tag.ClearRenderTarget;
+            data.ClearRenderTarget tv = new data.ClearRenderTarget();
+            tv._0 = (List<global::LambdaCube.IR.ClearImage>)fromJSON(Type.Array_ClearImage,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "GenerateMipMap") {
+            tagType = Command.Tag.GenerateMipMap;
+            data.GenerateMipMap tv = new data.GenerateMipMap();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "SaveImage") {
+            tagType = Command.Tag.SaveImage;
+            data.SaveImage tv = new data.SaveImage();
+            tv._0 = (int)fromJSON(Type.Int,obj["arg0"]);
+            tv._1 = (global::LambdaCube.IR.ImageRef)fromJSON(Type.ImageRef,obj["arg1"]);
+            return tv;
+          }
+          else if (tag == "LoadImage") {
+            tagType = Command.Tag.LoadImage;
+            data.LoadImage tv = new data.LoadImage();
+            tv._0 = (global::LambdaCube.IR.ImageRef)fromJSON(Type.ImageRef,obj["arg0"]);
+            tv._1 = (int)fromJSON(Type.Int,obj["arg1"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Command o = new Command();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.SamplerDescriptor: {
+          string tag = (string)obj["tag"];
+          SamplerDescriptor.Tag tagType;
+          if (tag == "SamplerDescriptor") {
+            tagType = SamplerDescriptor.Tag.SamplerDescriptor;
+            data.SamplerDescriptor tv = new data.SamplerDescriptor();
+            tv.samplerWrapS = (global::LambdaCube.IR.EdgeMode)fromJSON(Type.EdgeMode,obj["samplerWrapS"]);
+            tv.samplerWrapT = (Maybe<global::LambdaCube.IR.EdgeMode>)fromJSON(Type.Maybe_EdgeMode,obj["samplerWrapT"]);
+            tv.samplerWrapR = (Maybe<global::LambdaCube.IR.EdgeMode>)fromJSON(Type.Maybe_EdgeMode,obj["samplerWrapR"]);
+            tv.samplerMinFilter = (global::LambdaCube.IR.Filter)fromJSON(Type.Filter,obj["samplerMinFilter"]);
+            tv.samplerMagFilter = (global::LambdaCube.IR.Filter)fromJSON(Type.Filter,obj["samplerMagFilter"]);
+            tv.samplerBorderColor = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["samplerBorderColor"]);
+            tv.samplerMinLod = (Maybe<float>)fromJSON(Type.Maybe_Float,obj["samplerMinLod"]);
+            tv.samplerMaxLod = (Maybe<float>)fromJSON(Type.Maybe_Float,obj["samplerMaxLod"]);
+            tv.samplerLodBias = (float)fromJSON(Type.Float,obj["samplerLodBias"]);
+            tv.samplerCompareFunc = (Maybe<global::LambdaCube.IR.ComparisonFunction>)fromJSON(Type.Maybe_ComparisonFunction,obj["samplerCompareFunc"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          SamplerDescriptor o = new SamplerDescriptor();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.TextureDescriptor: {
+          string tag = (string)obj["tag"];
+          TextureDescriptor.Tag tagType;
+          if (tag == "TextureDescriptor") {
+            tagType = TextureDescriptor.Tag.TextureDescriptor;
+            data.TextureDescriptor tv = new data.TextureDescriptor();
+            tv.textureType = (global::LambdaCube.IR.TextureType)fromJSON(Type.TextureType,obj["textureType"]);
+            tv.textureSize = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["textureSize"]);
+            tv.textureSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["textureSemantic"]);
+            tv.textureSampler = (global::LambdaCube.IR.SamplerDescriptor)fromJSON(Type.SamplerDescriptor,obj["textureSampler"]);
+            tv.textureBaseLevel = (int)fromJSON(Type.Int,obj["textureBaseLevel"]);
+            tv.textureMaxLevel = (int)fromJSON(Type.Int,obj["textureMaxLevel"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          TextureDescriptor o = new TextureDescriptor();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Parameter: {
+          string tag = (string)obj["tag"];
+          Parameter.Tag tagType;
+          if (tag == "Parameter") {
+            tagType = Parameter.Tag.Parameter;
+            data.Parameter tv = new data.Parameter();
+            tv.name = (string)fromJSON(Type.String,obj["name"]);
+            tv.ty = (global::LambdaCube.IR.InputType)fromJSON(Type.InputType,obj["ty"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Parameter o = new Parameter();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Program: {
+          string tag = (string)obj["tag"];
+          Program.Tag tagType;
+          if (tag == "Program") {
+            tagType = Program.Tag.Program;
+            data.Program tv = new data.Program();
+            tv.programUniforms = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["programUniforms"]);
+            tv.programStreams = (Dictionary<string, global::LambdaCube.IR.Parameter>)fromJSON(Type.Map_String_Parameter,obj["programStreams"]);
+            tv.programInTextures = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["programInTextures"]);
+            tv.programOutput = (List<global::LambdaCube.IR.Parameter>)fromJSON(Type.Array_Parameter,obj["programOutput"]);
+            tv.vertexShader = (string)fromJSON(Type.String,obj["vertexShader"]);
+            tv.geometryShader = (Maybe<string>)fromJSON(Type.Maybe_String,obj["geometryShader"]);
+            tv.fragmentShader = (string)fromJSON(Type.String,obj["fragmentShader"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Program o = new Program();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Slot: {
+          string tag = (string)obj["tag"];
+          Slot.Tag tagType;
+          if (tag == "Slot") {
+            tagType = Slot.Tag.Slot;
+            data.Slot tv = new data.Slot();
+            tv.slotName = (string)fromJSON(Type.String,obj["slotName"]);
+            tv.slotStreams = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["slotStreams"]);
+            tv.slotUniforms = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["slotUniforms"]);
+            tv.slotPrimitive = (global::LambdaCube.IR.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["slotPrimitive"]);
+            tv.slotPrograms = (List<int>)fromJSON(Type.Array_Int,obj["slotPrograms"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Slot o = new Slot();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.StreamData: {
+          string tag = (string)obj["tag"];
+          StreamData.Tag tagType;
+          if (tag == "StreamData") {
+            tagType = StreamData.Tag.StreamData;
+            data.StreamData tv = new data.StreamData();
+            tv.streamData = (Dictionary<string, global::LambdaCube.IR.ArrayValue>)fromJSON(Type.Map_String_ArrayValue,obj["streamData"]);
+            tv.streamType = (Dictionary<string, global::LambdaCube.IR.InputType>)fromJSON(Type.Map_String_InputType,obj["streamType"]);
+            tv.streamPrimitive = (global::LambdaCube.IR.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["streamPrimitive"]);
+            tv.streamPrograms = (List<int>)fromJSON(Type.Array_Int,obj["streamPrograms"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          StreamData o = new StreamData();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.TargetItem: {
+          string tag = (string)obj["tag"];
+          TargetItem.Tag tagType;
+          if (tag == "TargetItem") {
+            tagType = TargetItem.Tag.TargetItem;
+            data.TargetItem tv = new data.TargetItem();
+            tv.targetSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["targetSemantic"]);
+            tv.targetRef = (Maybe<global::LambdaCube.IR.ImageRef>)fromJSON(Type.Maybe_ImageRef,obj["targetRef"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          TargetItem o = new TargetItem();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.RenderTarget: {
+          string tag = (string)obj["tag"];
+          RenderTarget.Tag tagType;
+          if (tag == "RenderTarget") {
+            tagType = RenderTarget.Tag.RenderTarget;
+            data.RenderTarget tv = new data.RenderTarget();
+            tv.renderTargets = (List<global::LambdaCube.IR.TargetItem>)fromJSON(Type.Array_TargetItem,obj["renderTargets"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          RenderTarget o = new RenderTarget();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Backend: {
+          string tag = (string)obj["tag"];
+          Backend.Tag tagType;
+          if (tag == "WebGL1") {
+            tagType = Backend.Tag.WebGL1;
+          }
+          else if (tag == "OpenGL33") {
+            tagType = Backend.Tag.OpenGL33;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Backend o = new Backend();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Pipeline: {
+          string tag = (string)obj["tag"];
+          Pipeline.Tag tagType;
+          if (tag == "Pipeline") {
+            tagType = Pipeline.Tag.Pipeline;
+            data.Pipeline tv = new data.Pipeline();
+            tv.info = (string)fromJSON(Type.String,obj["info"]);
+            tv.backend = (global::LambdaCube.IR.Backend)fromJSON(Type.Backend,obj["backend"]);
+            tv.textures = (List<global::LambdaCube.IR.TextureDescriptor>)fromJSON(Type.Array_TextureDescriptor,obj["textures"]);
+            tv.samplers = (List<global::LambdaCube.IR.SamplerDescriptor>)fromJSON(Type.Array_SamplerDescriptor,obj["samplers"]);
+            tv.targets = (List<global::LambdaCube.IR.RenderTarget>)fromJSON(Type.Array_RenderTarget,obj["targets"]);
+            tv.programs = (List<global::LambdaCube.IR.Program>)fromJSON(Type.Array_Program,obj["programs"]);
+            tv.slots = (List<global::LambdaCube.IR.Slot>)fromJSON(Type.Array_Slot,obj["slots"]);
+            tv.streams = (List<global::LambdaCube.IR.StreamData>)fromJSON(Type.Array_StreamData,obj["streams"]);
+            tv.commands = (List<global::LambdaCube.IR.Command>)fromJSON(Type.Array_Command,obj["commands"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Pipeline o = new Pipeline();
+          o.tag = tagType;
+          return o;
+        }
+      }
+      throw new Exception("unknown type");
+      return null;
+    }
+
+    JToken toJSON(ArrayValue v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ArrayValue.Tag.VBoolArray:
+          obj["tag"] = "VBoolArray";
+          {
+            var tv = (data.VBoolArray)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case ArrayValue.Tag.VIntArray:
+          obj["tag"] = "VIntArray";
+          {
+            var tv = (data.VIntArray)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case ArrayValue.Tag.VWordArray:
+          obj["tag"] = "VWordArray";
+          {
+            var tv = (data.VWordArray)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case ArrayValue.Tag.VFloatArray:
+          obj["tag"] = "VFloatArray";
+          {
+            var tv = (data.VFloatArray)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Value v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Value.Tag.VBool:
+          obj["tag"] = "VBool";
+          {
+            var tv = (data.VBool)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV2B:
+          obj["tag"] = "VV2B";
+          {
+            var tv = (data.VV2B)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV3B:
+          obj["tag"] = "VV3B";
+          {
+            var tv = (data.VV3B)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV4B:
+          obj["tag"] = "VV4B";
+          {
+            var tv = (data.VV4B)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VWord:
+          obj["tag"] = "VWord";
+          {
+            var tv = (data.VWord)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV2U:
+          obj["tag"] = "VV2U";
+          {
+            var tv = (data.VV2U)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV3U:
+          obj["tag"] = "VV3U";
+          {
+            var tv = (data.VV3U)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV4U:
+          obj["tag"] = "VV4U";
+          {
+            var tv = (data.VV4U)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VInt:
+          obj["tag"] = "VInt";
+          {
+            var tv = (data.VInt)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV2I:
+          obj["tag"] = "VV2I";
+          {
+            var tv = (data.VV2I)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV3I:
+          obj["tag"] = "VV3I";
+          {
+            var tv = (data.VV3I)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV4I:
+          obj["tag"] = "VV4I";
+          {
+            var tv = (data.VV4I)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VFloat:
+          obj["tag"] = "VFloat";
+          {
+            var tv = (data.VFloat)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV2F:
+          obj["tag"] = "VV2F";
+          {
+            var tv = (data.VV2F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV3F:
+          obj["tag"] = "VV3F";
+          {
+            var tv = (data.VV3F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VV4F:
+          obj["tag"] = "VV4F";
+          {
+            var tv = (data.VV4F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM22F:
+          obj["tag"] = "VM22F";
+          {
+            var tv = (data.VM22F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM23F:
+          obj["tag"] = "VM23F";
+          {
+            var tv = (data.VM23F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM24F:
+          obj["tag"] = "VM24F";
+          {
+            var tv = (data.VM24F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM32F:
+          obj["tag"] = "VM32F";
+          {
+            var tv = (data.VM32F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM33F:
+          obj["tag"] = "VM33F";
+          {
+            var tv = (data.VM33F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM34F:
+          obj["tag"] = "VM34F";
+          {
+            var tv = (data.VM34F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM42F:
+          obj["tag"] = "VM42F";
+          {
+            var tv = (data.VM42F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM43F:
+          obj["tag"] = "VM43F";
+          {
+            var tv = (data.VM43F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Value.Tag.VM44F:
+          obj["tag"] = "VM44F";
+          {
+            var tv = (data.VM44F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(InputType v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case InputType.Tag.Bool:
+          obj["tag"] = "Bool";
+          break;
+        case InputType.Tag.V2B:
+          obj["tag"] = "V2B";
+          break;
+        case InputType.Tag.V3B:
+          obj["tag"] = "V3B";
+          break;
+        case InputType.Tag.V4B:
+          obj["tag"] = "V4B";
+          break;
+        case InputType.Tag.Word:
+          obj["tag"] = "Word";
+          break;
+        case InputType.Tag.V2U:
+          obj["tag"] = "V2U";
+          break;
+        case InputType.Tag.V3U:
+          obj["tag"] = "V3U";
+          break;
+        case InputType.Tag.V4U:
+          obj["tag"] = "V4U";
+          break;
+        case InputType.Tag.Int:
+          obj["tag"] = "Int";
+          break;
+        case InputType.Tag.V2I:
+          obj["tag"] = "V2I";
+          break;
+        case InputType.Tag.V3I:
+          obj["tag"] = "V3I";
+          break;
+        case InputType.Tag.V4I:
+          obj["tag"] = "V4I";
+          break;
+        case InputType.Tag.Float:
+          obj["tag"] = "Float";
+          break;
+        case InputType.Tag.V2F:
+          obj["tag"] = "V2F";
+          break;
+        case InputType.Tag.V3F:
+          obj["tag"] = "V3F";
+          break;
+        case InputType.Tag.V4F:
+          obj["tag"] = "V4F";
+          break;
+        case InputType.Tag.M22F:
+          obj["tag"] = "M22F";
+          break;
+        case InputType.Tag.M23F:
+          obj["tag"] = "M23F";
+          break;
+        case InputType.Tag.M24F:
+          obj["tag"] = "M24F";
+          break;
+        case InputType.Tag.M32F:
+          obj["tag"] = "M32F";
+          break;
+        case InputType.Tag.M33F:
+          obj["tag"] = "M33F";
+          break;
+        case InputType.Tag.M34F:
+          obj["tag"] = "M34F";
+          break;
+        case InputType.Tag.M42F:
+          obj["tag"] = "M42F";
+          break;
+        case InputType.Tag.M43F:
+          obj["tag"] = "M43F";
+          break;
+        case InputType.Tag.M44F:
+          obj["tag"] = "M44F";
+          break;
+        case InputType.Tag.STexture1D:
+          obj["tag"] = "STexture1D";
+          break;
+        case InputType.Tag.STexture2D:
+          obj["tag"] = "STexture2D";
+          break;
+        case InputType.Tag.STextureCube:
+          obj["tag"] = "STextureCube";
+          break;
+        case InputType.Tag.STexture1DArray:
+          obj["tag"] = "STexture1DArray";
+          break;
+        case InputType.Tag.STexture2DArray:
+          obj["tag"] = "STexture2DArray";
+          break;
+        case InputType.Tag.STexture2DRect:
+          obj["tag"] = "STexture2DRect";
+          break;
+        case InputType.Tag.FTexture1D:
+          obj["tag"] = "FTexture1D";
+          break;
+        case InputType.Tag.FTexture2D:
+          obj["tag"] = "FTexture2D";
+          break;
+        case InputType.Tag.FTexture3D:
+          obj["tag"] = "FTexture3D";
+          break;
+        case InputType.Tag.FTextureCube:
+          obj["tag"] = "FTextureCube";
+          break;
+        case InputType.Tag.FTexture1DArray:
+          obj["tag"] = "FTexture1DArray";
+          break;
+        case InputType.Tag.FTexture2DArray:
+          obj["tag"] = "FTexture2DArray";
+          break;
+        case InputType.Tag.FTexture2DMS:
+          obj["tag"] = "FTexture2DMS";
+          break;
+        case InputType.Tag.FTexture2DMSArray:
+          obj["tag"] = "FTexture2DMSArray";
+          break;
+        case InputType.Tag.FTextureBuffer:
+          obj["tag"] = "FTextureBuffer";
+          break;
+        case InputType.Tag.FTexture2DRect:
+          obj["tag"] = "FTexture2DRect";
+          break;
+        case InputType.Tag.ITexture1D:
+          obj["tag"] = "ITexture1D";
+          break;
+        case InputType.Tag.ITexture2D:
+          obj["tag"] = "ITexture2D";
+          break;
+        case InputType.Tag.ITexture3D:
+          obj["tag"] = "ITexture3D";
+          break;
+        case InputType.Tag.ITextureCube:
+          obj["tag"] = "ITextureCube";
+          break;
+        case InputType.Tag.ITexture1DArray:
+          obj["tag"] = "ITexture1DArray";
+          break;
+        case InputType.Tag.ITexture2DArray:
+          obj["tag"] = "ITexture2DArray";
+          break;
+        case InputType.Tag.ITexture2DMS:
+          obj["tag"] = "ITexture2DMS";
+          break;
+        case InputType.Tag.ITexture2DMSArray:
+          obj["tag"] = "ITexture2DMSArray";
+          break;
+        case InputType.Tag.ITextureBuffer:
+          obj["tag"] = "ITextureBuffer";
+          break;
+        case InputType.Tag.ITexture2DRect:
+          obj["tag"] = "ITexture2DRect";
+          break;
+        case InputType.Tag.UTexture1D:
+          obj["tag"] = "UTexture1D";
+          break;
+        case InputType.Tag.UTexture2D:
+          obj["tag"] = "UTexture2D";
+          break;
+        case InputType.Tag.UTexture3D:
+          obj["tag"] = "UTexture3D";
+          break;
+        case InputType.Tag.UTextureCube:
+          obj["tag"] = "UTextureCube";
+          break;
+        case InputType.Tag.UTexture1DArray:
+          obj["tag"] = "UTexture1DArray";
+          break;
+        case InputType.Tag.UTexture2DArray:
+          obj["tag"] = "UTexture2DArray";
+          break;
+        case InputType.Tag.UTexture2DMS:
+          obj["tag"] = "UTexture2DMS";
+          break;
+        case InputType.Tag.UTexture2DMSArray:
+          obj["tag"] = "UTexture2DMSArray";
+          break;
+        case InputType.Tag.UTextureBuffer:
+          obj["tag"] = "UTextureBuffer";
+          break;
+        case InputType.Tag.UTexture2DRect:
+          obj["tag"] = "UTexture2DRect";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(PointSpriteCoordOrigin v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case PointSpriteCoordOrigin.Tag.LowerLeft:
+          obj["tag"] = "LowerLeft";
+          break;
+        case PointSpriteCoordOrigin.Tag.UpperLeft:
+          obj["tag"] = "UpperLeft";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(PointSize v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case PointSize.Tag.PointSize:
+          obj["tag"] = "PointSize";
+          {
+            var tv = (data.PointSize)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case PointSize.Tag.ProgramPointSize:
+          obj["tag"] = "ProgramPointSize";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(PolygonOffset v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case PolygonOffset.Tag.NoOffset:
+          obj["tag"] = "NoOffset";
+          break;
+        case PolygonOffset.Tag.Offset:
+          obj["tag"] = "Offset";
+          {
+            var tv = (data.Offset)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(FrontFace v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case FrontFace.Tag.CCW:
+          obj["tag"] = "CCW";
+          break;
+        case FrontFace.Tag.CW:
+          obj["tag"] = "CW";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(PolygonMode v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case PolygonMode.Tag.PolygonPoint:
+          obj["tag"] = "PolygonPoint";
+          {
+            var tv = (data.PolygonPoint)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case PolygonMode.Tag.PolygonLine:
+          obj["tag"] = "PolygonLine";
+          {
+            var tv = (data.PolygonLine)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case PolygonMode.Tag.PolygonFill:
+          obj["tag"] = "PolygonFill";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ProvokingVertex v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ProvokingVertex.Tag.FirstVertex:
+          obj["tag"] = "FirstVertex";
+          break;
+        case ProvokingVertex.Tag.LastVertex:
+          obj["tag"] = "LastVertex";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(CullMode v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case CullMode.Tag.CullNone:
+          obj["tag"] = "CullNone";
+          break;
+        case CullMode.Tag.CullFront:
+          obj["tag"] = "CullFront";
+          {
+            var tv = (data.CullFront)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case CullMode.Tag.CullBack:
+          obj["tag"] = "CullBack";
+          {
+            var tv = (data.CullBack)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ComparisonFunction v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ComparisonFunction.Tag.Never:
+          obj["tag"] = "Never";
+          break;
+        case ComparisonFunction.Tag.Less:
+          obj["tag"] = "Less";
+          break;
+        case ComparisonFunction.Tag.Equal:
+          obj["tag"] = "Equal";
+          break;
+        case ComparisonFunction.Tag.Lequal:
+          obj["tag"] = "Lequal";
+          break;
+        case ComparisonFunction.Tag.Greater:
+          obj["tag"] = "Greater";
+          break;
+        case ComparisonFunction.Tag.Notequal:
+          obj["tag"] = "Notequal";
+          break;
+        case ComparisonFunction.Tag.Gequal:
+          obj["tag"] = "Gequal";
+          break;
+        case ComparisonFunction.Tag.Always:
+          obj["tag"] = "Always";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(StencilOperation v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case StencilOperation.Tag.OpZero:
+          obj["tag"] = "OpZero";
+          break;
+        case StencilOperation.Tag.OpKeep:
+          obj["tag"] = "OpKeep";
+          break;
+        case StencilOperation.Tag.OpReplace:
+          obj["tag"] = "OpReplace";
+          break;
+        case StencilOperation.Tag.OpIncr:
+          obj["tag"] = "OpIncr";
+          break;
+        case StencilOperation.Tag.OpIncrWrap:
+          obj["tag"] = "OpIncrWrap";
+          break;
+        case StencilOperation.Tag.OpDecr:
+          obj["tag"] = "OpDecr";
+          break;
+        case StencilOperation.Tag.OpDecrWrap:
+          obj["tag"] = "OpDecrWrap";
+          break;
+        case StencilOperation.Tag.OpInvert:
+          obj["tag"] = "OpInvert";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(BlendEquation v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case BlendEquation.Tag.FuncAdd:
+          obj["tag"] = "FuncAdd";
+          break;
+        case BlendEquation.Tag.FuncSubtract:
+          obj["tag"] = "FuncSubtract";
+          break;
+        case BlendEquation.Tag.FuncReverseSubtract:
+          obj["tag"] = "FuncReverseSubtract";
+          break;
+        case BlendEquation.Tag.Min:
+          obj["tag"] = "Min";
+          break;
+        case BlendEquation.Tag.Max:
+          obj["tag"] = "Max";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(BlendingFactor v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case BlendingFactor.Tag.Zero:
+          obj["tag"] = "Zero";
+          break;
+        case BlendingFactor.Tag.One:
+          obj["tag"] = "One";
+          break;
+        case BlendingFactor.Tag.SrcColor:
+          obj["tag"] = "SrcColor";
+          break;
+        case BlendingFactor.Tag.OneMinusSrcColor:
+          obj["tag"] = "OneMinusSrcColor";
+          break;
+        case BlendingFactor.Tag.DstColor:
+          obj["tag"] = "DstColor";
+          break;
+        case BlendingFactor.Tag.OneMinusDstColor:
+          obj["tag"] = "OneMinusDstColor";
+          break;
+        case BlendingFactor.Tag.SrcAlpha:
+          obj["tag"] = "SrcAlpha";
+          break;
+        case BlendingFactor.Tag.OneMinusSrcAlpha:
+          obj["tag"] = "OneMinusSrcAlpha";
+          break;
+        case BlendingFactor.Tag.DstAlpha:
+          obj["tag"] = "DstAlpha";
+          break;
+        case BlendingFactor.Tag.OneMinusDstAlpha:
+          obj["tag"] = "OneMinusDstAlpha";
+          break;
+        case BlendingFactor.Tag.ConstantColor:
+          obj["tag"] = "ConstantColor";
+          break;
+        case BlendingFactor.Tag.OneMinusConstantColor:
+          obj["tag"] = "OneMinusConstantColor";
+          break;
+        case BlendingFactor.Tag.ConstantAlpha:
+          obj["tag"] = "ConstantAlpha";
+          break;
+        case BlendingFactor.Tag.OneMinusConstantAlpha:
+          obj["tag"] = "OneMinusConstantAlpha";
+          break;
+        case BlendingFactor.Tag.SrcAlphaSaturate:
+          obj["tag"] = "SrcAlphaSaturate";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(LogicOperation v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case LogicOperation.Tag.Clear:
+          obj["tag"] = "Clear";
+          break;
+        case LogicOperation.Tag.And:
+          obj["tag"] = "And";
+          break;
+        case LogicOperation.Tag.AndReverse:
+          obj["tag"] = "AndReverse";
+          break;
+        case LogicOperation.Tag.Copy:
+          obj["tag"] = "Copy";
+          break;
+        case LogicOperation.Tag.AndInverted:
+          obj["tag"] = "AndInverted";
+          break;
+        case LogicOperation.Tag.Noop:
+          obj["tag"] = "Noop";
+          break;
+        case LogicOperation.Tag.Xor:
+          obj["tag"] = "Xor";
+          break;
+        case LogicOperation.Tag.Or:
+          obj["tag"] = "Or";
+          break;
+        case LogicOperation.Tag.Nor:
+          obj["tag"] = "Nor";
+          break;
+        case LogicOperation.Tag.Equiv:
+          obj["tag"] = "Equiv";
+          break;
+        case LogicOperation.Tag.Invert:
+          obj["tag"] = "Invert";
+          break;
+        case LogicOperation.Tag.OrReverse:
+          obj["tag"] = "OrReverse";
+          break;
+        case LogicOperation.Tag.CopyInverted:
+          obj["tag"] = "CopyInverted";
+          break;
+        case LogicOperation.Tag.OrInverted:
+          obj["tag"] = "OrInverted";
+          break;
+        case LogicOperation.Tag.Nand:
+          obj["tag"] = "Nand";
+          break;
+        case LogicOperation.Tag.Set:
+          obj["tag"] = "Set";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(StencilOps v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case StencilOps.Tag.StencilOps:
+          obj["tag"] = "StencilOps";
+          {
+            var tv = (data.StencilOps)v;
+            obj["frontStencilOp"] = toJSON(tv.frontStencilOp);
+            obj["backStencilOp"] = toJSON(tv.backStencilOp);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(StencilTest v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case StencilTest.Tag.StencilTest:
+          obj["tag"] = "StencilTest";
+          {
+            var tv = (data.StencilTest)v;
+            obj["stencilComparision"] = toJSON(tv.stencilComparision);
+            obj["stencilReference"] = toJSON(tv.stencilReference);
+            obj["stencilMask"] = toJSON(tv.stencilMask);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(StencilTests v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case StencilTests.Tag.StencilTests:
+          obj["tag"] = "StencilTests";
+          {
+            var tv = (data.StencilTests)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(FetchPrimitive v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case FetchPrimitive.Tag.Points:
+          obj["tag"] = "Points";
+          break;
+        case FetchPrimitive.Tag.Lines:
+          obj["tag"] = "Lines";
+          break;
+        case FetchPrimitive.Tag.Triangles:
+          obj["tag"] = "Triangles";
+          break;
+        case FetchPrimitive.Tag.LinesAdjacency:
+          obj["tag"] = "LinesAdjacency";
+          break;
+        case FetchPrimitive.Tag.TrianglesAdjacency:
+          obj["tag"] = "TrianglesAdjacency";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(OutputPrimitive v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case OutputPrimitive.Tag.TrianglesOutput:
+          obj["tag"] = "TrianglesOutput";
+          break;
+        case OutputPrimitive.Tag.LinesOutput:
+          obj["tag"] = "LinesOutput";
+          break;
+        case OutputPrimitive.Tag.PointsOutput:
+          obj["tag"] = "PointsOutput";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ColorArity v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ColorArity.Tag.Red:
+          obj["tag"] = "Red";
+          break;
+        case ColorArity.Tag.RG:
+          obj["tag"] = "RG";
+          break;
+        case ColorArity.Tag.RGB:
+          obj["tag"] = "RGB";
+          break;
+        case ColorArity.Tag.RGBA:
+          obj["tag"] = "RGBA";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Blending v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Blending.Tag.NoBlending:
+          obj["tag"] = "NoBlending";
+          break;
+        case Blending.Tag.BlendLogicOp:
+          obj["tag"] = "BlendLogicOp";
+          {
+            var tv = (data.BlendLogicOp)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Blending.Tag.Blend:
+          obj["tag"] = "Blend";
+          {
+            var tv = (data.Blend)v;
+            obj["colorEqSrc"] = toJSON(tv.colorEqSrc);
+            obj["alphaEqSrc"] = toJSON(tv.alphaEqSrc);
+            obj["colorFSrc"] = toJSON(tv.colorFSrc);
+            obj["colorFDst"] = toJSON(tv.colorFDst);
+            obj["alphaFSrc"] = toJSON(tv.alphaFSrc);
+            obj["alphaFDst"] = toJSON(tv.alphaFDst);
+            obj["color"] = toJSON(tv.color);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(RasterContext v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case RasterContext.Tag.PointCtx:
+          obj["tag"] = "PointCtx";
+          {
+            var tv = (data.PointCtx)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+          }
+          break;
+        case RasterContext.Tag.LineCtx:
+          obj["tag"] = "LineCtx";
+          {
+            var tv = (data.LineCtx)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case RasterContext.Tag.TriangleCtx:
+          obj["tag"] = "TriangleCtx";
+          {
+            var tv = (data.TriangleCtx)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+            obj["arg3"] = toJSON(tv._3);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(FragmentOperation v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case FragmentOperation.Tag.DepthOp:
+          obj["tag"] = "DepthOp";
+          {
+            var tv = (data.DepthOp)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case FragmentOperation.Tag.StencilOp:
+          obj["tag"] = "StencilOp";
+          {
+            var tv = (data.StencilOp)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+          }
+          break;
+        case FragmentOperation.Tag.ColorOp:
+          obj["tag"] = "ColorOp";
+          {
+            var tv = (data.ColorOp)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(AccumulationContext v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case AccumulationContext.Tag.AccumulationContext:
+          obj["tag"] = "AccumulationContext";
+          {
+            var tv = (data.AccumulationContext)v;
+            obj["accViewportName"] = toJSON(tv.accViewportName);
+            obj["accOperations"] = toJSON(tv.accOperations);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(TextureDataType v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case TextureDataType.Tag.FloatT:
+          obj["tag"] = "FloatT";
+          {
+            var tv = (data.FloatT)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case TextureDataType.Tag.IntT:
+          obj["tag"] = "IntT";
+          {
+            var tv = (data.IntT)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case TextureDataType.Tag.WordT:
+          obj["tag"] = "WordT";
+          {
+            var tv = (data.WordT)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case TextureDataType.Tag.ShadowT:
+          obj["tag"] = "ShadowT";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(TextureType v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case TextureType.Tag.Texture1D:
+          obj["tag"] = "Texture1D";
+          {
+            var tv = (data.Texture1D)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case TextureType.Tag.Texture2D:
+          obj["tag"] = "Texture2D";
+          {
+            var tv = (data.Texture2D)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case TextureType.Tag.Texture3D:
+          obj["tag"] = "Texture3D";
+          {
+            var tv = (data.Texture3D)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case TextureType.Tag.TextureCube:
+          obj["tag"] = "TextureCube";
+          {
+            var tv = (data.TextureCube)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case TextureType.Tag.TextureRect:
+          obj["tag"] = "TextureRect";
+          {
+            var tv = (data.TextureRect)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case TextureType.Tag.Texture2DMS:
+          obj["tag"] = "Texture2DMS";
+          {
+            var tv = (data.Texture2DMS)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+            obj["arg3"] = toJSON(tv._3);
+          }
+          break;
+        case TextureType.Tag.TextureBuffer:
+          obj["tag"] = "TextureBuffer";
+          {
+            var tv = (data.TextureBuffer)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(MipMap v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case MipMap.Tag.Mip:
+          obj["tag"] = "Mip";
+          {
+            var tv = (data.Mip)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case MipMap.Tag.NoMip:
+          obj["tag"] = "NoMip";
+          break;
+        case MipMap.Tag.AutoMip:
+          obj["tag"] = "AutoMip";
+          {
+            var tv = (data.AutoMip)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Filter v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Filter.Tag.Nearest:
+          obj["tag"] = "Nearest";
+          break;
+        case Filter.Tag.Linear:
+          obj["tag"] = "Linear";
+          break;
+        case Filter.Tag.NearestMipmapNearest:
+          obj["tag"] = "NearestMipmapNearest";
+          break;
+        case Filter.Tag.NearestMipmapLinear:
+          obj["tag"] = "NearestMipmapLinear";
+          break;
+        case Filter.Tag.LinearMipmapNearest:
+          obj["tag"] = "LinearMipmapNearest";
+          break;
+        case Filter.Tag.LinearMipmapLinear:
+          obj["tag"] = "LinearMipmapLinear";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(EdgeMode v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case EdgeMode.Tag.Repeat:
+          obj["tag"] = "Repeat";
+          break;
+        case EdgeMode.Tag.MirroredRepeat:
+          obj["tag"] = "MirroredRepeat";
+          break;
+        case EdgeMode.Tag.ClampToEdge:
+          obj["tag"] = "ClampToEdge";
+          break;
+        case EdgeMode.Tag.ClampToBorder:
+          obj["tag"] = "ClampToBorder";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ImageSemantic v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ImageSemantic.Tag.Depth:
+          obj["tag"] = "Depth";
+          break;
+        case ImageSemantic.Tag.Stencil:
+          obj["tag"] = "Stencil";
+          break;
+        case ImageSemantic.Tag.Color:
+          obj["tag"] = "Color";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ImageRef v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ImageRef.Tag.TextureImage:
+          obj["tag"] = "TextureImage";
+          {
+            var tv = (data.TextureImage)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+          }
+          break;
+        case ImageRef.Tag.Framebuffer:
+          obj["tag"] = "Framebuffer";
+          {
+            var tv = (data.Framebuffer)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ClearImage v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ClearImage.Tag.ClearImage:
+          obj["tag"] = "ClearImage";
+          {
+            var tv = (data.ClearImage)v;
+            obj["imageSemantic"] = toJSON(tv.imageSemantic);
+            obj["clearValue"] = toJSON(tv.clearValue);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Command v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Command.Tag.SetRasterContext:
+          obj["tag"] = "SetRasterContext";
+          {
+            var tv = (data.SetRasterContext)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.SetAccumulationContext:
+          obj["tag"] = "SetAccumulationContext";
+          {
+            var tv = (data.SetAccumulationContext)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.SetRenderTarget:
+          obj["tag"] = "SetRenderTarget";
+          {
+            var tv = (data.SetRenderTarget)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.SetProgram:
+          obj["tag"] = "SetProgram";
+          {
+            var tv = (data.SetProgram)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.SetSamplerUniform:
+          obj["tag"] = "SetSamplerUniform";
+          {
+            var tv = (data.SetSamplerUniform)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case Command.Tag.SetTexture:
+          obj["tag"] = "SetTexture";
+          {
+            var tv = (data.SetTexture)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case Command.Tag.SetSampler:
+          obj["tag"] = "SetSampler";
+          {
+            var tv = (data.SetSampler)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case Command.Tag.RenderSlot:
+          obj["tag"] = "RenderSlot";
+          {
+            var tv = (data.RenderSlot)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.RenderStream:
+          obj["tag"] = "RenderStream";
+          {
+            var tv = (data.RenderStream)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.ClearRenderTarget:
+          obj["tag"] = "ClearRenderTarget";
+          {
+            var tv = (data.ClearRenderTarget)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.GenerateMipMap:
+          obj["tag"] = "GenerateMipMap";
+          {
+            var tv = (data.GenerateMipMap)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case Command.Tag.SaveImage:
+          obj["tag"] = "SaveImage";
+          {
+            var tv = (data.SaveImage)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+        case Command.Tag.LoadImage:
+          obj["tag"] = "LoadImage";
+          {
+            var tv = (data.LoadImage)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(SamplerDescriptor v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case SamplerDescriptor.Tag.SamplerDescriptor:
+          obj["tag"] = "SamplerDescriptor";
+          {
+            var tv = (data.SamplerDescriptor)v;
+            obj["samplerWrapS"] = toJSON(tv.samplerWrapS);
+            obj["samplerWrapT"] = toJSON(tv.samplerWrapT);
+            obj["samplerWrapR"] = toJSON(tv.samplerWrapR);
+            obj["samplerMinFilter"] = toJSON(tv.samplerMinFilter);
+            obj["samplerMagFilter"] = toJSON(tv.samplerMagFilter);
+            obj["samplerBorderColor"] = toJSON(tv.samplerBorderColor);
+            obj["samplerMinLod"] = toJSON(tv.samplerMinLod);
+            obj["samplerMaxLod"] = toJSON(tv.samplerMaxLod);
+            obj["samplerLodBias"] = toJSON(tv.samplerLodBias);
+            obj["samplerCompareFunc"] = toJSON(tv.samplerCompareFunc);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(TextureDescriptor v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case TextureDescriptor.Tag.TextureDescriptor:
+          obj["tag"] = "TextureDescriptor";
+          {
+            var tv = (data.TextureDescriptor)v;
+            obj["textureType"] = toJSON(tv.textureType);
+            obj["textureSize"] = toJSON(tv.textureSize);
+            obj["textureSemantic"] = toJSON(tv.textureSemantic);
+            obj["textureSampler"] = toJSON(tv.textureSampler);
+            obj["textureBaseLevel"] = toJSON(tv.textureBaseLevel);
+            obj["textureMaxLevel"] = toJSON(tv.textureMaxLevel);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Parameter v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Parameter.Tag.Parameter:
+          obj["tag"] = "Parameter";
+          {
+            var tv = (data.Parameter)v;
+            obj["name"] = toJSON(tv.name);
+            obj["ty"] = toJSON(tv.ty);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Program v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Program.Tag.Program:
+          obj["tag"] = "Program";
+          {
+            var tv = (data.Program)v;
+            obj["programUniforms"] = toJSON(tv.programUniforms);
+            obj["programStreams"] = toJSON(tv.programStreams);
+            obj["programInTextures"] = toJSON(tv.programInTextures);
+            obj["programOutput"] = toJSON(tv.programOutput);
+            obj["vertexShader"] = toJSON(tv.vertexShader);
+            obj["geometryShader"] = toJSON(tv.geometryShader);
+            obj["fragmentShader"] = toJSON(tv.fragmentShader);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Slot v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Slot.Tag.Slot:
+          obj["tag"] = "Slot";
+          {
+            var tv = (data.Slot)v;
+            obj["slotName"] = toJSON(tv.slotName);
+            obj["slotStreams"] = toJSON(tv.slotStreams);
+            obj["slotUniforms"] = toJSON(tv.slotUniforms);
+            obj["slotPrimitive"] = toJSON(tv.slotPrimitive);
+            obj["slotPrograms"] = toJSON(tv.slotPrograms);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(StreamData v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case StreamData.Tag.StreamData:
+          obj["tag"] = "StreamData";
+          {
+            var tv = (data.StreamData)v;
+            obj["streamData"] = toJSON(tv.streamData);
+            obj["streamType"] = toJSON(tv.streamType);
+            obj["streamPrimitive"] = toJSON(tv.streamPrimitive);
+            obj["streamPrograms"] = toJSON(tv.streamPrograms);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(TargetItem v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case TargetItem.Tag.TargetItem:
+          obj["tag"] = "TargetItem";
+          {
+            var tv = (data.TargetItem)v;
+            obj["targetSemantic"] = toJSON(tv.targetSemantic);
+            obj["targetRef"] = toJSON(tv.targetRef);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(RenderTarget v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case RenderTarget.Tag.RenderTarget:
+          obj["tag"] = "RenderTarget";
+          {
+            var tv = (data.RenderTarget)v;
+            obj["renderTargets"] = toJSON(tv.renderTargets);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Backend v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Backend.Tag.WebGL1:
+          obj["tag"] = "WebGL1";
+          break;
+        case Backend.Tag.OpenGL33:
+          obj["tag"] = "OpenGL33";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Pipeline v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Pipeline.Tag.Pipeline:
+          obj["tag"] = "Pipeline";
+          {
+            var tv = (data.Pipeline)v;
+            obj["info"] = toJSON(tv.info);
+            obj["backend"] = toJSON(tv.backend);
+            obj["textures"] = toJSON(tv.textures);
+            obj["samplers"] = toJSON(tv.samplers);
+            obj["targets"] = toJSON(tv.targets);
+            obj["programs"] = toJSON(tv.programs);
+            obj["slots"] = toJSON(tv.slots);
+            obj["streams"] = toJSON(tv.streams);
+            obj["commands"] = toJSON(tv.commands);
+          }
+          break;
+      }
+      return obj;
+    }
+
+    JToken toJSON(int v) { return new JValue(v); }
+    JToken toJSON(uint v) { return new JValue(v); }
+    JToken toJSON(float v) { return new JValue(v); }
+    JToken toJSON(bool v) { return new JValue(v); }
+    JToken toJSON(string v) { return new JValue(v); }
+    JToken toJSON(V2<int> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<uint> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<float> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<bool> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<V2<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<V3<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<V4<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V3<int> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<uint> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<float> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<bool> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<V2<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<V3<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<V4<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V4<int> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<uint> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<float> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<bool> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<V2<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<V3<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<V4<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(List<int> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<uint> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<float> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<bool> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.ClearImage> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.Command> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.Parameter> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.Program> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.RenderTarget> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.SamplerDescriptor> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.Slot> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.StreamData> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.TargetItem> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.TextureDescriptor> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.IR.FragmentOperation> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(Maybe<int> v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    JToken toJSON(Maybe<float> v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    JToken toJSON(Maybe<string> v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    JToken toJSON(Maybe<global::LambdaCube.IR.ComparisonFunction> v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    JToken toJSON(Maybe<global::LambdaCube.IR.EdgeMode> v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    JToken toJSON(Maybe<global::LambdaCube.IR.ImageRef> v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    JToken toJSON(Dictionary<string, global::LambdaCube.IR.ArrayValue> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, global::LambdaCube.IR.InputType> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, global::LambdaCube.IR.Parameter> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+  }
+}
diff --git a/ddl/out/LambdaCube.IR.hpp b/ddl/out/LambdaCube.IR.hpp
index 0e139b1..d6d74ac 100644
--- a/ddl/out/LambdaCube.IR.hpp
+++ b/ddl/out/LambdaCube.IR.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.426854000000Z
+=======
+// 2016-03-20T21:42:12.172652000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.IR_H
 #define HEADER_LambdaCube.IR_H
diff --git a/ddl/out/LambdaCube.IR.hs b/ddl/out/LambdaCube.IR.hs
index 7776a6d..2a414dc 100644
--- a/ddl/out/LambdaCube.IR.hs
+++ b/ddl/out/LambdaCube.IR.hs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.426854000000Z
+=======
+-- 2016-03-20T21:42:12.172652000000Z
+>>>>>>> working c# backend
 
 {-# LANGUAGE OverloadedStrings, RecordWildCards #-}
 module LambdaCube.IR where
diff --git a/ddl/out/LambdaCube.IR.java b/ddl/out/LambdaCube.IR.java
new file mode 100644
index 0000000..b819bcb
--- /dev/null
+++ b/ddl/out/LambdaCube.IR.java
@@ -0,0 +1,877 @@
+// generated file, do not modify!
+// 2016-03-14T10:58:29.577511000000Z
+
+
+public class LambdaCube.IR {
+  public class ArrayValue {
+    public enum Tag { 
+      VBoolArray,
+      VIntArray,
+      VWordArray,
+      VFloatArray
+    }
+    public Tag tag;
+
+    public class VBoolArray extends ArrayValue { 
+      public ArrayList<Boolean> _0;
+    }
+    public class VIntArray extends ArrayValue { 
+      public ArrayList<Integer> _0;
+    }
+    public class VWordArray extends ArrayValue { 
+      public ArrayList<Integer> _0;
+    }
+    public class VFloatArray extends ArrayValue { 
+      public ArrayList<Float> _0;
+    }
+  }
+
+  public class Value {
+    public enum Tag { 
+      VBool,
+      VV2B,
+      VV3B,
+      VV4B,
+      VWord,
+      VV2U,
+      VV3U,
+      VV4U,
+      VInt,
+      VV2I,
+      VV3I,
+      VV4I,
+      VFloat,
+      VV2F,
+      VV3F,
+      VV4F,
+      VM22F,
+      VM23F,
+      VM24F,
+      VM32F,
+      VM33F,
+      VM34F,
+      VM42F,
+      VM43F,
+      VM44F
+    }
+    public Tag tag;
+
+    public class VBool extends Value { 
+      public Boolean _0;
+    }
+    public class VV2B extends Value { 
+      public int _0;
+    }
+    public class VV3B extends Value { 
+      public int _0;
+    }
+    public class VV4B extends Value { 
+      public int _0;
+    }
+    public class VWord extends Value { 
+      public Integer _0;
+    }
+    public class VV2U extends Value { 
+      public int _0;
+    }
+    public class VV3U extends Value { 
+      public int _0;
+    }
+    public class VV4U extends Value { 
+      public int _0;
+    }
+    public class VInt extends Value { 
+      public Integer _0;
+    }
+    public class VV2I extends Value { 
+      public int _0;
+    }
+    public class VV3I extends Value { 
+      public int _0;
+    }
+    public class VV4I extends Value { 
+      public int _0;
+    }
+    public class VFloat extends Value { 
+      public Float _0;
+    }
+    public class VV2F extends Value { 
+      public int _0;
+    }
+    public class VV3F extends Value { 
+      public int _0;
+    }
+    public class VV4F extends Value { 
+      public int _0;
+    }
+    public class VM22F extends Value { 
+      public int _0;
+    }
+    public class VM23F extends Value { 
+      public int _0;
+    }
+    public class VM24F extends Value { 
+      public int _0;
+    }
+    public class VM32F extends Value { 
+      public int _0;
+    }
+    public class VM33F extends Value { 
+      public int _0;
+    }
+    public class VM34F extends Value { 
+      public int _0;
+    }
+    public class VM42F extends Value { 
+      public int _0;
+    }
+    public class VM43F extends Value { 
+      public int _0;
+    }
+    public class VM44F extends Value { 
+      public int _0;
+    }
+  }
+
+  public class InputType {
+    public enum Tag { 
+      Bool,
+      V2B,
+      V3B,
+      V4B,
+      Word,
+      V2U,
+      V3U,
+      V4U,
+      Int,
+      V2I,
+      V3I,
+      V4I,
+      Float,
+      V2F,
+      V3F,
+      V4F,
+      M22F,
+      M23F,
+      M24F,
+      M32F,
+      M33F,
+      M34F,
+      M42F,
+      M43F,
+      M44F,
+      STexture1D,
+      STexture2D,
+      STextureCube,
+      STexture1DArray,
+      STexture2DArray,
+      STexture2DRect,
+      FTexture1D,
+      FTexture2D,
+      FTexture3D,
+      FTextureCube,
+      FTexture1DArray,
+      FTexture2DArray,
+      FTexture2DMS,
+      FTexture2DMSArray,
+      FTextureBuffer,
+      FTexture2DRect,
+      ITexture1D,
+      ITexture2D,
+      ITexture3D,
+      ITextureCube,
+      ITexture1DArray,
+      ITexture2DArray,
+      ITexture2DMS,
+      ITexture2DMSArray,
+      ITextureBuffer,
+      ITexture2DRect,
+      UTexture1D,
+      UTexture2D,
+      UTexture3D,
+      UTextureCube,
+      UTexture1DArray,
+      UTexture2DArray,
+      UTexture2DMS,
+      UTexture2DMSArray,
+      UTextureBuffer,
+      UTexture2DRect
+    }
+    public Tag tag;
+
+  }
+
+  public class PointSpriteCoordOrigin {
+    public enum Tag { 
+      LowerLeft,
+      UpperLeft
+    }
+    public Tag tag;
+
+  }
+
+  public class PointSize {
+    public enum Tag { 
+      PointSize,
+      ProgramPointSize
+    }
+    public Tag tag;
+
+    public class PointSize extends PointSize { 
+      public Float _0;
+    }
+  }
+
+  public class PolygonOffset {
+    public enum Tag { 
+      NoOffset,
+      Offset
+    }
+    public Tag tag;
+
+    public class Offset extends PolygonOffset { 
+      public Float _0;
+      public Float _1;
+    }
+  }
+
+  public class FrontFace {
+    public enum Tag { 
+      CCW,
+      CW
+    }
+    public Tag tag;
+
+  }
+
+  public class PolygonMode {
+    public enum Tag { 
+      PolygonPoint,
+      PolygonLine,
+      PolygonFill
+    }
+    public Tag tag;
+
+    public class PolygonPoint extends PolygonMode { 
+      public PointSize _0;
+    }
+    public class PolygonLine extends PolygonMode { 
+      public Float _0;
+    }
+  }
+
+  public class ProvokingVertex {
+    public enum Tag { 
+      FirstVertex,
+      LastVertex
+    }
+    public Tag tag;
+
+  }
+
+  public class CullMode {
+    public enum Tag { 
+      CullNone,
+      CullFront,
+      CullBack
+    }
+    public Tag tag;
+
+    public class CullFront extends CullMode { 
+      public FrontFace _0;
+    }
+    public class CullBack extends CullMode { 
+      public FrontFace _0;
+    }
+  }
+
+  public class ComparisonFunction {
+    public enum Tag { 
+      Never,
+      Less,
+      Equal,
+      Lequal,
+      Greater,
+      Notequal,
+      Gequal,
+      Always
+    }
+    public Tag tag;
+
+  }
+
+  public class StencilOperation {
+    public enum Tag { 
+      OpZero,
+      OpKeep,
+      OpReplace,
+      OpIncr,
+      OpIncrWrap,
+      OpDecr,
+      OpDecrWrap,
+      OpInvert
+    }
+    public Tag tag;
+
+  }
+
+  public class BlendEquation {
+    public enum Tag { 
+      FuncAdd,
+      FuncSubtract,
+      FuncReverseSubtract,
+      Min,
+      Max
+    }
+    public Tag tag;
+
+  }
+
+  public class BlendingFactor {
+    public enum Tag { 
+      Zero,
+      One,
+      SrcColor,
+      OneMinusSrcColor,
+      DstColor,
+      OneMinusDstColor,
+      SrcAlpha,
+      OneMinusSrcAlpha,
+      DstAlpha,
+      OneMinusDstAlpha,
+      ConstantColor,
+      OneMinusConstantColor,
+      ConstantAlpha,
+      OneMinusConstantAlpha,
+      SrcAlphaSaturate
+    }
+    public Tag tag;
+
+  }
+
+  public class LogicOperation {
+    public enum Tag { 
+      Clear,
+      And,
+      AndReverse,
+      Copy,
+      AndInverted,
+      Noop,
+      Xor,
+      Or,
+      Nor,
+      Equiv,
+      Invert,
+      OrReverse,
+      CopyInverted,
+      OrInverted,
+      Nand,
+      Set
+    }
+    public Tag tag;
+
+  }
+
+  public class StencilOps {
+    public enum Tag { 
+      StencilOps
+    }
+    public Tag tag;
+
+    public class StencilOps extends StencilOps { 
+      public StencilOperation frontStencilOp;
+      public StencilOperation backStencilOp;
+    }
+  }
+
+  public class StencilTest {
+    public enum Tag { 
+      StencilTest
+    }
+    public Tag tag;
+
+    public class StencilTest extends StencilTest { 
+      public ComparisonFunction stencilComparision;
+      public Integer stencilReference;
+      public Integer stencilMask;
+    }
+  }
+
+  public class StencilTests {
+    public enum Tag { 
+      StencilTests
+    }
+    public Tag tag;
+
+    public class StencilTests extends StencilTests { 
+      public StencilTest _0;
+      public StencilTest _1;
+    }
+  }
+
+  public class FetchPrimitive {
+    public enum Tag { 
+      Points,
+      Lines,
+      Triangles,
+      LinesAdjacency,
+      TrianglesAdjacency
+    }
+    public Tag tag;
+
+  }
+
+  public class OutputPrimitive {
+    public enum Tag { 
+      TrianglesOutput,
+      LinesOutput,
+      PointsOutput
+    }
+    public Tag tag;
+
+  }
+
+  public class ColorArity {
+    public enum Tag { 
+      Red,
+      RG,
+      RGB,
+      RGBA
+    }
+    public Tag tag;
+
+  }
+
+  public class Blending {
+    public enum Tag { 
+      NoBlending,
+      BlendLogicOp,
+      Blend
+    }
+    public Tag tag;
+
+    public class BlendLogicOp extends Blending { 
+      public LogicOperation _0;
+    }
+    public class Blend extends Blending { 
+      public BlendEquation colorEqSrc;
+      public BlendEquation alphaEqSrc;
+      public BlendingFactor colorFSrc;
+      public BlendingFactor colorFDst;
+      public BlendingFactor alphaFSrc;
+      public BlendingFactor alphaFDst;
+      public int color;
+    }
+  }
+
+  public class RasterContext {
+    public enum Tag { 
+      PointCtx,
+      LineCtx,
+      TriangleCtx
+    }
+    public Tag tag;
+
+    public class PointCtx extends RasterContext { 
+      public PointSize _0;
+      public Float _1;
+      public PointSpriteCoordOrigin _2;
+    }
+    public class LineCtx extends RasterContext { 
+      public Float _0;
+      public ProvokingVertex _1;
+    }
+    public class TriangleCtx extends RasterContext { 
+      public CullMode _0;
+      public PolygonMode _1;
+      public PolygonOffset _2;
+      public ProvokingVertex _3;
+    }
+  }
+
+  public class FragmentOperation {
+    public enum Tag { 
+      DepthOp,
+      StencilOp,
+      ColorOp
+    }
+    public Tag tag;
+
+    public class DepthOp extends FragmentOperation { 
+      public ComparisonFunction _0;
+      public Boolean _1;
+    }
+    public class StencilOp extends FragmentOperation { 
+      public StencilTests _0;
+      public StencilOps _1;
+      public StencilOps _2;
+    }
+    public class ColorOp extends FragmentOperation { 
+      public Blending _0;
+      public Value _1;
+    }
+  }
+
+  public class AccumulationContext {
+    public enum Tag { 
+      AccumulationContext
+    }
+    public Tag tag;
+
+    public class AccumulationContext extends AccumulationContext { 
+      public int accViewportName;
+      public ArrayList<FragmentOperation> accOperations;
+    }
+  }
+
+  public class TextureDataType {
+    public enum Tag { 
+      FloatT,
+      IntT,
+      WordT,
+      ShadowT
+    }
+    public Tag tag;
+
+    public class FloatT extends TextureDataType { 
+      public ColorArity _0;
+    }
+    public class IntT extends TextureDataType { 
+      public ColorArity _0;
+    }
+    public class WordT extends TextureDataType { 
+      public ColorArity _0;
+    }
+  }
+
+  public class TextureType {
+    public enum Tag { 
+      Texture1D,
+      Texture2D,
+      Texture3D,
+      TextureCube,
+      TextureRect,
+      Texture2DMS,
+      TextureBuffer
+    }
+    public Tag tag;
+
+    public class Texture1D extends TextureType { 
+      public TextureDataType _0;
+      public Integer _1;
+    }
+    public class Texture2D extends TextureType { 
+      public TextureDataType _0;
+      public Integer _1;
+    }
+    public class Texture3D extends TextureType { 
+      public TextureDataType _0;
+    }
+    public class TextureCube extends TextureType { 
+      public TextureDataType _0;
+    }
+    public class TextureRect extends TextureType { 
+      public TextureDataType _0;
+    }
+    public class Texture2DMS extends TextureType { 
+      public TextureDataType _0;
+      public Integer _1;
+      public Integer _2;
+      public Boolean _3;
+    }
+    public class TextureBuffer extends TextureType { 
+      public TextureDataType _0;
+    }
+  }
+
+  public class MipMap {
+    public enum Tag { 
+      Mip,
+      NoMip,
+      AutoMip
+    }
+    public Tag tag;
+
+    public class Mip extends MipMap { 
+      public Integer _0;
+      public Integer _1;
+    }
+    public class AutoMip extends MipMap { 
+      public Integer _0;
+      public Integer _1;
+    }
+  }
+
+  public class Filter {
+    public enum Tag { 
+      Nearest,
+      Linear,
+      NearestMipmapNearest,
+      NearestMipmapLinear,
+      LinearMipmapNearest,
+      LinearMipmapLinear
+    }
+    public Tag tag;
+
+  }
+
+  public class EdgeMode {
+    public enum Tag { 
+      Repeat,
+      MirroredRepeat,
+      ClampToEdge,
+      ClampToBorder
+    }
+    public Tag tag;
+
+  }
+
+  public class ImageSemantic {
+    public enum Tag { 
+      Depth,
+      Stencil,
+      Color
+    }
+    public Tag tag;
+
+  }
+
+  public class ImageRef {
+    public enum Tag { 
+      TextureImage,
+      Framebuffer
+    }
+    public Tag tag;
+
+    public class TextureImage extends ImageRef { 
+      public Integer _0;
+      public Integer _1;
+      public int _2;
+    }
+    public class Framebuffer extends ImageRef { 
+      public ImageSemantic _0;
+    }
+  }
+
+  public class ClearImage {
+    public enum Tag { 
+      ClearImage
+    }
+    public Tag tag;
+
+    public class ClearImage extends ClearImage { 
+      public ImageSemantic imageSemantic;
+      public Value clearValue;
+    }
+  }
+
+  public class Command {
+    public enum Tag { 
+      SetRasterContext,
+      SetAccumulationContext,
+      SetRenderTarget,
+      SetProgram,
+      SetSamplerUniform,
+      SetTexture,
+      SetSampler,
+      RenderSlot,
+      RenderStream,
+      ClearRenderTarget,
+      GenerateMipMap,
+      SaveImage,
+      LoadImage
+    }
+    public Tag tag;
+
+    public class SetRasterContext extends Command { 
+      public RasterContext _0;
+    }
+    public class SetAccumulationContext extends Command { 
+      public AccumulationContext _0;
+    }
+    public class SetRenderTarget extends Command { 
+      public Integer _0;
+    }
+    public class SetProgram extends Command { 
+      public Integer _0;
+    }
+    public class SetSamplerUniform extends Command { 
+      public String _0;
+      public Integer _1;
+    }
+    public class SetTexture extends Command { 
+      public Integer _0;
+      public Integer _1;
+    }
+    public class SetSampler extends Command { 
+      public Integer _0;
+      public int _1;
+    }
+    public class RenderSlot extends Command { 
+      public Integer _0;
+    }
+    public class RenderStream extends Command { 
+      public Integer _0;
+    }
+    public class ClearRenderTarget extends Command { 
+      public ArrayList<ClearImage> _0;
+    }
+    public class GenerateMipMap extends Command { 
+      public Integer _0;
+    }
+    public class SaveImage extends Command { 
+      public Integer _0;
+      public ImageRef _1;
+    }
+    public class LoadImage extends Command { 
+      public ImageRef _0;
+      public Integer _1;
+    }
+  }
+
+  public class SamplerDescriptor {
+    public enum Tag { 
+      SamplerDescriptor
+    }
+    public Tag tag;
+
+    public class SamplerDescriptor extends SamplerDescriptor { 
+      public EdgeMode samplerWrapS;
+      public int samplerWrapT;
+      public int samplerWrapR;
+      public Filter samplerMinFilter;
+      public Filter samplerMagFilter;
+      public Value samplerBorderColor;
+      public int samplerMinLod;
+      public int samplerMaxLod;
+      public Float samplerLodBias;
+      public int samplerCompareFunc;
+    }
+  }
+
+  public class TextureDescriptor {
+    public enum Tag { 
+      TextureDescriptor
+    }
+    public Tag tag;
+
+    public class TextureDescriptor extends TextureDescriptor { 
+      public TextureType textureType;
+      public Value textureSize;
+      public ImageSemantic textureSemantic;
+      public SamplerDescriptor textureSampler;
+      public Integer textureBaseLevel;
+      public Integer textureMaxLevel;
+    }
+  }
+
+  public class Parameter {
+    public enum Tag { 
+      Parameter
+    }
+    public Tag tag;
+
+    public class Parameter extends Parameter { 
+      public String name;
+      public InputType ty;
+    }
+  }
+
+  public class Program {
+    public enum Tag { 
+      Program
+    }
+    public Tag tag;
+
+    public class Program extends Program { 
+      public HashMap<String, InputType> programUniforms;
+      public HashMap<String, Parameter> programStreams;
+      public HashMap<String, InputType> programInTextures;
+      public ArrayList<Parameter> programOutput;
+      public String vertexShader;
+      public int geometryShader;
+      public String fragmentShader;
+    }
+  }
+
+  public class Slot {
+    public enum Tag { 
+      Slot
+    }
+    public Tag tag;
+
+    public class Slot extends Slot { 
+      public String slotName;
+      public HashMap<String, InputType> slotStreams;
+      public HashMap<String, InputType> slotUniforms;
+      public FetchPrimitive slotPrimitive;
+      public ArrayList<Integer> slotPrograms;
+    }
+  }
+
+  public class StreamData {
+    public enum Tag { 
+      StreamData
+    }
+    public Tag tag;
+
+    public class StreamData extends StreamData { 
+      public HashMap<String, ArrayValue> streamData;
+      public HashMap<String, InputType> streamType;
+      public FetchPrimitive streamPrimitive;
+      public ArrayList<Integer> streamPrograms;
+    }
+  }
+
+  public class TargetItem {
+    public enum Tag { 
+      TargetItem
+    }
+    public Tag tag;
+
+    public class TargetItem extends TargetItem { 
+      public ImageSemantic targetSemantic;
+      public int targetRef;
+    }
+  }
+
+  public class RenderTarget {
+    public enum Tag { 
+      RenderTarget
+    }
+    public Tag tag;
+
+    public class RenderTarget extends RenderTarget { 
+      public ArrayList<TargetItem> renderTargets;
+    }
+  }
+
+  public class Backend {
+    public enum Tag { 
+      WebGL1,
+      OpenGL33
+    }
+    public Tag tag;
+
+  }
+
+  public class Pipeline {
+    public enum Tag { 
+      Pipeline
+    }
+    public Tag tag;
+
+    public class Pipeline extends Pipeline { 
+      public String info;
+      public Backend backend;
+      public ArrayList<TextureDescriptor> textures;
+      public ArrayList<SamplerDescriptor> samplers;
+      public ArrayList<RenderTarget> targets;
+      public ArrayList<Program> programs;
+      public ArrayList<Slot> slots;
+      public ArrayList<StreamData> streams;
+      public ArrayList<Command> commands;
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/ddl/out/LambdaCube.IR.purs b/ddl/out/LambdaCube.IR.purs
index 5e2e548..7a36d7e 100644
--- a/ddl/out/LambdaCube.IR.purs
+++ b/ddl/out/LambdaCube.IR.purs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.426854000000Z
+=======
+-- 2016-03-20T21:42:12.172652000000Z
+>>>>>>> working c# backend
 
 module LambdaCube.IR where
 import Prelude
diff --git a/ddl/out/LambdaCube.IR.swift b/ddl/out/LambdaCube.IR.swift
index 3131320..4cc6239 100644
--- a/ddl/out/LambdaCube.IR.swift
+++ b/ddl/out/LambdaCube.IR.swift
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.426854000000Z
+=======
+// 2016-03-20T21:42:12.172652000000Z
+>>>>>>> working c# backend
 
 typealias StreamName = Int
 
diff --git a/ddl/out/LambdaCube.IR2.hpp b/ddl/out/LambdaCube.IR2.hpp
index 48153e5..a2e531a 100644
--- a/ddl/out/LambdaCube.IR2.hpp
+++ b/ddl/out/LambdaCube.IR2.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.426854000000Z
+=======
+// 2016-03-20T21:42:12.172652000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.IR_H
 #define HEADER_LambdaCube.IR_H
diff --git a/ddl/out/LambdaCube.Mesh.cpp b/ddl/out/LambdaCube.Mesh.cpp
index ccbf035..aa1ca00 100644
--- a/ddl/out/LambdaCube.Mesh.cpp
+++ b/ddl/out/LambdaCube.Mesh.cpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.781208000000Z
+=======
+// 2016-03-20T21:42:12.936741000000Z
+>>>>>>> working c# backend
 
 #include "LambdaCube.Mesh.hpp"
 template<> json toJSON<std::shared_ptr<MeshAttribute>>(std::shared_ptr<MeshAttribute> &v) {
diff --git a/ddl/out/LambdaCube.Mesh.cs b/ddl/out/LambdaCube.Mesh.cs
new file mode 100644
index 0000000..62b8d29
--- /dev/null
+++ b/ddl/out/LambdaCube.Mesh.cs
@@ -0,0 +1,529 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.391032000000Z
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+
+namespace LambdaCube.Mesh {
+  class MeshAttribute {
+      public enum Tag { 
+        A_Float,
+        A_V2F,
+        A_V3F,
+        A_V4F,
+        A_M22F,
+        A_M33F,
+        A_M44F,
+        A_Int,
+        A_Word
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class A_Float : LambdaCube.Mesh.MeshAttribute { 
+      public List<float> _0;
+      public A_Float() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_Float; }
+    };
+    class A_V2F : LambdaCube.Mesh.MeshAttribute { 
+      public List<V2<float>> _0;
+      public A_V2F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_V2F; }
+    };
+    class A_V3F : LambdaCube.Mesh.MeshAttribute { 
+      public List<V3<float>> _0;
+      public A_V3F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_V3F; }
+    };
+    class A_V4F : LambdaCube.Mesh.MeshAttribute { 
+      public List<V4<float>> _0;
+      public A_V4F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_V4F; }
+    };
+    class A_M22F : LambdaCube.Mesh.MeshAttribute { 
+      public List<V2<V2<float>>> _0;
+      public A_M22F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_M22F; }
+    };
+    class A_M33F : LambdaCube.Mesh.MeshAttribute { 
+      public List<V3<V3<float>>> _0;
+      public A_M33F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_M33F; }
+    };
+    class A_M44F : LambdaCube.Mesh.MeshAttribute { 
+      public List<V4<V4<float>>> _0;
+      public A_M44F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_M44F; }
+    };
+    class A_Int : LambdaCube.Mesh.MeshAttribute { 
+      public List<int> _0;
+      public A_Int() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_Int; }
+    };
+    class A_Word : LambdaCube.Mesh.MeshAttribute { 
+      public List<uint> _0;
+      public A_Word() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_Word; }
+    };
+  }
+  class MeshPrimitive {
+      public enum Tag { 
+        P_Points,
+        P_TriangleStrip,
+        P_Triangles,
+        P_TriangleStripI,
+        P_TrianglesI
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class P_TriangleStripI : LambdaCube.Mesh.MeshPrimitive { 
+      public List<int> _0;
+      public P_TriangleStripI() { tag = LambdaCube.Mesh.MeshPrimitive.Tag.P_TriangleStripI; }
+    };
+    class P_TrianglesI : LambdaCube.Mesh.MeshPrimitive { 
+      public List<int> _0;
+      public P_TrianglesI() { tag = LambdaCube.Mesh.MeshPrimitive.Tag.P_TrianglesI; }
+    };
+  }
+  class Mesh {
+      public enum Tag { 
+        Mesh
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Mesh : LambdaCube.Mesh.Mesh { 
+      public Dictionary<string, global::LambdaCube.Mesh.MeshAttribute> mAttributes;
+      public global::LambdaCube.Mesh.MeshPrimitive mPrimitive;
+      public Mesh() { tag = LambdaCube.Mesh.Mesh.Tag.Mesh; }
+    };
+  }
+
+  // JSON deserializer
+  enum Type { 
+    Int32,
+    Word32,
+    Float,
+    String,
+    V2_Float,
+    V2_V2_Float,
+    V3_Float,
+    V3_V3_Float,
+    V4_Float,
+    V4_V4_Float,
+    Array_Int32,
+    Array_Word32,
+    Array_Float,
+    Array_V2_Float,
+    Array_V2_V2_Float,
+    Array_V3_Float,
+    Array_V3_V3_Float,
+    Array_V4_Float,
+    Array_V4_V4_Float,
+    Map_String_MeshAttribute,
+    Mesh,
+    MeshAttribute,
+    MeshPrimitive
+  }
+
+  class Loader {
+    public static object fromJSON(Type type, JToken obj) {
+      switch (type) {
+        case Type.Int32: return (int)obj;
+        case Type.Word32: return (uint)obj;
+        case Type.Float: return (float)obj;
+        case Type.String: return (string)obj;
+        case Type.V2_Float:
+          return new V2<float>
+            { x = (float)fromJSON(Type.Float,obj["x"])
+            , y = (float)fromJSON(Type.Float,obj["y"])
+            };
+        case Type.V2_V2_Float:
+          return new V2<V2<float>>
+            { x = (V2<float>)fromJSON(Type.V2_Float,obj["x"])
+            , y = (V2<float>)fromJSON(Type.V2_Float,obj["y"])
+            };
+        case Type.V3_Float:
+          return new V3<float>
+            { x = (float)fromJSON(Type.Float,obj["x"])
+            , y = (float)fromJSON(Type.Float,obj["y"])
+            , z = (float)fromJSON(Type.Float,obj["z"])
+            };
+        case Type.V3_V3_Float:
+          return new V3<V3<float>>
+            { x = (V3<float>)fromJSON(Type.V3_Float,obj["x"])
+            , y = (V3<float>)fromJSON(Type.V3_Float,obj["y"])
+            , z = (V3<float>)fromJSON(Type.V3_Float,obj["z"])
+            };
+        case Type.V4_Float:
+          return new V4<float>
+            { x = (float)fromJSON(Type.Float,obj["x"])
+            , y = (float)fromJSON(Type.Float,obj["y"])
+            , z = (float)fromJSON(Type.Float,obj["z"])
+            , w = (float)fromJSON(Type.Float,obj["w"])
+            };
+        case Type.V4_V4_Float:
+          return new V4<V4<float>>
+            { x = (V4<float>)fromJSON(Type.V4_Float,obj["x"])
+            , y = (V4<float>)fromJSON(Type.V4_Float,obj["y"])
+            , z = (V4<float>)fromJSON(Type.V4_Float,obj["z"])
+            , w = (V4<float>)fromJSON(Type.V4_Float,obj["w"])
+            };
+        case Type.Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList();
+        case Type.Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList();
+        case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
+        case Type.Array_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_Float, x)).ToList();
+        case Type.Array_V2_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_V2_Float, x)).ToList();
+        case Type.Array_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_Float, x)).ToList();
+        case Type.Array_V3_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_V3_Float, x)).ToList();
+        case Type.Array_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_Float, x)).ToList();
+        case Type.Array_V4_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_V4_Float, x)).ToList();
+        case Type.Map_String_MeshAttribute: {
+          var map = new Dictionary<string, global::LambdaCube.Mesh.MeshAttribute> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.Mesh.MeshAttribute)fromJSON(Type.MeshAttribute,i.Value));
+          }
+          return map;
+        }
+
+        case Type.MeshAttribute: {
+          string tag = (string)obj["tag"];
+          MeshAttribute.Tag tagType;
+          if (tag == "A_Float") {
+            tagType = MeshAttribute.Tag.A_Float;
+            data.A_Float tv = new data.A_Float();
+            tv._0 = (List<float>)fromJSON(Type.Array_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_V2F") {
+            tagType = MeshAttribute.Tag.A_V2F;
+            data.A_V2F tv = new data.A_V2F();
+            tv._0 = (List<V2<float>>)fromJSON(Type.Array_V2_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_V3F") {
+            tagType = MeshAttribute.Tag.A_V3F;
+            data.A_V3F tv = new data.A_V3F();
+            tv._0 = (List<V3<float>>)fromJSON(Type.Array_V3_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_V4F") {
+            tagType = MeshAttribute.Tag.A_V4F;
+            data.A_V4F tv = new data.A_V4F();
+            tv._0 = (List<V4<float>>)fromJSON(Type.Array_V4_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_M22F") {
+            tagType = MeshAttribute.Tag.A_M22F;
+            data.A_M22F tv = new data.A_M22F();
+            tv._0 = (List<V2<V2<float>>>)fromJSON(Type.Array_V2_V2_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_M33F") {
+            tagType = MeshAttribute.Tag.A_M33F;
+            data.A_M33F tv = new data.A_M33F();
+            tv._0 = (List<V3<V3<float>>>)fromJSON(Type.Array_V3_V3_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_M44F") {
+            tagType = MeshAttribute.Tag.A_M44F;
+            data.A_M44F tv = new data.A_M44F();
+            tv._0 = (List<V4<V4<float>>>)fromJSON(Type.Array_V4_V4_Float,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_Int") {
+            tagType = MeshAttribute.Tag.A_Int;
+            data.A_Int tv = new data.A_Int();
+            tv._0 = (List<int>)fromJSON(Type.Array_Int32,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "A_Word") {
+            tagType = MeshAttribute.Tag.A_Word;
+            data.A_Word tv = new data.A_Word();
+            tv._0 = (List<uint>)fromJSON(Type.Array_Word32,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          MeshAttribute o = new MeshAttribute();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.MeshPrimitive: {
+          string tag = (string)obj["tag"];
+          MeshPrimitive.Tag tagType;
+          if (tag == "P_Points") {
+            tagType = MeshPrimitive.Tag.P_Points;
+          }
+          else if (tag == "P_TriangleStrip") {
+            tagType = MeshPrimitive.Tag.P_TriangleStrip;
+          }
+          else if (tag == "P_Triangles") {
+            tagType = MeshPrimitive.Tag.P_Triangles;
+          }
+          else if (tag == "P_TriangleStripI") {
+            tagType = MeshPrimitive.Tag.P_TriangleStripI;
+            data.P_TriangleStripI tv = new data.P_TriangleStripI();
+            tv._0 = (List<int>)fromJSON(Type.Array_Int32,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "P_TrianglesI") {
+            tagType = MeshPrimitive.Tag.P_TrianglesI;
+            data.P_TrianglesI tv = new data.P_TrianglesI();
+            tv._0 = (List<int>)fromJSON(Type.Array_Int32,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          MeshPrimitive o = new MeshPrimitive();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Mesh: {
+          string tag = (string)obj["tag"];
+          Mesh.Tag tagType;
+          if (tag == "Mesh") {
+            tagType = Mesh.Tag.Mesh;
+            data.Mesh tv = new data.Mesh();
+            tv.mAttributes = (Dictionary<string, global::LambdaCube.Mesh.MeshAttribute>)fromJSON(Type.Map_String_MeshAttribute,obj["mAttributes"]);
+            tv.mPrimitive = (global::LambdaCube.Mesh.MeshPrimitive)fromJSON(Type.MeshPrimitive,obj["mPrimitive"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Mesh o = new Mesh();
+          o.tag = tagType;
+          return o;
+        }
+      }
+      throw new Exception("unknown type");
+      return null;
+    }
+
+    JToken toJSON(MeshAttribute v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case MeshAttribute.Tag.A_Float:
+          obj["tag"] = "A_Float";
+          {
+            var tv = (data.A_Float)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_V2F:
+          obj["tag"] = "A_V2F";
+          {
+            var tv = (data.A_V2F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_V3F:
+          obj["tag"] = "A_V3F";
+          {
+            var tv = (data.A_V3F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_V4F:
+          obj["tag"] = "A_V4F";
+          {
+            var tv = (data.A_V4F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_M22F:
+          obj["tag"] = "A_M22F";
+          {
+            var tv = (data.A_M22F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_M33F:
+          obj["tag"] = "A_M33F";
+          {
+            var tv = (data.A_M33F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_M44F:
+          obj["tag"] = "A_M44F";
+          {
+            var tv = (data.A_M44F)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_Int:
+          obj["tag"] = "A_Int";
+          {
+            var tv = (data.A_Int)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshAttribute.Tag.A_Word:
+          obj["tag"] = "A_Word";
+          {
+            var tv = (data.A_Word)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(MeshPrimitive v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case MeshPrimitive.Tag.P_Points:
+          obj["tag"] = "P_Points";
+          break;
+        case MeshPrimitive.Tag.P_TriangleStrip:
+          obj["tag"] = "P_TriangleStrip";
+          break;
+        case MeshPrimitive.Tag.P_Triangles:
+          obj["tag"] = "P_Triangles";
+          break;
+        case MeshPrimitive.Tag.P_TriangleStripI:
+          obj["tag"] = "P_TriangleStripI";
+          {
+            var tv = (data.P_TriangleStripI)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case MeshPrimitive.Tag.P_TrianglesI:
+          obj["tag"] = "P_TrianglesI";
+          {
+            var tv = (data.P_TrianglesI)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Mesh v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Mesh.Tag.Mesh:
+          obj["tag"] = "Mesh";
+          {
+            var tv = (data.Mesh)v;
+            obj["mAttributes"] = toJSON(tv.mAttributes);
+            obj["mPrimitive"] = toJSON(tv.mPrimitive);
+          }
+          break;
+      }
+      return obj;
+    }
+
+    JToken toJSON(int v) { return new JValue(v); }
+    JToken toJSON(uint v) { return new JValue(v); }
+    JToken toJSON(float v) { return new JValue(v); }
+    JToken toJSON(string v) { return new JValue(v); }
+    JToken toJSON(V2<float> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V2<V2<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    JToken toJSON(V3<float> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V3<V3<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    JToken toJSON(V4<float> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(V4<V4<float>> v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    JToken toJSON(List<int> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<uint> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<float> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<V2<float>> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<V2<V2<float>>> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<V3<float>> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<V3<V3<float>>> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<V4<float>> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<V4<V4<float>>> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, global::LambdaCube.Mesh.MeshAttribute> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+  }
+}
diff --git a/ddl/out/LambdaCube.Mesh.hpp b/ddl/out/LambdaCube.Mesh.hpp
index 29bb2ba..d0899fd 100644
--- a/ddl/out/LambdaCube.Mesh.hpp
+++ b/ddl/out/LambdaCube.Mesh.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.781208000000Z
+=======
+// 2016-03-20T21:42:12.936741000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.Mesh_H
 #define HEADER_LambdaCube.Mesh_H
diff --git a/ddl/out/LambdaCube.Mesh.hs b/ddl/out/LambdaCube.Mesh.hs
index 1e7926a..ddf90c9 100644
--- a/ddl/out/LambdaCube.Mesh.hs
+++ b/ddl/out/LambdaCube.Mesh.hs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.781208000000Z
+=======
+-- 2016-03-20T21:42:12.936741000000Z
+>>>>>>> working c# backend
 
 {-# LANGUAGE OverloadedStrings, RecordWildCards #-}
 module LambdaCube.Mesh where
diff --git a/ddl/out/LambdaCube.Mesh.java b/ddl/out/LambdaCube.Mesh.java
new file mode 100644
index 0000000..2cf85c7
--- /dev/null
+++ b/ddl/out/LambdaCube.Mesh.java
@@ -0,0 +1,79 @@
+// generated file, do not modify!
+// 2016-03-14T10:58:29.976813000000Z
+
+
+public class LambdaCube.Mesh {
+  public class MeshAttribute {
+    public enum Tag { 
+      A_Float,
+      A_V2F,
+      A_V3F,
+      A_V4F,
+      A_M22F,
+      A_M33F,
+      A_M44F,
+      A_Int,
+      A_Word
+    }
+    public Tag tag;
+
+    public class A_Float extends MeshAttribute { 
+      public ArrayList<Float> _0;
+    }
+    public class A_V2F extends MeshAttribute { 
+      public ArrayList<int> _0;
+    }
+    public class A_V3F extends MeshAttribute { 
+      public ArrayList<int> _0;
+    }
+    public class A_V4F extends MeshAttribute { 
+      public ArrayList<int> _0;
+    }
+    public class A_M22F extends MeshAttribute { 
+      public ArrayList<int> _0;
+    }
+    public class A_M33F extends MeshAttribute { 
+      public ArrayList<int> _0;
+    }
+    public class A_M44F extends MeshAttribute { 
+      public ArrayList<int> _0;
+    }
+    public class A_Int extends MeshAttribute { 
+      public ArrayList<Integer> _0;
+    }
+    public class A_Word extends MeshAttribute { 
+      public ArrayList<Integer> _0;
+    }
+  }
+
+  public class MeshPrimitive {
+    public enum Tag { 
+      P_Points,
+      P_TriangleStrip,
+      P_Triangles,
+      P_TriangleStripI,
+      P_TrianglesI
+    }
+    public Tag tag;
+
+    public class P_TriangleStripI extends MeshPrimitive { 
+      public ArrayList<Integer> _0;
+    }
+    public class P_TrianglesI extends MeshPrimitive { 
+      public ArrayList<Integer> _0;
+    }
+  }
+
+  public class Mesh {
+    public enum Tag { 
+      Mesh
+    }
+    public Tag tag;
+
+    public class Mesh extends Mesh { 
+      public HashMap<String, MeshAttribute> mAttributes;
+      public MeshPrimitive mPrimitive;
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/ddl/out/LambdaCube.Mesh.purs b/ddl/out/LambdaCube.Mesh.purs
index 22a8380..60a61e2 100644
--- a/ddl/out/LambdaCube.Mesh.purs
+++ b/ddl/out/LambdaCube.Mesh.purs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.781208000000Z
+=======
+-- 2016-03-20T21:42:12.936741000000Z
+>>>>>>> working c# backend
 
 module LambdaCube.Mesh where
 import Prelude
diff --git a/ddl/out/LambdaCube.Mesh.swift b/ddl/out/LambdaCube.Mesh.swift
index e300c0f..ff4ac52 100644
--- a/ddl/out/LambdaCube.Mesh.swift
+++ b/ddl/out/LambdaCube.Mesh.swift
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.781208000000Z
+=======
+// 2016-03-20T21:42:12.936741000000Z
+>>>>>>> working c# backend
 
 enum MeshAttribute {
   case A_Float(Array<Float>)
diff --git a/ddl/out/LambdaCube.Mesh2.hpp b/ddl/out/LambdaCube.Mesh2.hpp
index 56cf730..fc84a17 100644
--- a/ddl/out/LambdaCube.Mesh2.hpp
+++ b/ddl/out/LambdaCube.Mesh2.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.781208000000Z
+=======
+// 2016-03-20T21:42:12.936741000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.Mesh_H
 #define HEADER_LambdaCube.Mesh_H
diff --git a/ddl/out/LambdaCube.PipelineSchema.cpp b/ddl/out/LambdaCube.PipelineSchema.cpp
index 9e2604a..450bf72 100644
--- a/ddl/out/LambdaCube.PipelineSchema.cpp
+++ b/ddl/out/LambdaCube.PipelineSchema.cpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.761274000000Z
+=======
+// 2016-03-20T21:42:12.892571000000Z
+>>>>>>> working c# backend
 
 #include "LambdaCube.PipelineSchema.hpp"
 template<> json toJSON<std::shared_ptr<StreamType>>(std::shared_ptr<StreamType> &v) {
diff --git a/ddl/out/LambdaCube.PipelineSchema.cs b/ddl/out/LambdaCube.PipelineSchema.cs
new file mode 100644
index 0000000..945ae0c
--- /dev/null
+++ b/ddl/out/LambdaCube.PipelineSchema.cs
@@ -0,0 +1,339 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.343859000000Z
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+using LambdaCube.IR;
+
+namespace LambdaCube.PipelineSchema {
+  class StreamType {
+      public enum Tag { 
+        Attribute_Word,
+        Attribute_V2U,
+        Attribute_V3U,
+        Attribute_V4U,
+        Attribute_Int,
+        Attribute_V2I,
+        Attribute_V3I,
+        Attribute_V4I,
+        Attribute_Float,
+        Attribute_V2F,
+        Attribute_V3F,
+        Attribute_V4F,
+        Attribute_M22F,
+        Attribute_M23F,
+        Attribute_M24F,
+        Attribute_M32F,
+        Attribute_M33F,
+        Attribute_M34F,
+        Attribute_M42F,
+        Attribute_M43F,
+        Attribute_M44F
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+  }
+  class ObjectArraySchema {
+      public enum Tag { 
+        ObjectArraySchema
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class ObjectArraySchema : LambdaCube.PipelineSchema.ObjectArraySchema { 
+      public global::LambdaCube.PipelineSchema.FetchPrimitive primitive;
+      public Dictionary<string, global::LambdaCube.PipelineSchema.StreamType> attributes;
+      public ObjectArraySchema() { tag = LambdaCube.PipelineSchema.ObjectArraySchema.Tag.ObjectArraySchema; }
+    };
+  }
+  class PipelineSchema {
+      public enum Tag { 
+        PipelineSchema
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class PipelineSchema : LambdaCube.PipelineSchema.PipelineSchema { 
+      public Dictionary<string, global::LambdaCube.PipelineSchema.ObjectArraySchema> objectArrays;
+      public Dictionary<string, global::LambdaCube.PipelineSchema.InputType> uniforms;
+      public PipelineSchema() { tag = LambdaCube.PipelineSchema.PipelineSchema.Tag.PipelineSchema; }
+    };
+  }
+
+  // JSON deserializer
+  enum Type { 
+    String,
+    Map_String_InputType,
+    Map_String_ObjectArraySchema,
+    Map_String_StreamType,
+    FetchPrimitive,
+    InputType,
+    ObjectArraySchema,
+    PipelineSchema,
+    StreamType
+  }
+
+  class Loader {
+    public static object fromJSON(Type type, JToken obj) {
+      switch (type) {
+        case Type.String: return (string)obj;
+        case Type.Map_String_InputType: {
+          var map = new Dictionary<string, global::LambdaCube.PipelineSchema.InputType> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.PipelineSchema.InputType)fromJSON(Type.InputType,i.Value));
+          }
+          return map;
+        }
+        case Type.Map_String_ObjectArraySchema: {
+          var map = new Dictionary<string, global::LambdaCube.PipelineSchema.ObjectArraySchema> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.PipelineSchema.ObjectArraySchema)fromJSON(Type.ObjectArraySchema,i.Value));
+          }
+          return map;
+        }
+        case Type.Map_String_StreamType: {
+          var map = new Dictionary<string, global::LambdaCube.PipelineSchema.StreamType> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::LambdaCube.PipelineSchema.StreamType)fromJSON(Type.StreamType,i.Value));
+          }
+          return map;
+        }
+
+        case Type.StreamType: {
+          string tag = (string)obj["tag"];
+          StreamType.Tag tagType;
+          if (tag == "Attribute_Word") {
+            tagType = StreamType.Tag.Attribute_Word;
+          }
+          else if (tag == "Attribute_V2U") {
+            tagType = StreamType.Tag.Attribute_V2U;
+          }
+          else if (tag == "Attribute_V3U") {
+            tagType = StreamType.Tag.Attribute_V3U;
+          }
+          else if (tag == "Attribute_V4U") {
+            tagType = StreamType.Tag.Attribute_V4U;
+          }
+          else if (tag == "Attribute_Int") {
+            tagType = StreamType.Tag.Attribute_Int;
+          }
+          else if (tag == "Attribute_V2I") {
+            tagType = StreamType.Tag.Attribute_V2I;
+          }
+          else if (tag == "Attribute_V3I") {
+            tagType = StreamType.Tag.Attribute_V3I;
+          }
+          else if (tag == "Attribute_V4I") {
+            tagType = StreamType.Tag.Attribute_V4I;
+          }
+          else if (tag == "Attribute_Float") {
+            tagType = StreamType.Tag.Attribute_Float;
+          }
+          else if (tag == "Attribute_V2F") {
+            tagType = StreamType.Tag.Attribute_V2F;
+          }
+          else if (tag == "Attribute_V3F") {
+            tagType = StreamType.Tag.Attribute_V3F;
+          }
+          else if (tag == "Attribute_V4F") {
+            tagType = StreamType.Tag.Attribute_V4F;
+          }
+          else if (tag == "Attribute_M22F") {
+            tagType = StreamType.Tag.Attribute_M22F;
+          }
+          else if (tag == "Attribute_M23F") {
+            tagType = StreamType.Tag.Attribute_M23F;
+          }
+          else if (tag == "Attribute_M24F") {
+            tagType = StreamType.Tag.Attribute_M24F;
+          }
+          else if (tag == "Attribute_M32F") {
+            tagType = StreamType.Tag.Attribute_M32F;
+          }
+          else if (tag == "Attribute_M33F") {
+            tagType = StreamType.Tag.Attribute_M33F;
+          }
+          else if (tag == "Attribute_M34F") {
+            tagType = StreamType.Tag.Attribute_M34F;
+          }
+          else if (tag == "Attribute_M42F") {
+            tagType = StreamType.Tag.Attribute_M42F;
+          }
+          else if (tag == "Attribute_M43F") {
+            tagType = StreamType.Tag.Attribute_M43F;
+          }
+          else if (tag == "Attribute_M44F") {
+            tagType = StreamType.Tag.Attribute_M44F;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          StreamType o = new StreamType();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.ObjectArraySchema: {
+          string tag = (string)obj["tag"];
+          ObjectArraySchema.Tag tagType;
+          if (tag == "ObjectArraySchema") {
+            tagType = ObjectArraySchema.Tag.ObjectArraySchema;
+            data.ObjectArraySchema tv = new data.ObjectArraySchema();
+            tv.primitive = (global::LambdaCube.PipelineSchema.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["primitive"]);
+            tv.attributes = (Dictionary<string, global::LambdaCube.PipelineSchema.StreamType>)fromJSON(Type.Map_String_StreamType,obj["attributes"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ObjectArraySchema o = new ObjectArraySchema();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.PipelineSchema: {
+          string tag = (string)obj["tag"];
+          PipelineSchema.Tag tagType;
+          if (tag == "PipelineSchema") {
+            tagType = PipelineSchema.Tag.PipelineSchema;
+            data.PipelineSchema tv = new data.PipelineSchema();
+            tv.objectArrays = (Dictionary<string, global::LambdaCube.PipelineSchema.ObjectArraySchema>)fromJSON(Type.Map_String_ObjectArraySchema,obj["objectArrays"]);
+            tv.uniforms = (Dictionary<string, global::LambdaCube.PipelineSchema.InputType>)fromJSON(Type.Map_String_InputType,obj["uniforms"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          PipelineSchema o = new PipelineSchema();
+          o.tag = tagType;
+          return o;
+        }
+      }
+      throw new Exception("unknown type");
+      return null;
+    }
+
+    JToken toJSON(StreamType v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case StreamType.Tag.Attribute_Word:
+          obj["tag"] = "Attribute_Word";
+          break;
+        case StreamType.Tag.Attribute_V2U:
+          obj["tag"] = "Attribute_V2U";
+          break;
+        case StreamType.Tag.Attribute_V3U:
+          obj["tag"] = "Attribute_V3U";
+          break;
+        case StreamType.Tag.Attribute_V4U:
+          obj["tag"] = "Attribute_V4U";
+          break;
+        case StreamType.Tag.Attribute_Int:
+          obj["tag"] = "Attribute_Int";
+          break;
+        case StreamType.Tag.Attribute_V2I:
+          obj["tag"] = "Attribute_V2I";
+          break;
+        case StreamType.Tag.Attribute_V3I:
+          obj["tag"] = "Attribute_V3I";
+          break;
+        case StreamType.Tag.Attribute_V4I:
+          obj["tag"] = "Attribute_V4I";
+          break;
+        case StreamType.Tag.Attribute_Float:
+          obj["tag"] = "Attribute_Float";
+          break;
+        case StreamType.Tag.Attribute_V2F:
+          obj["tag"] = "Attribute_V2F";
+          break;
+        case StreamType.Tag.Attribute_V3F:
+          obj["tag"] = "Attribute_V3F";
+          break;
+        case StreamType.Tag.Attribute_V4F:
+          obj["tag"] = "Attribute_V4F";
+          break;
+        case StreamType.Tag.Attribute_M22F:
+          obj["tag"] = "Attribute_M22F";
+          break;
+        case StreamType.Tag.Attribute_M23F:
+          obj["tag"] = "Attribute_M23F";
+          break;
+        case StreamType.Tag.Attribute_M24F:
+          obj["tag"] = "Attribute_M24F";
+          break;
+        case StreamType.Tag.Attribute_M32F:
+          obj["tag"] = "Attribute_M32F";
+          break;
+        case StreamType.Tag.Attribute_M33F:
+          obj["tag"] = "Attribute_M33F";
+          break;
+        case StreamType.Tag.Attribute_M34F:
+          obj["tag"] = "Attribute_M34F";
+          break;
+        case StreamType.Tag.Attribute_M42F:
+          obj["tag"] = "Attribute_M42F";
+          break;
+        case StreamType.Tag.Attribute_M43F:
+          obj["tag"] = "Attribute_M43F";
+          break;
+        case StreamType.Tag.Attribute_M44F:
+          obj["tag"] = "Attribute_M44F";
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(ObjectArraySchema v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ObjectArraySchema.Tag.ObjectArraySchema:
+          obj["tag"] = "ObjectArraySchema";
+          {
+            var tv = (data.ObjectArraySchema)v;
+            obj["primitive"] = toJSON(tv.primitive);
+            obj["attributes"] = toJSON(tv.attributes);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(PipelineSchema v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case PipelineSchema.Tag.PipelineSchema:
+          obj["tag"] = "PipelineSchema";
+          {
+            var tv = (data.PipelineSchema)v;
+            obj["objectArrays"] = toJSON(tv.objectArrays);
+            obj["uniforms"] = toJSON(tv.uniforms);
+          }
+          break;
+      }
+      return obj;
+    }
+
+    JToken toJSON(string v) { return new JValue(v); }
+    JToken toJSON(Dictionary<string, global::LambdaCube.PipelineSchema.InputType> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, global::LambdaCube.PipelineSchema.ObjectArraySchema> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, global::LambdaCube.PipelineSchema.StreamType> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+  }
+}
diff --git a/ddl/out/LambdaCube.PipelineSchema.hpp b/ddl/out/LambdaCube.PipelineSchema.hpp
index 82e9853..afddf06 100644
--- a/ddl/out/LambdaCube.PipelineSchema.hpp
+++ b/ddl/out/LambdaCube.PipelineSchema.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.761274000000Z
+=======
+// 2016-03-20T21:42:12.892571000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.PipelineSchema_H
 #define HEADER_LambdaCube.PipelineSchema_H
diff --git a/ddl/out/LambdaCube.PipelineSchema.hs b/ddl/out/LambdaCube.PipelineSchema.hs
index ba83200..90ad67a 100644
--- a/ddl/out/LambdaCube.PipelineSchema.hs
+++ b/ddl/out/LambdaCube.PipelineSchema.hs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.761274000000Z
+=======
+-- 2016-03-20T21:42:12.892571000000Z
+>>>>>>> working c# backend
 
 {-# LANGUAGE OverloadedStrings, RecordWildCards #-}
 module LambdaCube.PipelineSchema where
diff --git a/ddl/out/LambdaCube.PipelineSchema.java b/ddl/out/LambdaCube.PipelineSchema.java
new file mode 100644
index 0000000..c71e7c0
--- /dev/null
+++ b/ddl/out/LambdaCube.PipelineSchema.java
@@ -0,0 +1,59 @@
+// generated file, do not modify!
+// 2016-03-14T10:58:29.954220000000Z
+
+import LambdaCube.IR;
+
+public class LambdaCube.PipelineSchema {
+  public class StreamType {
+    public enum Tag { 
+      Attribute_Word,
+      Attribute_V2U,
+      Attribute_V3U,
+      Attribute_V4U,
+      Attribute_Int,
+      Attribute_V2I,
+      Attribute_V3I,
+      Attribute_V4I,
+      Attribute_Float,
+      Attribute_V2F,
+      Attribute_V3F,
+      Attribute_V4F,
+      Attribute_M22F,
+      Attribute_M23F,
+      Attribute_M24F,
+      Attribute_M32F,
+      Attribute_M33F,
+      Attribute_M34F,
+      Attribute_M42F,
+      Attribute_M43F,
+      Attribute_M44F
+    }
+    public Tag tag;
+
+  }
+
+  public class ObjectArraySchema {
+    public enum Tag { 
+      ObjectArraySchema
+    }
+    public Tag tag;
+
+    public class ObjectArraySchema extends ObjectArraySchema { 
+      public FetchPrimitive primitive;
+      public HashMap<String, StreamType> attributes;
+    }
+  }
+
+  public class PipelineSchema {
+    public enum Tag { 
+      PipelineSchema
+    }
+    public Tag tag;
+
+    public class PipelineSchema extends PipelineSchema { 
+      public HashMap<String, ObjectArraySchema> objectArrays;
+      public HashMap<String, InputType> uniforms;
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/ddl/out/LambdaCube.PipelineSchema.purs b/ddl/out/LambdaCube.PipelineSchema.purs
index 1f741cb..a1919a1 100644
--- a/ddl/out/LambdaCube.PipelineSchema.purs
+++ b/ddl/out/LambdaCube.PipelineSchema.purs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.761274000000Z
+=======
+-- 2016-03-20T21:42:12.892571000000Z
+>>>>>>> working c# backend
 
 module LambdaCube.PipelineSchema where
 import Prelude
diff --git a/ddl/out/LambdaCube.PipelineSchema.swift b/ddl/out/LambdaCube.PipelineSchema.swift
index 0c48df8..418ed7b 100644
--- a/ddl/out/LambdaCube.PipelineSchema.swift
+++ b/ddl/out/LambdaCube.PipelineSchema.swift
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.761274000000Z
+=======
+// 2016-03-20T21:42:12.892571000000Z
+>>>>>>> working c# backend
 
 enum StreamType {
   case Attribute_Word
diff --git a/ddl/out/LambdaCube.PipelineSchema2.hpp b/ddl/out/LambdaCube.PipelineSchema2.hpp
index 691aa9b..9d5acfe 100644
--- a/ddl/out/LambdaCube.PipelineSchema2.hpp
+++ b/ddl/out/LambdaCube.PipelineSchema2.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.761274000000Z
+=======
+// 2016-03-20T21:42:12.892571000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.PipelineSchema_H
 #define HEADER_LambdaCube.PipelineSchema_H
diff --git a/ddl/out/LambdaCube.TypeInfo.cpp b/ddl/out/LambdaCube.TypeInfo.cpp
index bf793c3..a32436c 100644
--- a/ddl/out/LambdaCube.TypeInfo.cpp
+++ b/ddl/out/LambdaCube.TypeInfo.cpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.810157000000Z
+=======
+// 2016-03-20T21:42:12.996366000000Z
+>>>>>>> working c# backend
 
 #include "LambdaCube.TypeInfo.hpp"
 template<> json toJSON<std::shared_ptr<Range>>(std::shared_ptr<Range> &v) {
diff --git a/ddl/out/LambdaCube.TypeInfo.cs b/ddl/out/LambdaCube.TypeInfo.cs
new file mode 100644
index 0000000..967aa01
--- /dev/null
+++ b/ddl/out/LambdaCube.TypeInfo.cs
@@ -0,0 +1,218 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.460562000000Z
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+using LambdaCube.IR;
+
+namespace LambdaCube.TypeInfo {
+  class Range {
+      public enum Tag { 
+        Range
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Range : LambdaCube.TypeInfo.Range { 
+      public int startLine;
+      public int startColumn;
+      public int endLine;
+      public int endColumn;
+      public Range() { tag = LambdaCube.TypeInfo.Range.Tag.Range; }
+    };
+  }
+  class TypeInfo {
+      public enum Tag { 
+        TypeInfo
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class TypeInfo : LambdaCube.TypeInfo.TypeInfo { 
+      public global::LambdaCube.TypeInfo.Range range;
+      public string text;
+      public TypeInfo() { tag = LambdaCube.TypeInfo.TypeInfo.Tag.TypeInfo; }
+    };
+  }
+  class CompileResult {
+      public enum Tag { 
+        CompileError,
+        Compiled
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class CompileError : LambdaCube.TypeInfo.CompileResult { 
+      public List<global::LambdaCube.TypeInfo.Range> _0;
+      public string _1;
+      public List<global::LambdaCube.TypeInfo.TypeInfo> _2;
+      public CompileError() { tag = LambdaCube.TypeInfo.CompileResult.Tag.CompileError; }
+    };
+    class Compiled : LambdaCube.TypeInfo.CompileResult { 
+      public string _0;
+      public global::LambdaCube.TypeInfo.Pipeline _1;
+      public List<global::LambdaCube.TypeInfo.TypeInfo> _2;
+      public Compiled() { tag = LambdaCube.TypeInfo.CompileResult.Tag.Compiled; }
+    };
+  }
+
+  // JSON deserializer
+  enum Type { 
+    Int,
+    String,
+    Array_Range,
+    Array_TypeInfo,
+    CompileResult,
+    Pipeline,
+    Range,
+    TypeInfo
+  }
+
+  class Loader {
+    public static object fromJSON(Type type, JToken obj) {
+      switch (type) {
+        case Type.Int: return (int)obj;
+        case Type.String: return (string)obj;
+        case Type.Array_Range: return ((JArray)obj).Select(x => fromJSON (Type.Range, x)).ToList();
+        case Type.Array_TypeInfo: return ((JArray)obj).Select(x => fromJSON (Type.TypeInfo, x)).ToList();
+
+        case Type.Range: {
+          string tag = (string)obj["tag"];
+          Range.Tag tagType;
+          if (tag == "Range") {
+            tagType = Range.Tag.Range;
+            data.Range tv = new data.Range();
+            tv.startLine = (int)fromJSON(Type.Int,obj["startLine"]);
+            tv.startColumn = (int)fromJSON(Type.Int,obj["startColumn"]);
+            tv.endLine = (int)fromJSON(Type.Int,obj["endLine"]);
+            tv.endColumn = (int)fromJSON(Type.Int,obj["endColumn"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Range o = new Range();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.TypeInfo: {
+          string tag = (string)obj["tag"];
+          TypeInfo.Tag tagType;
+          if (tag == "TypeInfo") {
+            tagType = TypeInfo.Tag.TypeInfo;
+            data.TypeInfo tv = new data.TypeInfo();
+            tv.range = (global::LambdaCube.TypeInfo.Range)fromJSON(Type.Range,obj["range"]);
+            tv.text = (string)fromJSON(Type.String,obj["text"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          TypeInfo o = new TypeInfo();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.CompileResult: {
+          string tag = (string)obj["tag"];
+          CompileResult.Tag tagType;
+          if (tag == "CompileError") {
+            tagType = CompileResult.Tag.CompileError;
+            data.CompileError tv = new data.CompileError();
+            tv._0 = (List<global::LambdaCube.TypeInfo.Range>)fromJSON(Type.Array_Range,obj["arg0"]);
+            tv._1 = (string)fromJSON(Type.String,obj["arg1"]);
+            tv._2 = (List<global::LambdaCube.TypeInfo.TypeInfo>)fromJSON(Type.Array_TypeInfo,obj["arg2"]);
+            return tv;
+          }
+          else if (tag == "Compiled") {
+            tagType = CompileResult.Tag.Compiled;
+            data.Compiled tv = new data.Compiled();
+            tv._0 = (string)fromJSON(Type.String,obj["arg0"]);
+            tv._1 = (global::LambdaCube.TypeInfo.Pipeline)fromJSON(Type.Pipeline,obj["arg1"]);
+            tv._2 = (List<global::LambdaCube.TypeInfo.TypeInfo>)fromJSON(Type.Array_TypeInfo,obj["arg2"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          CompileResult o = new CompileResult();
+          o.tag = tagType;
+          return o;
+        }
+      }
+      throw new Exception("unknown type");
+      return null;
+    }
+
+    JToken toJSON(Range v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Range.Tag.Range:
+          obj["tag"] = "Range";
+          {
+            var tv = (data.Range)v;
+            obj["startLine"] = toJSON(tv.startLine);
+            obj["startColumn"] = toJSON(tv.startColumn);
+            obj["endLine"] = toJSON(tv.endLine);
+            obj["endColumn"] = toJSON(tv.endColumn);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(TypeInfo v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case TypeInfo.Tag.TypeInfo:
+          obj["tag"] = "TypeInfo";
+          {
+            var tv = (data.TypeInfo)v;
+            obj["range"] = toJSON(tv.range);
+            obj["text"] = toJSON(tv.text);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(CompileResult v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case CompileResult.Tag.CompileError:
+          obj["tag"] = "CompileError";
+          {
+            var tv = (data.CompileError)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+          }
+          break;
+        case CompileResult.Tag.Compiled:
+          obj["tag"] = "Compiled";
+          {
+            var tv = (data.Compiled)v;
+            obj["arg0"] = toJSON(tv._0);
+            obj["arg1"] = toJSON(tv._1);
+            obj["arg2"] = toJSON(tv._2);
+          }
+          break;
+      }
+      return obj;
+    }
+
+    JToken toJSON(int v) { return new JValue(v); }
+    JToken toJSON(string v) { return new JValue(v); }
+    JToken toJSON(List<global::LambdaCube.TypeInfo.Range> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::LambdaCube.TypeInfo.TypeInfo> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+  }
+}
diff --git a/ddl/out/LambdaCube.TypeInfo.hpp b/ddl/out/LambdaCube.TypeInfo.hpp
index 66a4eba..05fbd45 100644
--- a/ddl/out/LambdaCube.TypeInfo.hpp
+++ b/ddl/out/LambdaCube.TypeInfo.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.810157000000Z
+=======
+// 2016-03-20T21:42:12.996366000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.TypeInfo_H
 #define HEADER_LambdaCube.TypeInfo_H
diff --git a/ddl/out/LambdaCube.TypeInfo.hs b/ddl/out/LambdaCube.TypeInfo.hs
index 77ccbfd..fa8ddc6 100644
--- a/ddl/out/LambdaCube.TypeInfo.hs
+++ b/ddl/out/LambdaCube.TypeInfo.hs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.810157000000Z
+=======
+-- 2016-03-20T21:42:12.996366000000Z
+>>>>>>> working c# backend
 
 {-# LANGUAGE OverloadedStrings, RecordWildCards #-}
 module LambdaCube.TypeInfo where
diff --git a/ddl/out/LambdaCube.TypeInfo.java b/ddl/out/LambdaCube.TypeInfo.java
new file mode 100644
index 0000000..59c2a26
--- /dev/null
+++ b/ddl/out/LambdaCube.TypeInfo.java
@@ -0,0 +1,52 @@
+// generated file, do not modify!
+// 2016-03-14T10:58:30.014693000000Z
+
+import LambdaCube.IR;
+
+public class LambdaCube.TypeInfo {
+  public class Range {
+    public enum Tag { 
+      Range
+    }
+    public Tag tag;
+
+    public class Range extends Range { 
+      public Integer startLine;
+      public Integer startColumn;
+      public Integer endLine;
+      public Integer endColumn;
+    }
+  }
+
+  public class TypeInfo {
+    public enum Tag { 
+      TypeInfo
+    }
+    public Tag tag;
+
+    public class TypeInfo extends TypeInfo { 
+      public Range range;
+      public String text;
+    }
+  }
+
+  public class CompileResult {
+    public enum Tag { 
+      CompileError,
+      Compiled
+    }
+    public Tag tag;
+
+    public class CompileError extends CompileResult { 
+      public ArrayList<Range> _0;
+      public String _1;
+      public ArrayList<TypeInfo> _2;
+    }
+    public class Compiled extends CompileResult { 
+      public String _0;
+      public Pipeline _1;
+      public ArrayList<TypeInfo> _2;
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/ddl/out/LambdaCube.TypeInfo.purs b/ddl/out/LambdaCube.TypeInfo.purs
index 1b7cef8..b33afda 100644
--- a/ddl/out/LambdaCube.TypeInfo.purs
+++ b/ddl/out/LambdaCube.TypeInfo.purs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.810157000000Z
+=======
+-- 2016-03-20T21:42:12.996366000000Z
+>>>>>>> working c# backend
 
 module LambdaCube.TypeInfo where
 import Prelude
diff --git a/ddl/out/LambdaCube.TypeInfo.swift b/ddl/out/LambdaCube.TypeInfo.swift
index 8bb041f..e4776e9 100644
--- a/ddl/out/LambdaCube.TypeInfo.swift
+++ b/ddl/out/LambdaCube.TypeInfo.swift
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.810157000000Z
+=======
+// 2016-03-20T21:42:12.996366000000Z
+>>>>>>> working c# backend
 
 enum Range {
   case Range(Range_Data)
diff --git a/ddl/out/LambdaCube.TypeInfo2.hpp b/ddl/out/LambdaCube.TypeInfo2.hpp
index f80978f..8a69dcf 100644
--- a/ddl/out/LambdaCube.TypeInfo2.hpp
+++ b/ddl/out/LambdaCube.TypeInfo2.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.810157000000Z
+=======
+// 2016-03-20T21:42:12.996366000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_LambdaCube.TypeInfo_H
 #define HEADER_LambdaCube.TypeInfo_H
diff --git a/ddl/out/TestData.cpp b/ddl/out/TestData.cpp
index 8b2cdf5..b7d4d31 100644
--- a/ddl/out/TestData.cpp
+++ b/ddl/out/TestData.cpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.829757000000Z
+=======
+// 2016-03-20T21:42:13.043021000000Z
+>>>>>>> working c# backend
 
 #include "TestData.hpp"
 template<> json toJSON<std::shared_ptr<ClientInfo>>(std::shared_ptr<ClientInfo> &v) {
diff --git a/ddl/out/TestData.cs b/ddl/out/TestData.cs
new file mode 100644
index 0000000..0ea14a3
--- /dev/null
+++ b/ddl/out/TestData.cs
@@ -0,0 +1,499 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+
+using LambdaCube.IR;
+using LambdaCube.Mesh;
+using LambdaCube.PipelineSchema;
+
+namespace TestData {
+  class ClientInfo {
+      public enum Tag { 
+        ClientInfo
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class ClientInfo : TestData.ClientInfo { 
+      public string clientName;
+      public global::TestData.Backend clientBackend;
+      public ClientInfo() { tag = TestData.ClientInfo.Tag.ClientInfo; }
+    };
+  }
+  class Frame {
+      public enum Tag { 
+        Frame
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Frame : TestData.Frame { 
+      public int renderCount;
+      public Dictionary<string, global::TestData.Value> frameUniforms;
+      public Dictionary<string, int> frameTextures;
+      public Frame() { tag = TestData.Frame.Tag.Frame; }
+    };
+  }
+  class Scene {
+      public enum Tag { 
+        Scene
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class Scene : TestData.Scene { 
+      public Dictionary<string, List<int>> objectArrays;
+      public int renderTargetWidth;
+      public int renderTargetHeight;
+      public List<global::TestData.Frame> frames;
+      public Scene() { tag = TestData.Scene.Tag.Scene; }
+    };
+  }
+  class PipelineInfo {
+      public enum Tag { 
+        PipelineInfo
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class PipelineInfo : TestData.PipelineInfo { 
+      public string pipelineName;
+      public global::TestData.Pipeline pipeline;
+      public PipelineInfo() { tag = TestData.PipelineInfo.Tag.PipelineInfo; }
+    };
+  }
+  class RenderJob {
+      public enum Tag { 
+        RenderJob
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class RenderJob : TestData.RenderJob { 
+      public List<global::TestData.Mesh> meshes;
+      public List<string> textures;
+      public global::TestData.PipelineSchema schema;
+      public List<global::TestData.Scene> scenes;
+      public List<global::TestData.PipelineInfo> pipelines;
+      public RenderJob() { tag = TestData.RenderJob.Tag.RenderJob; }
+    };
+  }
+  class FrameResult {
+      public enum Tag { 
+        FrameResult
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class FrameResult : TestData.FrameResult { 
+      public List<float> frRenderTimes;
+      public int frImageWidth;
+      public int frImageHeight;
+      public FrameResult() { tag = TestData.FrameResult.Tag.FrameResult; }
+    };
+  }
+  class RenderJobResult {
+      public enum Tag { 
+        RenderJobResult,
+        RenderJobError
+      };
+      public Tag tag;
+  };
+
+  namespace data { 
+    class RenderJobResult : TestData.RenderJobResult { 
+      public global::TestData.FrameResult _0;
+      public RenderJobResult() { tag = TestData.RenderJobResult.Tag.RenderJobResult; }
+    };
+    class RenderJobError : TestData.RenderJobResult { 
+      public string _0;
+      public RenderJobError() { tag = TestData.RenderJobResult.Tag.RenderJobError; }
+    };
+  }
+
+  // JSON deserializer
+  enum Type { 
+    Int,
+    Float,
+    String,
+    Array_Int,
+    Array_Float,
+    Array_String,
+    Array_Frame,
+    Array_Mesh,
+    Array_PipelineInfo,
+    Array_Scene,
+    Map_String_Int,
+    Map_String_Array_Int,
+    Map_String_Value,
+    Backend,
+    ClientInfo,
+    Frame,
+    FrameResult,
+    Mesh,
+    Pipeline,
+    PipelineInfo,
+    PipelineSchema,
+    RenderJob,
+    RenderJobResult,
+    Scene,
+    Value
+  }
+
+  class Loader {
+    public static object fromJSON(Type type, JToken obj) {
+      switch (type) {
+        case Type.Int: return (int)obj;
+        case Type.Float: return (float)obj;
+        case Type.String: return (string)obj;
+        case Type.Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList();
+        case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
+        case Type.Array_String: return ((JArray)obj).Select(x => fromJSON (Type.String, x)).ToList();
+        case Type.Array_Frame: return ((JArray)obj).Select(x => fromJSON (Type.Frame, x)).ToList();
+        case Type.Array_Mesh: return ((JArray)obj).Select(x => fromJSON (Type.Mesh, x)).ToList();
+        case Type.Array_PipelineInfo: return ((JArray)obj).Select(x => fromJSON (Type.PipelineInfo, x)).ToList();
+        case Type.Array_Scene: return ((JArray)obj).Select(x => fromJSON (Type.Scene, x)).ToList();
+        case Type.Map_String_Int: {
+          var map = new Dictionary<string, int> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (int)fromJSON(Type.Int,i.Value));
+          }
+          return map;
+        }
+        case Type.Map_String_Array_Int: {
+          var map = new Dictionary<string, List<int>> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (List<int>)fromJSON(Type.Array_Int,i.Value));
+          }
+          return map;
+        }
+        case Type.Map_String_Value: {
+          var map = new Dictionary<string, global::TestData.Value> ();
+          foreach(var i in (JObject)obj) {
+            map.Add( (string)fromJSON(Type.String,i.Key)
+                   , (global::TestData.Value)fromJSON(Type.Value,i.Value));
+          }
+          return map;
+        }
+
+        case Type.ClientInfo: {
+          string tag = (string)obj["tag"];
+          ClientInfo.Tag tagType;
+          if (tag == "ClientInfo") {
+            tagType = ClientInfo.Tag.ClientInfo;
+            data.ClientInfo tv = new data.ClientInfo();
+            tv.clientName = (string)fromJSON(Type.String,obj["clientName"]);
+            tv.clientBackend = (global::TestData.Backend)fromJSON(Type.Backend,obj["clientBackend"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          ClientInfo o = new ClientInfo();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Frame: {
+          string tag = (string)obj["tag"];
+          Frame.Tag tagType;
+          if (tag == "Frame") {
+            tagType = Frame.Tag.Frame;
+            data.Frame tv = new data.Frame();
+            tv.renderCount = (int)fromJSON(Type.Int,obj["renderCount"]);
+            tv.frameUniforms = (Dictionary<string, global::TestData.Value>)fromJSON(Type.Map_String_Value,obj["frameUniforms"]);
+            tv.frameTextures = (Dictionary<string, int>)fromJSON(Type.Map_String_Int,obj["frameTextures"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Frame o = new Frame();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.Scene: {
+          string tag = (string)obj["tag"];
+          Scene.Tag tagType;
+          if (tag == "Scene") {
+            tagType = Scene.Tag.Scene;
+            data.Scene tv = new data.Scene();
+            tv.objectArrays = (Dictionary<string, List<int>>)fromJSON(Type.Map_String_Array_Int,obj["objectArrays"]);
+            tv.renderTargetWidth = (int)fromJSON(Type.Int,obj["renderTargetWidth"]);
+            tv.renderTargetHeight = (int)fromJSON(Type.Int,obj["renderTargetHeight"]);
+            tv.frames = (List<global::TestData.Frame>)fromJSON(Type.Array_Frame,obj["frames"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          Scene o = new Scene();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.PipelineInfo: {
+          string tag = (string)obj["tag"];
+          PipelineInfo.Tag tagType;
+          if (tag == "PipelineInfo") {
+            tagType = PipelineInfo.Tag.PipelineInfo;
+            data.PipelineInfo tv = new data.PipelineInfo();
+            tv.pipelineName = (string)fromJSON(Type.String,obj["pipelineName"]);
+            tv.pipeline = (global::TestData.Pipeline)fromJSON(Type.Pipeline,obj["pipeline"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          PipelineInfo o = new PipelineInfo();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.RenderJob: {
+          string tag = (string)obj["tag"];
+          RenderJob.Tag tagType;
+          if (tag == "RenderJob") {
+            tagType = RenderJob.Tag.RenderJob;
+            data.RenderJob tv = new data.RenderJob();
+            tv.meshes = (List<global::TestData.Mesh>)fromJSON(Type.Array_Mesh,obj["meshes"]);
+            tv.textures = (List<string>)fromJSON(Type.Array_String,obj["textures"]);
+            tv.schema = (global::TestData.PipelineSchema)fromJSON(Type.PipelineSchema,obj["schema"]);
+            tv.scenes = (List<global::TestData.Scene>)fromJSON(Type.Array_Scene,obj["scenes"]);
+            tv.pipelines = (List<global::TestData.PipelineInfo>)fromJSON(Type.Array_PipelineInfo,obj["pipelines"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          RenderJob o = new RenderJob();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.FrameResult: {
+          string tag = (string)obj["tag"];
+          FrameResult.Tag tagType;
+          if (tag == "FrameResult") {
+            tagType = FrameResult.Tag.FrameResult;
+            data.FrameResult tv = new data.FrameResult();
+            tv.frRenderTimes = (List<float>)fromJSON(Type.Array_Float,obj["frRenderTimes"]);
+            tv.frImageWidth = (int)fromJSON(Type.Int,obj["frImageWidth"]);
+            tv.frImageHeight = (int)fromJSON(Type.Int,obj["frImageHeight"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          FrameResult o = new FrameResult();
+          o.tag = tagType;
+          return o;
+        }
+        case Type.RenderJobResult: {
+          string tag = (string)obj["tag"];
+          RenderJobResult.Tag tagType;
+          if (tag == "RenderJobResult") {
+            tagType = RenderJobResult.Tag.RenderJobResult;
+            data.RenderJobResult tv = new data.RenderJobResult();
+            tv._0 = (global::TestData.FrameResult)fromJSON(Type.FrameResult,obj["arg0"]);
+            return tv;
+          }
+          else if (tag == "RenderJobError") {
+            tagType = RenderJobResult.Tag.RenderJobError;
+            data.RenderJobError tv = new data.RenderJobError();
+            tv._0 = (string)fromJSON(Type.String,obj["arg0"]);
+            return tv;
+          }
+          else throw new Exception("unknown constructor: " + tag);
+          RenderJobResult o = new RenderJobResult();
+          o.tag = tagType;
+          return o;
+        }
+      }
+      throw new Exception("unknown type");
+      return null;
+    }
+
+    JToken toJSON(ClientInfo v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case ClientInfo.Tag.ClientInfo:
+          obj["tag"] = "ClientInfo";
+          {
+            var tv = (data.ClientInfo)v;
+            obj["clientName"] = toJSON(tv.clientName);
+            obj["clientBackend"] = toJSON(tv.clientBackend);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Frame v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Frame.Tag.Frame:
+          obj["tag"] = "Frame";
+          {
+            var tv = (data.Frame)v;
+            obj["renderCount"] = toJSON(tv.renderCount);
+            obj["frameUniforms"] = toJSON(tv.frameUniforms);
+            obj["frameTextures"] = toJSON(tv.frameTextures);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(Scene v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case Scene.Tag.Scene:
+          obj["tag"] = "Scene";
+          {
+            var tv = (data.Scene)v;
+            obj["objectArrays"] = toJSON(tv.objectArrays);
+            obj["renderTargetWidth"] = toJSON(tv.renderTargetWidth);
+            obj["renderTargetHeight"] = toJSON(tv.renderTargetHeight);
+            obj["frames"] = toJSON(tv.frames);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(PipelineInfo v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case PipelineInfo.Tag.PipelineInfo:
+          obj["tag"] = "PipelineInfo";
+          {
+            var tv = (data.PipelineInfo)v;
+            obj["pipelineName"] = toJSON(tv.pipelineName);
+            obj["pipeline"] = toJSON(tv.pipeline);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(RenderJob v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case RenderJob.Tag.RenderJob:
+          obj["tag"] = "RenderJob";
+          {
+            var tv = (data.RenderJob)v;
+            obj["meshes"] = toJSON(tv.meshes);
+            obj["textures"] = toJSON(tv.textures);
+            obj["schema"] = toJSON(tv.schema);
+            obj["scenes"] = toJSON(tv.scenes);
+            obj["pipelines"] = toJSON(tv.pipelines);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(FrameResult v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case FrameResult.Tag.FrameResult:
+          obj["tag"] = "FrameResult";
+          {
+            var tv = (data.FrameResult)v;
+            obj["frRenderTimes"] = toJSON(tv.frRenderTimes);
+            obj["frImageWidth"] = toJSON(tv.frImageWidth);
+            obj["frImageHeight"] = toJSON(tv.frImageHeight);
+          }
+          break;
+      }
+      return obj;
+    }
+    JToken toJSON(RenderJobResult v) {
+      var obj = new JObject();
+      switch (v.tag) { 
+        case RenderJobResult.Tag.RenderJobResult:
+          obj["tag"] = "RenderJobResult";
+          {
+            var tv = (data.RenderJobResult)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+        case RenderJobResult.Tag.RenderJobError:
+          obj["tag"] = "RenderJobError";
+          {
+            var tv = (data.RenderJobError)v;
+            obj["arg0"] = toJSON(tv._0);
+          }
+          break;
+      }
+      return obj;
+    }
+
+    JToken toJSON(int v) { return new JValue(v); }
+    JToken toJSON(float v) { return new JValue(v); }
+    JToken toJSON(string v) { return new JValue(v); }
+    JToken toJSON(List<int> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<float> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<string> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::TestData.Frame> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::TestData.Mesh> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::TestData.PipelineInfo> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(List<global::TestData.Scene> v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, int> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, List<int>> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    JToken toJSON(Dictionary<string, global::TestData.Value> v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+  }
+}
diff --git a/ddl/out/TestData.hpp b/ddl/out/TestData.hpp
index bf90d88..00cdfda 100644
--- a/ddl/out/TestData.hpp
+++ b/ddl/out/TestData.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.829757000000Z
+=======
+// 2016-03-20T21:42:13.043021000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_TestData_H
 #define HEADER_TestData_H
diff --git a/ddl/out/TestData.hs b/ddl/out/TestData.hs
index 489e3c3..60f8ff9 100644
--- a/ddl/out/TestData.hs
+++ b/ddl/out/TestData.hs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.829757000000Z
+=======
+-- 2016-03-20T21:42:13.043021000000Z
+>>>>>>> working c# backend
 
 {-# LANGUAGE OverloadedStrings, RecordWildCards #-}
 module TestData where
diff --git a/ddl/out/TestData.java b/ddl/out/TestData.java
new file mode 100644
index 0000000..aa6b656
--- /dev/null
+++ b/ddl/out/TestData.java
@@ -0,0 +1,103 @@
+// generated file, do not modify!
+// 2016-03-14T10:58:30.042864000000Z
+
+import LambdaCube.IR;
+import LambdaCube.Mesh;
+import LambdaCube.PipelineSchema;
+
+public class TestData {
+  public class ClientInfo {
+    public enum Tag { 
+      ClientInfo
+    }
+    public Tag tag;
+
+    public class ClientInfo extends ClientInfo { 
+      public String clientName;
+      public Backend clientBackend;
+    }
+  }
+
+  public class Frame {
+    public enum Tag { 
+      Frame
+    }
+    public Tag tag;
+
+    public class Frame extends Frame { 
+      public Integer renderCount;
+      public HashMap<String, Value> frameUniforms;
+      public HashMap<String, Integer> frameTextures;
+    }
+  }
+
+  public class Scene {
+    public enum Tag { 
+      Scene
+    }
+    public Tag tag;
+
+    public class Scene extends Scene { 
+      public HashMap<String, ArrayList<Integer>> objectArrays;
+      public Integer renderTargetWidth;
+      public Integer renderTargetHeight;
+      public ArrayList<Frame> frames;
+    }
+  }
+
+  public class PipelineInfo {
+    public enum Tag { 
+      PipelineInfo
+    }
+    public Tag tag;
+
+    public class PipelineInfo extends PipelineInfo { 
+      public String pipelineName;
+      public Pipeline pipeline;
+    }
+  }
+
+  public class RenderJob {
+    public enum Tag { 
+      RenderJob
+    }
+    public Tag tag;
+
+    public class RenderJob extends RenderJob { 
+      public ArrayList<Mesh> meshes;
+      public ArrayList<String> textures;
+      public PipelineSchema schema;
+      public ArrayList<Scene> scenes;
+      public ArrayList<PipelineInfo> pipelines;
+    }
+  }
+
+  public class FrameResult {
+    public enum Tag { 
+      FrameResult
+    }
+    public Tag tag;
+
+    public class FrameResult extends FrameResult { 
+      public ArrayList<Float> frRenderTimes;
+      public Integer frImageWidth;
+      public Integer frImageHeight;
+    }
+  }
+
+  public class RenderJobResult {
+    public enum Tag { 
+      RenderJobResult,
+      RenderJobError
+    }
+    public Tag tag;
+
+    public class RenderJobResult extends RenderJobResult { 
+      public FrameResult _0;
+    }
+    public class RenderJobError extends RenderJobResult { 
+      public String _0;
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/ddl/out/TestData.purs b/ddl/out/TestData.purs
index e4da3b2..47f46ca 100644
--- a/ddl/out/TestData.purs
+++ b/ddl/out/TestData.purs
@@ -1,5 +1,9 @@
 -- generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 -- 2016-03-01T13:00:40.829757000000Z
+=======
+-- 2016-03-20T21:42:13.043021000000Z
+>>>>>>> working c# backend
 
 module TestData where
 import Prelude
diff --git a/ddl/out/TestData.swift b/ddl/out/TestData.swift
index adb9e25..6e31913 100644
--- a/ddl/out/TestData.swift
+++ b/ddl/out/TestData.swift
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.829757000000Z
+=======
+// 2016-03-20T21:42:13.043021000000Z
+>>>>>>> working c# backend
 
 enum ClientInfo {
   case ClientInfo(ClientInfo_Data)
diff --git a/ddl/out/TestData2.hpp b/ddl/out/TestData2.hpp
index 49ac46e..a88050a 100644
--- a/ddl/out/TestData2.hpp
+++ b/ddl/out/TestData2.hpp
@@ -1,5 +1,9 @@
 // generated file, do not modify!
+<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9
 // 2016-03-01T13:00:40.829757000000Z
+=======
+// 2016-03-20T21:42:13.043021000000Z
+>>>>>>> working c# backend
 
 #ifndef HEADER_TestData_H
 #define HEADER_TestData_H
diff --git a/ddl/out/java/LambdaCube/IR/AccumulationContext.java b/ddl/out/java/LambdaCube/IR/AccumulationContext.java
new file mode 100644
index 0000000..a190597
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/AccumulationContext.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class AccumulationContext {
+  public enum Tag { 
+    AccumulationContext
+  }
+  public Tag tag;
+
+  public class AccumulationContext_ extends AccumulationContext { 
+    public Maybe<String> accViewportName;
+    public ArrayList<FragmentOperation> accOperations;
+    public AccumulationContext_() { tag = AccumulationContext.Tag.AccumulationContext; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ArrayValue.java b/ddl/out/java/LambdaCube/IR/ArrayValue.java
new file mode 100644
index 0000000..b176300
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ArrayValue.java
@@ -0,0 +1,37 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ArrayValue {
+  public enum Tag { 
+    VBoolArray,
+    VIntArray,
+    VWordArray,
+    VFloatArray
+  }
+  public Tag tag;
+
+  public class VBoolArray_ extends ArrayValue { 
+    public ArrayList<Boolean> _0;
+    public VBoolArray_() { tag = ArrayValue.Tag.VBoolArray; }
+  }
+  public class VIntArray_ extends ArrayValue { 
+    public ArrayList<Integer> _0;
+    public VIntArray_() { tag = ArrayValue.Tag.VIntArray; }
+  }
+  public class VWordArray_ extends ArrayValue { 
+    public ArrayList<Integer> _0;
+    public VWordArray_() { tag = ArrayValue.Tag.VWordArray; }
+  }
+  public class VFloatArray_ extends ArrayValue { 
+    public ArrayList<Float> _0;
+    public VFloatArray_() { tag = ArrayValue.Tag.VFloatArray; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Backend.java b/ddl/out/java/LambdaCube/IR/Backend.java
new file mode 100644
index 0000000..bbe74b8
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Backend.java
@@ -0,0 +1,19 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Backend {
+  public enum Tag { 
+    WebGL1,
+    OpenGL33
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/BlendEquation.java b/ddl/out/java/LambdaCube/IR/BlendEquation.java
new file mode 100644
index 0000000..6dd1523
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/BlendEquation.java
@@ -0,0 +1,22 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class BlendEquation {
+  public enum Tag { 
+    FuncAdd,
+    FuncSubtract,
+    FuncReverseSubtract,
+    Min,
+    Max
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Blending.java b/ddl/out/java/LambdaCube/IR/Blending.java
new file mode 100644
index 0000000..331ae4e
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Blending.java
@@ -0,0 +1,34 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Blending {
+  public enum Tag { 
+    NoBlending,
+    BlendLogicOp,
+    Blend
+  }
+  public Tag tag;
+
+  public class BlendLogicOp_ extends Blending { 
+    public LogicOperation _0;
+    public BlendLogicOp_() { tag = Blending.Tag.BlendLogicOp; }
+  }
+  public class Blend_ extends Blending { 
+    public BlendEquation colorEqSrc;
+    public BlendEquation alphaEqSrc;
+    public BlendingFactor colorFSrc;
+    public BlendingFactor colorFDst;
+    public BlendingFactor alphaFSrc;
+    public BlendingFactor alphaFDst;
+    public V4<Float> color;
+    public Blend_() { tag = Blending.Tag.Blend; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/BlendingFactor.java b/ddl/out/java/LambdaCube/IR/BlendingFactor.java
new file mode 100644
index 0000000..fe73075
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/BlendingFactor.java
@@ -0,0 +1,32 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class BlendingFactor {
+  public enum Tag { 
+    Zero,
+    One,
+    SrcColor,
+    OneMinusSrcColor,
+    DstColor,
+    OneMinusDstColor,
+    SrcAlpha,
+    OneMinusSrcAlpha,
+    DstAlpha,
+    OneMinusDstAlpha,
+    ConstantColor,
+    OneMinusConstantColor,
+    ConstantAlpha,
+    OneMinusConstantAlpha,
+    SrcAlphaSaturate
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ClearImage.java b/ddl/out/java/LambdaCube/IR/ClearImage.java
new file mode 100644
index 0000000..64491e9
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ClearImage.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ClearImage {
+  public enum Tag { 
+    ClearImage
+  }
+  public Tag tag;
+
+  public class ClearImage_ extends ClearImage { 
+    public ImageSemantic imageSemantic;
+    public Value clearValue;
+    public ClearImage_() { tag = ClearImage.Tag.ClearImage; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ColorArity.java b/ddl/out/java/LambdaCube/IR/ColorArity.java
new file mode 100644
index 0000000..77ba1a0
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ColorArity.java
@@ -0,0 +1,21 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ColorArity {
+  public enum Tag { 
+    Red,
+    RG,
+    RGB,
+    RGBA
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Command.java b/ddl/out/java/LambdaCube/IR/Command.java
new file mode 100644
index 0000000..90ec2c5
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Command.java
@@ -0,0 +1,87 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Command {
+  public enum Tag { 
+    SetRasterContext,
+    SetAccumulationContext,
+    SetRenderTarget,
+    SetProgram,
+    SetSamplerUniform,
+    SetTexture,
+    SetSampler,
+    RenderSlot,
+    RenderStream,
+    ClearRenderTarget,
+    GenerateMipMap,
+    SaveImage,
+    LoadImage
+  }
+  public Tag tag;
+
+  public class SetRasterContext_ extends Command { 
+    public RasterContext _0;
+    public SetRasterContext_() { tag = Command.Tag.SetRasterContext; }
+  }
+  public class SetAccumulationContext_ extends Command { 
+    public AccumulationContext _0;
+    public SetAccumulationContext_() { tag = Command.Tag.SetAccumulationContext; }
+  }
+  public class SetRenderTarget_ extends Command { 
+    public Integer _0;
+    public SetRenderTarget_() { tag = Command.Tag.SetRenderTarget; }
+  }
+  public class SetProgram_ extends Command { 
+    public Integer _0;
+    public SetProgram_() { tag = Command.Tag.SetProgram; }
+  }
+  public class SetSamplerUniform_ extends Command { 
+    public String _0;
+    public Integer _1;
+    public SetSamplerUniform_() { tag = Command.Tag.SetSamplerUniform; }
+  }
+  public class SetTexture_ extends Command { 
+    public Integer _0;
+    public Integer _1;
+    public SetTexture_() { tag = Command.Tag.SetTexture; }
+  }
+  public class SetSampler_ extends Command { 
+    public Integer _0;
+    public Maybe<Integer> _1;
+    public SetSampler_() { tag = Command.Tag.SetSampler; }
+  }
+  public class RenderSlot_ extends Command { 
+    public Integer _0;
+    public RenderSlot_() { tag = Command.Tag.RenderSlot; }
+  }
+  public class RenderStream_ extends Command { 
+    public Integer _0;
+    public RenderStream_() { tag = Command.Tag.RenderStream; }
+  }
+  public class ClearRenderTarget_ extends Command { 
+    public ArrayList<ClearImage> _0;
+    public ClearRenderTarget_() { tag = Command.Tag.ClearRenderTarget; }
+  }
+  public class GenerateMipMap_ extends Command { 
+    public Integer _0;
+    public GenerateMipMap_() { tag = Command.Tag.GenerateMipMap; }
+  }
+  public class SaveImage_ extends Command { 
+    public Integer _0;
+    public ImageRef _1;
+    public SaveImage_() { tag = Command.Tag.SaveImage; }
+  }
+  public class LoadImage_ extends Command { 
+    public ImageRef _0;
+    public Integer _1;
+    public LoadImage_() { tag = Command.Tag.LoadImage; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ComparisonFunction.java b/ddl/out/java/LambdaCube/IR/ComparisonFunction.java
new file mode 100644
index 0000000..d3c5112
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ComparisonFunction.java
@@ -0,0 +1,25 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ComparisonFunction {
+  public enum Tag { 
+    Never,
+    Less,
+    Equal,
+    Lequal,
+    Greater,
+    Notequal,
+    Gequal,
+    Always
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/CullMode.java b/ddl/out/java/LambdaCube/IR/CullMode.java
new file mode 100644
index 0000000..f2ce3a8
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/CullMode.java
@@ -0,0 +1,28 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class CullMode {
+  public enum Tag { 
+    CullNone,
+    CullFront,
+    CullBack
+  }
+  public Tag tag;
+
+  public class CullFront_ extends CullMode { 
+    public FrontFace _0;
+    public CullFront_() { tag = CullMode.Tag.CullFront; }
+  }
+  public class CullBack_ extends CullMode { 
+    public FrontFace _0;
+    public CullBack_() { tag = CullMode.Tag.CullBack; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/EdgeMode.java b/ddl/out/java/LambdaCube/IR/EdgeMode.java
new file mode 100644
index 0000000..19a8eba
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/EdgeMode.java
@@ -0,0 +1,21 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class EdgeMode {
+  public enum Tag { 
+    Repeat,
+    MirroredRepeat,
+    ClampToEdge,
+    ClampToBorder
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/FetchPrimitive.java b/ddl/out/java/LambdaCube/IR/FetchPrimitive.java
new file mode 100644
index 0000000..16453bc
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/FetchPrimitive.java
@@ -0,0 +1,22 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class FetchPrimitive {
+  public enum Tag { 
+    Points,
+    Lines,
+    Triangles,
+    LinesAdjacency,
+    TrianglesAdjacency
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Filter.java b/ddl/out/java/LambdaCube/IR/Filter.java
new file mode 100644
index 0000000..4bd3b7c
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Filter.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Filter {
+  public enum Tag { 
+    Nearest,
+    Linear,
+    NearestMipmapNearest,
+    NearestMipmapLinear,
+    LinearMipmapNearest,
+    LinearMipmapLinear
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/FragmentOperation.java b/ddl/out/java/LambdaCube/IR/FragmentOperation.java
new file mode 100644
index 0000000..35aa5a9
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/FragmentOperation.java
@@ -0,0 +1,36 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class FragmentOperation {
+  public enum Tag { 
+    DepthOp,
+    StencilOp,
+    ColorOp
+  }
+  public Tag tag;
+
+  public class DepthOp_ extends FragmentOperation { 
+    public ComparisonFunction _0;
+    public Boolean _1;
+    public DepthOp_() { tag = FragmentOperation.Tag.DepthOp; }
+  }
+  public class StencilOp_ extends FragmentOperation { 
+    public StencilTests _0;
+    public StencilOps _1;
+    public StencilOps _2;
+    public StencilOp_() { tag = FragmentOperation.Tag.StencilOp; }
+  }
+  public class ColorOp_ extends FragmentOperation { 
+    public Blending _0;
+    public Value _1;
+    public ColorOp_() { tag = FragmentOperation.Tag.ColorOp; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/FrontFace.java b/ddl/out/java/LambdaCube/IR/FrontFace.java
new file mode 100644
index 0000000..dff345f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/FrontFace.java
@@ -0,0 +1,19 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class FrontFace {
+  public enum Tag { 
+    CCW,
+    CW
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ImageRef.java b/ddl/out/java/LambdaCube/IR/ImageRef.java
new file mode 100644
index 0000000..51385dc
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ImageRef.java
@@ -0,0 +1,29 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ImageRef {
+  public enum Tag { 
+    TextureImage,
+    Framebuffer
+  }
+  public Tag tag;
+
+  public class TextureImage_ extends ImageRef { 
+    public Integer _0;
+    public Integer _1;
+    public Maybe<Integer> _2;
+    public TextureImage_() { tag = ImageRef.Tag.TextureImage; }
+  }
+  public class Framebuffer_ extends ImageRef { 
+    public ImageSemantic _0;
+    public Framebuffer_() { tag = ImageRef.Tag.Framebuffer; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ImageSemantic.java b/ddl/out/java/LambdaCube/IR/ImageSemantic.java
new file mode 100644
index 0000000..22aea08
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ImageSemantic.java
@@ -0,0 +1,20 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ImageSemantic {
+  public enum Tag { 
+    Depth,
+    Stencil,
+    Color
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/InputType.java b/ddl/out/java/LambdaCube/IR/InputType.java
new file mode 100644
index 0000000..f8764d1
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/InputType.java
@@ -0,0 +1,78 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class InputType {
+  public enum Tag { 
+    Bool,
+    V2B,
+    V3B,
+    V4B,
+    Word,
+    V2U,
+    V3U,
+    V4U,
+    Int,
+    V2I,
+    V3I,
+    V4I,
+    Float,
+    V2F,
+    V3F,
+    V4F,
+    M22F,
+    M23F,
+    M24F,
+    M32F,
+    M33F,
+    M34F,
+    M42F,
+    M43F,
+    M44F,
+    STexture1D,
+    STexture2D,
+    STextureCube,
+    STexture1DArray,
+    STexture2DArray,
+    STexture2DRect,
+    FTexture1D,
+    FTexture2D,
+    FTexture3D,
+    FTextureCube,
+    FTexture1DArray,
+    FTexture2DArray,
+    FTexture2DMS,
+    FTexture2DMSArray,
+    FTextureBuffer,
+    FTexture2DRect,
+    ITexture1D,
+    ITexture2D,
+    ITexture3D,
+    ITextureCube,
+    ITexture1DArray,
+    ITexture2DArray,
+    ITexture2DMS,
+    ITexture2DMSArray,
+    ITextureBuffer,
+    ITexture2DRect,
+    UTexture1D,
+    UTexture2D,
+    UTexture3D,
+    UTextureCube,
+    UTexture1DArray,
+    UTexture2DArray,
+    UTexture2DMS,
+    UTexture2DMSArray,
+    UTextureBuffer,
+    UTexture2DRect
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/JSON.java b/ddl/out/java/LambdaCube/IR/JSON.java
new file mode 100644
index 0000000..3515e25
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/JSON.java
@@ -0,0 +1,1460 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import org.json.*;
+import RT.*;
+
+
+public class JSON {
+  // JSON deserializer
+  public enum Type { 
+    Int,
+    Int32,
+    Word,
+    Word32,
+    Float,
+    Bool,
+    String,
+    V2_Int,
+    V2_Word,
+    V2_Float,
+    V2_Bool,
+    V2_V2_Float,
+    V2_V3_Float,
+    V2_V4_Float,
+    V3_Int,
+    V3_Word,
+    V3_Float,
+    V3_Bool,
+    V3_V2_Float,
+    V3_V3_Float,
+    V3_V4_Float,
+    V4_Int,
+    V4_Word,
+    V4_Float,
+    V4_Bool,
+    V4_V2_Float,
+    V4_V3_Float,
+    V4_V4_Float,
+    Array_Int,
+    Array_Int32,
+    Array_Word32,
+    Array_Float,
+    Array_Bool,
+    Array_ClearImage,
+    Array_Command,
+    Array_Parameter,
+    Array_Program,
+    Array_RenderTarget,
+    Array_SamplerDescriptor,
+    Array_Slot,
+    Array_StreamData,
+    Array_TargetItem,
+    Array_TextureDescriptor,
+    List_FragmentOperation,
+    Maybe_Int,
+    Maybe_Float,
+    Maybe_String,
+    Maybe_ComparisonFunction,
+    Maybe_EdgeMode,
+    Maybe_ImageRef,
+    Map_String_ArrayValue,
+    Map_String_InputType,
+    Map_String_Parameter,
+    AccumulationContext,
+    ArrayValue,
+    Backend,
+    BlendEquation,
+    Blending,
+    BlendingFactor,
+    ClearImage,
+    ColorArity,
+    Command,
+    ComparisonFunction,
+    CullMode,
+    EdgeMode,
+    FetchPrimitive,
+    Filter,
+    FragmentOperation,
+    FrontFace,
+    ImageRef,
+    ImageSemantic,
+    InputType,
+    LogicOperation,
+    MipMap,
+    OutputPrimitive,
+    Parameter,
+    Pipeline,
+    PointSize,
+    PointSpriteCoordOrigin,
+    PolygonMode,
+    PolygonOffset,
+    Program,
+    ProvokingVertex,
+    RasterContext,
+    RenderTarget,
+    SamplerDescriptor,
+    Slot,
+    StencilOperation,
+    StencilOps,
+    StencilTest,
+    StencilTests,
+    StreamData,
+    TargetItem,
+    TextureDataType,
+    TextureDescriptor,
+    TextureType,
+    Value
+  }
+
+  public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception {
+    switch (type) {
+      case Int: return (Integer)rawObj;
+      case Int32: return (Integer)rawObj;
+      case Word: return (Integer)rawObj;
+      case Word32: return (Integer)rawObj;
+      case Float: return (Float)rawObj;
+      case Bool: return (Boolean)rawObj;
+      case String: return (String)rawObj;
+      case V2_Int: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<Integer>
+          ( (Integer)fromJSON(Type.Int,obj.get("x"))
+          , (Integer)fromJSON(Type.Int,obj.get("y"))
+          );
+      }
+      case V2_Word: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<Integer>
+          ( (Integer)fromJSON(Type.Word,obj.get("x"))
+          , (Integer)fromJSON(Type.Word,obj.get("y"))
+          );
+      }
+      case V2_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<Float>
+          ( (Float)fromJSON(Type.Float,obj.get("x"))
+          , (Float)fromJSON(Type.Float,obj.get("y"))
+          );
+      }
+      case V2_Bool: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<Boolean>
+          ( (Boolean)fromJSON(Type.Bool,obj.get("x"))
+          , (Boolean)fromJSON(Type.Bool,obj.get("y"))
+          );
+      }
+      case V2_V2_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<V2<Float>>
+          ( (V2<Float>)fromJSON(Type.V2_Float,obj.get("x"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("y"))
+          );
+      }
+      case V2_V3_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<V3<Float>>
+          ( (V3<Float>)fromJSON(Type.V3_Float,obj.get("x"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("y"))
+          );
+      }
+      case V2_V4_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<V4<Float>>
+          ( (V4<Float>)fromJSON(Type.V4_Float,obj.get("x"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("y"))
+          );
+      }
+      case V3_Int: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<Integer>
+          ( (Integer)fromJSON(Type.Int,obj.get("x"))
+          , (Integer)fromJSON(Type.Int,obj.get("y"))
+          , (Integer)fromJSON(Type.Int,obj.get("z"))
+          );
+      }
+      case V3_Word: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<Integer>
+          ( (Integer)fromJSON(Type.Word,obj.get("x"))
+          , (Integer)fromJSON(Type.Word,obj.get("y"))
+          , (Integer)fromJSON(Type.Word,obj.get("z"))
+          );
+      }
+      case V3_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<Float>
+          ( (Float)fromJSON(Type.Float,obj.get("x"))
+          , (Float)fromJSON(Type.Float,obj.get("y"))
+          , (Float)fromJSON(Type.Float,obj.get("z"))
+          );
+      }
+      case V3_Bool: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<Boolean>
+          ( (Boolean)fromJSON(Type.Bool,obj.get("x"))
+          , (Boolean)fromJSON(Type.Bool,obj.get("y"))
+          , (Boolean)fromJSON(Type.Bool,obj.get("z"))
+          );
+      }
+      case V3_V2_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<V2<Float>>
+          ( (V2<Float>)fromJSON(Type.V2_Float,obj.get("x"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("y"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("z"))
+          );
+      }
+      case V3_V3_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<V3<Float>>
+          ( (V3<Float>)fromJSON(Type.V3_Float,obj.get("x"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("y"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("z"))
+          );
+      }
+      case V3_V4_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<V4<Float>>
+          ( (V4<Float>)fromJSON(Type.V4_Float,obj.get("x"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("y"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("z"))
+          );
+      }
+      case V4_Int: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<Integer>
+          ( (Integer)fromJSON(Type.Int,obj.get("x"))
+          , (Integer)fromJSON(Type.Int,obj.get("y"))
+          , (Integer)fromJSON(Type.Int,obj.get("z"))
+          , (Integer)fromJSON(Type.Int,obj.get("w"))
+          );
+      }
+      case V4_Word: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<Integer>
+          ( (Integer)fromJSON(Type.Word,obj.get("x"))
+          , (Integer)fromJSON(Type.Word,obj.get("y"))
+          , (Integer)fromJSON(Type.Word,obj.get("z"))
+          , (Integer)fromJSON(Type.Word,obj.get("w"))
+          );
+      }
+      case V4_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<Float>
+          ( (Float)fromJSON(Type.Float,obj.get("x"))
+          , (Float)fromJSON(Type.Float,obj.get("y"))
+          , (Float)fromJSON(Type.Float,obj.get("z"))
+          , (Float)fromJSON(Type.Float,obj.get("w"))
+          );
+      }
+      case V4_Bool: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<Boolean>
+          ( (Boolean)fromJSON(Type.Bool,obj.get("x"))
+          , (Boolean)fromJSON(Type.Bool,obj.get("y"))
+          , (Boolean)fromJSON(Type.Bool,obj.get("z"))
+          , (Boolean)fromJSON(Type.Bool,obj.get("w"))
+          );
+      }
+      case V4_V2_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<V2<Float>>
+          ( (V2<Float>)fromJSON(Type.V2_Float,obj.get("x"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("y"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("z"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("w"))
+          );
+      }
+      case V4_V3_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<V3<Float>>
+          ( (V3<Float>)fromJSON(Type.V3_Float,obj.get("x"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("y"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("z"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("w"))
+          );
+      }
+      case V4_V4_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<V4<Float>>
+          ( (V4<Float>)fromJSON(Type.V4_Float,obj.get("x"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("y"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("z"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("w"))
+          );
+      }
+//      case Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList();
+//      case Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList();
+//      case Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList();
+//      case Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
+//      case Array_Bool: return ((JArray)obj).Select(x => fromJSON (Type.Bool, x)).ToList();
+//      case Array_ClearImage: return ((JArray)obj).Select(x => fromJSON (Type.ClearImage, x)).ToList();
+//      case Array_Command: return ((JArray)obj).Select(x => fromJSON (Type.Command, x)).ToList();
+//      case Array_Parameter: return ((JArray)obj).Select(x => fromJSON (Type.Parameter, x)).ToList();
+//      case Array_Program: return ((JArray)obj).Select(x => fromJSON (Type.Program, x)).ToList();
+//      case Array_RenderTarget: return ((JArray)obj).Select(x => fromJSON (Type.RenderTarget, x)).ToList();
+//      case Array_SamplerDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.SamplerDescriptor, x)).ToList();
+//      case Array_Slot: return ((JArray)obj).Select(x => fromJSON (Type.Slot, x)).ToList();
+//      case Array_StreamData: return ((JArray)obj).Select(x => fromJSON (Type.StreamData, x)).ToList();
+//      case Array_TargetItem: return ((JArray)obj).Select(x => fromJSON (Type.TargetItem, x)).ToList();
+//      case Array_TextureDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.TextureDescriptor, x)).ToList();
+//      case List_FragmentOperation: return ((JArray)obj).Select(x => fromJSON (Type.FragmentOperation, x)).ToList();
+/*
+      case Maybe_Int: {
+        var m = new Maybe<Integer> ();
+        if (obj == null || obj.Type == JTokenType.Null) {
+          m.valid = false;
+        } else {
+          m.valid = true;
+          m.data = (Integer)fromJSON (Type.Int,obj);
+        }
+        return m;
+      }
+*/
+/*
+      case Maybe_Float: {
+        var m = new Maybe<Float> ();
+        if (obj == null || obj.Type == JTokenType.Null) {
+          m.valid = false;
+        } else {
+          m.valid = true;
+          m.data = (Float)fromJSON (Type.Float,obj);
+        }
+        return m;
+      }
+*/
+/*
+      case Maybe_String: {
+        var m = new Maybe<String> ();
+        if (obj == null || obj.Type == JTokenType.Null) {
+          m.valid = false;
+        } else {
+          m.valid = true;
+          m.data = (String)fromJSON (Type.String,obj);
+        }
+        return m;
+      }
+*/
+/*
+      case Maybe_ComparisonFunction: {
+        var m = new Maybe<ComparisonFunction> ();
+        if (obj == null || obj.Type == JTokenType.Null) {
+          m.valid = false;
+        } else {
+          m.valid = true;
+          m.data = (ComparisonFunction)fromJSON (Type.ComparisonFunction,obj);
+        }
+        return m;
+      }
+*/
+/*
+      case Maybe_EdgeMode: {
+        var m = new Maybe<EdgeMode> ();
+        if (obj == null || obj.Type == JTokenType.Null) {
+          m.valid = false;
+        } else {
+          m.valid = true;
+          m.data = (EdgeMode)fromJSON (Type.EdgeMode,obj);
+        }
+        return m;
+      }
+*/
+/*
+      case Maybe_ImageRef: {
+        var m = new Maybe<ImageRef> ();
+        if (obj == null || obj.Type == JTokenType.Null) {
+          m.valid = false;
+        } else {
+          m.valid = true;
+          m.data = (ImageRef)fromJSON (Type.ImageRef,obj);
+        }
+        return m;
+      }
+*/
+/*
+      case Map_String_ArrayValue: {
+        var map = new HashMap<String, ArrayValue> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (ArrayValue)fromJSON(Type.ArrayValue,i.Value));
+        }
+        return map;
+      }
+*/
+/*
+      case Map_String_InputType: {
+        var map = new HashMap<String, InputType> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (InputType)fromJSON(Type.InputType,i.Value));
+        }
+        return map;
+      }
+*/
+/*
+      case Map_String_Parameter: {
+        var map = new HashMap<String, Parameter> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (Parameter)fromJSON(Type.Parameter,i.Value));
+        }
+        return map;
+      }
+*/
+
+      case ArrayValue: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "VBoolArray": {
+            ArrayValue.VBoolArray_ tv = new ArrayValue().new VBoolArray_();
+            tv._0 = (ArrayList<Boolean>)fromJSON(Type.Array_Bool,obj.get("arg0"));
+            return tv;
+          }
+          case "VIntArray": {
+            ArrayValue.VIntArray_ tv = new ArrayValue().new VIntArray_();
+            tv._0 = (ArrayList<Integer>)fromJSON(Type.Array_Int32,obj.get("arg0"));
+            return tv;
+          }
+          case "VWordArray": {
+            ArrayValue.VWordArray_ tv = new ArrayValue().new VWordArray_();
+            tv._0 = (ArrayList<Integer>)fromJSON(Type.Array_Word32,obj.get("arg0"));
+            return tv;
+          }
+          case "VFloatArray": {
+            ArrayValue.VFloatArray_ tv = new ArrayValue().new VFloatArray_();
+            tv._0 = (ArrayList<Float>)fromJSON(Type.Array_Float,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Value: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "VBool": {
+            Value.VBool_ tv = new Value().new VBool_();
+            tv._0 = (Boolean)fromJSON(Type.Bool,obj.get("arg0"));
+            return tv;
+          }
+          case "VV2B": {
+            Value.VV2B_ tv = new Value().new VV2B_();
+            tv._0 = (V2<Boolean>)fromJSON(Type.V2_Bool,obj.get("arg0"));
+            return tv;
+          }
+          case "VV3B": {
+            Value.VV3B_ tv = new Value().new VV3B_();
+            tv._0 = (V3<Boolean>)fromJSON(Type.V3_Bool,obj.get("arg0"));
+            return tv;
+          }
+          case "VV4B": {
+            Value.VV4B_ tv = new Value().new VV4B_();
+            tv._0 = (V4<Boolean>)fromJSON(Type.V4_Bool,obj.get("arg0"));
+            return tv;
+          }
+          case "VWord": {
+            Value.VWord_ tv = new Value().new VWord_();
+            tv._0 = (Integer)fromJSON(Type.Word32,obj.get("arg0"));
+            return tv;
+          }
+          case "VV2U": {
+            Value.VV2U_ tv = new Value().new VV2U_();
+            tv._0 = (V2<Integer>)fromJSON(Type.V2_Word,obj.get("arg0"));
+            return tv;
+          }
+          case "VV3U": {
+            Value.VV3U_ tv = new Value().new VV3U_();
+            tv._0 = (V3<Integer>)fromJSON(Type.V3_Word,obj.get("arg0"));
+            return tv;
+          }
+          case "VV4U": {
+            Value.VV4U_ tv = new Value().new VV4U_();
+            tv._0 = (V4<Integer>)fromJSON(Type.V4_Word,obj.get("arg0"));
+            return tv;
+          }
+          case "VInt": {
+            Value.VInt_ tv = new Value().new VInt_();
+            tv._0 = (Integer)fromJSON(Type.Int32,obj.get("arg0"));
+            return tv;
+          }
+          case "VV2I": {
+            Value.VV2I_ tv = new Value().new VV2I_();
+            tv._0 = (V2<Integer>)fromJSON(Type.V2_Int,obj.get("arg0"));
+            return tv;
+          }
+          case "VV3I": {
+            Value.VV3I_ tv = new Value().new VV3I_();
+            tv._0 = (V3<Integer>)fromJSON(Type.V3_Int,obj.get("arg0"));
+            return tv;
+          }
+          case "VV4I": {
+            Value.VV4I_ tv = new Value().new VV4I_();
+            tv._0 = (V4<Integer>)fromJSON(Type.V4_Int,obj.get("arg0"));
+            return tv;
+          }
+          case "VFloat": {
+            Value.VFloat_ tv = new Value().new VFloat_();
+            tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VV2F": {
+            Value.VV2F_ tv = new Value().new VV2F_();
+            tv._0 = (V2<Float>)fromJSON(Type.V2_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VV3F": {
+            Value.VV3F_ tv = new Value().new VV3F_();
+            tv._0 = (V3<Float>)fromJSON(Type.V3_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VV4F": {
+            Value.VV4F_ tv = new Value().new VV4F_();
+            tv._0 = (V4<Float>)fromJSON(Type.V4_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM22F": {
+            Value.VM22F_ tv = new Value().new VM22F_();
+            tv._0 = (V2<V2<Float>>)fromJSON(Type.V2_V2_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM23F": {
+            Value.VM23F_ tv = new Value().new VM23F_();
+            tv._0 = (V3<V2<Float>>)fromJSON(Type.V3_V2_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM24F": {
+            Value.VM24F_ tv = new Value().new VM24F_();
+            tv._0 = (V4<V2<Float>>)fromJSON(Type.V4_V2_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM32F": {
+            Value.VM32F_ tv = new Value().new VM32F_();
+            tv._0 = (V2<V3<Float>>)fromJSON(Type.V2_V3_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM33F": {
+            Value.VM33F_ tv = new Value().new VM33F_();
+            tv._0 = (V3<V3<Float>>)fromJSON(Type.V3_V3_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM34F": {
+            Value.VM34F_ tv = new Value().new VM34F_();
+            tv._0 = (V4<V3<Float>>)fromJSON(Type.V4_V3_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM42F": {
+            Value.VM42F_ tv = new Value().new VM42F_();
+            tv._0 = (V2<V4<Float>>)fromJSON(Type.V2_V4_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM43F": {
+            Value.VM43F_ tv = new Value().new VM43F_();
+            tv._0 = (V3<V4<Float>>)fromJSON(Type.V3_V4_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "VM44F": {
+            Value.VM44F_ tv = new Value().new VM44F_();
+            tv._0 = (V4<V4<Float>>)fromJSON(Type.V4_V4_Float,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case InputType: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        InputType.Tag tagType;
+        switch (tag) {
+          case "Bool": tagType = InputType.Tag.Bool; break;
+          case "V2B": tagType = InputType.Tag.V2B; break;
+          case "V3B": tagType = InputType.Tag.V3B; break;
+          case "V4B": tagType = InputType.Tag.V4B; break;
+          case "Word": tagType = InputType.Tag.Word; break;
+          case "V2U": tagType = InputType.Tag.V2U; break;
+          case "V3U": tagType = InputType.Tag.V3U; break;
+          case "V4U": tagType = InputType.Tag.V4U; break;
+          case "Int": tagType = InputType.Tag.Int; break;
+          case "V2I": tagType = InputType.Tag.V2I; break;
+          case "V3I": tagType = InputType.Tag.V3I; break;
+          case "V4I": tagType = InputType.Tag.V4I; break;
+          case "Float": tagType = InputType.Tag.Float; break;
+          case "V2F": tagType = InputType.Tag.V2F; break;
+          case "V3F": tagType = InputType.Tag.V3F; break;
+          case "V4F": tagType = InputType.Tag.V4F; break;
+          case "M22F": tagType = InputType.Tag.M22F; break;
+          case "M23F": tagType = InputType.Tag.M23F; break;
+          case "M24F": tagType = InputType.Tag.M24F; break;
+          case "M32F": tagType = InputType.Tag.M32F; break;
+          case "M33F": tagType = InputType.Tag.M33F; break;
+          case "M34F": tagType = InputType.Tag.M34F; break;
+          case "M42F": tagType = InputType.Tag.M42F; break;
+          case "M43F": tagType = InputType.Tag.M43F; break;
+          case "M44F": tagType = InputType.Tag.M44F; break;
+          case "STexture1D": tagType = InputType.Tag.STexture1D; break;
+          case "STexture2D": tagType = InputType.Tag.STexture2D; break;
+          case "STextureCube": tagType = InputType.Tag.STextureCube; break;
+          case "STexture1DArray": tagType = InputType.Tag.STexture1DArray; break;
+          case "STexture2DArray": tagType = InputType.Tag.STexture2DArray; break;
+          case "STexture2DRect": tagType = InputType.Tag.STexture2DRect; break;
+          case "FTexture1D": tagType = InputType.Tag.FTexture1D; break;
+          case "FTexture2D": tagType = InputType.Tag.FTexture2D; break;
+          case "FTexture3D": tagType = InputType.Tag.FTexture3D; break;
+          case "FTextureCube": tagType = InputType.Tag.FTextureCube; break;
+          case "FTexture1DArray": tagType = InputType.Tag.FTexture1DArray; break;
+          case "FTexture2DArray": tagType = InputType.Tag.FTexture2DArray; break;
+          case "FTexture2DMS": tagType = InputType.Tag.FTexture2DMS; break;
+          case "FTexture2DMSArray": tagType = InputType.Tag.FTexture2DMSArray; break;
+          case "FTextureBuffer": tagType = InputType.Tag.FTextureBuffer; break;
+          case "FTexture2DRect": tagType = InputType.Tag.FTexture2DRect; break;
+          case "ITexture1D": tagType = InputType.Tag.ITexture1D; break;
+          case "ITexture2D": tagType = InputType.Tag.ITexture2D; break;
+          case "ITexture3D": tagType = InputType.Tag.ITexture3D; break;
+          case "ITextureCube": tagType = InputType.Tag.ITextureCube; break;
+          case "ITexture1DArray": tagType = InputType.Tag.ITexture1DArray; break;
+          case "ITexture2DArray": tagType = InputType.Tag.ITexture2DArray; break;
+          case "ITexture2DMS": tagType = InputType.Tag.ITexture2DMS; break;
+          case "ITexture2DMSArray": tagType = InputType.Tag.ITexture2DMSArray; break;
+          case "ITextureBuffer": tagType = InputType.Tag.ITextureBuffer; break;
+          case "ITexture2DRect": tagType = InputType.Tag.ITexture2DRect; break;
+          case "UTexture1D": tagType = InputType.Tag.UTexture1D; break;
+          case "UTexture2D": tagType = InputType.Tag.UTexture2D; break;
+          case "UTexture3D": tagType = InputType.Tag.UTexture3D; break;
+          case "UTextureCube": tagType = InputType.Tag.UTextureCube; break;
+          case "UTexture1DArray": tagType = InputType.Tag.UTexture1DArray; break;
+          case "UTexture2DArray": tagType = InputType.Tag.UTexture2DArray; break;
+          case "UTexture2DMS": tagType = InputType.Tag.UTexture2DMS; break;
+          case "UTexture2DMSArray": tagType = InputType.Tag.UTexture2DMSArray; break;
+          case "UTextureBuffer": tagType = InputType.Tag.UTextureBuffer; break;
+          case "UTexture2DRect": tagType = InputType.Tag.UTexture2DRect; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        InputType o = new InputType();
+        o.tag = tagType;
+        return o;
+      }
+      case PointSpriteCoordOrigin: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        PointSpriteCoordOrigin.Tag tagType;
+        switch (tag) {
+          case "LowerLeft": tagType = PointSpriteCoordOrigin.Tag.LowerLeft; break;
+          case "UpperLeft": tagType = PointSpriteCoordOrigin.Tag.UpperLeft; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        PointSpriteCoordOrigin o = new PointSpriteCoordOrigin();
+        o.tag = tagType;
+        return o;
+      }
+      case PointSize: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        PointSize.Tag tagType;
+        switch (tag) {
+          case "PointSize": {
+            PointSize.PointSize_ tv = new PointSize().new PointSize_();
+            tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0"));
+            return tv;
+          }
+          case "ProgramPointSize": tagType = PointSize.Tag.ProgramPointSize; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        PointSize o = new PointSize();
+        o.tag = tagType;
+        return o;
+      }
+      case PolygonOffset: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        PolygonOffset.Tag tagType;
+        switch (tag) {
+          case "NoOffset": tagType = PolygonOffset.Tag.NoOffset; break;
+          case "Offset": {
+            PolygonOffset.Offset_ tv = new PolygonOffset().new Offset_();
+            tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0"));
+            tv._1 = (Float)fromJSON(Type.Float,obj.get("arg1"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        PolygonOffset o = new PolygonOffset();
+        o.tag = tagType;
+        return o;
+      }
+      case FrontFace: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        FrontFace.Tag tagType;
+        switch (tag) {
+          case "CCW": tagType = FrontFace.Tag.CCW; break;
+          case "CW": tagType = FrontFace.Tag.CW; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        FrontFace o = new FrontFace();
+        o.tag = tagType;
+        return o;
+      }
+      case PolygonMode: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        PolygonMode.Tag tagType;
+        switch (tag) {
+          case "PolygonPoint": {
+            PolygonMode.PolygonPoint_ tv = new PolygonMode().new PolygonPoint_();
+            tv._0 = (PointSize)fromJSON(Type.PointSize,obj.get("arg0"));
+            return tv;
+          }
+          case "PolygonLine": {
+            PolygonMode.PolygonLine_ tv = new PolygonMode().new PolygonLine_();
+            tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0"));
+            return tv;
+          }
+          case "PolygonFill": tagType = PolygonMode.Tag.PolygonFill; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        PolygonMode o = new PolygonMode();
+        o.tag = tagType;
+        return o;
+      }
+      case ProvokingVertex: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        ProvokingVertex.Tag tagType;
+        switch (tag) {
+          case "FirstVertex": tagType = ProvokingVertex.Tag.FirstVertex; break;
+          case "LastVertex": tagType = ProvokingVertex.Tag.LastVertex; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        ProvokingVertex o = new ProvokingVertex();
+        o.tag = tagType;
+        return o;
+      }
+      case CullMode: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        CullMode.Tag tagType;
+        switch (tag) {
+          case "CullNone": tagType = CullMode.Tag.CullNone; break;
+          case "CullFront": {
+            CullMode.CullFront_ tv = new CullMode().new CullFront_();
+            tv._0 = (FrontFace)fromJSON(Type.FrontFace,obj.get("arg0"));
+            return tv;
+          }
+          case "CullBack": {
+            CullMode.CullBack_ tv = new CullMode().new CullBack_();
+            tv._0 = (FrontFace)fromJSON(Type.FrontFace,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        CullMode o = new CullMode();
+        o.tag = tagType;
+        return o;
+      }
+      case ComparisonFunction: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        ComparisonFunction.Tag tagType;
+        switch (tag) {
+          case "Never": tagType = ComparisonFunction.Tag.Never; break;
+          case "Less": tagType = ComparisonFunction.Tag.Less; break;
+          case "Equal": tagType = ComparisonFunction.Tag.Equal; break;
+          case "Lequal": tagType = ComparisonFunction.Tag.Lequal; break;
+          case "Greater": tagType = ComparisonFunction.Tag.Greater; break;
+          case "Notequal": tagType = ComparisonFunction.Tag.Notequal; break;
+          case "Gequal": tagType = ComparisonFunction.Tag.Gequal; break;
+          case "Always": tagType = ComparisonFunction.Tag.Always; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        ComparisonFunction o = new ComparisonFunction();
+        o.tag = tagType;
+        return o;
+      }
+      case StencilOperation: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        StencilOperation.Tag tagType;
+        switch (tag) {
+          case "OpZero": tagType = StencilOperation.Tag.OpZero; break;
+          case "OpKeep": tagType = StencilOperation.Tag.OpKeep; break;
+          case "OpReplace": tagType = StencilOperation.Tag.OpReplace; break;
+          case "OpIncr": tagType = StencilOperation.Tag.OpIncr; break;
+          case "OpIncrWrap": tagType = StencilOperation.Tag.OpIncrWrap; break;
+          case "OpDecr": tagType = StencilOperation.Tag.OpDecr; break;
+          case "OpDecrWrap": tagType = StencilOperation.Tag.OpDecrWrap; break;
+          case "OpInvert": tagType = StencilOperation.Tag.OpInvert; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        StencilOperation o = new StencilOperation();
+        o.tag = tagType;
+        return o;
+      }
+      case BlendEquation: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        BlendEquation.Tag tagType;
+        switch (tag) {
+          case "FuncAdd": tagType = BlendEquation.Tag.FuncAdd; break;
+          case "FuncSubtract": tagType = BlendEquation.Tag.FuncSubtract; break;
+          case "FuncReverseSubtract": tagType = BlendEquation.Tag.FuncReverseSubtract; break;
+          case "Min": tagType = BlendEquation.Tag.Min; break;
+          case "Max": tagType = BlendEquation.Tag.Max; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        BlendEquation o = new BlendEquation();
+        o.tag = tagType;
+        return o;
+      }
+      case BlendingFactor: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        BlendingFactor.Tag tagType;
+        switch (tag) {
+          case "Zero": tagType = BlendingFactor.Tag.Zero; break;
+          case "One": tagType = BlendingFactor.Tag.One; break;
+          case "SrcColor": tagType = BlendingFactor.Tag.SrcColor; break;
+          case "OneMinusSrcColor": tagType = BlendingFactor.Tag.OneMinusSrcColor; break;
+          case "DstColor": tagType = BlendingFactor.Tag.DstColor; break;
+          case "OneMinusDstColor": tagType = BlendingFactor.Tag.OneMinusDstColor; break;
+          case "SrcAlpha": tagType = BlendingFactor.Tag.SrcAlpha; break;
+          case "OneMinusSrcAlpha": tagType = BlendingFactor.Tag.OneMinusSrcAlpha; break;
+          case "DstAlpha": tagType = BlendingFactor.Tag.DstAlpha; break;
+          case "OneMinusDstAlpha": tagType = BlendingFactor.Tag.OneMinusDstAlpha; break;
+          case "ConstantColor": tagType = BlendingFactor.Tag.ConstantColor; break;
+          case "OneMinusConstantColor": tagType = BlendingFactor.Tag.OneMinusConstantColor; break;
+          case "ConstantAlpha": tagType = BlendingFactor.Tag.ConstantAlpha; break;
+          case "OneMinusConstantAlpha": tagType = BlendingFactor.Tag.OneMinusConstantAlpha; break;
+          case "SrcAlphaSaturate": tagType = BlendingFactor.Tag.SrcAlphaSaturate; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        BlendingFactor o = new BlendingFactor();
+        o.tag = tagType;
+        return o;
+      }
+      case LogicOperation: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        LogicOperation.Tag tagType;
+        switch (tag) {
+          case "Clear": tagType = LogicOperation.Tag.Clear; break;
+          case "And": tagType = LogicOperation.Tag.And; break;
+          case "AndReverse": tagType = LogicOperation.Tag.AndReverse; break;
+          case "Copy": tagType = LogicOperation.Tag.Copy; break;
+          case "AndInverted": tagType = LogicOperation.Tag.AndInverted; break;
+          case "Noop": tagType = LogicOperation.Tag.Noop; break;
+          case "Xor": tagType = LogicOperation.Tag.Xor; break;
+          case "Or": tagType = LogicOperation.Tag.Or; break;
+          case "Nor": tagType = LogicOperation.Tag.Nor; break;
+          case "Equiv": tagType = LogicOperation.Tag.Equiv; break;
+          case "Invert": tagType = LogicOperation.Tag.Invert; break;
+          case "OrReverse": tagType = LogicOperation.Tag.OrReverse; break;
+          case "CopyInverted": tagType = LogicOperation.Tag.CopyInverted; break;
+          case "OrInverted": tagType = LogicOperation.Tag.OrInverted; break;
+          case "Nand": tagType = LogicOperation.Tag.Nand; break;
+          case "Set": tagType = LogicOperation.Tag.Set; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        LogicOperation o = new LogicOperation();
+        o.tag = tagType;
+        return o;
+      }
+      case StencilOps: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "StencilOps": {
+            StencilOps.StencilOps_ tv = new StencilOps().new StencilOps_();
+            tv.frontStencilOp = (StencilOperation)fromJSON(Type.StencilOperation,obj.get("frontStencilOp"));
+            tv.backStencilOp = (StencilOperation)fromJSON(Type.StencilOperation,obj.get("backStencilOp"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case StencilTest: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "StencilTest": {
+            StencilTest.StencilTest_ tv = new StencilTest().new StencilTest_();
+            tv.stencilComparision = (ComparisonFunction)fromJSON(Type.ComparisonFunction,obj.get("stencilComparision"));
+            tv.stencilReference = (Integer)fromJSON(Type.Int32,obj.get("stencilReference"));
+            tv.stencilMask = (Integer)fromJSON(Type.Word32,obj.get("stencilMask"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case StencilTests: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "StencilTests": {
+            StencilTests.StencilTests_ tv = new StencilTests().new StencilTests_();
+            tv._0 = (StencilTest)fromJSON(Type.StencilTest,obj.get("arg0"));
+            tv._1 = (StencilTest)fromJSON(Type.StencilTest,obj.get("arg1"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case FetchPrimitive: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        FetchPrimitive.Tag tagType;
+        switch (tag) {
+          case "Points": tagType = FetchPrimitive.Tag.Points; break;
+          case "Lines": tagType = FetchPrimitive.Tag.Lines; break;
+          case "Triangles": tagType = FetchPrimitive.Tag.Triangles; break;
+          case "LinesAdjacency": tagType = FetchPrimitive.Tag.LinesAdjacency; break;
+          case "TrianglesAdjacency": tagType = FetchPrimitive.Tag.TrianglesAdjacency; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        FetchPrimitive o = new FetchPrimitive();
+        o.tag = tagType;
+        return o;
+      }
+      case OutputPrimitive: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        OutputPrimitive.Tag tagType;
+        switch (tag) {
+          case "TrianglesOutput": tagType = OutputPrimitive.Tag.TrianglesOutput; break;
+          case "LinesOutput": tagType = OutputPrimitive.Tag.LinesOutput; break;
+          case "PointsOutput": tagType = OutputPrimitive.Tag.PointsOutput; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        OutputPrimitive o = new OutputPrimitive();
+        o.tag = tagType;
+        return o;
+      }
+      case ColorArity: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        ColorArity.Tag tagType;
+        switch (tag) {
+          case "Red": tagType = ColorArity.Tag.Red; break;
+          case "RG": tagType = ColorArity.Tag.RG; break;
+          case "RGB": tagType = ColorArity.Tag.RGB; break;
+          case "RGBA": tagType = ColorArity.Tag.RGBA; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        ColorArity o = new ColorArity();
+        o.tag = tagType;
+        return o;
+      }
+      case Blending: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        Blending.Tag tagType;
+        switch (tag) {
+          case "NoBlending": tagType = Blending.Tag.NoBlending; break;
+          case "BlendLogicOp": {
+            Blending.BlendLogicOp_ tv = new Blending().new BlendLogicOp_();
+            tv._0 = (LogicOperation)fromJSON(Type.LogicOperation,obj.get("arg0"));
+            return tv;
+          }
+          case "Blend": {
+            Blending.Blend_ tv = new Blending().new Blend_();
+            tv.colorEqSrc = (BlendEquation)fromJSON(Type.BlendEquation,obj.get("colorEqSrc"));
+            tv.alphaEqSrc = (BlendEquation)fromJSON(Type.BlendEquation,obj.get("alphaEqSrc"));
+            tv.colorFSrc = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("colorFSrc"));
+            tv.colorFDst = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("colorFDst"));
+            tv.alphaFSrc = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("alphaFSrc"));
+            tv.alphaFDst = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("alphaFDst"));
+            tv.color = (V4<Float>)fromJSON(Type.V4_Float,obj.get("color"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        Blending o = new Blending();
+        o.tag = tagType;
+        return o;
+      }
+      case RasterContext: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "PointCtx": {
+            RasterContext.PointCtx_ tv = new RasterContext().new PointCtx_();
+            tv._0 = (PointSize)fromJSON(Type.PointSize,obj.get("arg0"));
+            tv._1 = (Float)fromJSON(Type.Float,obj.get("arg1"));
+            tv._2 = (PointSpriteCoordOrigin)fromJSON(Type.PointSpriteCoordOrigin,obj.get("arg2"));
+            return tv;
+          }
+          case "LineCtx": {
+            RasterContext.LineCtx_ tv = new RasterContext().new LineCtx_();
+            tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0"));
+            tv._1 = (ProvokingVertex)fromJSON(Type.ProvokingVertex,obj.get("arg1"));
+            return tv;
+          }
+          case "TriangleCtx": {
+            RasterContext.TriangleCtx_ tv = new RasterContext().new TriangleCtx_();
+            tv._0 = (CullMode)fromJSON(Type.CullMode,obj.get("arg0"));
+            tv._1 = (PolygonMode)fromJSON(Type.PolygonMode,obj.get("arg1"));
+            tv._2 = (PolygonOffset)fromJSON(Type.PolygonOffset,obj.get("arg2"));
+            tv._3 = (ProvokingVertex)fromJSON(Type.ProvokingVertex,obj.get("arg3"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case FragmentOperation: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "DepthOp": {
+            FragmentOperation.DepthOp_ tv = new FragmentOperation().new DepthOp_();
+            tv._0 = (ComparisonFunction)fromJSON(Type.ComparisonFunction,obj.get("arg0"));
+            tv._1 = (Boolean)fromJSON(Type.Bool,obj.get("arg1"));
+            return tv;
+          }
+          case "StencilOp": {
+            FragmentOperation.StencilOp_ tv = new FragmentOperation().new StencilOp_();
+            tv._0 = (StencilTests)fromJSON(Type.StencilTests,obj.get("arg0"));
+            tv._1 = (StencilOps)fromJSON(Type.StencilOps,obj.get("arg1"));
+            tv._2 = (StencilOps)fromJSON(Type.StencilOps,obj.get("arg2"));
+            return tv;
+          }
+          case "ColorOp": {
+            FragmentOperation.ColorOp_ tv = new FragmentOperation().new ColorOp_();
+            tv._0 = (Blending)fromJSON(Type.Blending,obj.get("arg0"));
+            tv._1 = (Value)fromJSON(Type.Value,obj.get("arg1"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case AccumulationContext: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "AccumulationContext": {
+            AccumulationContext.AccumulationContext_ tv = new AccumulationContext().new AccumulationContext_();
+            tv.accViewportName = (Maybe<String>)fromJSON(Type.Maybe_String,obj.get("accViewportName"));
+            tv.accOperations = (ArrayList<FragmentOperation>)fromJSON(Type.List_FragmentOperation,obj.get("accOperations"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case TextureDataType: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        TextureDataType.Tag tagType;
+        switch (tag) {
+          case "FloatT": {
+            TextureDataType.FloatT_ tv = new TextureDataType().new FloatT_();
+            tv._0 = (ColorArity)fromJSON(Type.ColorArity,obj.get("arg0"));
+            return tv;
+          }
+          case "IntT": {
+            TextureDataType.IntT_ tv = new TextureDataType().new IntT_();
+            tv._0 = (ColorArity)fromJSON(Type.ColorArity,obj.get("arg0"));
+            return tv;
+          }
+          case "WordT": {
+            TextureDataType.WordT_ tv = new TextureDataType().new WordT_();
+            tv._0 = (ColorArity)fromJSON(Type.ColorArity,obj.get("arg0"));
+            return tv;
+          }
+          case "ShadowT": tagType = TextureDataType.Tag.ShadowT; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        TextureDataType o = new TextureDataType();
+        o.tag = tagType;
+        return o;
+      }
+      case TextureType: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Texture1D": {
+            TextureType.Texture1D_ tv = new TextureType().new Texture1D_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          case "Texture2D": {
+            TextureType.Texture2D_ tv = new TextureType().new Texture2D_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          case "Texture3D": {
+            TextureType.Texture3D_ tv = new TextureType().new Texture3D_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            return tv;
+          }
+          case "TextureCube": {
+            TextureType.TextureCube_ tv = new TextureType().new TextureCube_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            return tv;
+          }
+          case "TextureRect": {
+            TextureType.TextureRect_ tv = new TextureType().new TextureRect_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            return tv;
+          }
+          case "Texture2DMS": {
+            TextureType.Texture2DMS_ tv = new TextureType().new Texture2DMS_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            tv._2 = (Integer)fromJSON(Type.Int,obj.get("arg2"));
+            tv._3 = (Boolean)fromJSON(Type.Bool,obj.get("arg3"));
+            return tv;
+          }
+          case "TextureBuffer": {
+            TextureType.TextureBuffer_ tv = new TextureType().new TextureBuffer_();
+            tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case MipMap: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        MipMap.Tag tagType;
+        switch (tag) {
+          case "Mip": {
+            MipMap.Mip_ tv = new MipMap().new Mip_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          case "NoMip": tagType = MipMap.Tag.NoMip; break;
+          case "AutoMip": {
+            MipMap.AutoMip_ tv = new MipMap().new AutoMip_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        MipMap o = new MipMap();
+        o.tag = tagType;
+        return o;
+      }
+      case Filter: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        Filter.Tag tagType;
+        switch (tag) {
+          case "Nearest": tagType = Filter.Tag.Nearest; break;
+          case "Linear": tagType = Filter.Tag.Linear; break;
+          case "NearestMipmapNearest": tagType = Filter.Tag.NearestMipmapNearest; break;
+          case "NearestMipmapLinear": tagType = Filter.Tag.NearestMipmapLinear; break;
+          case "LinearMipmapNearest": tagType = Filter.Tag.LinearMipmapNearest; break;
+          case "LinearMipmapLinear": tagType = Filter.Tag.LinearMipmapLinear; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        Filter o = new Filter();
+        o.tag = tagType;
+        return o;
+      }
+      case EdgeMode: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        EdgeMode.Tag tagType;
+        switch (tag) {
+          case "Repeat": tagType = EdgeMode.Tag.Repeat; break;
+          case "MirroredRepeat": tagType = EdgeMode.Tag.MirroredRepeat; break;
+          case "ClampToEdge": tagType = EdgeMode.Tag.ClampToEdge; break;
+          case "ClampToBorder": tagType = EdgeMode.Tag.ClampToBorder; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        EdgeMode o = new EdgeMode();
+        o.tag = tagType;
+        return o;
+      }
+      case ImageSemantic: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        ImageSemantic.Tag tagType;
+        switch (tag) {
+          case "Depth": tagType = ImageSemantic.Tag.Depth; break;
+          case "Stencil": tagType = ImageSemantic.Tag.Stencil; break;
+          case "Color": tagType = ImageSemantic.Tag.Color; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        ImageSemantic o = new ImageSemantic();
+        o.tag = tagType;
+        return o;
+      }
+      case ImageRef: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "TextureImage": {
+            ImageRef.TextureImage_ tv = new ImageRef().new TextureImage_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            tv._2 = (Maybe<Integer>)fromJSON(Type.Maybe_Int,obj.get("arg2"));
+            return tv;
+          }
+          case "Framebuffer": {
+            ImageRef.Framebuffer_ tv = new ImageRef().new Framebuffer_();
+            tv._0 = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case ClearImage: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "ClearImage": {
+            ClearImage.ClearImage_ tv = new ClearImage().new ClearImage_();
+            tv.imageSemantic = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("imageSemantic"));
+            tv.clearValue = (Value)fromJSON(Type.Value,obj.get("clearValue"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Command: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "SetRasterContext": {
+            Command.SetRasterContext_ tv = new Command().new SetRasterContext_();
+            tv._0 = (RasterContext)fromJSON(Type.RasterContext,obj.get("arg0"));
+            return tv;
+          }
+          case "SetAccumulationContext": {
+            Command.SetAccumulationContext_ tv = new Command().new SetAccumulationContext_();
+            tv._0 = (AccumulationContext)fromJSON(Type.AccumulationContext,obj.get("arg0"));
+            return tv;
+          }
+          case "SetRenderTarget": {
+            Command.SetRenderTarget_ tv = new Command().new SetRenderTarget_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            return tv;
+          }
+          case "SetProgram": {
+            Command.SetProgram_ tv = new Command().new SetProgram_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            return tv;
+          }
+          case "SetSamplerUniform": {
+            Command.SetSamplerUniform_ tv = new Command().new SetSamplerUniform_();
+            tv._0 = (String)fromJSON(Type.String,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          case "SetTexture": {
+            Command.SetTexture_ tv = new Command().new SetTexture_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          case "SetSampler": {
+            Command.SetSampler_ tv = new Command().new SetSampler_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            tv._1 = (Maybe<Integer>)fromJSON(Type.Maybe_Int,obj.get("arg1"));
+            return tv;
+          }
+          case "RenderSlot": {
+            Command.RenderSlot_ tv = new Command().new RenderSlot_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            return tv;
+          }
+          case "RenderStream": {
+            Command.RenderStream_ tv = new Command().new RenderStream_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            return tv;
+          }
+          case "ClearRenderTarget": {
+            Command.ClearRenderTarget_ tv = new Command().new ClearRenderTarget_();
+            tv._0 = (ArrayList<ClearImage>)fromJSON(Type.Array_ClearImage,obj.get("arg0"));
+            return tv;
+          }
+          case "GenerateMipMap": {
+            Command.GenerateMipMap_ tv = new Command().new GenerateMipMap_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            return tv;
+          }
+          case "SaveImage": {
+            Command.SaveImage_ tv = new Command().new SaveImage_();
+            tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0"));
+            tv._1 = (ImageRef)fromJSON(Type.ImageRef,obj.get("arg1"));
+            return tv;
+          }
+          case "LoadImage": {
+            Command.LoadImage_ tv = new Command().new LoadImage_();
+            tv._0 = (ImageRef)fromJSON(Type.ImageRef,obj.get("arg0"));
+            tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case SamplerDescriptor: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "SamplerDescriptor": {
+            SamplerDescriptor.SamplerDescriptor_ tv = new SamplerDescriptor().new SamplerDescriptor_();
+            tv.samplerWrapS = (EdgeMode)fromJSON(Type.EdgeMode,obj.get("samplerWrapS"));
+            tv.samplerWrapT = (Maybe<EdgeMode>)fromJSON(Type.Maybe_EdgeMode,obj.get("samplerWrapT"));
+            tv.samplerWrapR = (Maybe<EdgeMode>)fromJSON(Type.Maybe_EdgeMode,obj.get("samplerWrapR"));
+            tv.samplerMinFilter = (Filter)fromJSON(Type.Filter,obj.get("samplerMinFilter"));
+            tv.samplerMagFilter = (Filter)fromJSON(Type.Filter,obj.get("samplerMagFilter"));
+            tv.samplerBorderColor = (Value)fromJSON(Type.Value,obj.get("samplerBorderColor"));
+            tv.samplerMinLod = (Maybe<Float>)fromJSON(Type.Maybe_Float,obj.get("samplerMinLod"));
+            tv.samplerMaxLod = (Maybe<Float>)fromJSON(Type.Maybe_Float,obj.get("samplerMaxLod"));
+            tv.samplerLodBias = (Float)fromJSON(Type.Float,obj.get("samplerLodBias"));
+            tv.samplerCompareFunc = (Maybe<ComparisonFunction>)fromJSON(Type.Maybe_ComparisonFunction,obj.get("samplerCompareFunc"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case TextureDescriptor: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "TextureDescriptor": {
+            TextureDescriptor.TextureDescriptor_ tv = new TextureDescriptor().new TextureDescriptor_();
+            tv.textureType = (TextureType)fromJSON(Type.TextureType,obj.get("textureType"));
+            tv.textureSize = (Value)fromJSON(Type.Value,obj.get("textureSize"));
+            tv.textureSemantic = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("textureSemantic"));
+            tv.textureSampler = (SamplerDescriptor)fromJSON(Type.SamplerDescriptor,obj.get("textureSampler"));
+            tv.textureBaseLevel = (Integer)fromJSON(Type.Int,obj.get("textureBaseLevel"));
+            tv.textureMaxLevel = (Integer)fromJSON(Type.Int,obj.get("textureMaxLevel"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Parameter: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Parameter": {
+            Parameter.Parameter_ tv = new Parameter().new Parameter_();
+            tv.name = (String)fromJSON(Type.String,obj.get("name"));
+            tv.ty = (InputType)fromJSON(Type.InputType,obj.get("ty"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Program: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Program": {
+            Program.Program_ tv = new Program().new Program_();
+            tv.programUniforms = (HashMap<String, InputType>)fromJSON(Type.Map_String_InputType,obj.get("programUniforms"));
+            tv.programStreams = (HashMap<String, Parameter>)fromJSON(Type.Map_String_Parameter,obj.get("programStreams"));
+            tv.programInTextures = (HashMap<String, InputType>)fromJSON(Type.Map_String_InputType,obj.get("programInTextures"));
+            tv.programOutput = (ArrayList<Parameter>)fromJSON(Type.Array_Parameter,obj.get("programOutput"));
+            tv.vertexShader = (String)fromJSON(Type.String,obj.get("vertexShader"));
+            tv.geometryShader = (Maybe<String>)fromJSON(Type.Maybe_String,obj.get("geometryShader"));
+            tv.fragmentShader = (String)fromJSON(Type.String,obj.get("fragmentShader"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Slot: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Slot": {
+            Slot.Slot_ tv = new Slot().new Slot_();
+            tv.slotName = (String)fromJSON(Type.String,obj.get("slotName"));
+            tv.slotStreams = (HashMap<String, InputType>)fromJSON(Type.Map_String_InputType,obj.get("slotStreams"));
+            tv.slotUniforms = (HashMap<String, InputType>)fromJSON(Type.Map_String_InputType,obj.get("slotUniforms"));
+            tv.slotPrimitive = (FetchPrimitive)fromJSON(Type.FetchPrimitive,obj.get("slotPrimitive"));
+            tv.slotPrograms = (ArrayList<Integer>)fromJSON(Type.Array_Int,obj.get("slotPrograms"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case StreamData: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "StreamData": {
+            StreamData.StreamData_ tv = new StreamData().new StreamData_();
+            tv.streamData = (HashMap<String, ArrayValue>)fromJSON(Type.Map_String_ArrayValue,obj.get("streamData"));
+            tv.streamType = (HashMap<String, InputType>)fromJSON(Type.Map_String_InputType,obj.get("streamType"));
+            tv.streamPrimitive = (FetchPrimitive)fromJSON(Type.FetchPrimitive,obj.get("streamPrimitive"));
+            tv.streamPrograms = (ArrayList<Integer>)fromJSON(Type.Array_Int,obj.get("streamPrograms"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case TargetItem: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "TargetItem": {
+            TargetItem.TargetItem_ tv = new TargetItem().new TargetItem_();
+            tv.targetSemantic = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("targetSemantic"));
+            tv.targetRef = (Maybe<ImageRef>)fromJSON(Type.Maybe_ImageRef,obj.get("targetRef"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case RenderTarget: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "RenderTarget": {
+            RenderTarget.RenderTarget_ tv = new RenderTarget().new RenderTarget_();
+            tv.renderTargets = (ArrayList<TargetItem>)fromJSON(Type.Array_TargetItem,obj.get("renderTargets"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Backend: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        Backend.Tag tagType;
+        switch (tag) {
+          case "WebGL1": tagType = Backend.Tag.WebGL1; break;
+          case "OpenGL33": tagType = Backend.Tag.OpenGL33; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        Backend o = new Backend();
+        o.tag = tagType;
+        return o;
+      }
+      case Pipeline: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Pipeline": {
+            Pipeline.Pipeline_ tv = new Pipeline().new Pipeline_();
+            tv.info = (String)fromJSON(Type.String,obj.get("info"));
+            tv.backend = (Backend)fromJSON(Type.Backend,obj.get("backend"));
+            tv.textures = (ArrayList<TextureDescriptor>)fromJSON(Type.Array_TextureDescriptor,obj.get("textures"));
+            tv.samplers = (ArrayList<SamplerDescriptor>)fromJSON(Type.Array_SamplerDescriptor,obj.get("samplers"));
+            tv.targets = (ArrayList<RenderTarget>)fromJSON(Type.Array_RenderTarget,obj.get("targets"));
+            tv.programs = (ArrayList<Program>)fromJSON(Type.Array_Program,obj.get("programs"));
+            tv.slots = (ArrayList<Slot>)fromJSON(Type.Array_Slot,obj.get("slots"));
+            tv.streams = (ArrayList<StreamData>)fromJSON(Type.Array_StreamData,obj.get("streams"));
+            tv.commands = (ArrayList<Command>)fromJSON(Type.Array_Command,obj.get("commands"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+    }
+    throw new Exception("unknown type");
+  }
+}
\ No newline at end of file
diff --git a/ddl/out/java/LambdaCube/IR/LogicOperation.java b/ddl/out/java/LambdaCube/IR/LogicOperation.java
new file mode 100644
index 0000000..351bfe5
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/LogicOperation.java
@@ -0,0 +1,33 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class LogicOperation {
+  public enum Tag { 
+    Clear,
+    And,
+    AndReverse,
+    Copy,
+    AndInverted,
+    Noop,
+    Xor,
+    Or,
+    Nor,
+    Equiv,
+    Invert,
+    OrReverse,
+    CopyInverted,
+    OrInverted,
+    Nand,
+    Set
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/MipMap.java b/ddl/out/java/LambdaCube/IR/MipMap.java
new file mode 100644
index 0000000..69c7fb4
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/MipMap.java
@@ -0,0 +1,30 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class MipMap {
+  public enum Tag { 
+    Mip,
+    NoMip,
+    AutoMip
+  }
+  public Tag tag;
+
+  public class Mip_ extends MipMap { 
+    public Integer _0;
+    public Integer _1;
+    public Mip_() { tag = MipMap.Tag.Mip; }
+  }
+  public class AutoMip_ extends MipMap { 
+    public Integer _0;
+    public Integer _1;
+    public AutoMip_() { tag = MipMap.Tag.AutoMip; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/OutputPrimitive.java b/ddl/out/java/LambdaCube/IR/OutputPrimitive.java
new file mode 100644
index 0000000..cda4e7a
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/OutputPrimitive.java
@@ -0,0 +1,20 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class OutputPrimitive {
+  public enum Tag { 
+    TrianglesOutput,
+    LinesOutput,
+    PointsOutput
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Parameter.java b/ddl/out/java/LambdaCube/IR/Parameter.java
new file mode 100644
index 0000000..11f6778
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Parameter.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Parameter {
+  public enum Tag { 
+    Parameter
+  }
+  public Tag tag;
+
+  public class Parameter_ extends Parameter { 
+    public String name;
+    public InputType ty;
+    public Parameter_() { tag = Parameter.Tag.Parameter; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Pipeline.java b/ddl/out/java/LambdaCube/IR/Pipeline.java
new file mode 100644
index 0000000..5a98897
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Pipeline.java
@@ -0,0 +1,30 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Pipeline {
+  public enum Tag { 
+    Pipeline
+  }
+  public Tag tag;
+
+  public class Pipeline_ extends Pipeline { 
+    public String info;
+    public Backend backend;
+    public ArrayList<TextureDescriptor> textures;
+    public ArrayList<SamplerDescriptor> samplers;
+    public ArrayList<RenderTarget> targets;
+    public ArrayList<Program> programs;
+    public ArrayList<Slot> slots;
+    public ArrayList<StreamData> streams;
+    public ArrayList<Command> commands;
+    public Pipeline_() { tag = Pipeline.Tag.Pipeline; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/PointSize.java b/ddl/out/java/LambdaCube/IR/PointSize.java
new file mode 100644
index 0000000..195cd89
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/PointSize.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class PointSize {
+  public enum Tag { 
+    PointSize,
+    ProgramPointSize
+  }
+  public Tag tag;
+
+  public class PointSize_ extends PointSize { 
+    public Float _0;
+    public PointSize_() { tag = PointSize.Tag.PointSize; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java b/ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java
new file mode 100644
index 0000000..6b705bb
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java
@@ -0,0 +1,19 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class PointSpriteCoordOrigin {
+  public enum Tag { 
+    LowerLeft,
+    UpperLeft
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/PolygonMode.java b/ddl/out/java/LambdaCube/IR/PolygonMode.java
new file mode 100644
index 0000000..a1beedc
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/PolygonMode.java
@@ -0,0 +1,28 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class PolygonMode {
+  public enum Tag { 
+    PolygonPoint,
+    PolygonLine,
+    PolygonFill
+  }
+  public Tag tag;
+
+  public class PolygonPoint_ extends PolygonMode { 
+    public PointSize _0;
+    public PolygonPoint_() { tag = PolygonMode.Tag.PolygonPoint; }
+  }
+  public class PolygonLine_ extends PolygonMode { 
+    public Float _0;
+    public PolygonLine_() { tag = PolygonMode.Tag.PolygonLine; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/PolygonOffset.java b/ddl/out/java/LambdaCube/IR/PolygonOffset.java
new file mode 100644
index 0000000..dea6684
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/PolygonOffset.java
@@ -0,0 +1,24 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class PolygonOffset {
+  public enum Tag { 
+    NoOffset,
+    Offset
+  }
+  public Tag tag;
+
+  public class Offset_ extends PolygonOffset { 
+    public Float _0;
+    public Float _1;
+    public Offset_() { tag = PolygonOffset.Tag.Offset; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Program.java b/ddl/out/java/LambdaCube/IR/Program.java
new file mode 100644
index 0000000..4f0e999
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Program.java
@@ -0,0 +1,28 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Program {
+  public enum Tag { 
+    Program
+  }
+  public Tag tag;
+
+  public class Program_ extends Program { 
+    public HashMap<String, InputType> programUniforms;
+    public HashMap<String, Parameter> programStreams;
+    public HashMap<String, InputType> programInTextures;
+    public ArrayList<Parameter> programOutput;
+    public String vertexShader;
+    public Maybe<String> geometryShader;
+    public String fragmentShader;
+    public Program_() { tag = Program.Tag.Program; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/ProvokingVertex.java b/ddl/out/java/LambdaCube/IR/ProvokingVertex.java
new file mode 100644
index 0000000..30ee0fc
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/ProvokingVertex.java
@@ -0,0 +1,19 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class ProvokingVertex {
+  public enum Tag { 
+    FirstVertex,
+    LastVertex
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/RasterContext.java b/ddl/out/java/LambdaCube/IR/RasterContext.java
new file mode 100644
index 0000000..c246a8a
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/RasterContext.java
@@ -0,0 +1,38 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class RasterContext {
+  public enum Tag { 
+    PointCtx,
+    LineCtx,
+    TriangleCtx
+  }
+  public Tag tag;
+
+  public class PointCtx_ extends RasterContext { 
+    public PointSize _0;
+    public Float _1;
+    public PointSpriteCoordOrigin _2;
+    public PointCtx_() { tag = RasterContext.Tag.PointCtx; }
+  }
+  public class LineCtx_ extends RasterContext { 
+    public Float _0;
+    public ProvokingVertex _1;
+    public LineCtx_() { tag = RasterContext.Tag.LineCtx; }
+  }
+  public class TriangleCtx_ extends RasterContext { 
+    public CullMode _0;
+    public PolygonMode _1;
+    public PolygonOffset _2;
+    public ProvokingVertex _3;
+    public TriangleCtx_() { tag = RasterContext.Tag.TriangleCtx; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/RenderTarget.java b/ddl/out/java/LambdaCube/IR/RenderTarget.java
new file mode 100644
index 0000000..816dbc6
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/RenderTarget.java
@@ -0,0 +1,22 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class RenderTarget {
+  public enum Tag { 
+    RenderTarget
+  }
+  public Tag tag;
+
+  public class RenderTarget_ extends RenderTarget { 
+    public ArrayList<TargetItem> renderTargets;
+    public RenderTarget_() { tag = RenderTarget.Tag.RenderTarget; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/SamplerDescriptor.java b/ddl/out/java/LambdaCube/IR/SamplerDescriptor.java
new file mode 100644
index 0000000..1149bf3
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/SamplerDescriptor.java
@@ -0,0 +1,31 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class SamplerDescriptor {
+  public enum Tag { 
+    SamplerDescriptor
+  }
+  public Tag tag;
+
+  public class SamplerDescriptor_ extends SamplerDescriptor { 
+    public EdgeMode samplerWrapS;
+    public Maybe<EdgeMode> samplerWrapT;
+    public Maybe<EdgeMode> samplerWrapR;
+    public Filter samplerMinFilter;
+    public Filter samplerMagFilter;
+    public Value samplerBorderColor;
+    public Maybe<Float> samplerMinLod;
+    public Maybe<Float> samplerMaxLod;
+    public Float samplerLodBias;
+    public Maybe<ComparisonFunction> samplerCompareFunc;
+    public SamplerDescriptor_() { tag = SamplerDescriptor.Tag.SamplerDescriptor; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Slot.java b/ddl/out/java/LambdaCube/IR/Slot.java
new file mode 100644
index 0000000..bd6fac3
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Slot.java
@@ -0,0 +1,26 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Slot {
+  public enum Tag { 
+    Slot
+  }
+  public Tag tag;
+
+  public class Slot_ extends Slot { 
+    public String slotName;
+    public HashMap<String, InputType> slotStreams;
+    public HashMap<String, InputType> slotUniforms;
+    public FetchPrimitive slotPrimitive;
+    public ArrayList<Integer> slotPrograms;
+    public Slot_() { tag = Slot.Tag.Slot; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/StencilOperation.java b/ddl/out/java/LambdaCube/IR/StencilOperation.java
new file mode 100644
index 0000000..ef3a62f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/StencilOperation.java
@@ -0,0 +1,25 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class StencilOperation {
+  public enum Tag { 
+    OpZero,
+    OpKeep,
+    OpReplace,
+    OpIncr,
+    OpIncrWrap,
+    OpDecr,
+    OpDecrWrap,
+    OpInvert
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/StencilOps.java b/ddl/out/java/LambdaCube/IR/StencilOps.java
new file mode 100644
index 0000000..54f6d95
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/StencilOps.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class StencilOps {
+  public enum Tag { 
+    StencilOps
+  }
+  public Tag tag;
+
+  public class StencilOps_ extends StencilOps { 
+    public StencilOperation frontStencilOp;
+    public StencilOperation backStencilOp;
+    public StencilOps_() { tag = StencilOps.Tag.StencilOps; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/StencilTest.java b/ddl/out/java/LambdaCube/IR/StencilTest.java
new file mode 100644
index 0000000..ef16647
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/StencilTest.java
@@ -0,0 +1,24 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class StencilTest {
+  public enum Tag { 
+    StencilTest
+  }
+  public Tag tag;
+
+  public class StencilTest_ extends StencilTest { 
+    public ComparisonFunction stencilComparision;
+    public Integer stencilReference;
+    public Integer stencilMask;
+    public StencilTest_() { tag = StencilTest.Tag.StencilTest; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/StencilTests.java b/ddl/out/java/LambdaCube/IR/StencilTests.java
new file mode 100644
index 0000000..d350f5f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/StencilTests.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class StencilTests {
+  public enum Tag { 
+    StencilTests
+  }
+  public Tag tag;
+
+  public class StencilTests_ extends StencilTests { 
+    public StencilTest _0;
+    public StencilTest _1;
+    public StencilTests_() { tag = StencilTests.Tag.StencilTests; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/StreamData.java b/ddl/out/java/LambdaCube/IR/StreamData.java
new file mode 100644
index 0000000..81c9d0b
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/StreamData.java
@@ -0,0 +1,25 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class StreamData {
+  public enum Tag { 
+    StreamData
+  }
+  public Tag tag;
+
+  public class StreamData_ extends StreamData { 
+    public HashMap<String, ArrayValue> streamData;
+    public HashMap<String, InputType> streamType;
+    public FetchPrimitive streamPrimitive;
+    public ArrayList<Integer> streamPrograms;
+    public StreamData_() { tag = StreamData.Tag.StreamData; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/TargetItem.java b/ddl/out/java/LambdaCube/IR/TargetItem.java
new file mode 100644
index 0000000..f6315fc
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/TargetItem.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class TargetItem {
+  public enum Tag { 
+    TargetItem
+  }
+  public Tag tag;
+
+  public class TargetItem_ extends TargetItem { 
+    public ImageSemantic targetSemantic;
+    public Maybe<ImageRef> targetRef;
+    public TargetItem_() { tag = TargetItem.Tag.TargetItem; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/TextureDataType.java b/ddl/out/java/LambdaCube/IR/TextureDataType.java
new file mode 100644
index 0000000..4725a3f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/TextureDataType.java
@@ -0,0 +1,33 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class TextureDataType {
+  public enum Tag { 
+    FloatT,
+    IntT,
+    WordT,
+    ShadowT
+  }
+  public Tag tag;
+
+  public class FloatT_ extends TextureDataType { 
+    public ColorArity _0;
+    public FloatT_() { tag = TextureDataType.Tag.FloatT; }
+  }
+  public class IntT_ extends TextureDataType { 
+    public ColorArity _0;
+    public IntT_() { tag = TextureDataType.Tag.IntT; }
+  }
+  public class WordT_ extends TextureDataType { 
+    public ColorArity _0;
+    public WordT_() { tag = TextureDataType.Tag.WordT; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/TextureDescriptor.java b/ddl/out/java/LambdaCube/IR/TextureDescriptor.java
new file mode 100644
index 0000000..d4d3cdd
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/TextureDescriptor.java
@@ -0,0 +1,27 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class TextureDescriptor {
+  public enum Tag { 
+    TextureDescriptor
+  }
+  public Tag tag;
+
+  public class TextureDescriptor_ extends TextureDescriptor { 
+    public TextureType textureType;
+    public Value textureSize;
+    public ImageSemantic textureSemantic;
+    public SamplerDescriptor textureSampler;
+    public Integer textureBaseLevel;
+    public Integer textureMaxLevel;
+    public TextureDescriptor_() { tag = TextureDescriptor.Tag.TextureDescriptor; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/TextureType.java b/ddl/out/java/LambdaCube/IR/TextureType.java
new file mode 100644
index 0000000..2425c1f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/TextureType.java
@@ -0,0 +1,57 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class TextureType {
+  public enum Tag { 
+    Texture1D,
+    Texture2D,
+    Texture3D,
+    TextureCube,
+    TextureRect,
+    Texture2DMS,
+    TextureBuffer
+  }
+  public Tag tag;
+
+  public class Texture1D_ extends TextureType { 
+    public TextureDataType _0;
+    public Integer _1;
+    public Texture1D_() { tag = TextureType.Tag.Texture1D; }
+  }
+  public class Texture2D_ extends TextureType { 
+    public TextureDataType _0;
+    public Integer _1;
+    public Texture2D_() { tag = TextureType.Tag.Texture2D; }
+  }
+  public class Texture3D_ extends TextureType { 
+    public TextureDataType _0;
+    public Texture3D_() { tag = TextureType.Tag.Texture3D; }
+  }
+  public class TextureCube_ extends TextureType { 
+    public TextureDataType _0;
+    public TextureCube_() { tag = TextureType.Tag.TextureCube; }
+  }
+  public class TextureRect_ extends TextureType { 
+    public TextureDataType _0;
+    public TextureRect_() { tag = TextureType.Tag.TextureRect; }
+  }
+  public class Texture2DMS_ extends TextureType { 
+    public TextureDataType _0;
+    public Integer _1;
+    public Integer _2;
+    public Boolean _3;
+    public Texture2DMS_() { tag = TextureType.Tag.Texture2DMS; }
+  }
+  public class TextureBuffer_ extends TextureType { 
+    public TextureDataType _0;
+    public TextureBuffer_() { tag = TextureType.Tag.TextureBuffer; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/IR/Value.java b/ddl/out/java/LambdaCube/IR/Value.java
new file mode 100644
index 0000000..75de175
--- /dev/null
+++ b/ddl/out/java/LambdaCube/IR/Value.java
@@ -0,0 +1,142 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:51.714241000000Z
+
+package LambdaCube.IR;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Value {
+  public enum Tag { 
+    VBool,
+    VV2B,
+    VV3B,
+    VV4B,
+    VWord,
+    VV2U,
+    VV3U,
+    VV4U,
+    VInt,
+    VV2I,
+    VV3I,
+    VV4I,
+    VFloat,
+    VV2F,
+    VV3F,
+    VV4F,
+    VM22F,
+    VM23F,
+    VM24F,
+    VM32F,
+    VM33F,
+    VM34F,
+    VM42F,
+    VM43F,
+    VM44F
+  }
+  public Tag tag;
+
+  public class VBool_ extends Value { 
+    public Boolean _0;
+    public VBool_() { tag = Value.Tag.VBool; }
+  }
+  public class VV2B_ extends Value { 
+    public V2<Boolean> _0;
+    public VV2B_() { tag = Value.Tag.VV2B; }
+  }
+  public class VV3B_ extends Value { 
+    public V3<Boolean> _0;
+    public VV3B_() { tag = Value.Tag.VV3B; }
+  }
+  public class VV4B_ extends Value { 
+    public V4<Boolean> _0;
+    public VV4B_() { tag = Value.Tag.VV4B; }
+  }
+  public class VWord_ extends Value { 
+    public Integer _0;
+    public VWord_() { tag = Value.Tag.VWord; }
+  }
+  public class VV2U_ extends Value { 
+    public V2<Integer> _0;
+    public VV2U_() { tag = Value.Tag.VV2U; }
+  }
+  public class VV3U_ extends Value { 
+    public V3<Integer> _0;
+    public VV3U_() { tag = Value.Tag.VV3U; }
+  }
+  public class VV4U_ extends Value { 
+    public V4<Integer> _0;
+    public VV4U_() { tag = Value.Tag.VV4U; }
+  }
+  public class VInt_ extends Value { 
+    public Integer _0;
+    public VInt_() { tag = Value.Tag.VInt; }
+  }
+  public class VV2I_ extends Value { 
+    public V2<Integer> _0;
+    public VV2I_() { tag = Value.Tag.VV2I; }
+  }
+  public class VV3I_ extends Value { 
+    public V3<Integer> _0;
+    public VV3I_() { tag = Value.Tag.VV3I; }
+  }
+  public class VV4I_ extends Value { 
+    public V4<Integer> _0;
+    public VV4I_() { tag = Value.Tag.VV4I; }
+  }
+  public class VFloat_ extends Value { 
+    public Float _0;
+    public VFloat_() { tag = Value.Tag.VFloat; }
+  }
+  public class VV2F_ extends Value { 
+    public V2<Float> _0;
+    public VV2F_() { tag = Value.Tag.VV2F; }
+  }
+  public class VV3F_ extends Value { 
+    public V3<Float> _0;
+    public VV3F_() { tag = Value.Tag.VV3F; }
+  }
+  public class VV4F_ extends Value { 
+    public V4<Float> _0;
+    public VV4F_() { tag = Value.Tag.VV4F; }
+  }
+  public class VM22F_ extends Value { 
+    public V2<V2<Float>> _0;
+    public VM22F_() { tag = Value.Tag.VM22F; }
+  }
+  public class VM23F_ extends Value { 
+    public V3<V2<Float>> _0;
+    public VM23F_() { tag = Value.Tag.VM23F; }
+  }
+  public class VM24F_ extends Value { 
+    public V4<V2<Float>> _0;
+    public VM24F_() { tag = Value.Tag.VM24F; }
+  }
+  public class VM32F_ extends Value { 
+    public V2<V3<Float>> _0;
+    public VM32F_() { tag = Value.Tag.VM32F; }
+  }
+  public class VM33F_ extends Value { 
+    public V3<V3<Float>> _0;
+    public VM33F_() { tag = Value.Tag.VM33F; }
+  }
+  public class VM34F_ extends Value { 
+    public V4<V3<Float>> _0;
+    public VM34F_() { tag = Value.Tag.VM34F; }
+  }
+  public class VM42F_ extends Value { 
+    public V2<V4<Float>> _0;
+    public VM42F_() { tag = Value.Tag.VM42F; }
+  }
+  public class VM43F_ extends Value { 
+    public V3<V4<Float>> _0;
+    public VM43F_() { tag = Value.Tag.VM43F; }
+  }
+  public class VM44F_ extends Value { 
+    public V4<V4<Float>> _0;
+    public VM44F_() { tag = Value.Tag.VM44F; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/Mesh/JSON.java b/ddl/out/java/LambdaCube/Mesh/JSON.java
new file mode 100644
index 0000000..db0641e
--- /dev/null
+++ b/ddl/out/java/LambdaCube/Mesh/JSON.java
@@ -0,0 +1,206 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.391032000000Z
+
+package LambdaCube.Mesh;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import org.json.*;
+import RT.*;
+
+
+public class JSON {
+  // JSON deserializer
+  public enum Type { 
+    Int32,
+    Word32,
+    Float,
+    String,
+    V2_Float,
+    V2_V2_Float,
+    V3_Float,
+    V3_V3_Float,
+    V4_Float,
+    V4_V4_Float,
+    Array_Int32,
+    Array_Word32,
+    Array_Float,
+    Array_V2_Float,
+    Array_V2_V2_Float,
+    Array_V3_Float,
+    Array_V3_V3_Float,
+    Array_V4_Float,
+    Array_V4_V4_Float,
+    Map_String_MeshAttribute,
+    Mesh,
+    MeshAttribute,
+    MeshPrimitive
+  }
+
+  public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception {
+    switch (type) {
+      case Int32: return (Integer)rawObj;
+      case Word32: return (Integer)rawObj;
+      case Float: return (Float)rawObj;
+      case String: return (String)rawObj;
+      case V2_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<Float>
+          ( (Float)fromJSON(Type.Float,obj.get("x"))
+          , (Float)fromJSON(Type.Float,obj.get("y"))
+          );
+      }
+      case V2_V2_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V2<V2<Float>>
+          ( (V2<Float>)fromJSON(Type.V2_Float,obj.get("x"))
+          , (V2<Float>)fromJSON(Type.V2_Float,obj.get("y"))
+          );
+      }
+      case V3_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<Float>
+          ( (Float)fromJSON(Type.Float,obj.get("x"))
+          , (Float)fromJSON(Type.Float,obj.get("y"))
+          , (Float)fromJSON(Type.Float,obj.get("z"))
+          );
+      }
+      case V3_V3_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V3<V3<Float>>
+          ( (V3<Float>)fromJSON(Type.V3_Float,obj.get("x"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("y"))
+          , (V3<Float>)fromJSON(Type.V3_Float,obj.get("z"))
+          );
+      }
+      case V4_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<Float>
+          ( (Float)fromJSON(Type.Float,obj.get("x"))
+          , (Float)fromJSON(Type.Float,obj.get("y"))
+          , (Float)fromJSON(Type.Float,obj.get("z"))
+          , (Float)fromJSON(Type.Float,obj.get("w"))
+          );
+      }
+      case V4_V4_Float: {
+        JSONObject obj = (JSONObject)rawObj;
+        return new V4<V4<Float>>
+          ( (V4<Float>)fromJSON(Type.V4_Float,obj.get("x"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("y"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("z"))
+          , (V4<Float>)fromJSON(Type.V4_Float,obj.get("w"))
+          );
+      }
+//      case Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList();
+//      case Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList();
+//      case Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
+//      case Array_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_Float, x)).ToList();
+//      case Array_V2_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_V2_Float, x)).ToList();
+//      case Array_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_Float, x)).ToList();
+//      case Array_V3_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_V3_Float, x)).ToList();
+//      case Array_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_Float, x)).ToList();
+//      case Array_V4_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_V4_Float, x)).ToList();
+/*
+      case Map_String_MeshAttribute: {
+        var map = new HashMap<String, MeshAttribute> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (MeshAttribute)fromJSON(Type.MeshAttribute,i.Value));
+        }
+        return map;
+      }
+*/
+
+      case MeshAttribute: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "A_Float": {
+            MeshAttribute.A_Float_ tv = new MeshAttribute().new A_Float_();
+            tv._0 = (ArrayList<Float>)fromJSON(Type.Array_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_V2F": {
+            MeshAttribute.A_V2F_ tv = new MeshAttribute().new A_V2F_();
+            tv._0 = (ArrayList<V2<Float>>)fromJSON(Type.Array_V2_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_V3F": {
+            MeshAttribute.A_V3F_ tv = new MeshAttribute().new A_V3F_();
+            tv._0 = (ArrayList<V3<Float>>)fromJSON(Type.Array_V3_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_V4F": {
+            MeshAttribute.A_V4F_ tv = new MeshAttribute().new A_V4F_();
+            tv._0 = (ArrayList<V4<Float>>)fromJSON(Type.Array_V4_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_M22F": {
+            MeshAttribute.A_M22F_ tv = new MeshAttribute().new A_M22F_();
+            tv._0 = (ArrayList<V2<V2<Float>>>)fromJSON(Type.Array_V2_V2_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_M33F": {
+            MeshAttribute.A_M33F_ tv = new MeshAttribute().new A_M33F_();
+            tv._0 = (ArrayList<V3<V3<Float>>>)fromJSON(Type.Array_V3_V3_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_M44F": {
+            MeshAttribute.A_M44F_ tv = new MeshAttribute().new A_M44F_();
+            tv._0 = (ArrayList<V4<V4<Float>>>)fromJSON(Type.Array_V4_V4_Float,obj.get("arg0"));
+            return tv;
+          }
+          case "A_Int": {
+            MeshAttribute.A_Int_ tv = new MeshAttribute().new A_Int_();
+            tv._0 = (ArrayList<Integer>)fromJSON(Type.Array_Int32,obj.get("arg0"));
+            return tv;
+          }
+          case "A_Word": {
+            MeshAttribute.A_Word_ tv = new MeshAttribute().new A_Word_();
+            tv._0 = (ArrayList<Integer>)fromJSON(Type.Array_Word32,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case MeshPrimitive: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        MeshPrimitive.Tag tagType;
+        switch (tag) {
+          case "P_Points": tagType = MeshPrimitive.Tag.P_Points; break;
+          case "P_TriangleStrip": tagType = MeshPrimitive.Tag.P_TriangleStrip; break;
+          case "P_Triangles": tagType = MeshPrimitive.Tag.P_Triangles; break;
+          case "P_TriangleStripI": {
+            MeshPrimitive.P_TriangleStripI_ tv = new MeshPrimitive().new P_TriangleStripI_();
+            tv._0 = (ArrayList<Integer>)fromJSON(Type.Array_Int32,obj.get("arg0"));
+            return tv;
+          }
+          case "P_TrianglesI": {
+            MeshPrimitive.P_TrianglesI_ tv = new MeshPrimitive().new P_TrianglesI_();
+            tv._0 = (ArrayList<Integer>)fromJSON(Type.Array_Int32,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        MeshPrimitive o = new MeshPrimitive();
+        o.tag = tagType;
+        return o;
+      }
+      case Mesh: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Mesh": {
+            Mesh.Mesh_ tv = new Mesh().new Mesh_();
+            tv.mAttributes = (HashMap<String, MeshAttribute>)fromJSON(Type.Map_String_MeshAttribute,obj.get("mAttributes"));
+            tv.mPrimitive = (MeshPrimitive)fromJSON(Type.MeshPrimitive,obj.get("mPrimitive"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+    }
+    throw new Exception("unknown type");
+  }
+}
\ No newline at end of file
diff --git a/ddl/out/java/LambdaCube/Mesh/Mesh.java b/ddl/out/java/LambdaCube/Mesh/Mesh.java
new file mode 100644
index 0000000..b708db9
--- /dev/null
+++ b/ddl/out/java/LambdaCube/Mesh/Mesh.java
@@ -0,0 +1,23 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.391032000000Z
+
+package LambdaCube.Mesh;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class Mesh {
+  public enum Tag { 
+    Mesh
+  }
+  public Tag tag;
+
+  public class Mesh_ extends Mesh { 
+    public HashMap<String, MeshAttribute> mAttributes;
+    public MeshPrimitive mPrimitive;
+    public Mesh_() { tag = Mesh.Tag.Mesh; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/Mesh/MeshAttribute.java b/ddl/out/java/LambdaCube/Mesh/MeshAttribute.java
new file mode 100644
index 0000000..585138c
--- /dev/null
+++ b/ddl/out/java/LambdaCube/Mesh/MeshAttribute.java
@@ -0,0 +1,62 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.391032000000Z
+
+package LambdaCube.Mesh;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class MeshAttribute {
+  public enum Tag { 
+    A_Float,
+    A_V2F,
+    A_V3F,
+    A_V4F,
+    A_M22F,
+    A_M33F,
+    A_M44F,
+    A_Int,
+    A_Word
+  }
+  public Tag tag;
+
+  public class A_Float_ extends MeshAttribute { 
+    public ArrayList<Float> _0;
+    public A_Float_() { tag = MeshAttribute.Tag.A_Float; }
+  }
+  public class A_V2F_ extends MeshAttribute { 
+    public ArrayList<V2<Float>> _0;
+    public A_V2F_() { tag = MeshAttribute.Tag.A_V2F; }
+  }
+  public class A_V3F_ extends MeshAttribute { 
+    public ArrayList<V3<Float>> _0;
+    public A_V3F_() { tag = MeshAttribute.Tag.A_V3F; }
+  }
+  public class A_V4F_ extends MeshAttribute { 
+    public ArrayList<V4<Float>> _0;
+    public A_V4F_() { tag = MeshAttribute.Tag.A_V4F; }
+  }
+  public class A_M22F_ extends MeshAttribute { 
+    public ArrayList<V2<V2<Float>>> _0;
+    public A_M22F_() { tag = MeshAttribute.Tag.A_M22F; }
+  }
+  public class A_M33F_ extends MeshAttribute { 
+    public ArrayList<V3<V3<Float>>> _0;
+    public A_M33F_() { tag = MeshAttribute.Tag.A_M33F; }
+  }
+  public class A_M44F_ extends MeshAttribute { 
+    public ArrayList<V4<V4<Float>>> _0;
+    public A_M44F_() { tag = MeshAttribute.Tag.A_M44F; }
+  }
+  public class A_Int_ extends MeshAttribute { 
+    public ArrayList<Integer> _0;
+    public A_Int_() { tag = MeshAttribute.Tag.A_Int; }
+  }
+  public class A_Word_ extends MeshAttribute { 
+    public ArrayList<Integer> _0;
+    public A_Word_() { tag = MeshAttribute.Tag.A_Word; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java b/ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java
new file mode 100644
index 0000000..8fd3b52
--- /dev/null
+++ b/ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java
@@ -0,0 +1,30 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.391032000000Z
+
+package LambdaCube.Mesh;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+
+public class MeshPrimitive {
+  public enum Tag { 
+    P_Points,
+    P_TriangleStrip,
+    P_Triangles,
+    P_TriangleStripI,
+    P_TrianglesI
+  }
+  public Tag tag;
+
+  public class P_TriangleStripI_ extends MeshPrimitive { 
+    public ArrayList<Integer> _0;
+    public P_TriangleStripI_() { tag = MeshPrimitive.Tag.P_TriangleStripI; }
+  }
+  public class P_TrianglesI_ extends MeshPrimitive { 
+    public ArrayList<Integer> _0;
+    public P_TrianglesI_() { tag = MeshPrimitive.Tag.P_TrianglesI; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/PipelineSchema/JSON.java b/ddl/out/java/LambdaCube/PipelineSchema/JSON.java
new file mode 100644
index 0000000..4303a7f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/PipelineSchema/JSON.java
@@ -0,0 +1,122 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.343859000000Z
+
+package LambdaCube.PipelineSchema;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import org.json.*;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class JSON {
+  // JSON deserializer
+  public enum Type { 
+    String,
+    Map_String_InputType,
+    Map_String_ObjectArraySchema,
+    Map_String_StreamType,
+    FetchPrimitive,
+    InputType,
+    ObjectArraySchema,
+    PipelineSchema,
+    StreamType
+  }
+
+  public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception {
+    switch (type) {
+      case String: return (String)rawObj;
+/*
+      case Map_String_InputType: {
+        var map = new HashMap<String, InputType> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (InputType)fromJSON(Type.InputType,i.Value));
+        }
+        return map;
+      }
+*/
+/*
+      case Map_String_ObjectArraySchema: {
+        var map = new HashMap<String, ObjectArraySchema> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (ObjectArraySchema)fromJSON(Type.ObjectArraySchema,i.Value));
+        }
+        return map;
+      }
+*/
+/*
+      case Map_String_StreamType: {
+        var map = new HashMap<String, StreamType> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (StreamType)fromJSON(Type.StreamType,i.Value));
+        }
+        return map;
+      }
+*/
+
+      case StreamType: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        StreamType.Tag tagType;
+        switch (tag) {
+          case "Attribute_Word": tagType = StreamType.Tag.Attribute_Word; break;
+          case "Attribute_V2U": tagType = StreamType.Tag.Attribute_V2U; break;
+          case "Attribute_V3U": tagType = StreamType.Tag.Attribute_V3U; break;
+          case "Attribute_V4U": tagType = StreamType.Tag.Attribute_V4U; break;
+          case "Attribute_Int": tagType = StreamType.Tag.Attribute_Int; break;
+          case "Attribute_V2I": tagType = StreamType.Tag.Attribute_V2I; break;
+          case "Attribute_V3I": tagType = StreamType.Tag.Attribute_V3I; break;
+          case "Attribute_V4I": tagType = StreamType.Tag.Attribute_V4I; break;
+          case "Attribute_Float": tagType = StreamType.Tag.Attribute_Float; break;
+          case "Attribute_V2F": tagType = StreamType.Tag.Attribute_V2F; break;
+          case "Attribute_V3F": tagType = StreamType.Tag.Attribute_V3F; break;
+          case "Attribute_V4F": tagType = StreamType.Tag.Attribute_V4F; break;
+          case "Attribute_M22F": tagType = StreamType.Tag.Attribute_M22F; break;
+          case "Attribute_M23F": tagType = StreamType.Tag.Attribute_M23F; break;
+          case "Attribute_M24F": tagType = StreamType.Tag.Attribute_M24F; break;
+          case "Attribute_M32F": tagType = StreamType.Tag.Attribute_M32F; break;
+          case "Attribute_M33F": tagType = StreamType.Tag.Attribute_M33F; break;
+          case "Attribute_M34F": tagType = StreamType.Tag.Attribute_M34F; break;
+          case "Attribute_M42F": tagType = StreamType.Tag.Attribute_M42F; break;
+          case "Attribute_M43F": tagType = StreamType.Tag.Attribute_M43F; break;
+          case "Attribute_M44F": tagType = StreamType.Tag.Attribute_M44F; break;
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+        StreamType o = new StreamType();
+        o.tag = tagType;
+        return o;
+      }
+      case ObjectArraySchema: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "ObjectArraySchema": {
+            ObjectArraySchema.ObjectArraySchema_ tv = new ObjectArraySchema().new ObjectArraySchema_();
+            tv.primitive = (FetchPrimitive)fromJSON(Type.FetchPrimitive,obj.get("primitive"));
+            tv.attributes = (HashMap<String, StreamType>)fromJSON(Type.Map_String_StreamType,obj.get("attributes"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case PipelineSchema: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "PipelineSchema": {
+            PipelineSchema.PipelineSchema_ tv = new PipelineSchema().new PipelineSchema_();
+            tv.objectArrays = (HashMap<String, ObjectArraySchema>)fromJSON(Type.Map_String_ObjectArraySchema,obj.get("objectArrays"));
+            tv.uniforms = (HashMap<String, InputType>)fromJSON(Type.Map_String_InputType,obj.get("uniforms"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+    }
+    throw new Exception("unknown type");
+  }
+}
\ No newline at end of file
diff --git a/ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java b/ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java
new file mode 100644
index 0000000..ffbcf56
--- /dev/null
+++ b/ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java
@@ -0,0 +1,24 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.343859000000Z
+
+package LambdaCube.PipelineSchema;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class ObjectArraySchema {
+  public enum Tag { 
+    ObjectArraySchema
+  }
+  public Tag tag;
+
+  public class ObjectArraySchema_ extends ObjectArraySchema { 
+    public FetchPrimitive primitive;
+    public HashMap<String, StreamType> attributes;
+    public ObjectArraySchema_() { tag = ObjectArraySchema.Tag.ObjectArraySchema; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java b/ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java
new file mode 100644
index 0000000..a2f22ac
--- /dev/null
+++ b/ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java
@@ -0,0 +1,24 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.343859000000Z
+
+package LambdaCube.PipelineSchema;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class PipelineSchema {
+  public enum Tag { 
+    PipelineSchema
+  }
+  public Tag tag;
+
+  public class PipelineSchema_ extends PipelineSchema { 
+    public HashMap<String, ObjectArraySchema> objectArrays;
+    public HashMap<String, InputType> uniforms;
+    public PipelineSchema_() { tag = PipelineSchema.Tag.PipelineSchema; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/PipelineSchema/StreamType.java b/ddl/out/java/LambdaCube/PipelineSchema/StreamType.java
new file mode 100644
index 0000000..75af8d5
--- /dev/null
+++ b/ddl/out/java/LambdaCube/PipelineSchema/StreamType.java
@@ -0,0 +1,39 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.343859000000Z
+
+package LambdaCube.PipelineSchema;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class StreamType {
+  public enum Tag { 
+    Attribute_Word,
+    Attribute_V2U,
+    Attribute_V3U,
+    Attribute_V4U,
+    Attribute_Int,
+    Attribute_V2I,
+    Attribute_V3I,
+    Attribute_V4I,
+    Attribute_Float,
+    Attribute_V2F,
+    Attribute_V3F,
+    Attribute_V4F,
+    Attribute_M22F,
+    Attribute_M23F,
+    Attribute_M24F,
+    Attribute_M32F,
+    Attribute_M33F,
+    Attribute_M34F,
+    Attribute_M42F,
+    Attribute_M43F,
+    Attribute_M44F
+  }
+  public Tag tag;
+
+}
+
diff --git a/ddl/out/java/LambdaCube/TypeInfo/CompileResult.java b/ddl/out/java/LambdaCube/TypeInfo/CompileResult.java
new file mode 100644
index 0000000..340d92e
--- /dev/null
+++ b/ddl/out/java/LambdaCube/TypeInfo/CompileResult.java
@@ -0,0 +1,32 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.460562000000Z
+
+package LambdaCube.TypeInfo;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class CompileResult {
+  public enum Tag { 
+    CompileError,
+    Compiled
+  }
+  public Tag tag;
+
+  public class CompileError_ extends CompileResult { 
+    public ArrayList<Range> _0;
+    public String _1;
+    public ArrayList<TypeInfo> _2;
+    public CompileError_() { tag = CompileResult.Tag.CompileError; }
+  }
+  public class Compiled_ extends CompileResult { 
+    public String _0;
+    public Pipeline _1;
+    public ArrayList<TypeInfo> _2;
+    public Compiled_() { tag = CompileResult.Tag.Compiled; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/TypeInfo/JSON.java b/ddl/out/java/LambdaCube/TypeInfo/JSON.java
new file mode 100644
index 0000000..410ce3f
--- /dev/null
+++ b/ddl/out/java/LambdaCube/TypeInfo/JSON.java
@@ -0,0 +1,85 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.460562000000Z
+
+package LambdaCube.TypeInfo;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import org.json.*;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class JSON {
+  // JSON deserializer
+  public enum Type { 
+    Int,
+    String,
+    Array_Range,
+    Array_TypeInfo,
+    CompileResult,
+    Pipeline,
+    Range,
+    TypeInfo
+  }
+
+  public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception {
+    switch (type) {
+      case Int: return (Integer)rawObj;
+      case String: return (String)rawObj;
+//      case Array_Range: return ((JArray)obj).Select(x => fromJSON (Type.Range, x)).ToList();
+//      case Array_TypeInfo: return ((JArray)obj).Select(x => fromJSON (Type.TypeInfo, x)).ToList();
+
+      case Range: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Range": {
+            Range.Range_ tv = new Range().new Range_();
+            tv.startLine = (Integer)fromJSON(Type.Int,obj.get("startLine"));
+            tv.startColumn = (Integer)fromJSON(Type.Int,obj.get("startColumn"));
+            tv.endLine = (Integer)fromJSON(Type.Int,obj.get("endLine"));
+            tv.endColumn = (Integer)fromJSON(Type.Int,obj.get("endColumn"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case TypeInfo: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "TypeInfo": {
+            TypeInfo.TypeInfo_ tv = new TypeInfo().new TypeInfo_();
+            tv.range = (Range)fromJSON(Type.Range,obj.get("range"));
+            tv.text = (String)fromJSON(Type.String,obj.get("text"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case CompileResult: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "CompileError": {
+            CompileResult.CompileError_ tv = new CompileResult().new CompileError_();
+            tv._0 = (ArrayList<Range>)fromJSON(Type.Array_Range,obj.get("arg0"));
+            tv._1 = (String)fromJSON(Type.String,obj.get("arg1"));
+            tv._2 = (ArrayList<TypeInfo>)fromJSON(Type.Array_TypeInfo,obj.get("arg2"));
+            return tv;
+          }
+          case "Compiled": {
+            CompileResult.Compiled_ tv = new CompileResult().new Compiled_();
+            tv._0 = (String)fromJSON(Type.String,obj.get("arg0"));
+            tv._1 = (Pipeline)fromJSON(Type.Pipeline,obj.get("arg1"));
+            tv._2 = (ArrayList<TypeInfo>)fromJSON(Type.Array_TypeInfo,obj.get("arg2"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+    }
+    throw new Exception("unknown type");
+  }
+}
\ No newline at end of file
diff --git a/ddl/out/java/LambdaCube/TypeInfo/Range.java b/ddl/out/java/LambdaCube/TypeInfo/Range.java
new file mode 100644
index 0000000..8bb89d4
--- /dev/null
+++ b/ddl/out/java/LambdaCube/TypeInfo/Range.java
@@ -0,0 +1,26 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.460562000000Z
+
+package LambdaCube.TypeInfo;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class Range {
+  public enum Tag { 
+    Range
+  }
+  public Tag tag;
+
+  public class Range_ extends Range { 
+    public Integer startLine;
+    public Integer startColumn;
+    public Integer endLine;
+    public Integer endColumn;
+    public Range_() { tag = Range.Tag.Range; }
+  }
+}
+
diff --git a/ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java b/ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java
new file mode 100644
index 0000000..a134fdb
--- /dev/null
+++ b/ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java
@@ -0,0 +1,24 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.460562000000Z
+
+package LambdaCube.TypeInfo;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+
+public class TypeInfo {
+  public enum Tag { 
+    TypeInfo
+  }
+  public Tag tag;
+
+  public class TypeInfo_ extends TypeInfo { 
+    public Range range;
+    public String text;
+    public TypeInfo_() { tag = TypeInfo.Tag.TypeInfo; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/ClientInfo.java b/ddl/out/java/TestData/ClientInfo.java
new file mode 100644
index 0000000..667c957
--- /dev/null
+++ b/ddl/out/java/TestData/ClientInfo.java
@@ -0,0 +1,26 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class ClientInfo {
+  public enum Tag { 
+    ClientInfo
+  }
+  public Tag tag;
+
+  public class ClientInfo_ extends ClientInfo { 
+    public String clientName;
+    public Backend clientBackend;
+    public ClientInfo_() { tag = ClientInfo.Tag.ClientInfo; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/Frame.java b/ddl/out/java/TestData/Frame.java
new file mode 100644
index 0000000..39db4a4
--- /dev/null
+++ b/ddl/out/java/TestData/Frame.java
@@ -0,0 +1,27 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class Frame {
+  public enum Tag { 
+    Frame
+  }
+  public Tag tag;
+
+  public class Frame_ extends Frame { 
+    public Integer renderCount;
+    public HashMap<String, Value> frameUniforms;
+    public HashMap<String, Integer> frameTextures;
+    public Frame_() { tag = Frame.Tag.Frame; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/FrameResult.java b/ddl/out/java/TestData/FrameResult.java
new file mode 100644
index 0000000..e1e51db
--- /dev/null
+++ b/ddl/out/java/TestData/FrameResult.java
@@ -0,0 +1,27 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class FrameResult {
+  public enum Tag { 
+    FrameResult
+  }
+  public Tag tag;
+
+  public class FrameResult_ extends FrameResult { 
+    public ArrayList<Float> frRenderTimes;
+    public Integer frImageWidth;
+    public Integer frImageHeight;
+    public FrameResult_() { tag = FrameResult.Tag.FrameResult; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/JSON.java b/ddl/out/java/TestData/JSON.java
new file mode 100644
index 0000000..4fbe47e
--- /dev/null
+++ b/ddl/out/java/TestData/JSON.java
@@ -0,0 +1,193 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import org.json.*;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class JSON {
+  // JSON deserializer
+  public enum Type { 
+    Int,
+    Float,
+    String,
+    Array_Int,
+    Array_Float,
+    Array_String,
+    Array_Frame,
+    Array_Mesh,
+    Array_PipelineInfo,
+    Array_Scene,
+    Map_String_Int,
+    Map_String_Array_Int,
+    Map_String_Value,
+    Backend,
+    ClientInfo,
+    Frame,
+    FrameResult,
+    Mesh,
+    Pipeline,
+    PipelineInfo,
+    PipelineSchema,
+    RenderJob,
+    RenderJobResult,
+    Scene,
+    Value
+  }
+
+  public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception {
+    switch (type) {
+      case Int: return (Integer)rawObj;
+      case Float: return (Float)rawObj;
+      case String: return (String)rawObj;
+//      case Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList();
+//      case Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList();
+//      case Array_String: return ((JArray)obj).Select(x => fromJSON (Type.String, x)).ToList();
+//      case Array_Frame: return ((JArray)obj).Select(x => fromJSON (Type.Frame, x)).ToList();
+//      case Array_Mesh: return ((JArray)obj).Select(x => fromJSON (Type.Mesh, x)).ToList();
+//      case Array_PipelineInfo: return ((JArray)obj).Select(x => fromJSON (Type.PipelineInfo, x)).ToList();
+//      case Array_Scene: return ((JArray)obj).Select(x => fromJSON (Type.Scene, x)).ToList();
+/*
+      case Map_String_Int: {
+        var map = new HashMap<String, Integer> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (Integer)fromJSON(Type.Int,i.Value));
+        }
+        return map;
+      }
+*/
+/*
+      case Map_String_Array_Int: {
+        var map = new HashMap<String, ArrayList<Integer>> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (ArrayList<Integer>)fromJSON(Type.Array_Int,i.Value));
+        }
+        return map;
+      }
+*/
+/*
+      case Map_String_Value: {
+        var map = new HashMap<String, Value> ();
+        foreach(var i in (JSONObject)rawObj) {
+          map.Add( (String)fromJSON(Type.String,i.Key)
+                 , (Value)fromJSON(Type.Value,i.Value));
+        }
+        return map;
+      }
+*/
+
+      case ClientInfo: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "ClientInfo": {
+            ClientInfo.ClientInfo_ tv = new ClientInfo().new ClientInfo_();
+            tv.clientName = (String)fromJSON(Type.String,obj.get("clientName"));
+            tv.clientBackend = (Backend)fromJSON(Type.Backend,obj.get("clientBackend"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Frame: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Frame": {
+            Frame.Frame_ tv = new Frame().new Frame_();
+            tv.renderCount = (Integer)fromJSON(Type.Int,obj.get("renderCount"));
+            tv.frameUniforms = (HashMap<String, Value>)fromJSON(Type.Map_String_Value,obj.get("frameUniforms"));
+            tv.frameTextures = (HashMap<String, Integer>)fromJSON(Type.Map_String_Int,obj.get("frameTextures"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case Scene: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "Scene": {
+            Scene.Scene_ tv = new Scene().new Scene_();
+            tv.objectArrays = (HashMap<String, ArrayList<Integer>>)fromJSON(Type.Map_String_Array_Int,obj.get("objectArrays"));
+            tv.renderTargetWidth = (Integer)fromJSON(Type.Int,obj.get("renderTargetWidth"));
+            tv.renderTargetHeight = (Integer)fromJSON(Type.Int,obj.get("renderTargetHeight"));
+            tv.frames = (ArrayList<Frame>)fromJSON(Type.Array_Frame,obj.get("frames"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case PipelineInfo: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "PipelineInfo": {
+            PipelineInfo.PipelineInfo_ tv = new PipelineInfo().new PipelineInfo_();
+            tv.pipelineName = (String)fromJSON(Type.String,obj.get("pipelineName"));
+            tv.pipeline = (Pipeline)fromJSON(Type.Pipeline,obj.get("pipeline"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case RenderJob: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "RenderJob": {
+            RenderJob.RenderJob_ tv = new RenderJob().new RenderJob_();
+            tv.meshes = (ArrayList<Mesh>)fromJSON(Type.Array_Mesh,obj.get("meshes"));
+            tv.textures = (ArrayList<String>)fromJSON(Type.Array_String,obj.get("textures"));
+            tv.schema = (PipelineSchema)fromJSON(Type.PipelineSchema,obj.get("schema"));
+            tv.scenes = (ArrayList<Scene>)fromJSON(Type.Array_Scene,obj.get("scenes"));
+            tv.pipelines = (ArrayList<PipelineInfo>)fromJSON(Type.Array_PipelineInfo,obj.get("pipelines"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case FrameResult: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "FrameResult": {
+            FrameResult.FrameResult_ tv = new FrameResult().new FrameResult_();
+            tv.frRenderTimes = (ArrayList<Float>)fromJSON(Type.Array_Float,obj.get("frRenderTimes"));
+            tv.frImageWidth = (Integer)fromJSON(Type.Int,obj.get("frImageWidth"));
+            tv.frImageHeight = (Integer)fromJSON(Type.Int,obj.get("frImageHeight"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+      case RenderJobResult: {
+        JSONObject obj = (JSONObject)rawObj;
+        String tag = obj.getString("tag");
+        switch (tag) {
+          case "RenderJobResult": {
+            RenderJobResult.RenderJobResult_ tv = new RenderJobResult().new RenderJobResult_();
+            tv._0 = (FrameResult)fromJSON(Type.FrameResult,obj.get("arg0"));
+            return tv;
+          }
+          case "RenderJobError": {
+            RenderJobResult.RenderJobError_ tv = new RenderJobResult().new RenderJobError_();
+            tv._0 = (String)fromJSON(Type.String,obj.get("arg0"));
+            return tv;
+          }
+          default: throw new Exception("unknown constructor: " + tag);
+        }
+      }
+    }
+    throw new Exception("unknown type");
+  }
+}
\ No newline at end of file
diff --git a/ddl/out/java/TestData/PipelineInfo.java b/ddl/out/java/TestData/PipelineInfo.java
new file mode 100644
index 0000000..6171080
--- /dev/null
+++ b/ddl/out/java/TestData/PipelineInfo.java
@@ -0,0 +1,26 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class PipelineInfo {
+  public enum Tag { 
+    PipelineInfo
+  }
+  public Tag tag;
+
+  public class PipelineInfo_ extends PipelineInfo { 
+    public String pipelineName;
+    public Pipeline pipeline;
+    public PipelineInfo_() { tag = PipelineInfo.Tag.PipelineInfo; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/RenderJob.java b/ddl/out/java/TestData/RenderJob.java
new file mode 100644
index 0000000..523cf47
--- /dev/null
+++ b/ddl/out/java/TestData/RenderJob.java
@@ -0,0 +1,29 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class RenderJob {
+  public enum Tag { 
+    RenderJob
+  }
+  public Tag tag;
+
+  public class RenderJob_ extends RenderJob { 
+    public ArrayList<Mesh> meshes;
+    public ArrayList<String> textures;
+    public PipelineSchema schema;
+    public ArrayList<Scene> scenes;
+    public ArrayList<PipelineInfo> pipelines;
+    public RenderJob_() { tag = RenderJob.Tag.RenderJob; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/RenderJobResult.java b/ddl/out/java/TestData/RenderJobResult.java
new file mode 100644
index 0000000..8a55fca
--- /dev/null
+++ b/ddl/out/java/TestData/RenderJobResult.java
@@ -0,0 +1,30 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class RenderJobResult {
+  public enum Tag { 
+    RenderJobResult,
+    RenderJobError
+  }
+  public Tag tag;
+
+  public class RenderJobResult_ extends RenderJobResult { 
+    public FrameResult _0;
+    public RenderJobResult_() { tag = RenderJobResult.Tag.RenderJobResult; }
+  }
+  public class RenderJobError_ extends RenderJobResult { 
+    public String _0;
+    public RenderJobError_() { tag = RenderJobResult.Tag.RenderJobError; }
+  }
+}
+
diff --git a/ddl/out/java/TestData/Scene.java b/ddl/out/java/TestData/Scene.java
new file mode 100644
index 0000000..ef60dde
--- /dev/null
+++ b/ddl/out/java/TestData/Scene.java
@@ -0,0 +1,28 @@
+// generated file, do not modify!
+// 2016-03-21T11:41:52.508392000000Z
+
+package TestData;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import RT.*;
+
+import LambdaCube.IR.*;
+import LambdaCube.Mesh.*;
+import LambdaCube.PipelineSchema.*;
+
+public class Scene {
+  public enum Tag { 
+    Scene
+  }
+  public Tag tag;
+
+  public class Scene_ extends Scene { 
+    public HashMap<String, ArrayList<Integer>> objectArrays;
+    public Integer renderTargetWidth;
+    public Integer renderTargetHeight;
+    public ArrayList<Frame> frames;
+    public Scene_() { tag = Scene.Tag.Scene; }
+  }
+}
+
diff --git a/ddl/templates/data.cs.ede b/ddl/templates/data.cs.ede
index c88d41c..13d20f9 100644
--- a/ddl/templates/data.cs.ede
+++ b/ddl/templates/data.cs.ede
@@ -1,27 +1,201 @@
 // generated file, do not modify!
 // {{ dateTime }}
 
+using System;
+using System.Linq;
 using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
 
 {% for m in imports %}
 using {{ m.value }};
 {% endfor %}
 
-{% for t in dataAndType %}
-{% case t.value | constType %}
-{% when "DataDef" %}
-class {{ t.value.dataName }} {
-    public enum Tag { {% for c in t.value.constructors %}
-      {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
-    };
-    public Tag tag;
-};
-
-namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
-  class {{ c.value.name }} : global::{{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
-    public {{ f.value.fieldType | csType }} {{ f.value.fieldName }};{% else %}
-    public {{ f.value.fieldType | csType | parens }} _{{ f.index0 }};{% endif %}{% endfor %}
-  };{% endif %}{% endfor %}
+namespace {{ moduleName }} {
+  {% for t in dataAndType %}
+  {% case t.value | constType %}
+  {% when "DataDef" %}
+  class {{ t.value.dataName }} {
+      public enum Tag { {% for c in t.value.constructors %}
+        {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
+      };
+      public Tag tag;
+  };
+
+  namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
+    class {{ c.value.name }} : {{ moduleName }}.{{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+      public {{ f.value.fieldType | csType }} {{ f.value.fieldName }};{% else %}
+      public {{ f.value.fieldType | csType | parens }} _{{ f.index0 }};{% endif %}{% endfor %}
+      public {{ c.value.name }}() { tag = {{ moduleName }}.{{ t.value.dataName }}.Tag.{{ c.value.name }}; }
+    };{% endif %}{% endfor %}
+  }
+  {% endcase %}
+  {% endfor %}
+
+  // JSON deserializer
+  enum Type { {% for t in usedTypes %}
+    {{ t.value | csTypeEnum }}{% if !t.last %},{% endif %}{% endfor %}
+  }
+
+  class Loader {
+    public static object fromJSON(Type type, JToken obj) {
+      switch (type) {
+        {% for t in usedTypes %}
+        {% case t.value.tag %}
+        {% when "Data" %}
+        {% when "V2" %}
+        case Type.{{ t.value | csTypeEnum }}:
+          return new {{ t.value | csType }}
+            { x = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["x"])
+            , y = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["y"])
+            };
+        {% when "V3" %}
+        case Type.{{ t.value | csTypeEnum }}:
+          return new {{ t.value | csType }}
+            { x = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["x"])
+            , y = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["y"])
+            , z = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["z"])
+            };
+        {% when "V4" %}
+        case Type.{{ t.value | csTypeEnum }}:
+          return new {{ t.value | csType }}
+            { x = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["x"])
+            , y = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["y"])
+            , z = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["z"])
+            , w = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["w"])
+            };
+        {% when "Map" %}
+        case Type.{{ t.value | csTypeEnum }}: {
+          var map = new {{ t.value | csType }} ();
+          foreach(var i in (JObject)obj) {
+            map.Add( ({{ t.value.key_ | csType }})fromJSON(Type.{{ t.value.key_ | csTypeEnum }},i.Key)
+                   , ({{ t.value.value_ | csType }})fromJSON(Type.{{ t.value.value_ | csTypeEnum }},i.Value));
+          }
+          return map;
+        }
+        {% when "Array" %}
+        case Type.{{ t.value | csTypeEnum }}: return ((JArray)obj).Select(x => fromJSON (Type.{{ t.value.type_ | csTypeEnum }}, x)).ToList();
+        {% when "List" %}
+        case Type.{{ t.value | csTypeEnum }}: return ((JArray)obj).Select(x => fromJSON (Type.{{ t.value.type_ | csTypeEnum }}, x)).ToList();
+        {% when "Maybe" %}
+        case Type.{{ t.value | csTypeEnum }}: {
+          var m = new {{ t.value | csType }} ();
+          if (obj == null || obj.Type == JTokenType.Null) {
+            m.valid = false;
+          } else {
+            m.valid = true;
+            m.data = ({{ t.value.type_ | csType }})fromJSON (Type.{{ t.value.type_ | csTypeEnum }},obj);
+          }
+          return m;
+        }
+        {% else %}
+        case Type.{{ t.value | csTypeEnum }}: return ({{ t.value | csType }})obj;
+        {% endcase %}
+        {% endfor %}
+
+        {% for t in definitions %}
+        case Type.{{ t.value.dataName }}: {
+          string tag = (string)obj["tag"];
+          {{ t.value.dataName }}.Tag tagType;
+          {% for c in t.value.constructors %}
+          {% if !c.first %}else {% endif %}if (tag == "{{ c.value.name }}") {
+            tagType = {{ t.value.dataName }}.Tag.{{ c.value.name }};
+            {% if !(c.value.fields | empty) %}
+            data.{{ c.value.name }} tv = new data.{{ c.value.name }}();{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+            tv.{{ f.value.fieldName }} = ({{ f.value.fieldType | csType }})fromJSON(Type.{{ f.value.fieldType | csTypeEnum }},obj["{{ f.value.fieldName }}"]);{% else %}
+            tv._{{ f.index0 }} = ({{ f.value.fieldType | csType }})fromJSON(Type.{{ f.value.fieldType | csTypeEnum }},obj["arg{{ f.index0 }}"]);{% endif %}{% endfor %}
+            return tv;
+            {% endif %}
+          }
+          {% endfor %}
+          else throw new Exception("unknown constructor: " + tag);
+          {{ t.value.dataName }} o = new {{ t.value.dataName }}();
+          o.tag = tagType;
+          return o;
+        }
+        {% endfor %}
+      }
+      throw new Exception("unknown type");
+      return null;
+    }
+
+    {% for t in definitions %}
+    JToken toJSON({{ t.value.dataName }} v) {
+      var obj = new JObject();
+      switch (v.tag) { {% for c in t.value.constructors %}
+        case {{ t.value.dataName }}.Tag.{{ c.value.name }}:
+          obj["tag"] = "{{ c.value.name }}";{% if !(c.value.fields | empty) %}
+          {
+            var tv = (data.{{ c.value.name }})v;{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+            obj["{{ f.value.fieldName }}"] = toJSON(tv.{{ f.value.fieldName }});{% else %}
+            obj["arg{{ f.index0 }}"] = toJSON(tv._{{ f.index0 }});{% endif %}{% endfor %}
+          }{% endif %}
+          break;{% endfor %}
+      }
+      return obj;
+    }
+    {% endfor %}
+
+    {% for t in usedCSTypes %}
+    {% case t.value.tag %}
+    {% when "Data" %}
+    {% when "V2" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      return obj;
+    }
+    {% when "V3" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      return obj;
+    }
+    {% when "V4" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      var obj = new JObject();
+      obj["x"] = toJSON(v.x);
+      obj["y"] = toJSON(v.y);
+      obj["z"] = toJSON(v.z);
+      obj["w"] = toJSON(v.w);
+      return obj;
+    }
+    {% when "Maybe" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      if (v.valid) {
+        return toJSON(v.data);
+      }
+      return new JValue((string)null);
+    }
+    {% when "Map" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      var obj = new JObject();
+      foreach (var i in v) {
+        obj[i.Key] = toJSON(i.Value);
+      }
+      return obj;
+    }
+    {% when "Array" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    {% when "List" %}
+    JToken toJSON({{ t.value | csType }} v) {
+      var obj = new JArray();
+      foreach (var i in v) {
+        obj.Add(toJSON(i));
+      }
+      return obj;
+    }
+    {% else %}
+    JToken toJSON({{ t.value | csType }} v) { return new JValue(v); }
+    {% endcase %}
+    {% endfor %}
+  }
 }
-{% endcase %}
-{% endfor %}
diff --git a/ddl/templates/data.hpp.ede b/ddl/templates/data.hpp.ede
index dab478c..5220cf4 100644
--- a/ddl/templates/data.hpp.ede
+++ b/ddl/templates/data.hpp.ede
@@ -30,7 +30,7 @@ namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | emp
 {% when "TypeAlias" %}
 {% case t.value.aliasType.tag %}
 {% when "Data" %}
-typedef {{ t.value.aliasType.contents }} {{ t.value.aliasName }};
+typedef {{ t.value.aliasType.name_ }} {{ t.value.aliasName }};
 {% else %}
 typedef {{ t.value.aliasType | cppType }} {{ t.value.aliasName }};
 {% endcase %}
diff --git a/ddl/templates/data.hpp2.ede b/ddl/templates/data.hpp2.ede
index b28562d..7ae1b13 100644
--- a/ddl/templates/data.hpp2.ede
+++ b/ddl/templates/data.hpp2.ede
@@ -34,7 +34,7 @@ public:
 {% when "TypeAlias" %}
 {% case t.value.aliasType.tag %}
 {% when "Data" %}
-typedef {{ t.value.aliasType.contents }} {{ t.value.aliasName }};
+typedef {{ t.value.aliasType.name_ }} {{ t.value.aliasName }};
 {% else %}
 typedef {{ t.value.aliasType | cppType }} {{ t.value.aliasName }};
 {% endcase %}
diff --git a/ddl/templates/data.java.ede b/ddl/templates/data.java.ede
index c85a521..2aec628 100644
--- a/ddl/templates/data.java.ede
+++ b/ddl/templates/data.java.ede
@@ -1,26 +1,27 @@
 // generated file, do not modify!
 // {{ dateTime }}
 
+package {{ moduleName }};
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
 {% for m in imports %}
-import {{ m.value }};
+import {{ m.value }}.*;
 {% endfor %}
 
-public class {{ moduleName }} {
-{% for t in dataAndType %}
-{% case t.value | constType %}
+{% case def | constType %}
 {% when "DataDef" %}
-  public class {{ t.value.dataName }} {
-    public enum Tag { {% for c in t.value.constructors %}
-      {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
-    }
-    public Tag tag;
-{% for c in t.value.constructors %}{% if !(c.value.fields | empty) %}
-    public class {{ c.value.name }}_ extends {{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
-      public {{ f.value.fieldType | javaType }} {{ f.value.fieldName }};{% else %}
-      public {{ f.value.fieldType | javaType }} _{{ f.index0 }};{% endif %}{% endfor %}
-    }{% endif %}{% endfor %}
+public class {{ def.dataName }} {
+  public enum Tag { {% for c in def.constructors %}
+    {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %}
   }
+  public Tag tag;
+{% for c in def.constructors %}{% if !(c.value.fields | empty) %}
+  public class {{ c.value.name }}_ extends {{ def.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %}
+    public {{ f.value.fieldType | javaType }} {{ f.value.fieldName }};{% else %}
+    public {{ f.value.fieldType | javaType }} _{{ f.index0 }};{% endif %}{% endfor %}
+  }{% endif %}{% endfor %}
+}
 
 {% endcase %}
-{% endfor %}
-}
\ No newline at end of file