diff --git a/src/genny/common.nim b/src/genny/common.nim
index 3ce4583..aeb3f31 100644
--- a/src/genny/common.nim
+++ b/src/genny/common.nim
@@ -68,18 +68,34 @@ proc toVarCase*(s: string): string =
   if i < s.len:
     result.add s[i .. ^1]
 
-proc getSeqName*(sym: NimNode): string =
-  if sym.kind == nnkBracketExpr:
-    result = &"Seq{sym[1]}"
+proc getName*(sym: NimNode): string =
+  if sym.kind == nnkSym:
+    let impl = sym.getImpl()
+    if impl.kind == nnkProcDef and impl[5].kind != nnkEmpty:
+      # generic procedure instance
+      # for now, just add every type to the name
+      #
+      # we could only add the generic one, but that requires smart
+      # matching between the impl & the TypeInst
+      var res= sym.repr
+      for param in sym.getTypeInst()[0][1..^1]:
+        res &= capitalizeAscii(param[1].getName())
+      res
+    else:
+      sym.repr
+  elif sym.kind == nnkBracketExpr:
+    for gen in sym:
+      result &= capitalizeAscii(gen.getName())
+    result
   else:
-    result = &"Seq{sym}"
-  result[3] = toUpperAscii(result[3])
+    sym.repr
 
-proc getName*(sym: NimNode): string =
+proc getSeqName*(sym: NimNode): string =
   if sym.kind == nnkBracketExpr:
-    sym.getSeqName()
+    sym.getName()
   else:
-    sym.repr
+    "Seq" & sym.getName()
+
 
 proc raises*(procSym: NimNode): bool =
   for pragma in procSym.getImpl()[4]:
diff --git a/src/genny/internal.nim b/src/genny/internal.nim
index c9c37aa..f917615 100644
--- a/src/genny/internal.nim
+++ b/src/genny/internal.nim
@@ -16,13 +16,13 @@ proc exportProcInternal*(
   prefixes: openarray[NimNode] = []
 ) =
   let
-    procName = sym.repr
+    procName = getName(sym)
     procNameSnaked = toSnakeCase(procName)
     procType = sym.getTypeInst()
     procParams = procType[0][1 .. ^1]
     procReturn = procType[0][0]
     procRaises = sym.raises()
-    procReturnsSeq = procReturn.kind == nnkBracketExpr
+    procReturnsSeq = procReturn.kind == nnkBracketExpr and procReturn[0].repr == "seq"
 
   var apiProcName = &"$lib_"
   if owner != nil:
@@ -51,7 +51,7 @@ proc exportProcInternal*(
     internal.add "  "
   if procReturnsSeq:
     internal.add &"{procReturn.getSeqName()}(s: "
-  internal.add &"{procName}("
+  internal.add &"{sym.repr}("
   for param in procParams:
     for i in 0 .. param.len - 3:
       internal.add &"{toSnakeCase(param[i].repr)}"
@@ -71,7 +71,7 @@ proc exportProcInternal*(
 
 proc exportObjectInternal*(sym: NimNode, constructor: NimNode) =
   let
-    objName = sym.repr
+    objName = sym.getName()
     objNameSnaked = toSnakeCase(objName)
 
   if constructor != nil:
@@ -97,14 +97,14 @@ proc exportObjectInternal*(sym: NimNode, constructor: NimNode) =
         fieldType = fieldSym.getTypeInst()
       internal.add &"{toSnakeCase(fieldName)}: {exportTypeNim(fieldType)}, "
     internal.removeSuffix ", "
-    internal.add &"): {objName} {exportProcPragmas} =\n"
+    internal.add &"): {sym.repr} {exportProcPragmas} =\n"
     for fieldSym in objType[2]:
       let
         fieldName = fieldSym.repr
       internal.add &"  result.{toSnakeCase(fieldName)} = {toSnakeCase(fieldName)}\n"
     internal.add "\n"
 
-  internal.add &"proc $lib_{objNameSnaked}_eq*(a, b: {objName}): bool {exportProcPragmas}=\n"
+  internal.add &"proc $lib_{objNameSnaked}_eq*(a, b: {sym.repr}): bool {exportProcPragmas}=\n"
   let objType = sym.getType()
   internal.add "  "
   for fieldSym in objType[2]:
@@ -120,11 +120,11 @@ proc exportRefObjectInternal*(
   constructor: NimNode
 ) =
   let
-    objName = sym.repr
+    objName = getName(sym)
     objNameSnaked = toSnakeCase(objName)
     objType = sym.getType()[1].getType()
 
-  internal.add &"proc $lib_{objNameSnaked}_unref*(x: {objName}) {exportProcPragmas}"
+  internal.add &"proc $lib_{objNameSnaked}_unref*(x: {repr(sym)}) {exportProcPragmas}"
   internal.add " =\n"
   internal.add "  GC_unref(x)\n"
   internal.add "\n"
diff --git a/src/genny/languages/c.nim b/src/genny/languages/c.nim
index c025203..926df5b 100644
--- a/src/genny/languages/c.nim
+++ b/src/genny/languages/c.nim
@@ -14,7 +14,7 @@ proc exportTypeC(sym: NimNode): string =
     elif sym[0].repr == "seq":
       result = sym.getSeqName()
     else:
-      error(&"Unexpected bracket expression {sym[0].repr}[")
+      result = sym.getName()
   else:
     result =
       case sym.repr:
@@ -52,7 +52,7 @@ proc exportTypeC(sym: NimNode, name: string): string =
     elif sym[0].repr == "seq":
       result = sym.getSeqName() & " " & name
     else:
-      error(&"Unexpected bracket expression {sym[0].repr}[")
+      result = sym.getName()
   else:
     result = exportTypeC(sym) & " " & name
 
@@ -90,7 +90,7 @@ proc exportProcC*(
   prefixes: openarray[NimNode] = []
 ) =
   let
-    procName = sym.repr
+    procName = sym.getName()
     procNameSnaked = toSnakeCase(procName)
     procType = sym.getTypeInst()
     procParams = procType[0][1 .. ^1]
@@ -131,21 +131,23 @@ proc exportProcC*(
   dllProc(&"$lib_{apiProcName}", dllParams, exportTypeC(procReturn))
 
 proc exportObjectC*(sym: NimNode, constructor: NimNode) =
-  let objName = sym.repr
+  let
+    objName = sym.getName()
+    impl = sym.getTypeImpl()
 
   types.add &"typedef struct {objName} " & "{\n"
-  for identDefs in sym.getImpl()[2][2]:
+  for identDefs in impl[2]:
     for property in identDefs[0 .. ^3]:
-      types.add &"  {exportTypeC(identDefs[^2], toSnakeCase(property[1].repr))};\n"
+      types.add &"  {exportTypeC(identDefs[^2], toSnakeCase(property.repr))};\n"
   types.add "} " & &"{objName};\n\n"
 
   if constructor != nil:
     exportProcC(constructor)
   else:
     procs.add &"{objName} $lib_{toSnakeCase(objName)}("
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
-        procs.add &"{exportTypeC(identDefs[^2], toSnakeCase(property[1].repr))}, "
+        procs.add &"{exportTypeC(identDefs[^2], toSnakeCase(property.repr))}, "
     procs.removeSuffix ", "
     procs.add ");\n\n"
 
@@ -173,7 +175,7 @@ proc exportRefObjectC*(
   constructor: NimNode
 ) =
   let
-    objName = sym.repr
+    objName = sym.getName()
     objNameSnaked = toSnakeCase(objName)
     objType = sym.getType()[1].getType()
 
diff --git a/src/genny/languages/nim.nim b/src/genny/languages/nim.nim
index 685678c..30b118a 100644
--- a/src/genny/languages/nim.nim
+++ b/src/genny/languages/nim.nim
@@ -6,9 +6,10 @@ var
 
 proc exportTypeNim*(sym: NimNode): string =
   if sym.kind == nnkBracketExpr:
-    if sym[0].repr != "seq":
-      error(&"Unexpected bracket expression {sym[0].repr}[", sym)
-    result = sym.getSeqName()
+    if sym[0].repr == "seq":
+      result = sym.getSeqName()
+    else:
+      result = sym.repr
   else:
     if sym.repr == "string":
       result = "cstring"
@@ -28,9 +29,8 @@ proc convertExportFromNim*(sym: NimNode): string =
 
 proc convertImportToNim*(sym: NimNode): string =
   if sym.kind == nnkBracketExpr:
-    if sym[0].repr != "seq":
-      error(&"Unexpected bracket expression {sym[0].repr}[", sym)
-    result = ".s"
+    if sym[0].repr == "seq":
+      result = ".s"
   else:
     if sym.repr == "string":
       result = ".`$`"
@@ -55,7 +55,7 @@ proc exportProcNim*(
   prefixes: openarray[NimNode] = []
 ) =
   let
-    procName = sym.repr
+    procName = sym.getName()
     procNameSnaked = toSnakeCase(procName)
     procType = sym.getTypeInst()
     procParams = procType[0][1 .. ^1]
@@ -92,7 +92,7 @@ proc exportProcNim*(
   procs.add "\n"
   procs.add "\n"
 
-  procs.add &"proc {procName}*("
+  procs.add &"proc {sym.repr}*("
   for i, param in procParams:
     var paramType = param[1]
     if paramType.repr.endsWith(":type"):
@@ -125,13 +125,15 @@ proc exportProcNim*(
   procs.add "\n"
 
 proc exportObjectNim*(sym: NimNode, constructor: NimNode) =
-  let objName = sym.repr
+  let
+    objName = sym.getName()
+    impl = sym.getTypeImpl()
 
   if objName in ["Vector2", "Matrix3", "Rect", "Color"]:
     return
 
   types.add &"type {objName}* = object\n"
-  for identDefs in sym.getImpl()[2][2]:
+  for identDefs in impl[2]:
     for property in identDefs[0 .. ^3]:
       types.add &"  {property.repr}: {identDefs[^2].repr}\n"
   types.add "\n"
@@ -140,15 +142,15 @@ proc exportObjectNim*(sym: NimNode, constructor: NimNode) =
     exportProcNim(constructor)
   else:
     types.add &"proc {toVarCase(objName)}*("
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
-        types.add &"{toSnakeCase(property[1].repr)}: {identDefs[^2].repr}, "
+        types.add &"{toSnakeCase(property.repr)}: {identDefs[^2].repr}, "
     types.removeSuffix ", "
     types.add &"): {objName} =\n"
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
-        types.add &"  result.{toSnakeCase(property[1].repr)} = "
-        types.add &"{toSnakeCase(property[1].repr)}\n"
+        types.add &"  result.{toSnakeCase(property.repr)} = "
+        types.add &"{toSnakeCase(property.repr)}\n"
     types.add "\n"
 
 proc genRefObject(objName: string) =
diff --git a/src/genny/languages/node.nim b/src/genny/languages/node.nim
index 19c1ec0..15e8e06 100644
--- a/src/genny/languages/node.nim
+++ b/src/genny/languages/node.nim
@@ -15,7 +15,7 @@ proc exportTypeNode(sym: NimNode): string =
     elif sym[0].repr == "seq":
       result = sym.getSeqName()
     else:
-      error(&"Unexpected bracket expression {sym[0].repr}[")
+      result = sym.getName()
   else:
     result =
       case sym.repr:
@@ -43,7 +43,7 @@ proc exportTypeNode(sym: NimNode): string =
 
       of "": "'void'"
       else:
-        sym.repr
+        sym.getName()
 
 proc convertExportFromNode*(sym: NimNode): string =
   discard
@@ -79,7 +79,7 @@ proc exportProcNode*(
   prefixes: openarray[NimNode] = []
 ) =
   let
-    procName = sym.repr
+    procName = sym.getName()
     procNameSnaked = toSnakeCase(procName)
     procType = sym.getTypeInst()
     procParams = procType[0][1 .. ^1]
@@ -181,13 +181,15 @@ proc exportProcNode*(
   dllProc(apiProcName, procParams, exportTypeNode(procReturn))
 
 proc exportObjectNode*(sym: NimNode, constructor: NimNode) =
-  let objName = sym.repr
+  let
+    objName = sym.getName()
+    impl = sym.getTypeImpl()
 
   exports.add &"exports.{objName} = {objName};\n"
   types.add &"const {objName} = Struct(" & "{\n"
-  for identDefs in sym.getImpl()[2][2]:
+  for identDefs in impl[2]:
     for property in identDefs[0 .. ^3]:
-      types.add &"  '{property[1].repr}':"
+      types.add &"  '{property.repr}':"
       types.add &"{exportTypeNode(identDefs[^2])},\n"
   types.removeSuffix ",\n"
   types.add "\n})\n"
@@ -217,25 +219,25 @@ proc exportObjectNode*(sym: NimNode, constructor: NimNode) =
   else:
     exports.add &"exports.{toVarCase(objName)} = {toVarCase(objName)};\n"
     types.add &"{toVarCase(objName)} = function("
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
-        types.add &"{toSnakeCase(property[1].repr)}, "
+        types.add &"{toSnakeCase(property.repr)}, "
     types.removeSuffix ", "
     types.add "){\n"
     types.add &"  var v = new {objName}();\n"
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
         types.add "  "
-        types.add &"v.{toSnakeCase(property[1].repr)} = "
-        types.add &"{toSnakeCase(property[1].repr)}\n"
+        types.add &"v.{toSnakeCase(property.repr)} = "
+        types.add &"{toSnakeCase(property.repr)}\n"
     types.add "  return v;\n"
     types.add "}\n"
 
   types.add &"{objName}.prototype.isEqual = function(other){{\n"
   types.add &"  return "
-  for identDefs in sym.getImpl()[2][2]:
+  for identDefs in impl[2]:
     for property in identDefs[0 .. ^3]:
-      types.add &"self.{property[1].repr} == other.{property[1].repr} && "
+      types.add &"self.{property.repr} == other.{property.repr} && "
   types.removeSuffix " && "
   types.add ";\n"
   types.add "};\n"
@@ -298,7 +300,7 @@ proc exportRefObjectNode*(
   constructor: NimNode
 ) =
   let
-    objName = sym.repr
+    objName = sym.getName()
     objNameSnaked = toSnakeCase(objName)
     objType = sym.getType()[1].getType()
 
diff --git a/src/genny/languages/python.nim b/src/genny/languages/python.nim
index 876179e..eef225d 100644
--- a/src/genny/languages/python.nim
+++ b/src/genny/languages/python.nim
@@ -16,7 +16,7 @@ proc exportTypePy(sym: NimNode): string =
     elif sym[0].repr == "seq":
       result = sym.getSeqName()
     else:
-      error(&"Unexpected bracket expression {sym[0].repr}[")
+      result = sym.getName()
   else:
     result =
       case sym.repr:
@@ -204,13 +204,15 @@ proc exportProcPy*(
   dllProc(&"dll.$lib_{apiProcName}", toArgTypes(dllParams), exportTypePy(procReturn))
 
 proc exportObjectPy*(sym: NimNode, constructor: NimNode) =
-  let objName = sym.repr
+  let
+    objName = sym.getName()
+    impl = sym.getTypeImpl()
 
   types.add &"class {objName}(Structure):\n"
   types.add "    _fields_ = [\n"
-  for identDefs in sym.getImpl()[2][2]:
+  for identDefs in impl[2]:
     for property in identDefs[0 .. ^3]:
-      types.add &"        (\"{toSnakeCase(property[1].repr)}\""
+      types.add &"        (\"{toSnakeCase(property.repr)}\""
       types.add ", "
       types.add &"{exportTypePy(identDefs[^2])}),\n"
   types.removeSuffix ",\n"
@@ -234,10 +236,10 @@ proc exportObjectPy*(sym: NimNode, constructor: NimNode) =
       types.add ", "
     types.removeSuffix ", "
     types.add ")\n"
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
-        types.add &"        self.{toSnakeCase(property[1].repr)} = "
-        types.add &"tmp.{toSnakeCase(property[1].repr)}\n"
+        types.add &"        self.{toSnakeCase(property.repr)} = "
+        types.add &"tmp.{toSnakeCase(property.repr)}\n"
     types.add "\n"
     var dllParams: seq[NimNode]
     for param in constructorParams:
@@ -245,27 +247,27 @@ proc exportObjectPy*(sym: NimNode, constructor: NimNode) =
     dllProc(&"dll.$lib_{toSnakeCase(objName)}", toArgTypes(dllParams), objName)
   else:
     types.add "    def __init__(self, "
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
-        types.add &"{toSnakeCase(property[1].repr)}, "
+        types.add &"{toSnakeCase(property.repr)}, "
     types.removeSuffix ", "
     types.add "):\n"
-    for identDefs in sym.getImpl()[2][2]:
+    for identDefs in impl[2]:
       for property in identDefs[0 .. ^3]:
         types.add "        "
-        types.add &"self.{toSnakeCase(property[1].repr)} = "
-        types.add &"{toSnakeCase(property[1].repr)}\n"
+        types.add &"self.{toSnakeCase(property.repr)} = "
+        types.add &"{toSnakeCase(property.repr)}\n"
     types.add "\n"
 
   types.add "    def __eq__(self, obj):\n"
   types.add "        return "
-  for identDefs in sym.getImpl()[2][2]:
+  for identDefs in impl[2]:
     for property in identDefs[0 .. ^3]:
       if identDefs[^2].len > 0 and identDefs[^2][0].repr == "array":
         for i in 0 ..< identDefs[^2][1].intVal:
-          types.add &"self.{toSnakeCase(property[1].repr)}[{i}] == obj.{toSnakeCase(property[1].repr)}[{i}] and "
+          types.add &"self.{toSnakeCase(property.repr)}[{i}] == obj.{toSnakeCase(property.repr)}[{i}] and "
       else:
-        types.add &"self.{toSnakeCase(property[1].repr)} == obj.{toSnakeCase(property[1].repr)} and "
+        types.add &"self.{toSnakeCase(property.repr)} == obj.{toSnakeCase(property.repr)} and "
   types.removeSuffix " and "
   types.add "\n"
   types.add "\n"
@@ -337,7 +339,7 @@ proc exportRefObjectPy*(
   constructor: NimNode
 ) =
   let
-    objName = sym.repr
+    objName = sym.getName()
     objNameSnaked = toSnakeCase(objName)
     objType = sym.getType()[1].getType()
 
diff --git a/tests/generated/internal.nim b/tests/generated/internal.nim
index c2a5882..032bc4c 100644
--- a/tests/generated/internal.nim
+++ b/tests/generated/internal.nim
@@ -127,3 +127,18 @@ proc test_seq_string_unref*(s: SeqString) {.raises: [], cdecl, exportc, dynlib.}
 proc test_get_datas*(): SeqString {.raises: [], cdecl, exportc, dynlib.} =
   SeqString(s: getDatas())
 
+proc test_gen_simple_int*(a: int): GenSimple[int] {.raises: [], cdecl, exportc, dynlib.} =
+  result.a = a
+
+proc test_gen_simple_int_eq*(a, b: GenSimple[int]): bool {.raises: [], cdecl, exportc, dynlib.}=
+  a.a == b.a
+
+proc test_gen_ref_int_unref*(x: GenRef[int]) {.raises: [], cdecl, exportc, dynlib.} =
+  GC_unref(x)
+
+proc test_new_gen_ref_int*(v: int): GenRef[int] {.raises: [], cdecl, exportc, dynlib.} =
+  newGenRef(v)
+
+proc test_gen_ref_int_noop_gen_ref_int*(x: GenRef[int]): GenRef[int] {.raises: [], cdecl, exportc, dynlib.} =
+  noop(x)
+
diff --git a/tests/generated/test.h b/tests/generated/test.h
index 13b6c3e..0f9b089 100644
--- a/tests/generated/test.h
+++ b/tests/generated/test.h
@@ -28,6 +28,12 @@ typedef struct SimpleObjWithProc {
 
 typedef long long SeqString;
 
+typedef struct GenSimpleInt {
+  long long a;
+} GenSimpleInt;
+
+typedef long long GenRefInt;
+
 /**
  * Returns the integer passed in.
  */
@@ -110,4 +116,14 @@ void test_seq_string_clear(SeqString seq_string);
 
 SeqString test_get_datas();
 
+GenSimpleInt test_gen_simple_int(long long a);
+
+char test_gen_simple_int_eq(GenSimpleInt a, GenSimpleInt b);
+
+void test_gen_ref_int_unref(GenRefInt gen_ref_int);
+
+GenRefInt test_new_gen_ref(long long v);
+
+GenRefInt test_gen_ref_int_noop_gen_ref_int(GenRefInt);
+
 #endif
diff --git a/tests/generated/test.js b/tests/generated/test.js
index 3e8cdfd..9596cb1 100644
--- a/tests/generated/test.js
+++ b/tests/generated/test.js
@@ -190,6 +190,38 @@ function getDatas(){
   return result
 }
 
+const GenSimpleInt = Struct({
+  'a':'int64'
+})
+genSimpleInt = function(a){
+  var v = new GenSimpleInt();
+  v.a = a
+  return v;
+}
+GenSimpleInt.prototype.isEqual = function(other){
+  return self.a == other.a;
+};
+
+GenRefInt = Struct({'nimRef': 'uint64'});
+GenRefInt.prototype.isNull = function(){
+  return this.nimRef == 0;
+};
+GenRefInt.prototype.isEqual = function(other){
+  return this.nimRef == other.nimRef;
+};
+GenRefInt.prototype.unref = function(){
+  return dll.test_gen_ref_int_unref(this)
+};
+function newGenRefInt(v){
+  var result = dll.test_new_gen_ref(v)
+  return result
+}
+
+GenRefInt.prototype.noop = function(){
+  result = dll.test_gen_ref_int_noop_gen_ref_int(this)
+  return result
+}
+
 
 var dllPath = ""
 if(process.platform == "win32") {
@@ -235,6 +267,9 @@ dll = ffi.Library(dllPath, {
   'test_seq_string_add': ['void', [SeqString, 'string']],
   'test_seq_string_clear': ['void', [SeqString]],
   'test_get_datas': [SeqString, []],
+  'test_gen_ref_int_unref': ['void', [GenRefInt]],
+  'test_new_gen_ref': [GenRefInt, ['int64']],
+  'test_gen_ref_int_noop_gen_ref_int': [GenRefInt, [GenRefInt]],
 });
 
 exports.SIMPLE_CONST = 123
@@ -254,3 +289,7 @@ exports.SimpleObjWithProc = SimpleObjWithProc;
 exports.simpleObjWithProc = simpleObjWithProc;
 exports.SeqStringType = SeqString
 exports.getDatas = getDatas
+exports.GenSimpleInt = GenSimpleInt;
+exports.genSimpleInt = genSimpleInt;
+exports.GenRefIntType = GenRefInt
+exports.GenRefInt = newGenRefInt
diff --git a/tests/generated/test.nim b/tests/generated/test.nim
index 292e36e..9712ddf 100644
--- a/tests/generated/test.nim
+++ b/tests/generated/test.nim
@@ -21,9 +21,9 @@ type SimpleEnum* = enum
   Third
 
 type SimpleObj* = object
-  simpleA*: int
-  simpleB*: byte
-  simpleC*: bool
+  simpleA: int
+  simpleB: byte
+  simpleC: bool
 
 proc simpleObj*(simple_a: int, simple_b: byte, simple_c: bool): SimpleObj =
   result.simple_a = simple_a
@@ -61,9 +61,9 @@ proc `=destroy`(x: var RefObjWithSeqObj) =
   test_ref_obj_with_seq_unref(x)
 
 type SimpleObjWithProc* = object
-  simpleA*: int
-  simpleB*: byte
-  simpleC*: bool
+  simpleA: int
+  simpleB: byte
+  simpleC: bool
 
 proc simpleObjWithProc*(simple_a: int, simple_b: byte, simple_c: bool): SimpleObjWithProc =
   result.simple_a = simple_a
@@ -80,6 +80,22 @@ proc test_seq_string_unref(x: SeqStringObj) {.importc: "test_seq_string_unref",
 proc `=destroy`(x: var SeqStringObj) =
   test_seq_string_unref(x)
 
+type GenSimpleInt* = object
+  a: int
+
+proc genSimpleInt*(a: int): GenSimpleInt =
+  result.a = a
+
+type GenRefIntObj = object
+  reference: pointer
+
+type GenRefInt* = ref GenRefIntObj
+
+proc test_gen_ref_int_unref(x: GenRefIntObj) {.importc: "test_gen_ref_int_unref", cdecl.}
+
+proc `=destroy`(x: var GenRefIntObj) =
+  test_gen_ref_int_unref(x)
+
 proc test_simple_call(a: int): int {.importc: "test_simple_call", cdecl.}
 
 proc simpleCall*(a: int): int {.inline.} =
@@ -236,3 +252,13 @@ proc test_get_datas(): SeqString {.importc: "test_get_datas", cdecl.}
 proc getDatas*(): SeqString {.inline.} =
   result = test_get_datas()
 
+proc test_new_gen_ref_int(v: int): GenRef[int] {.importc: "test_new_gen_ref_int", cdecl.}
+
+proc newGenRef*(v: int): GenRef[int] {.inline.} =
+  result = test_new_gen_ref_int(v)
+
+proc test_gen_ref_int_noop_gen_ref_int(x: GenRef[int]): GenRef[int] {.importc: "test_gen_ref_int_noop_gen_ref_int", cdecl.}
+
+proc noop*(x: GenRef[int]): GenRef[int] {.inline.} =
+  result = test_gen_ref_int_noop_gen_ref_int(x)
+
diff --git a/tests/generated/test.py b/tests/generated/test.py
index e9f3274..ad0ae90 100644
--- a/tests/generated/test.py
+++ b/tests/generated/test.py
@@ -234,6 +234,37 @@ def get_datas():
     result = dll.test_get_datas()
     return result
 
+class GenSimpleInt(Structure):
+    _fields_ = [
+        ("a", c_longlong)
+    ]
+
+    def __init__(self, a):
+        self.a = a
+
+    def __eq__(self, obj):
+        return self.a == obj.a
+
+class GenRefInt(Structure):
+    _fields_ = [("ref", c_ulonglong)]
+
+    def __bool__(self):
+        return self.ref != None
+
+    def __eq__(self, obj):
+        return self.ref == obj.ref
+
+    def __del__(self):
+        dll.test_gen_ref_int_unref(self)
+
+    def __init__(self, v):
+        result = dll.test_new_gen_ref(v)
+        self.ref = result
+
+    def noop(self):
+        result = dll.test_gen_ref_int_noop(self)
+        return result
+
 dll.test_simple_call.argtypes = [c_longlong]
 dll.test_simple_call.restype = c_longlong
 
@@ -336,3 +367,12 @@ def get_datas():
 dll.test_get_datas.argtypes = []
 dll.test_get_datas.restype = SeqString
 
+dll.test_gen_ref_int_unref.argtypes = [GenRefInt]
+dll.test_gen_ref_int_unref.restype = None
+
+dll.test_new_gen_ref.argtypes = [c_longlong]
+dll.test_new_gen_ref.restype = c_ulonglong
+
+dll.test_gen_ref_int_noop.argtypes = [GenRefInt]
+dll.test_gen_ref_int_noop.restype = GenRefInt
+
diff --git a/tests/test.nim b/tests/test.nim
index 84c7ca5..389bb14 100644
--- a/tests/test.nim
+++ b/tests/test.nim
@@ -113,6 +113,28 @@ exportSeq seq[string]:
 exportProcs:
   getDatas
 
+## Generics
+
+type
+  GenSimple[T] = object
+    a: T
+
+  GenRef[T] = ref GenSimple[T]
+
+proc noop[T](x: GenRef[T]): GenRef[T] = x
+
+proc newGenRef[T](v: T): GenRef[T] =
+  GenRef[T](a: v)
+
+exportObject GenSimple[int]:
+  discard
+
+exportRefObject GenRef[int]:
+  constructor:
+    newGenRef[int](int)
+  procs:
+    noop(GenRef[int])
+
 writeFiles("tests/generated", "test")
 
 include generated/internal