diff --git a/android-lib/build.gradle b/android-lib/build.gradle
index 92a3adc..d76b3dc 100644
--- a/android-lib/build.gradle
+++ b/android-lib/build.gradle
@@ -8,7 +8,7 @@
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
         classpath 'com.android.tools.build:gradle:1.2.3'
         classpath 'com.jakewharton.sdkmanager:gradle-plugin:0.12.0'
-        classpath 'io.v:gradle-plugin:1.4'
+        classpath 'io.v:gradle-plugin:1.6'
     }
 }
 
@@ -59,8 +59,11 @@
     }
 }
 
+def jiriRoot = VanadiumEnvironment.getVanadiumEnvironment().jiriRoot.getAbsolutePath()
+
 vdl {
     inputPaths += 'src/main/java'
+    vdlToolPath = 'vdl'
 }
 
 public static isDarwin() {
@@ -85,7 +88,6 @@
 
 class VanadiumEnvironment {
     File jiriRoot;
-    File jiriBin;
 
     public static getVanadiumEnvironment() {
         VanadiumEnvironment result = new VanadiumEnvironment()
@@ -97,13 +99,6 @@
         }
 
         result.jiriRoot = new File(System.getenv()['JIRI_ROOT'])
-        result.jiriBin = new File(result.jiriRoot, ['.jiri_root', 'scripts', 'jiri'].join(File.separator))
-        if (!result.jiriBin.exists() || !result.jiriBin.isFile() || !result.jiriBin.canExecute()) {
-            throw new InvalidUserDataException(
-                    result.jiriBin.toString() + " does not exist or is not an executable file. "
-                    + "Please follow the Vanadium installation instructions at "
-                    + "https://vanadium.github.io/installation/")
-        }
         return result
     }
 }
@@ -124,10 +119,9 @@
 // Returns a task that will build the Vanadium native library for the given architecture.
 def buildVanadiumLib(VanadiumSupportedArchitecture arch) {
     def jiriRoot = VanadiumEnvironment.getVanadiumEnvironment().jiriRoot.getAbsolutePath()
-    def jiriBin = VanadiumEnvironment.getVanadiumEnvironment().jiriBin.getAbsolutePath()
 
     def check = task("checkVanadiumAndroidEnvironment-${arch.goArch}", type: Exec) {
-        commandLine jiriBin, 'profile', 'list',
+        commandLine 'jiri', 'profile', 'list',
                 '--info', 'Target.InstallationDir', "--target=${arch.goArch}-android", 'v23:android'
         standardOutput = new ByteArrayOutputStream()
         doLast {
@@ -150,7 +144,7 @@
         // safe here.)
         environment "GOOS", "android"
         environment "GOARCH", "${arch.goArch}"
-        commandLine jiriBin, 'go', "--target=${arch.goArch}-android", 'install',
+        commandLine 'jiri', 'go', "--target=${arch.goArch}-android", 'install',
                 '-buildmode=c-shared', '-v', '-tags', 'android',
           '-installsuffix=shared', 'v.io/x/jni/main'
     }
diff --git a/gradle-plugin/build.gradle b/gradle-plugin/build.gradle
index 4f1cbe9..8bea40a 100644
--- a/gradle-plugin/build.gradle
+++ b/gradle-plugin/build.gradle
@@ -1,6 +1,6 @@
 // You should change this after releasing a new version of the gradle plugin. See the
 // list of published versions at https://repo1.maven.org/maven2/io/v/gradle-plugin.
-def releaseVersion = '1.5'
+def releaseVersion = '1.7'
 
 buildscript {
     repositories {
diff --git a/gradle-plugin/src/main/groovy/io/v/vdl/vdl.groovy b/gradle-plugin/src/main/groovy/io/v/vdl/vdl.groovy
index c90bf1e..aba3c56 100644
--- a/gradle-plugin/src/main/groovy/io/v/vdl/vdl.groovy
+++ b/gradle-plugin/src/main/groovy/io/v/vdl/vdl.groovy
@@ -42,10 +42,10 @@
 
                 generateTask.environment(VDLROOT: getVdlRootPath(project))
                 generateTask.environment(VDLPATH: vdlPaths.join(":"))
-		String vdlToolPath = 'build/vdltool/vdl-' + getOsName()
-		if (project.vdl.vdlToolPath != "") {
-			vdlToolPath = project.vdl.vdlToolPath
-		}
+                String vdlToolPath = 'build/vdltool/vdl-' + getOsName()
+                if (project.vdl.vdlToolPath != "") {
+                    vdlToolPath = project.vdl.vdlToolPath
+                }
                 List<String> commandLine = [vdlToolPath,
                                             'generate',
                                             '--lang=java',
diff --git a/lib/build.gradle b/lib/build.gradle
index f79bd35..00250ea 100644
--- a/lib/build.gradle
+++ b/lib/build.gradle
@@ -7,7 +7,7 @@
     }
     dependencies {
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
-        classpath 'io.v:gradle-plugin:1.4'
+        classpath 'io.v:gradle-plugin:1.6'
     }
 }
 
@@ -78,13 +78,11 @@
 }
 
 def jiriRoot = VanadiumEnvironment.getVanadiumEnvironment().jiriRoot.getAbsolutePath()
-def jiriBin = VanadiumEnvironment.getVanadiumEnvironment().jiriBin.getAbsolutePath()
 
 sourceSets.main.java.srcDirs += 'generated-src/vdl'
 
 class VanadiumEnvironment {
     File jiriRoot;
-    File jiriBin;
 
     public static getVanadiumEnvironment() {
         VanadiumEnvironment result = new VanadiumEnvironment()
@@ -96,13 +94,6 @@
         }
 
         result.jiriRoot = new File(System.getenv()['JIRI_ROOT'])
-        result.jiriBin = new File(result.jiriRoot, ['.jiri_root', 'scripts', 'jiri'].join(File.separator))
-        if (!result.jiriBin.exists() || !result.jiriBin.isFile() || !result.jiriBin.canExecute()) {
-            throw new InvalidUserDataException(
-                    result.jiriBin.toString() + " does not exist or is not an executable file. "
-                    + "Please follow the Vanadium installation instructions at "
-                    + "https://vanadium.github.io/installation/")
-        }
         return result
     }
 }
@@ -134,7 +125,7 @@
 
     // NOTE(spetrovic): we add the '-installsuffix=shared' flag because the build doesn't work
     // without it on linux/arm.  (There is some conflict with "regular", i.e., non-shared builds).
-    commandLine jiriBin, 'go', '--profiles=v23:java', 'install', '-buildmode=c-shared', '-v',
+    commandLine 'jiri', 'go', '--profiles=v23:java', 'install', '-buildmode=c-shared', '-v',
                 '-tags', 'java', '-installsuffix=shared', 'v.io/x/jni/main'
 }
 
@@ -333,7 +324,7 @@
     inputPaths += [jiriRoot, 'release', 'go', 'src'].join(File.separator)
     vdlRootPath = [jiriRoot, 'release', 'go', 'src', 'v.io', 'v23', 'vdlroot'].join(File.separator)
     generateVdlRoot = true
-    vdlToolPath = [jiriRoot, 'release', 'go', 'bin', 'vdl'].join(File.separator)
+    vdlToolPath = 'vdl'
 }
 
 bintray {
diff --git a/lib/src/main/java/io/v/v23/vdl/Kind.java b/lib/src/main/java/io/v/v23/vdl/Kind.java
index 66130f9..5d69118 100644
--- a/lib/src/main/java/io/v/v23/vdl/Kind.java
+++ b/lib/src/main/java/io/v/v23/vdl/Kind.java
@@ -19,8 +19,6 @@
     INT64,
     FLOAT32,
     FLOAT64,
-    COMPLEX64,
-    COMPLEX128,
     STRING,
     ENUM,
     TYPEOBJECT,
diff --git a/lib/src/main/java/io/v/v23/vdl/Types.java b/lib/src/main/java/io/v/v23/vdl/Types.java
index 10d6c1d..6215464 100644
--- a/lib/src/main/java/io/v/v23/vdl/Types.java
+++ b/lib/src/main/java/io/v/v23/vdl/Types.java
@@ -101,16 +101,6 @@
     public static final VdlType FLOAT64 = createPrimitiveType(Kind.FLOAT64);
 
     /**
-     * The {@code VdlType} object representing the VDL type complex64, it is unnamed.
-     */
-    public static final VdlType COMPLEX64 = createPrimitiveType(Kind.COMPLEX64);
-
-    /**
-     * The {@code VdlType} object representing the VDL type complex128, it is unnamed.
-     */
-    public static final VdlType COMPLEX128 = createPrimitiveType(Kind.COMPLEX128);
-
-    /**
      * The {@code VdlType} object representing the VDL type string, it is unnamed.
      */
     public static final VdlType STRING = createPrimitiveType(Kind.STRING);
@@ -138,8 +128,6 @@
         typeCache.put(VdlInt64.class, INT64);
         typeCache.put(VdlFloat32.class, FLOAT32);
         typeCache.put(VdlFloat64.class, FLOAT64);
-        typeCache.put(VdlComplex64.class, COMPLEX64);
-        typeCache.put(VdlComplex128.class, COMPLEX128);
         typeCache.put(VdlString.class, STRING);
         typeCache.put(VdlTypeObject.class, TYPEOBJECT);
 
@@ -214,10 +202,6 @@
                 return FLOAT32;
             case FLOAT64:
                 return FLOAT64;
-            case COMPLEX64:
-                return COMPLEX64;
-            case COMPLEX128:
-                return COMPLEX128;
             case STRING:
                 return STRING;
             case TYPEOBJECT:
@@ -384,10 +368,6 @@
                 return Boolean.class;
             case BYTE:
                 return Byte.class;
-            case COMPLEX128:
-                return VdlComplex128.class;
-            case COMPLEX64:
-                return VdlComplex64.class;
             case FLOAT32:
                 return Float.class;
             case FLOAT64:
diff --git a/lib/src/main/java/io/v/v23/vdl/VdlComplex128.java b/lib/src/main/java/io/v/v23/vdl/VdlComplex128.java
deleted file mode 100644
index 0140d06..0000000
--- a/lib/src/main/java/io/v/v23/vdl/VdlComplex128.java
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package io.v.v23.vdl;
-
-/**
- * VdlComplex128 is a representation of a VDL complex128.
- */
-public class VdlComplex128 extends VdlValue {
-    private static final long serialVersionUID = 1L;
-
-    private final double real;
-    private final double imag;
-
-    public VdlComplex128(VdlType type, double real, double imag) {
-        super(type);
-        assertKind(Kind.COMPLEX128);
-        this.real = real;
-        this.imag = imag;
-    }
-
-    public VdlComplex128(double real, double imag) {
-        this(Types.COMPLEX128, real, imag);
-    }
-
-    public VdlComplex128(double real) {
-        this(real, 0);
-    }
-
-    public VdlComplex128() {
-        this(0, 0);
-    }
-
-    public double getReal() {
-        return real;
-    }
-
-    public double getImag() {
-        return imag;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (!(obj instanceof VdlComplex128)) return false;
-        VdlComplex128 other = (VdlComplex128) obj;
-        return real == other.real && imag == other.imag;
-    }
-
-    @Override
-    public int hashCode() {
-        return Double.valueOf(real).hashCode() ^ Double.valueOf(imag).hashCode();
-    }
-
-    @Override
-    public String toString() {
-        return "{real=" + Double.toString(real) + ", imag=" + Double.toString(imag) + "}";
-    }
-}
diff --git a/lib/src/main/java/io/v/v23/vdl/VdlComplex64.java b/lib/src/main/java/io/v/v23/vdl/VdlComplex64.java
deleted file mode 100644
index 1766ab4..0000000
--- a/lib/src/main/java/io/v/v23/vdl/VdlComplex64.java
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2015 The Vanadium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package io.v.v23.vdl;
-
-/**
- * VdlComplex64 is a representation of a VDL complex64.
- */
-public class VdlComplex64 extends VdlValue {
-    private static final long serialVersionUID = 1L;
-
-    private final float real;
-    private final float imag;
-
-    public VdlComplex64(VdlType type, float real, float imag) {
-        super(type);
-        assertKind(Kind.COMPLEX64);
-        this.real = real;
-        this.imag = imag;
-    }
-
-    public VdlComplex64(float real, float imag) {
-        this(Types.COMPLEX64, real, imag);
-    }
-
-    public VdlComplex64(float real) {
-        this(real, 0);
-    }
-
-    public VdlComplex64() {
-        this(0, 0);
-    }
-
-    public float getReal() {
-        return real;
-    }
-
-    public float getImag() {
-        return imag;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (this == obj) return true;
-        if (!(obj instanceof VdlComplex64)) return false;
-        VdlComplex64 other = (VdlComplex64) obj;
-        return real == other.real && imag == other.imag;
-    }
-
-    @Override
-    public int hashCode() {
-        return Float.valueOf(real).hashCode() ^ Float.valueOf(imag).hashCode();
-    }
-
-    @Override
-    public String toString() {
-        return "{real=" + Float.toString(real) + ", imag=" + Float.toString(imag) + "}";
-    }
-}
diff --git a/lib/src/main/java/io/v/v23/vdl/VdlValue.java b/lib/src/main/java/io/v/v23/vdl/VdlValue.java
index b123df0..de6a453 100644
--- a/lib/src/main/java/io/v/v23/vdl/VdlValue.java
+++ b/lib/src/main/java/io/v/v23/vdl/VdlValue.java
@@ -111,10 +111,6 @@
                 return new VdlBool();
             case BYTE:
                 return new VdlByte();
-            case COMPLEX128:
-                return new VdlComplex128(0);
-            case COMPLEX64:
-                return new VdlComplex64(0);
             case ENUM:
                 return new VdlEnum(type, type.getLabels().get(0));
             case FLOAT32:
diff --git a/lib/src/main/java/io/v/v23/vom/BinaryDecoder.java b/lib/src/main/java/io/v/v23/vom/BinaryDecoder.java
index b4c011d..e9323a0 100644
--- a/lib/src/main/java/io/v/v23/vom/BinaryDecoder.java
+++ b/lib/src/main/java/io/v/v23/vom/BinaryDecoder.java
@@ -217,9 +217,6 @@
                 return readVdlBool(target);
             case BYTE:
                 return readVdlByte(target);
-            case COMPLEX64:
-            case COMPLEX128:
-                return readVdlComplex(target);
             case ENUM:
                 return readVdlEnum(actualType, target);
             case FLOAT32:
@@ -375,11 +372,6 @@
         return ConvertUtil.convertFromByte(b, target);
     }
 
-    private Object readVdlComplex(ConversionTarget target) throws IOException, ConversionException {
-        return ConvertUtil.convertFromComplex(BinaryUtil.decodeDouble(in),
-                BinaryUtil.decodeDouble(in), target);
-    }
-
     private Object readVdlEnum(VdlType actualType, ConversionTarget target) throws IOException,
             ConversionException {
         int enumIndex = (int) BinaryUtil.decodeUint(in);
diff --git a/lib/src/main/java/io/v/v23/vom/BinaryEncoder.java b/lib/src/main/java/io/v/v23/vom/BinaryEncoder.java
index 4296d00..3182060 100644
--- a/lib/src/main/java/io/v/v23/vom/BinaryEncoder.java
+++ b/lib/src/main/java/io/v/v23/vom/BinaryEncoder.java
@@ -11,8 +11,6 @@
 import io.v.v23.vdl.VdlArray;
 import io.v.v23.vdl.VdlBool;
 import io.v.v23.vdl.VdlByte;
-import io.v.v23.vdl.VdlComplex128;
-import io.v.v23.vdl.VdlComplex64;
 import io.v.v23.vdl.VdlEnum;
 import io.v.v23.vdl.VdlField;
 import io.v.v23.vdl.VdlFloat32;
@@ -192,8 +190,6 @@
             case INT64:
             case FLOAT32:
             case FLOAT64:
-            case COMPLEX64:
-            case COMPLEX128:
             case STRING:
                 return new WireType.NamedT(new WireNamed(
                         type.getName(), getTypeInternal(Types.primitiveTypeFromKind(type.getKind()), pending)));
@@ -286,9 +282,6 @@
                 }
             case BOOL:
                 return writeVdlBool(out, value);
-            case COMPLEX64:
-            case COMPLEX128:
-                return writeVdlComplex(out, value);
             case ENUM:
                 return writeVdlEnum(out, value);
             case FLOAT32:
@@ -464,24 +457,6 @@
     }
 
     /**
-     * Writes a VDL complex to output stream and returns true iff the value is non-zero.
-     */
-    private boolean writeVdlComplex(EncodingStream out, Object value) throws IOException {
-        if (value instanceof VdlComplex64) {
-            boolean isNonZero = BinaryUtil.encodeDouble(out, ((VdlComplex64) value).getReal());
-            isNonZero |= BinaryUtil.encodeDouble(out, ((VdlComplex64) value).getImag());
-            return isNonZero;
-        } else if (value instanceof VdlComplex128) {
-            boolean isNonZero = BinaryUtil.encodeDouble(out, ((VdlComplex128) value).getReal());
-            isNonZero |= BinaryUtil.encodeDouble(out, ((VdlComplex128) value).getImag());
-            return isNonZero;
-        } else {
-            throw new IOException("Unsupported VDL complex value (type " + value.getClass()
-                    + ", value " + value + ")");
-        }
-    }
-
-    /**
      * Writes a VDL enum to output stream and returns true iff the value is non-zero.
      */
     private boolean writeVdlEnum(EncodingStream out, Object value) throws IOException {
diff --git a/lib/src/main/java/io/v/v23/vom/BinaryUtil.java b/lib/src/main/java/io/v/v23/vom/BinaryUtil.java
index cb8fa43..7fcfdd4 100644
--- a/lib/src/main/java/io/v/v23/vom/BinaryUtil.java
+++ b/lib/src/main/java/io/v/v23/vom/BinaryUtil.java
@@ -158,8 +158,6 @@
         switch (type.getKind()) {
             case ANY:
             case ARRAY:
-            case COMPLEX64:
-            case COMPLEX128:
             case LIST:
             case MAP:
             case OPTIONAL:
diff --git a/lib/src/main/java/io/v/v23/vom/BootstrapType.java b/lib/src/main/java/io/v/v23/vom/BootstrapType.java
index 9c81e97..c044561 100644
--- a/lib/src/main/java/io/v/v23/vom/BootstrapType.java
+++ b/lib/src/main/java/io/v/v23/vom/BootstrapType.java
@@ -34,8 +34,6 @@
                 .put(Types.INT64, Constants.WIRE_ID_INT_64)
                 .put(Types.FLOAT32, Constants.WIRE_ID_FLOAT_32)
                 .put(Types.FLOAT64, Constants.WIRE_ID_FLOAT_64)
-                .put(Types.COMPLEX64, Constants.WIRE_ID_COMPLEX_64)
-                .put(Types.COMPLEX128, Constants.WIRE_ID_COMPLEX_128)
                 .put(Types.TYPEOBJECT, Constants.WIRE_ID_TYPE_OBJECT)
                 .put(Types.ANY, Constants.WIRE_ID_ANY)
 
diff --git a/lib/src/main/java/io/v/v23/vom/ConversionTarget.java b/lib/src/main/java/io/v/v23/vom/ConversionTarget.java
index 8c552cf..a8602ad 100644
--- a/lib/src/main/java/io/v/v23/vom/ConversionTarget.java
+++ b/lib/src/main/java/io/v/v23/vom/ConversionTarget.java
@@ -11,8 +11,6 @@
 import io.v.v23.vdl.VdlArray;
 import io.v.v23.vdl.VdlBool;
 import io.v.v23.vdl.VdlByte;
-import io.v.v23.vdl.VdlComplex128;
-import io.v.v23.vdl.VdlComplex64;
 import io.v.v23.vdl.VdlEnum;
 import io.v.v23.vdl.VdlFloat32;
 import io.v.v23.vdl.VdlFloat64;
@@ -50,8 +48,6 @@
             case ARRAY: return new TypeToken<VdlArray<VdlValue>>(){}.getType();
             case BOOL: return VdlBool.class;
             case BYTE: return VdlByte.class;
-            case COMPLEX128: return VdlComplex128.class;
-            case COMPLEX64: return VdlComplex64.class;
             case ENUM: return VdlEnum.class;
             case FLOAT32: return VdlFloat32.class;
             case FLOAT64: return VdlFloat64.class;
diff --git a/lib/src/main/java/io/v/v23/vom/ConvertUtil.java b/lib/src/main/java/io/v/v23/vom/ConvertUtil.java
index 166d35c..7d58008 100644
--- a/lib/src/main/java/io/v/v23/vom/ConvertUtil.java
+++ b/lib/src/main/java/io/v/v23/vom/ConvertUtil.java
@@ -101,7 +101,7 @@
     }
 
     /**
-     * Converts uint values to uint, int, float or complex values only.
+     * Converts uint values to uint, int or float values only.
      * This is used to check O(n) conversion rules instead of O(n^2) for n numeric types.
      */
     private static Object convertUint(long value, ConversionTarget target)
@@ -133,7 +133,7 @@
     }
 
     /**
-     * Converts int values to int, float or complex values only.
+     * Converts int values to int or float values only.
      * This is used to check O(n) conversion rules instead of O(n^2) for n numeric types.
      */
     private static Object convertInt(long value, ConversionTarget target)
@@ -157,7 +157,6 @@
             case INT64:
                 return ReflectUtil.createPrimitive(target, value, Long.TYPE);
             case FLOAT32:
-            case COMPLEX64:
                 if (ConvertUtil.canConvertIntToFloat(value, 32)) {
                     return convertDouble(value, target);
                 }
@@ -171,7 +170,7 @@
     }
 
     /**
-     * Converts float values to float or complex values only.
+     * Converts float values to float values only.
      * This is used to check O(n) conversion rules instead of O(n^2) for n numeric types.
      */
     private static Object convertDouble(double value, ConversionTarget target)
@@ -181,36 +180,26 @@
                 return ReflectUtil.createPrimitive(target, (float) value, Float.TYPE);
             case FLOAT64:
                 return ReflectUtil.createPrimitive(target, value, Double.TYPE);
-            default:
-                return convertComplex(value, 0, target);
         }
+        throw new ConversionException("Can't convert " + value + " to " + target.getTargetType());
     }
 
     /**
-     * Converts complex values to complex values only.
-     * This is used to check O(n) conversion rules instead of O(n^2) for n numeric types.
-     */
-    private static Object convertComplex(double real, double imag, ConversionTarget target)
-            throws ConversionException {
-        return ReflectUtil.createComplex(target, real, imag);
-    }
-
-    /**
-     * Converts from uint to number, one of uint, int, float or complex.
+     * Converts from uint to number, one of uint, int or float.
      */
     static Object convertFromUint(long value, ConversionTarget target) throws ConversionException {
         return convertUint(value, target);
     }
 
     /**
-     * Converts from byte to number, one of uint, int, float or complex.
+     * Converts from byte to number, one of uint, int or float.
      */
     static Object convertFromByte(byte value, ConversionTarget target) throws ConversionException {
         return convertUint(value & 0xffL, target);
     }
 
     /**
-     * Converts from int to number, one of uint, int, float or complex.
+     * Converts from int to number, one of uint, int or float.
      */
     static Object convertFromInt(long value, ConversionTarget target) throws ConversionException {
         if (canConvertIntToUint(value, 64)) {
@@ -221,7 +210,7 @@
     }
 
     /**
-     * Converts from float to number, one of uint, int, float or complex.
+     * Converts from float to number, one of uint, int or float.
      */
     static Object convertFromDouble(double value, ConversionTarget target)
             throws ConversionException {
@@ -233,8 +222,6 @@
                 break;
             case FLOAT32:
             case FLOAT64:
-            case COMPLEX128:
-            case COMPLEX64:
                 break;
             default:
                 if (canConvertFloatToInt(value, 64)) {
@@ -245,18 +232,6 @@
     }
 
     /**
-     * Converts from complex to number, one of uint, int, float or complex.
-     */
-    static Object convertFromComplex(double real, double imag, ConversionTarget target)
-            throws ConversionException {
-        if (imag == 0) {
-            return convertFromDouble(real, target);
-        } else {
-            return convertComplex(real, imag, target);
-        }
-    }
-
-    /**
      * Converts from []byte to []number, [N]number, string or enum.
      */
     static Object convertFromBytes(byte[] bytes, ConversionTarget target)
diff --git a/lib/src/main/java/io/v/v23/vom/ReflectUtil.java b/lib/src/main/java/io/v/v23/vom/ReflectUtil.java
index fcbd55d..92771d8 100644
--- a/lib/src/main/java/io/v/v23/vom/ReflectUtil.java
+++ b/lib/src/main/java/io/v/v23/vom/ReflectUtil.java
@@ -5,8 +5,6 @@
 package io.v.v23.vom;
 
 import io.v.v23.vdl.VdlArray;
-import io.v.v23.vdl.VdlComplex128;
-import io.v.v23.vdl.VdlComplex64;
 import io.v.v23.vdl.VdlEnum;
 import io.v.v23.vdl.VdlList;
 import io.v.v23.vdl.VdlMap;
@@ -57,32 +55,6 @@
     }
 
     /**
-     * Creates an instance of VDL complex. The target class should be inherited from
-     * {@code VdlValue}.
-     */
-    static VdlValue createComplex(ConversionTarget target, double real, double imag)
-            throws ConversionException {
-        Class<?> targetClass = target.getTargetClass();
-        try {
-            if (targetClass == VdlComplex64.class) {
-                return new VdlComplex64(target.getVdlType(), (float) real, (float) imag);
-            } else if (targetClass == VdlComplex128.class) {
-                return new VdlComplex128(target.getVdlType(), real, imag);
-            } else if (VdlComplex64.class.isAssignableFrom(targetClass)) {
-                return (VdlValue) targetClass.getConstructor(Float.TYPE, Float.TYPE)
-                        .newInstance((float) real, (float) imag);
-            } else if (VdlComplex128.class.isAssignableFrom(targetClass)) {
-                return (VdlValue) targetClass.getConstructor(Double.TYPE, Double.TYPE)
-                        .newInstance(real, imag);
-            }
-        } catch (Exception e) {
-            throw new ConversionException(
-                    new VdlComplex128(real, imag), targetClass, e);
-        }
-        throw new ConversionException(new VdlComplex128(real, imag), targetClass);
-    }
-
-    /**
      * Creates an instance of VDL enum. The target class should be inherited from {@code VdlEnum}.
      */
     static VdlEnum createEnum(ConversionTarget target, String label) throws ConversionException {
diff --git a/lib/src/main/java/io/v/v23/vom/TypeCompatibility.java b/lib/src/main/java/io/v/v23/vom/TypeCompatibility.java
index 96de1e6..4257deb 100644
--- a/lib/src/main/java/io/v/v23/vom/TypeCompatibility.java
+++ b/lib/src/main/java/io/v/v23/vom/TypeCompatibility.java
@@ -139,8 +139,6 @@
     private static boolean isNumber(VdlType type) {
         switch (type.getKind()) {
             case BYTE:
-            case COMPLEX128:
-            case COMPLEX64:
             case FLOAT32:
             case FLOAT64:
             case INT16:
diff --git a/lib/src/test/java/io/v/v23/vdl/TypeTest.java b/lib/src/test/java/io/v/v23/vdl/TypeTest.java
index efe0169..02161b5 100644
--- a/lib/src/test/java/io/v/v23/vdl/TypeTest.java
+++ b/lib/src/test/java/io/v/v23/vdl/TypeTest.java
@@ -66,14 +66,6 @@
     private static final class MyString extends VdlString {
         private static final long serialVersionUID = 1L;
     }
-    @GeneratedFromVdl(name = "MyComplex64")
-    private static final class MyComplex64 extends VdlComplex64 {
-        private static final long serialVersionUID = 1L;
-    }
-    @GeneratedFromVdl(name = "MyComplex128")
-    private static final class MyComplex128 extends VdlComplex128 {
-        private static final long serialVersionUID = 1L;
-    }
 
     @SuppressWarnings("unused")
     @GeneratedFromVdl(name = "MyUnion")
@@ -178,8 +170,6 @@
         VdlType myFloat32 = Types.named("MyFloat32", Types.FLOAT32);
         VdlType myFloat64 = Types.named("MyFloat64", Types.FLOAT64);
         VdlType myString = Types.named("MyString", Types.STRING);
-        VdlType myComplex64 = Types.named("MyComplex64", Types.COMPLEX64);
-        VdlType myComplex128 = Types.named("MyComplex128", Types.COMPLEX128);
 
         VdlType myUnion = Types.named("MyUnion", Types.unionOf(new VdlField("A", myInt16),
                 new VdlField("B", Types.INT32), new VdlField("C", Types.INT64)));
@@ -210,8 +200,6 @@
                 .put(myFloat32, MyFloat32.class)
                 .put(myFloat64, MyFloat64.class)
                 .put(myString, MyString.class)
-                .put(myComplex64, MyComplex64.class)
-                .put(myComplex128, MyComplex128.class)
                 .put(myUnion, MyUnion.class)
                 .put(myEnum, MyEnum.class)
                 .put(myArray12, MyArray12.class)
diff --git a/lib/src/test/java/io/v/v23/vom/BinaryEncoderTest.java b/lib/src/test/java/io/v/v23/vom/BinaryEncoderTest.java
index 002b3ef..9abb3a4 100644
--- a/lib/src/test/java/io/v/v23/vom/BinaryEncoderTest.java
+++ b/lib/src/test/java/io/v/v23/vom/BinaryEncoderTest.java
@@ -13,8 +13,6 @@
 import io.v.v23.vdl.Types;
 import io.v.v23.vdl.VdlAny;
 import io.v.v23.vdl.VdlArray;
-import io.v.v23.vdl.VdlComplex128;
-import io.v.v23.vdl.VdlComplex64;
 import io.v.v23.vdl.VdlEnum;
 import io.v.v23.vdl.VdlField;
 import io.v.v23.vdl.VdlOptional;
@@ -37,8 +35,6 @@
                     new VdlArray<Integer>(Types.arrayOf(4, Types.INT32), new Integer[]{0, 0, 0, 0}))
             .put(Types.BOOL, false)
             .put(Types.BYTE, (byte) 0)
-            .put(Types.COMPLEX128, new VdlComplex128(0, 0))
-            .put(Types.COMPLEX64, new VdlComplex64(0, 0))
             .put(Types.enumOf("A", "B", "C"), new VdlEnum(Types.enumOf("A", "B", "C"), "A"))
             .put(Types.FLOAT32, 0f)
             .put(Types.FLOAT64, 0.)
diff --git a/lib/src/test/java/io/v/v23/vom/ConvertUtilTest.java b/lib/src/test/java/io/v/v23/vom/ConvertUtilTest.java
index 253fed8..15b07a5 100644
--- a/lib/src/test/java/io/v/v23/vom/ConvertUtilTest.java
+++ b/lib/src/test/java/io/v/v23/vom/ConvertUtilTest.java
@@ -10,8 +10,6 @@
 
 import io.v.v23.vdl.Types;
 import io.v.v23.vdl.VdlByte;
-import io.v.v23.vdl.VdlComplex128;
-import io.v.v23.vdl.VdlComplex64;
 import io.v.v23.vdl.VdlFloat32;
 import io.v.v23.vdl.VdlFloat64;
 import io.v.v23.vdl.VdlInt16;
@@ -24,8 +22,6 @@
 import io.v.v23.vdl.VdlUint64;
 import io.v.v23.vom.testdata.types.NArray2Uint64;
 import io.v.v23.vom.testdata.types.NByte;
-import io.v.v23.vom.testdata.types.NComplex128;
-import io.v.v23.vom.testdata.types.NComplex64;
 import io.v.v23.vom.testdata.types.NEnum;
 import io.v.v23.vom.testdata.types.NFloat32;
 import io.v.v23.vom.testdata.types.NFloat64;
@@ -77,85 +73,74 @@
         {Long.TYPE, Long.class, VdlInt64.class, NInt64.class},
         {Float.TYPE, Float.class, VdlFloat32.class, NFloat32.class},
         {Double.TYPE, Double.class, VdlFloat64.class, NFloat64.class},
-        {NComplex64.class, VdlComplex64.class},
-        {NComplex128.class, VdlComplex128.class}
     };
 
     private static final NumericConversionTestCase[] numericTests = {
+        // TODO(bprosnitz) This test is really cryptic - it should probably use a list or set of types instead.
         // bytes
-        new NumericConversionTestCase((byte) 0,                                 "11111111111"),
-        new NumericConversionTestCase((byte) 0xf,                               "11111111111"),
-        new NumericConversionTestCase((byte) 0xff,                              "11111111111"),
+        new NumericConversionTestCase((byte) 0,                                 "111111111"),
+        new NumericConversionTestCase((byte) 0xf,                               "111111111"),
+        new NumericConversionTestCase((byte) 0xff,                              "111111111"),
         // uints
-        new NumericConversionTestCase(new VdlUint64(0L),                        "11111111111"),
-        new NumericConversionTestCase(new VdlUint64(0xfL),                      "11111111111"),
-        new NumericConversionTestCase(new VdlUint64(0xffL),                     "11111111111"),
-        new NumericConversionTestCase(new VdlUint64(0xfffL),                    "01111111111"),
-        new NumericConversionTestCase(new VdlUint64(0x7ffL),                    "01111111111"),
-        new NumericConversionTestCase(new VdlUint64(0xffffL),                   "01110111111"),
-        new NumericConversionTestCase(new VdlUint64(0xffffffL),                 "00110111111"),
-        new NumericConversionTestCase(new VdlUint64(0x1000000L),                "00110111111"),
-        new NumericConversionTestCase(new VdlUint64(0x1000001L),                "00110110101"),
-        new NumericConversionTestCase(new VdlUint64(0x7fffffffL),               "00110110101"),
-        new NumericConversionTestCase(new VdlUint64(0xffffffffL),               "00110010101"),
-        new NumericConversionTestCase(new VdlUint64(0xffffffffffffL),           "00010010101"),
-        new NumericConversionTestCase(new VdlUint64(0x20000000000000L),         "00010010101"),
-        new NumericConversionTestCase(new VdlUint64(0x20000000000001L),         "00010010000"),
-        new NumericConversionTestCase(new VdlUint64(0x7fffffffffffffffL),       "00010010000"),
-        new NumericConversionTestCase(new VdlUint64(0xffffffffffffffffL),       "00010000000"),
+        new NumericConversionTestCase(new VdlUint64(0L),                        "111111111"),
+        new NumericConversionTestCase(new VdlUint64(0xfL),                      "111111111"),
+        new NumericConversionTestCase(new VdlUint64(0xffL),                     "111111111"),
+        new NumericConversionTestCase(new VdlUint64(0xfffL),                    "011111111"),
+        new NumericConversionTestCase(new VdlUint64(0x7ffL),                    "011111111"),
+        new NumericConversionTestCase(new VdlUint64(0xffffL),                   "011101111"),
+        new NumericConversionTestCase(new VdlUint64(0xffffffL),                 "001101111"),
+        new NumericConversionTestCase(new VdlUint64(0x1000000L),                "001101111"),
+        new NumericConversionTestCase(new VdlUint64(0x1000001L),                "001101101"),
+        new NumericConversionTestCase(new VdlUint64(0x7fffffffL),               "001101101"),
+        new NumericConversionTestCase(new VdlUint64(0xffffffffL),               "001100101"),
+        new NumericConversionTestCase(new VdlUint64(0xffffffffffffL),           "000100101"),
+        new NumericConversionTestCase(new VdlUint64(0x20000000000000L),         "000100101"),
+        new NumericConversionTestCase(new VdlUint64(0x20000000000001L),         "000100100"),
+        new NumericConversionTestCase(new VdlUint64(0x7fffffffffffffffL),       "000100100"),
+        new NumericConversionTestCase(new VdlUint64(0xffffffffffffffffL),       "000100000"),
         // positive ints
-        new NumericConversionTestCase(0L,                                       "11111111111"),
-        new NumericConversionTestCase(0xfL,                                     "11111111111"),
-        new NumericConversionTestCase(0xffL,                                    "11111111111"),
-        new NumericConversionTestCase(0xfffL,                                   "01111111111"),
-        new NumericConversionTestCase(0x7ffL,                                   "01111111111"),
-        new NumericConversionTestCase(0xffffL,                                  "01110111111"),
-        new NumericConversionTestCase(0xffffffL,                                "00110111111"),
-        new NumericConversionTestCase(0x1000000L,                               "00110111111"),
-        new NumericConversionTestCase(0x1000001L,                               "00110110101"),
-        new NumericConversionTestCase(0x7fffffffL,                              "00110110101"),
-        new NumericConversionTestCase(0xffffffffL,                              "00110010101"),
-        new NumericConversionTestCase(0xffffffffffffL,                          "00010010101"),
-        new NumericConversionTestCase(0x20000000000000L,                        "00010010101"),
-        new NumericConversionTestCase(0x7fffffffffffffffL,                      "00010010000"),
+        new NumericConversionTestCase(0L,                                       "111111111"),
+        new NumericConversionTestCase(0xfL,                                     "111111111"),
+        new NumericConversionTestCase(0xffL,                                    "111111111"),
+        new NumericConversionTestCase(0xfffL,                                   "011111111"),
+        new NumericConversionTestCase(0x7ffL,                                   "011111111"),
+        new NumericConversionTestCase(0xffffL,                                  "011101111"),
+        new NumericConversionTestCase(0xffffffL,                                "001101111"),
+        new NumericConversionTestCase(0x1000000L,                               "001101111"),
+        new NumericConversionTestCase(0x1000001L,                               "001101101"),
+        new NumericConversionTestCase(0x7fffffffL,                              "001101101"),
+        new NumericConversionTestCase(0xffffffffL,                              "001100101"),
+        new NumericConversionTestCase(0xffffffffffffL,                          "000100101"),
+        new NumericConversionTestCase(0x20000000000000L,                        "000100101"),
+        new NumericConversionTestCase(0x7fffffffffffffffL,                      "000100100"),
         // negative ints
-        new NumericConversionTestCase(-1L,                                      "00001111111"),
-        new NumericConversionTestCase(-0x10L,                                   "00001111111"),
-        new NumericConversionTestCase(-0x80L,                                   "00001111111"),
-        new NumericConversionTestCase(-0x800L,                                  "00001111111"),
-        new NumericConversionTestCase(-0x8000L,                                 "00001111111"),
-        new NumericConversionTestCase(-0x800000L,                               "00000111111"),
-        new NumericConversionTestCase(-0x80000000L,                             "00000110101"),
-        new NumericConversionTestCase(-0x800000000000L,                         "00000010101"),
-        new NumericConversionTestCase(-0x20000000000000L,                       "00000010101"),
-        new NumericConversionTestCase(-0x8000000000000000L,                     "00000010000"),
+        new NumericConversionTestCase(-1L,                                      "000011111"),
+        new NumericConversionTestCase(-0x10L,                                   "000011111"),
+        new NumericConversionTestCase(-0x80L,                                   "000011111"),
+        new NumericConversionTestCase(-0x800L,                                  "000011111"),
+        new NumericConversionTestCase(-0x8000L,                                 "000011111"),
+        new NumericConversionTestCase(-0x800000L,                               "000001111"),
+        new NumericConversionTestCase(-0x80000000L,                             "000001101"),
+        new NumericConversionTestCase(-0x800000000000L,                         "000000101"),
+        new NumericConversionTestCase(-0x20000000000000L,                       "000000101"),
+        new NumericConversionTestCase(-0x8000000000000000L,                     "000000100"),
         // positive floats
-        new NumericConversionTestCase(1e0f,                                     "11111111111"),
-        new NumericConversionTestCase(1e2f,                                     "11111111111"),
-        new NumericConversionTestCase(1e4f,                                     "01111111111"),
-        new NumericConversionTestCase(1e8f,                                     "00110111111"),
-        new NumericConversionTestCase(1e16f,                                    "00010011111"),
-        new NumericConversionTestCase(1e19f,                                    "00010001111"),
-        new NumericConversionTestCase(1e20f,                                    "00000001111"),
-        new NumericConversionTestCase(1.1e0f,                                   "00000001111"),
+        new NumericConversionTestCase(1e0f,                                     "111111111"),
+        new NumericConversionTestCase(1e2f,                                     "111111111"),
+        new NumericConversionTestCase(1e4f,                                     "011111111"),
+        new NumericConversionTestCase(1e8f,                                     "001101111"),
+        new NumericConversionTestCase(1e16f,                                    "000100111"),
+        new NumericConversionTestCase(1e19f,                                    "000100011"),
+        new NumericConversionTestCase(1e20f,                                    "000000011"),
+        new NumericConversionTestCase(1.1e0f,                                   "000000011"),
         // negative doubles
-        new NumericConversionTestCase(-1e0f,                                    "00001111111"),
-        new NumericConversionTestCase(-1e2f,                                    "00001111111"),
-        new NumericConversionTestCase(-1e4f,                                    "00001111111"),
-        new NumericConversionTestCase(-1e8f,                                    "00000111111"),
-        new NumericConversionTestCase(-1e16f,                                   "00000011111"),
-        new NumericConversionTestCase(-1e20f,                                   "00000001111"),
-        new NumericConversionTestCase(-1.1e0f,                                  "00000001111"),
-        // complex values
-        new NumericConversionTestCase(new VdlComplex128(0f),                    "11111111111"),
-        new NumericConversionTestCase(new VdlComplex128(1e8f),                  "00110111111"),
-        new NumericConversionTestCase(new VdlComplex128(1e20f),                 "00000001111"),
-        new NumericConversionTestCase(new VdlComplex128(1.1e0f),                "00000001111"),
-        new NumericConversionTestCase(new VdlComplex128(-1f),                   "00001111111"),
-        new NumericConversionTestCase(new VdlComplex128(-1e8f),                 "00000111111"),
-        new NumericConversionTestCase(new VdlComplex128(-1e20f),                "00000001111"),
-        new NumericConversionTestCase(new VdlComplex128(-1.1e0f),               "00000001111"),
-        new NumericConversionTestCase(new VdlComplex128(0f, 1f),                "00000000011"),
+        new NumericConversionTestCase(-1e0f,                                    "000011111"),
+        new NumericConversionTestCase(-1e2f,                                    "000011111"),
+        new NumericConversionTestCase(-1e4f,                                    "000011111"),
+        new NumericConversionTestCase(-1e8f,                                    "000001111"),
+        new NumericConversionTestCase(-1e16f,                                   "000000111"),
+        new NumericConversionTestCase(-1e20f,                                   "000000011"),
+        new NumericConversionTestCase(-1.1e0f,                                  "000000011"),
     };
 
     private static final Type[][] bytesTypes = {
@@ -192,10 +177,6 @@
                 return ConvertUtil.convertFromInt((Long) value, target);
             } else if (value instanceof Float) {
                 return ConvertUtil.convertFromDouble((Float) value, target);
-            } else if (value instanceof VdlComplex128) {
-                double real = ((VdlComplex128) value).getReal();
-                double imag = ((VdlComplex128) value).getImag();
-                return ConvertUtil.convertFromComplex(real, imag, target);
             } else {
                 throw new IllegalArgumentException("Unexpected value " + value);
             }
@@ -226,14 +207,6 @@
         return BigDecimal.valueOf(value).multiply(BigDecimal.valueOf(2).pow(power));
     }
 
-    private BigDecimal normalizeComplex(VdlComplex128 value) {
-        BigDecimal result = normalizeDouble(value.getReal());
-        if (value.getImag() !=0 ) {
-            result = result.add(normalizeDouble(value.getImag()).multiply(BigDecimal.TEN.pow(100)));
-        }
-        return result;
-    }
-
     private BigDecimal normalize(Object value) {
         if (value instanceof Byte) {
             return normalizeUint(((Byte) value) & 0xffL);
@@ -262,14 +235,9 @@
         } else if (value instanceof Double) {
             return normalizeDouble((Double) value);
         } else if (value instanceof VdlFloat32) {
-            return normalizeComplex(new VdlComplex128(((VdlFloat32) value).getValue()));
+            return normalizeDouble(((VdlFloat32)value).getValue());
         } else if (value instanceof VdlFloat64) {
-            return normalizeComplex(new VdlComplex128(((VdlFloat64) value).getValue()));
-        } else if (value instanceof VdlComplex64) {
-            return normalizeComplex(new VdlComplex128(((VdlComplex64) value).getReal(),
-                    ((VdlComplex64) value).getImag()));
-        } else if (value instanceof VdlComplex128) {
-            return normalizeComplex((VdlComplex128) value);
+            return normalizeDouble(((VdlFloat64)value).getValue());
         } else {
             throw new IllegalArgumentException("Unexpected value " + value);
         }