diff --git a/bind/bind_test.go b/bind/bind_test.go
index eb75115..98b88c6 100644
--- a/bind/bind_test.go
+++ b/bind/bind_test.go
@@ -32,6 +32,7 @@
 	"testdata/issue12328.go",
 	"testdata/issue12403.go",
 	"testdata/try.go",
+	"testdata/vars.go",
 }
 
 var fset = token.NewFileSet()
diff --git a/bind/gengo.go b/bind/gengo.go
index 258621d..da3c574 100644
--- a/bind/gengo.go
+++ b/bind/gengo.go
@@ -192,6 +192,29 @@
 	g.Printf("}\n\n")
 }
 
+func (g *goGen) genVar(o *types.Var) {
+	// TODO(hyangah): non-struct pointer types (*int), struct type.
+
+	v := fmt.Sprintf("%s.%s", g.pkg.Name(), o.Name())
+
+	// var I int
+	//
+	// func var_setI(out, in *seq.Buffer)
+	g.Printf("func var_set%s(out, in *seq.Buffer) {\n", o.Name())
+	g.Indent()
+	g.genRead("v", "in", o.Type())
+	g.Printf("%s = v\n", v)
+	g.Outdent()
+	g.Printf("}\n")
+
+	// func var_getI(out, in *seq.Buffer)
+	g.Printf("func var_get%s(out, in *seq.Buffer) {\n", o.Name())
+	g.Indent()
+	g.genWrite(v, "out", o.Type())
+	g.Outdent()
+	g.Printf("}\n")
+}
+
 func (g *goGen) genInterface(obj *types.TypeName) {
 	iface := obj.Type().(*types.Named).Underlying().(*types.Interface)
 	ifaceDesc := fmt.Sprintf("go.%s.%s", g.pkg.Name(), obj.Name())
@@ -374,7 +397,7 @@
 func (g *goGen) gen() error {
 	g.genPreamble()
 
-	var funcs []string
+	var funcs, vars []string
 
 	scope := g.pkg.Scope()
 	names := scope.Names()
@@ -401,6 +424,9 @@
 			case *types.Interface:
 				g.genInterface(obj)
 			}
+		case *types.Var:
+			g.genVar(obj)
+			vars = append(vars, obj.Name())
 		case *types.Const:
 		default:
 			g.errorf("not yet supported, name for %v / %T", obj, obj)
@@ -418,6 +444,18 @@
 		g.Printf("}\n")
 	}
 
+	if len(vars) > 0 {
+		g.Printf("func init() {\n")
+		g.Indent()
+		for _, name := range vars {
+			varDesc := fmt.Sprintf("%s.%s", g.pkg.Name(), name)
+			g.Printf("seq.Register(%q, %d, var_set%s)\n", varDesc, 1, name)
+			g.Printf("seq.Register(%q, %d, var_get%s)\n", varDesc, 2, name)
+		}
+		g.Outdent()
+		g.Printf("}\n")
+	}
+
 	if len(g.err) > 0 {
 		return g.err
 	}
diff --git a/bind/genjava.go b/bind/genjava.go
index d4bd18e..4b14860 100644
--- a/bind/genjava.go
+++ b/bind/genjava.go
@@ -459,6 +459,35 @@
 	return nil
 }
 
+func (g *javaGen) genVar(o *types.Var) {
+	jType := g.javaType(o.Type())
+	varDesc := fmt.Sprintf("%s.%s", g.pkg.Name(), o.Name())
+
+	// setter
+	g.Printf("public static void set%s(%s v) {\n", o.Name(), jType)
+	g.Indent()
+	g.Printf("Seq in = new Seq();\n")
+	g.Printf("Seq out = new Seq();\n")
+	g.Printf("in.write%s;\n", seqWrite(o.Type(), "v"))
+	g.Printf("Seq.send(%q, 1, in, out);\n", varDesc)
+	g.Outdent()
+	g.Printf("}\n")
+	g.Printf("\n")
+
+	// getter
+	g.Printf("public static %s get%s() {\n", jType, o.Name())
+	g.Indent()
+	g.Printf("Seq in = new Seq();\n")
+	g.Printf("Seq out = new Seq();\n")
+	g.Printf("Seq.send(%q, 2, in, out);\n", varDesc)
+	g.Printf("%s ", jType)
+	g.genRead("v", "out", o.Type())
+	g.Printf("return v;\n")
+	g.Outdent()
+	g.Printf("}\n")
+	g.Printf("\n")
+}
+
 func (g *javaGen) genFunc(o *types.Func, method bool) {
 	if err := g.funcSignature(o, !method); err != nil {
 		g.errorf("%v", err)
@@ -634,9 +663,11 @@
 	g.Printf("public abstract class %s {\n", g.className())
 	g.Indent()
 	g.Printf("private %s() {} // uninstantiable\n\n", g.className())
+
+	var funcs []string
+
 	scope := g.pkg.Scope()
 	names := scope.Names()
-	var funcs []string
 	for _, name := range names {
 		obj := scope.Lookup(name)
 		if !obj.Exported() {
@@ -663,6 +694,8 @@
 			}
 		case *types.Const:
 			g.genConst(o)
+		case *types.Var:
+			g.genVar(o)
 		default:
 			g.errorf("unsupported exported type: %T", obj)
 		}
diff --git a/bind/genobjc.go b/bind/genobjc.go
index 181b17a..25bc35c 100644
--- a/bind/genobjc.go
+++ b/bind/genobjc.go
@@ -29,6 +29,7 @@
 	funcs      []*types.Func
 	names      []*types.TypeName
 	constants  []*types.Const
+	vars       []*types.Var
 }
 
 func (g *objcGen) init() {
@@ -56,9 +57,10 @@
 				continue
 			}
 			g.constants = append(g.constants, obj)
+		case *types.Var:
+			g.vars = append(g.vars, obj)
 		default:
 			g.errorf("unsupported exported type for %s: %T", obj.Name(), obj)
-			// TODO(hyangah): *types.Var
 		}
 	}
 }
@@ -119,6 +121,14 @@
 		g.Printf("\n")
 	}
 
+	// var
+	for _, obj := range g.vars {
+		objcType := g.objcType(obj.Type())
+		g.Printf("FOUNDATION_EXPORT void %s_set%s(%s v);\n", g.namePrefix, obj.Name(), objcType)
+		g.Printf("FOUNDATION_EXPORT %s %s%s();\n", objcType, g.namePrefix, obj.Name())
+		g.Printf("\n")
+	}
+
 	// static functions.
 	for _, obj := range g.funcs {
 		g.genFuncH(obj)
@@ -186,6 +196,15 @@
 	if len(g.constants) > 0 {
 		g.Printf("\n")
 	}
+
+	// vars
+	for _, o := range g.vars {
+		g.genVarM(o)
+	}
+	if len(g.vars) > 0 {
+		g.Printf("\n")
+	}
+
 	// global functions.
 	for _, obj := range g.funcs {
 		g.genFuncM(obj)
@@ -210,6 +229,35 @@
 	return nil
 }
 
+func (g *objcGen) genVarM(o *types.Var) {
+	varDesc := fmt.Sprintf("%q", g.pkg.Name()+"."+o.Name())
+	objcType := g.objcType(o.Type())
+
+	// setter
+	s1 := &funcSummary{
+		name:   g.namePrefix + "_set" + o.Name(),
+		ret:    "void",
+		params: []paramInfo{{typ: o.Type(), name: "v"}},
+	}
+	g.Printf("void %s(%s v) {\n", s1.name, objcType)
+	g.Indent()
+	g.genFunc(varDesc, "1", s1, false)
+	g.Outdent()
+	g.Printf("}\n\n")
+
+	// getter
+	s2 := &funcSummary{
+		name:      g.namePrefix + o.Name(),
+		ret:       objcType,
+		retParams: []paramInfo{{typ: o.Type(), name: "ret"}},
+	}
+	g.Printf("%s %s() {\n", s2.ret, s2.name)
+	g.Indent()
+	g.genFunc(varDesc, "2", s2, false)
+	g.Outdent()
+	g.Printf("}\n\n")
+}
+
 func (g *objcGen) genConstM(o *types.Const) {
 	cName := fmt.Sprintf("%s%s", g.namePrefix, o.Name())
 	cType := g.objcType(o.Type())
diff --git a/bind/java/SeqTest.java b/bind/java/SeqTest.java
index 2f0927f..a797543 100644
--- a/bind/java/SeqTest.java
+++ b/bind/java/SeqTest.java
@@ -33,6 +33,34 @@
     assertEquals("const MaxFloat32", 3.40282346638528859811704183484516925440e+38, Testpkg.MaxFloat32, 0.0001);
     assertEquals("const Log2E", 1/0.693147180559945309417232121458176568075500134360255254120680009, Testpkg.Log2E, 0.0001);
   }
+
+  public void testVar() {
+    assertEquals("var StringVar", "a string var", Testpkg.getStringVar());
+
+    String newStringVar = "a new string var";
+    Testpkg.setStringVar(newStringVar);
+    assertEquals("var StringVar", newStringVar, Testpkg.getStringVar());
+
+    assertEquals("var IntVar", 77, Testpkg.getIntVar());
+
+    long newIntVar = 777;
+    Testpkg.setIntVar(newIntVar);
+    assertEquals("var IntVar", newIntVar, Testpkg.getIntVar());
+
+    Testpkg.S s0 = Testpkg.getStructVar();
+    assertEquals("var StructVar", "a struct var", s0.String());
+    Testpkg.S s1 = Testpkg.New();
+    Testpkg.setStructVar(s1);
+    assertEquals("var StructVar", s1.String(), Testpkg.getStructVar().String());
+
+    // TODO(hyangah): handle nil return value (translate to null)
+
+    AnI obj = new AnI();
+    obj.name = "this is an I";
+    Testpkg.setInterfaceVar(obj);
+    assertEquals("var InterfaceVar", obj.String(), Testpkg.getInterfaceVar().String());
+  }
+
   public void testAssets() {
     String want = "Hello, Assets.\n";
     String got = Testpkg.ReadAsset();
diff --git a/bind/java/testpkg/testpkg.go b/bind/java/testpkg/testpkg.go
index 1b3f498..806e3c7 100644
--- a/bind/java/testpkg/testpkg.go
+++ b/bind/java/testpkg/testpkg.go
@@ -39,6 +39,13 @@
 	Log2E                          = math.Log2E
 )
 
+var (
+	StringVar    = "a string var"
+	IntVar       = 77
+	StructVar    = &S{name: "a struct var"}
+	InterfaceVar I
+)
+
 type I interface {
 	F()
 
@@ -104,8 +111,10 @@
 	numSCollected++
 }
 
+var seq = 0
+
 func New() *S {
-	s := &S{innerObj: new(int), name: "new"}
+	s := &S{innerObj: new(int), name: fmt.Sprintf("new%d", seq)}
 	runtime.SetFinalizer(s.innerObj, finalizeInner)
 	return s
 }
diff --git a/bind/objc/SeqTest.m b/bind/objc/SeqTest.m
index 5d1cbf8..77a1281 100644
--- a/bind/objc/SeqTest.m
+++ b/bind/objc/SeqTest.m
@@ -271,6 +271,50 @@
   }
 }
 
+void testVar() {
+  NSString *s = GoTestpkgStringVar();
+  if (![s isEqualToString:@"a string var"]) {
+    ERROR(@"GoTestpkgStringVar = %@, want 'a string var'", s);
+  }
+  s = @"a new string var";
+  GoTestpkg_setStringVar(s);
+  NSString *s2 = GoTestpkgStringVar();
+  if (![s2 isEqualToString:s]) {
+    ERROR(@"GoTestpkgStringVar = %@, want %@", s2, s);
+  }
+
+  int64_t i = GoTestpkgIntVar();
+  if (i != 77) {
+    ERROR(@"GoTestpkgIntVar = %lld, want 77", i);
+  }
+  GoTestpkg_setIntVar(777);
+  i = GoTestpkgIntVar();
+  if (i != 777) {
+    ERROR(@"GoTestpkgIntVar = %lld, want 777", i);
+  }
+
+  GoTestpkgNode *n0 = GoTestpkgStructVar();
+  if (![n0.V isEqualToString:@"a struct var"]) {
+    ERROR(@"GoTestpkgStructVar = %@, want 'a struct var'", n0.V);
+  }
+  GoTestpkgNode *n1 = GoTestpkgNewNode(@"a new struct var");
+  GoTestpkg_setStructVar(n1);
+  GoTestpkgNode *n2 = GoTestpkgStructVar();
+  if (![n2.V isEqualToString:@"a new struct var"]) {
+    ERROR(@"GoTestpkgStructVar = %@, want 'a new struct var'", n2.V);
+  }
+
+  Number *num = [[Number alloc] init];
+  num.value = 12345;
+  GoTestpkg_setInterfaceVar(num);
+  id<GoTestpkgI> iface = GoTestpkgInterfaceVar();
+  int64_t x = [iface Times:10];
+  int64_t y = [num Times:10];
+  if (x != y) {
+    ERROR(@"GoTestpkgInterfaceVar Times 10 = %lld, want %lld", x, y);
+  }
+}
+
 // Invokes functions and object methods defined in Testpkg.h.
 //
 // TODO(hyangah): apply testing framework (e.g. XCTestCase)
@@ -286,8 +330,6 @@
       ERROR(@"GoTestpkgSum(31, 21) = %lld, want 52\n", sum);
     }
 
-    testConst();
-
     testHello(@"세계"); // korean, utf-8, world.
 
     unichar t[] = {
@@ -315,7 +357,11 @@
             numI);
     }
 
+    testConst();
+
     testIssue12307();
+
+    testVar();
   }
 
   fprintf(stderr, "%s\n", err ? "FAIL" : "PASS");
diff --git a/bind/objc/testpkg/go_testpkg/go_testpkg.go b/bind/objc/testpkg/go_testpkg/go_testpkg.go
index 45a23da..d6d3dbf 100644
--- a/bind/objc/testpkg/go_testpkg/go_testpkg.go
+++ b/bind/objc/testpkg/go_testpkg/go_testpkg.go
@@ -158,6 +158,26 @@
 	testpkg.Int(param_x)
 }
 
+func var_setIntVar(out, in *seq.Buffer) {
+	v := in.ReadInt()
+	testpkg.IntVar = v
+}
+func var_getIntVar(out, in *seq.Buffer) {
+	out.WriteInt(testpkg.IntVar)
+}
+func var_setInterfaceVar(out, in *seq.Buffer) {
+	var v testpkg.I
+	v_ref := in.ReadRef()
+	if v_ref.Num < 0 { // go object
+		v = v_ref.Get().(testpkg.I)
+	} else { // foreign object
+		v = (*proxyI)(v_ref)
+	}
+	testpkg.InterfaceVar = v
+}
+func var_getInterfaceVar(out, in *seq.Buffer) {
+	out.WriteGoRef(testpkg.InterfaceVar)
+}
 func proxy_Multiply(out, in *seq.Buffer) {
 	param_idx := in.ReadInt32()
 	param_val := in.ReadInt32()
@@ -312,6 +332,22 @@
 	seq.Register(proxyS_Descriptor, proxyS_TryTwoStrings_Code, proxyS_TryTwoStrings)
 }
 
+func var_setStringVar(out, in *seq.Buffer) {
+	v := in.ReadString()
+	testpkg.StringVar = v
+}
+func var_getStringVar(out, in *seq.Buffer) {
+	out.WriteString(testpkg.StringVar)
+}
+func var_setStructVar(out, in *seq.Buffer) {
+	// Must be a Go object
+	v_ref := in.ReadRef()
+	v := v_ref.Get().(*testpkg.Node)
+	testpkg.StructVar = v
+}
+func var_getStructVar(out, in *seq.Buffer) {
+	out.WriteGoRef(testpkg.StructVar)
+}
 func proxy_Sum(out, in *seq.Buffer) {
 	param_x := in.ReadInt64()
 	param_y := in.ReadInt64()
@@ -343,3 +379,13 @@
 	seq.Register("testpkg", 16, proxy_Sum)
 	seq.Register("testpkg", 17, proxy_UnregisterI)
 }
+func init() {
+	seq.Register("testpkg.IntVar", 1, var_setIntVar)
+	seq.Register("testpkg.IntVar", 2, var_getIntVar)
+	seq.Register("testpkg.InterfaceVar", 1, var_setInterfaceVar)
+	seq.Register("testpkg.InterfaceVar", 2, var_getInterfaceVar)
+	seq.Register("testpkg.StringVar", 1, var_setStringVar)
+	seq.Register("testpkg.StringVar", 2, var_getStringVar)
+	seq.Register("testpkg.StructVar", 1, var_setStructVar)
+	seq.Register("testpkg.StructVar", 2, var_getStructVar)
+}
diff --git a/bind/objc/testpkg/objc_testpkg/GoTestpkg.h b/bind/objc/testpkg/objc_testpkg/GoTestpkg.h
index 8c33bc7..5f4a469 100644
--- a/bind/objc/testpkg/objc_testpkg/GoTestpkg.h
+++ b/bind/objc/testpkg/objc_testpkg/GoTestpkg.h
@@ -56,6 +56,18 @@
 FOUNDATION_EXPORT const float GoTestpkgSmallestNonzeroFloat32;
 FOUNDATION_EXPORT const double GoTestpkgSmallestNonzeroFloat64;
 
+FOUNDATION_EXPORT void GoTestpkg_setIntVar(int v);
+FOUNDATION_EXPORT int GoTestpkgIntVar();
+
+FOUNDATION_EXPORT void GoTestpkg_setInterfaceVar(id<GoTestpkgI> v);
+FOUNDATION_EXPORT id<GoTestpkgI> GoTestpkgInterfaceVar();
+
+FOUNDATION_EXPORT void GoTestpkg_setStringVar(NSString* v);
+FOUNDATION_EXPORT NSString* GoTestpkgStringVar();
+
+FOUNDATION_EXPORT void GoTestpkg_setStructVar(GoTestpkgNode* v);
+FOUNDATION_EXPORT GoTestpkgNode* GoTestpkgStructVar();
+
 FOUNDATION_EXPORT NSData* GoTestpkgBytesAppend(NSData* a, NSData* b);
 
 FOUNDATION_EXPORT BOOL GoTestpkgCallIError(id<GoTestpkgI> i, BOOL triggerError, NSError** error);
diff --git a/bind/objc/testpkg/objc_testpkg/GoTestpkg.m b/bind/objc/testpkg/objc_testpkg/GoTestpkg.m
index 4ef2d3c..72b96db 100644
--- a/bind/objc/testpkg/objc_testpkg/GoTestpkg.m
+++ b/bind/objc/testpkg/objc_testpkg/GoTestpkg.m
@@ -312,6 +312,101 @@
 const float GoTestpkgSmallestNonzeroFloat32 = 0;
 const double GoTestpkgSmallestNonzeroFloat64 = 5e-324;
 
+void GoTestpkg_setIntVar(int v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeInt(&in_, v);
+	go_seq_send("testpkg.IntVar", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+int GoTestpkgIntVar() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("testpkg.IntVar", 2, &in_, &out_);
+	int ret = go_seq_readInt(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoTestpkg_setInterfaceVar(id<GoTestpkgI> v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	if ([(id<NSObject>)(v) isKindOfClass:[GoTestpkgI class]]) {
+		id<goSeqRefInterface> v_proxy = (id<goSeqRefInterface>)(v);
+		go_seq_writeRef(&in_, v_proxy.ref);
+	} else {
+		go_seq_writeObjcRef(&in_, v);
+	}
+	go_seq_send("testpkg.InterfaceVar", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+id<GoTestpkgI> GoTestpkgInterfaceVar() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("testpkg.InterfaceVar", 2, &in_, &out_);
+	GoSeqRef* ret_ref = go_seq_readRef(&out_);
+	id<GoTestpkgI> ret = ret_ref.obj;
+	if (ret == NULL) {
+		ret = [[GoTestpkgI alloc] initWithRef:ret_ref];
+	}
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoTestpkg_setStringVar(NSString* v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeUTF8(&in_, v);
+	go_seq_send("testpkg.StringVar", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+NSString* GoTestpkgStringVar() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("testpkg.StringVar", 2, &in_, &out_);
+	NSString* ret = go_seq_readUTF8(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoTestpkg_setStructVar(GoTestpkgNode* v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	if ([(id<NSObject>)(v) isKindOfClass:[GoTestpkgNode class]]) {
+		id<goSeqRefInterface> v_proxy = (id<goSeqRefInterface>)(v);
+		go_seq_writeRef(&in_, v_proxy.ref);
+	} else {
+		go_seq_writeObjcRef(&in_, v);
+	}
+	go_seq_send("testpkg.StructVar", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+GoTestpkgNode* GoTestpkgStructVar() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("testpkg.StructVar", 2, &in_, &out_);
+	GoSeqRef* ret_ref = go_seq_readRef(&out_);
+	GoTestpkgNode* ret = ret_ref.obj;
+	if (ret == NULL) {
+		ret = [[GoTestpkgNode alloc] initWithRef:ret_ref];
+	}
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+
 NSData* GoTestpkgBytesAppend(NSData* a, NSData* b) {
 	GoSeq in_ = {};
 	GoSeq out_ = {};
diff --git a/bind/objc/testpkg/testpkg.go b/bind/objc/testpkg/testpkg.go
index fb6150c..2a152c8 100644
--- a/bind/objc/testpkg/testpkg.go
+++ b/bind/objc/testpkg/testpkg.go
@@ -32,6 +32,13 @@
 	Log2E                          = math.Log2E
 )
 
+var (
+	StringVar    = "a string var"
+	IntVar       = 77
+	StructVar    = &Node{V: "a struct var"}
+	InterfaceVar I
+)
+
 type I interface {
 	Times(v int32) int64
 	Error(triggerError bool) error
diff --git a/bind/testdata/vars.go b/bind/testdata/vars.go
new file mode 100644
index 0000000..a863970
--- /dev/null
+++ b/bind/testdata/vars.go
@@ -0,0 +1,24 @@
+package vars
+
+var (
+	AString = "String"
+
+	AnInt         = -1
+	AnInt8  int8  = 8
+	AnInt16 int16 = 16
+	AnInt32 int32 = 32
+	AnInt64 int64 = 64
+
+	AFloat           = -2.0
+	AFloat32 float32 = 32.0
+	AFloat64 float64 = 64.0
+
+	ABool = true
+
+	AStructPtr  *S
+	AnInterface I
+)
+
+type S struct{}
+
+type I interface{}
diff --git a/bind/testdata/vars.go.golden b/bind/testdata/vars.go.golden
new file mode 100644
index 0000000..5a9d02d
--- /dev/null
+++ b/bind/testdata/vars.go.golden
@@ -0,0 +1,145 @@
+// Package go_vars is an autogenerated binder stub for package vars.
+//   gobind -lang=go vars
+//
+// File is generated by gobind. Do not edit.
+package go_vars
+
+import (
+	"golang.org/x/mobile/bind/seq"
+	"vars"
+)
+
+func var_setABool(out, in *seq.Buffer) {
+	v := in.ReadBool()
+	vars.ABool = v
+}
+func var_getABool(out, in *seq.Buffer) {
+	out.WriteBool(vars.ABool)
+}
+func var_setAFloat(out, in *seq.Buffer) {
+	v := in.ReadFloat64()
+	vars.AFloat = v
+}
+func var_getAFloat(out, in *seq.Buffer) {
+	out.WriteFloat64(vars.AFloat)
+}
+func var_setAFloat32(out, in *seq.Buffer) {
+	v := in.ReadFloat32()
+	vars.AFloat32 = v
+}
+func var_getAFloat32(out, in *seq.Buffer) {
+	out.WriteFloat32(vars.AFloat32)
+}
+func var_setAFloat64(out, in *seq.Buffer) {
+	v := in.ReadFloat64()
+	vars.AFloat64 = v
+}
+func var_getAFloat64(out, in *seq.Buffer) {
+	out.WriteFloat64(vars.AFloat64)
+}
+func var_setAString(out, in *seq.Buffer) {
+	v := in.ReadString()
+	vars.AString = v
+}
+func var_getAString(out, in *seq.Buffer) {
+	out.WriteString(vars.AString)
+}
+func var_setAStructPtr(out, in *seq.Buffer) {
+	// Must be a Go object
+	v_ref := in.ReadRef()
+	v := v_ref.Get().(*vars.S)
+	vars.AStructPtr = v
+}
+func var_getAStructPtr(out, in *seq.Buffer) {
+	out.WriteGoRef(vars.AStructPtr)
+}
+func var_setAnInt(out, in *seq.Buffer) {
+	v := in.ReadInt()
+	vars.AnInt = v
+}
+func var_getAnInt(out, in *seq.Buffer) {
+	out.WriteInt(vars.AnInt)
+}
+func var_setAnInt16(out, in *seq.Buffer) {
+	v := in.ReadInt16()
+	vars.AnInt16 = v
+}
+func var_getAnInt16(out, in *seq.Buffer) {
+	out.WriteInt16(vars.AnInt16)
+}
+func var_setAnInt32(out, in *seq.Buffer) {
+	v := in.ReadInt32()
+	vars.AnInt32 = v
+}
+func var_getAnInt32(out, in *seq.Buffer) {
+	out.WriteInt32(vars.AnInt32)
+}
+func var_setAnInt64(out, in *seq.Buffer) {
+	v := in.ReadInt64()
+	vars.AnInt64 = v
+}
+func var_getAnInt64(out, in *seq.Buffer) {
+	out.WriteInt64(vars.AnInt64)
+}
+func var_setAnInt8(out, in *seq.Buffer) {
+	v := in.ReadInt8()
+	vars.AnInt8 = v
+}
+func var_getAnInt8(out, in *seq.Buffer) {
+	out.WriteInt8(vars.AnInt8)
+}
+func var_setAnInterface(out, in *seq.Buffer) {
+	var v vars.I
+	v_ref := in.ReadRef()
+	if v_ref.Num < 0 { // go object
+		v = v_ref.Get().(vars.I)
+	} else { // foreign object
+		v = (*proxyI)(v_ref)
+	}
+	vars.AnInterface = v
+}
+func var_getAnInterface(out, in *seq.Buffer) {
+	out.WriteGoRef(vars.AnInterface)
+}
+
+const (
+	proxyI_Descriptor = "go.vars.I"
+)
+
+type proxyI seq.Ref
+
+const (
+	proxyS_Descriptor = "go.vars.S"
+)
+
+type proxyS seq.Ref
+
+func init() {
+}
+
+func init() {
+	seq.Register("vars.ABool", 1, var_setABool)
+	seq.Register("vars.ABool", 2, var_getABool)
+	seq.Register("vars.AFloat", 1, var_setAFloat)
+	seq.Register("vars.AFloat", 2, var_getAFloat)
+	seq.Register("vars.AFloat32", 1, var_setAFloat32)
+	seq.Register("vars.AFloat32", 2, var_getAFloat32)
+	seq.Register("vars.AFloat64", 1, var_setAFloat64)
+	seq.Register("vars.AFloat64", 2, var_getAFloat64)
+	seq.Register("vars.AString", 1, var_setAString)
+	seq.Register("vars.AString", 2, var_getAString)
+	seq.Register("vars.AStructPtr", 1, var_setAStructPtr)
+	seq.Register("vars.AStructPtr", 2, var_getAStructPtr)
+	seq.Register("vars.AnInt", 1, var_setAnInt)
+	seq.Register("vars.AnInt", 2, var_getAnInt)
+	seq.Register("vars.AnInt16", 1, var_setAnInt16)
+	seq.Register("vars.AnInt16", 2, var_getAnInt16)
+	seq.Register("vars.AnInt32", 1, var_setAnInt32)
+	seq.Register("vars.AnInt32", 2, var_getAnInt32)
+	seq.Register("vars.AnInt64", 1, var_setAnInt64)
+	seq.Register("vars.AnInt64", 2, var_getAnInt64)
+	seq.Register("vars.AnInt8", 1, var_setAnInt8)
+	seq.Register("vars.AnInt8", 2, var_getAnInt8)
+	seq.Register("vars.AnInterface", 1, var_setAnInterface)
+	seq.Register("vars.AnInterface", 2, var_getAnInterface)
+}
diff --git a/bind/testdata/vars.java.golden b/bind/testdata/vars.java.golden
new file mode 100644
index 0000000..bbd2c0b
--- /dev/null
+++ b/bind/testdata/vars.java.golden
@@ -0,0 +1,261 @@
+// Java class go.vars.Vars is a proxy for talking to a Go program.
+//   gobind -lang=java vars
+//
+// File is generated by gobind. Do not edit.
+package go.vars;
+
+import go.Seq;
+
+public abstract class Vars {
+    private Vars() {} // uninstantiable
+    
+    public static void setABool(boolean v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeBool(v);
+        Seq.send("vars.ABool", 1, in, out);
+    }
+    
+    public static boolean getABool() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.ABool", 2, in, out);
+        boolean v = out.readBool();
+        return v;
+    }
+    
+    public static void setAFloat(double v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeFloat64(v);
+        Seq.send("vars.AFloat", 1, in, out);
+    }
+    
+    public static double getAFloat() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AFloat", 2, in, out);
+        double v = out.readFloat64();
+        return v;
+    }
+    
+    public static void setAFloat32(float v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeFloat32(v);
+        Seq.send("vars.AFloat32", 1, in, out);
+    }
+    
+    public static float getAFloat32() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AFloat32", 2, in, out);
+        float v = out.readFloat32();
+        return v;
+    }
+    
+    public static void setAFloat64(double v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeFloat64(v);
+        Seq.send("vars.AFloat64", 1, in, out);
+    }
+    
+    public static double getAFloat64() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AFloat64", 2, in, out);
+        double v = out.readFloat64();
+        return v;
+    }
+    
+    public static void setAString(String v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeString(v);
+        Seq.send("vars.AString", 1, in, out);
+    }
+    
+    public static String getAString() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AString", 2, in, out);
+        String v = out.readString();
+        return v;
+    }
+    
+    public static void setAStructPtr(S v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeRef(v.ref());
+        Seq.send("vars.AStructPtr", 1, in, out);
+    }
+    
+    public static S getAStructPtr() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AStructPtr", 2, in, out);
+        S v = new S(out.readRef());
+        return v;
+    }
+    
+    public static void setAnInt(long v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeInt(v);
+        Seq.send("vars.AnInt", 1, in, out);
+    }
+    
+    public static long getAnInt() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AnInt", 2, in, out);
+        long v = out.readInt();
+        return v;
+    }
+    
+    public static void setAnInt16(short v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeInt16(v);
+        Seq.send("vars.AnInt16", 1, in, out);
+    }
+    
+    public static short getAnInt16() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AnInt16", 2, in, out);
+        short v = out.readInt16();
+        return v;
+    }
+    
+    public static void setAnInt32(int v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeInt32(v);
+        Seq.send("vars.AnInt32", 1, in, out);
+    }
+    
+    public static int getAnInt32() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AnInt32", 2, in, out);
+        int v = out.readInt32();
+        return v;
+    }
+    
+    public static void setAnInt64(long v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeInt64(v);
+        Seq.send("vars.AnInt64", 1, in, out);
+    }
+    
+    public static long getAnInt64() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AnInt64", 2, in, out);
+        long v = out.readInt64();
+        return v;
+    }
+    
+    public static void setAnInt8(byte v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeInt8(v);
+        Seq.send("vars.AnInt8", 1, in, out);
+    }
+    
+    public static byte getAnInt8() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AnInt8", 2, in, out);
+        byte v = out.readInt8();
+        return v;
+    }
+    
+    public static void setAnInterface(I v) {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        in.writeRef(v.ref());
+        Seq.send("vars.AnInterface", 1, in, out);
+    }
+    
+    public static I getAnInterface() {
+        Seq in = new Seq();
+        Seq out = new Seq();
+        Seq.send("vars.AnInterface", 2, in, out);
+        I v = new I.Proxy(out.readRef());
+        return v;
+    }
+    
+    public interface I extends go.Seq.Object {
+        public static abstract class Stub implements I {
+            static final String DESCRIPTOR = "go.vars.I";
+            
+            private final go.Seq.Ref ref;
+            public Stub() {
+                ref = go.Seq.createRef(this);
+            }
+            
+            public go.Seq.Ref ref() { return ref; }
+            
+            public void call(int code, go.Seq in, go.Seq out) {
+                switch (code) {
+                default:
+                    throw new RuntimeException("unknown code: "+ code);
+                }
+            }
+        }
+        
+        static final class Proxy implements I {
+            static final String DESCRIPTOR = Stub.DESCRIPTOR;
+        
+            private go.Seq.Ref ref;
+        
+            Proxy(go.Seq.Ref ref) { this.ref = ref; }
+        
+            public go.Seq.Ref ref() { return ref; }
+        
+            public void call(int code, go.Seq in, go.Seq out) {
+                throw new RuntimeException("cycle: cannot call proxy");
+            }
+        
+        }
+    }
+    
+    public static final class S implements go.Seq.Object {
+        private static final String DESCRIPTOR = "go.vars.S";
+        
+        private go.Seq.Ref ref;
+        
+        private S(go.Seq.Ref ref) { this.ref = ref; }
+        
+        public go.Seq.Ref ref() { return ref; }
+        
+        public void call(int code, go.Seq in, go.Seq out) {
+            throw new RuntimeException("internal error: cycle: cannot call concrete proxy");
+        }
+        
+        @Override public boolean equals(Object o) {
+            if (o == null || !(o instanceof S)) {
+                return false;
+            }
+            S that = (S)o;
+            return true;
+        }
+        
+        @Override public int hashCode() {
+            return java.util.Arrays.hashCode(new Object[] {});
+        }
+        
+        @Override public String toString() {
+            StringBuilder b = new StringBuilder();
+            b.append("S").append("{");
+            return b.append("}").toString();
+        }
+        
+    }
+    
+    private static final String DESCRIPTOR = "vars";
+}
diff --git a/bind/testdata/vars.objc.h.golden b/bind/testdata/vars.objc.h.golden
new file mode 100644
index 0000000..7984017
--- /dev/null
+++ b/bind/testdata/vars.objc.h.golden
@@ -0,0 +1,59 @@
+// Objective-C API for talking to vars Go package.
+//   gobind -lang=objc vars
+//
+// File is generated by gobind. Do not edit.
+
+#ifndef __GoVars_H__
+#define __GoVars_H__
+
+#include <Foundation/Foundation.h>
+
+@class GoVarsS;
+
+@protocol GoVarsI
+@end
+
+@interface GoVarsS : NSObject {
+}
+@property(strong, readonly) id ref;
+
+- (id)initWithRef:(id)ref;
+@end
+
+FOUNDATION_EXPORT void GoVars_setABool(BOOL v);
+FOUNDATION_EXPORT BOOL GoVarsABool();
+
+FOUNDATION_EXPORT void GoVars_setAFloat(double v);
+FOUNDATION_EXPORT double GoVarsAFloat();
+
+FOUNDATION_EXPORT void GoVars_setAFloat32(float v);
+FOUNDATION_EXPORT float GoVarsAFloat32();
+
+FOUNDATION_EXPORT void GoVars_setAFloat64(double v);
+FOUNDATION_EXPORT double GoVarsAFloat64();
+
+FOUNDATION_EXPORT void GoVars_setAString(NSString* v);
+FOUNDATION_EXPORT NSString* GoVarsAString();
+
+FOUNDATION_EXPORT void GoVars_setAStructPtr(GoVarsS* v);
+FOUNDATION_EXPORT GoVarsS* GoVarsAStructPtr();
+
+FOUNDATION_EXPORT void GoVars_setAnInt(int v);
+FOUNDATION_EXPORT int GoVarsAnInt();
+
+FOUNDATION_EXPORT void GoVars_setAnInt16(int16_t v);
+FOUNDATION_EXPORT int16_t GoVarsAnInt16();
+
+FOUNDATION_EXPORT void GoVars_setAnInt32(int32_t v);
+FOUNDATION_EXPORT int32_t GoVarsAnInt32();
+
+FOUNDATION_EXPORT void GoVars_setAnInt64(int64_t v);
+FOUNDATION_EXPORT int64_t GoVarsAnInt64();
+
+FOUNDATION_EXPORT void GoVars_setAnInt8(int8_t v);
+FOUNDATION_EXPORT int8_t GoVarsAnInt8();
+
+FOUNDATION_EXPORT void GoVars_setAnInterface(id<GoVarsI> v);
+FOUNDATION_EXPORT id<GoVarsI> GoVarsAnInterface();
+
+#endif
diff --git a/bind/testdata/vars.objc.m.golden b/bind/testdata/vars.objc.m.golden
new file mode 100644
index 0000000..3bb1288
--- /dev/null
+++ b/bind/testdata/vars.objc.m.golden
@@ -0,0 +1,308 @@
+// Objective-C API for talking to vars Go package.
+//   gobind -lang=objc vars
+//
+// File is generated by gobind. Do not edit.
+
+#include "GoVars.h"
+#include <Foundation/Foundation.h>
+#include "seq.h"
+
+static NSString* errDomain = @"go.vars";
+
+@protocol goSeqRefInterface
+-(GoSeqRef*) ref;
+@end
+
+#define _DESCRIPTOR_ "vars"
+
+
+#define _GO_vars_I_DESCRIPTOR_ "go.vars.I"
+
+@interface GoVarsI : NSObject <GoVarsI> {
+}
+@property(strong, readonly) id ref;
+
+- (id)initWithRef:(id)ref;
+@end
+
+@implementation GoVarsI {
+}
+
+- (id)initWithRef:(id)ref {
+	self = [super init];
+	if (self) { _ref = ref; }
+	return self;
+}
+
+@end
+
+static void proxyGoVarsI(id obj, int code, GoSeq* in, GoSeq* out) {
+	switch (code) {
+	default:
+		NSLog(@"unknown code %x for _GO_vars_I_DESCRIPTOR_", code);
+	}
+}
+
+#define _GO_vars_S_DESCRIPTOR_ "go.vars.S"
+
+@implementation GoVarsS {
+}
+
+- (id)initWithRef:(id)ref {
+	self = [super init];
+	if (self) { _ref = ref; }
+	return self;
+}
+
+@end
+
+void GoVars_setABool(BOOL v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeBool(&in_, v);
+	go_seq_send("vars.ABool", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+BOOL GoVarsABool() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.ABool", 2, &in_, &out_);
+	BOOL ret = go_seq_readBool(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAFloat(double v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeFloat64(&in_, v);
+	go_seq_send("vars.AFloat", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+double GoVarsAFloat() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AFloat", 2, &in_, &out_);
+	double ret = go_seq_readFloat64(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAFloat32(float v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeFloat32(&in_, v);
+	go_seq_send("vars.AFloat32", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+float GoVarsAFloat32() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AFloat32", 2, &in_, &out_);
+	float ret = go_seq_readFloat32(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAFloat64(double v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeFloat64(&in_, v);
+	go_seq_send("vars.AFloat64", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+double GoVarsAFloat64() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AFloat64", 2, &in_, &out_);
+	double ret = go_seq_readFloat64(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAString(NSString* v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeUTF8(&in_, v);
+	go_seq_send("vars.AString", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+NSString* GoVarsAString() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AString", 2, &in_, &out_);
+	NSString* ret = go_seq_readUTF8(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAStructPtr(GoVarsS* v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	if ([(id<NSObject>)(v) isKindOfClass:[GoVarsS class]]) {
+		id<goSeqRefInterface> v_proxy = (id<goSeqRefInterface>)(v);
+		go_seq_writeRef(&in_, v_proxy.ref);
+	} else {
+		go_seq_writeObjcRef(&in_, v);
+	}
+	go_seq_send("vars.AStructPtr", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+GoVarsS* GoVarsAStructPtr() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AStructPtr", 2, &in_, &out_);
+	GoSeqRef* ret_ref = go_seq_readRef(&out_);
+	GoVarsS* ret = ret_ref.obj;
+	if (ret == NULL) {
+		ret = [[GoVarsS alloc] initWithRef:ret_ref];
+	}
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAnInt(int v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeInt(&in_, v);
+	go_seq_send("vars.AnInt", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+int GoVarsAnInt() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AnInt", 2, &in_, &out_);
+	int ret = go_seq_readInt(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAnInt16(int16_t v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeInt16(&in_, v);
+	go_seq_send("vars.AnInt16", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+int16_t GoVarsAnInt16() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AnInt16", 2, &in_, &out_);
+	int16_t ret = go_seq_readInt16(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAnInt32(int32_t v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeInt32(&in_, v);
+	go_seq_send("vars.AnInt32", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+int32_t GoVarsAnInt32() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AnInt32", 2, &in_, &out_);
+	int32_t ret = go_seq_readInt32(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAnInt64(int64_t v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeInt64(&in_, v);
+	go_seq_send("vars.AnInt64", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+int64_t GoVarsAnInt64() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AnInt64", 2, &in_, &out_);
+	int64_t ret = go_seq_readInt64(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAnInt8(int8_t v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_writeInt8(&in_, v);
+	go_seq_send("vars.AnInt8", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+int8_t GoVarsAnInt8() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AnInt8", 2, &in_, &out_);
+	int8_t ret = go_seq_readInt8(&out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+void GoVars_setAnInterface(id<GoVarsI> v) {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	if ([(id<NSObject>)(v) isKindOfClass:[GoVarsI class]]) {
+		id<goSeqRefInterface> v_proxy = (id<goSeqRefInterface>)(v);
+		go_seq_writeRef(&in_, v_proxy.ref);
+	} else {
+		go_seq_writeObjcRef(&in_, v);
+	}
+	go_seq_send("vars.AnInterface", 1, &in_, &out_);
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+}
+
+id<GoVarsI> GoVarsAnInterface() {
+	GoSeq in_ = {};
+	GoSeq out_ = {};
+	go_seq_send("vars.AnInterface", 2, &in_, &out_);
+	GoSeqRef* ret_ref = go_seq_readRef(&out_);
+	id<GoVarsI> ret = ret_ref.obj;
+	if (ret == NULL) {
+		ret = [[GoVarsI alloc] initWithRef:ret_ref];
+	}
+	go_seq_free(&in_);
+	go_seq_free(&out_);
+	return ret;
+}
+
+
+__attribute__((constructor)) static void init() {
+	go_seq_register_proxy("go.vars.I", proxyGoVarsI);
+}