diff --git a/fonts/FiraSansOT-Medium_gpos.otf b/fonts/FiraSansOT-Medium_gpos.otf
new file mode 100644
index 00000000..0a158367
Binary files /dev/null and b/fonts/FiraSansOT-Medium_gpos.otf differ
diff --git a/src/opentype.js b/src/opentype.js
index a364e871..993335af 100644
--- a/src/opentype.js
+++ b/src/opentype.js
@@ -179,7 +179,7 @@ function parseBuffer(buffer) {
     }
 
     if (gposOffset) {
-        gpos.parse(data, gposOffset, font);
+        font.tables.gpos = gpos.parse(data, gposOffset, font);
     }
 
     return font;
diff --git a/src/parse.js b/src/parse.js
index 7550be50..6997506f 100644
--- a/src/parse.js
+++ b/src/parse.js
@@ -104,6 +104,33 @@ Parser.prototype.parseByte = function() {
     return v;
 };
 
+Parser.prototype.hexdump = function(length, width) {
+    var length = length || 32;
+    var width = width || 8;
+
+    function paddedHex(v, n){
+        return (v + (1<<(4*n))).toString(16).substr(-n).toUpperCase();
+    }
+
+    var result = "";
+    var values = [];
+    for (var i=0; i < length; i++){
+        var v = this.data.getUint8(this.offset + this.relativeOffset + i);
+        values.push(paddedHex(v,2));
+        if (i % width === width-1){
+            var address = width * Math.floor(i/width);
+            result += paddedHex(address,4) + ":\t";
+            result += values.join(' ') + "\n";
+            values = []
+        }
+    }
+    if (values.length){
+        result += width * Math.floor(i/width) + ":\t";
+        result += values.join('\t') + "\n";
+    }
+    return result;
+};
+
 Parser.prototype.parseChar = function() {
     var v = this.data.getInt8(this.offset + this.relativeOffset);
     this.relativeOffset += 1;
diff --git a/src/table.js b/src/table.js
index d47fea98..1712ef8a 100644
--- a/src/table.js
+++ b/src/table.js
@@ -31,11 +31,15 @@ Table.prototype.sizeOf = function() {
     var v = 0;
     for (var i = 0; i < this.fields.length; i += 1) {
         var field = this.fields[i];
+        check.assert(field.name !== undefined, 'Field at index i='+i+' has undefined name and its value is "' + field.value + '". The field object is:'+ field + ' this.tableName='+this.tableName);
+
         var value = this[field.name];
         if (value === undefined) {
             value = field.value;
         }
 
+        check.assert(value !== undefined, 'field.name: "' + field.name + '" has undefined value!');
+
         if (typeof value.sizeOf === 'function') {
             v += value.sizeOf();
         } else {
diff --git a/src/tables/gpos.js b/src/tables/gpos.js
index 61dddb84..38a11715 100644
--- a/src/tables/gpos.js
+++ b/src/tables/gpos.js
@@ -5,6 +5,7 @@
 
 var check = require('../check');
 var parse = require('../parse');
+var table = require('../table');
 
 // Parse ScriptList and FeatureList tables of GPOS, GSUB, GDEF, BASE, JSTF tables.
 // These lists are unused by now, this function is just the basis for a real parsing.
@@ -22,21 +23,29 @@ function parseTaggedListTable(data, start) {
 // Parse a coverage table in a GSUB, GPOS or GDEF table.
 // Format 1 is a simple list of glyph ids,
 // Format 2 is a list of ranges. It is expanded in a list of glyphs, maybe not the best idea.
-function parseCoverageTable(data, start) {
+function parseCoverageTable(data, start, subtable) {
     var p = new parse.Parser(data, start);
-    var format = p.parseUShort();
-    var count =  p.parseUShort();
-    if (format === 1) {
-        return p.parseUShortList(count);
+    subtable.coveragetable = [];
+    subtable.coveragetable.format = p.parseUShort();
+    subtable.coveragetable.count =  p.parseUShort();
+    if (subtable.coveragetable.format === 1) {
+        return p.parseUShortList(subtable.coveragetable.count);
     }
-    else if (format === 2) {
+    else if (subtable.coveragetable.format === 2) {
+        subtable.ranges = [];
         var coverage = [];
+        var count = subtable.coveragetable.count;
         for (; count--;) {
-            var begin = p.parseUShort();
-            var end = p.parseUShort();
-            var index = p.parseUShort();
-            for (var i = begin; i <= end; i++) {
-                coverage[index++] = i;
+            var range = {
+                'begin': p.parseUShort(),
+                'end': p.parseUShort(),
+                'index': p.parseUShort()
+            };
+            subtable.ranges.push(range);
+
+            var index = range.index;
+            for (var j = range.begin; j <= range.end; j++) {
+                coverage[index++] = j;
             }
         }
 
@@ -92,54 +101,109 @@ function parseClassDefTable(data, start) {
 }
 
 // Parse a pair adjustment positioning subtable, format 1 or format 2
-// The subtable is returned in the form of a lookup function.
 function parsePairPosSubTable(data, start) {
     var p = new parse.Parser(data, start);
+    console.error("parsePairPosSubTable(data, start="+start+"): \n" + p.hexdump());
+
+    var subTable = {};
+    var coverageOffset;
+    var value1;
+    var value2;
+
     // This part is common to format 1 and format 2 subtables
-    var format = p.parseUShort();
-    var coverageOffset = p.parseUShort();
-    var coverage = parseCoverageTable(data, start + coverageOffset);
+    subTable.format = p.parseUShort();
+    coverageOffset = p.parseUShort();
+    subTable.valueFormat1 = p.parseUShort();
+    subTable.valueFormat2 = p.parseUShort();
+
+    console.error("subTable.format: " + subTable.format);
+    console.error("coverageOffset: " + coverageOffset);
+    console.error("valueFormat1: " + subTable.valueFormat1);
+    console.error("valueFormat2: " + subTable.valueFormat2);
+
     // valueFormat 4: XAdvance only, 1: XPlacement only, 0: no ValueRecord for second glyph
     // Only valueFormat1=4 and valueFormat2=0 is supported.
-    var valueFormat1 = p.parseUShort();
-    var valueFormat2 = p.parseUShort();
-    var value1;
-    var value2;
-    if (valueFormat1 !== 4 || valueFormat2 !== 0) return;
-    var sharedPairSets = {};
-    if (format === 1) {
+    check.argument(subTable.valueFormat1 == 4 && subTable.valueFormat2 == 0,
+                   'GPOS table: Only valueFormat1 = 4 and valueFormat2 = 0 is supported.');
+
+    subTable.coverage = parseCoverageTable(data, start + coverageOffset, subTable);
+
+    if (subTable.format == 1) {
         // Pair Positioning Adjustment: Format 1
+
         var pairSetCount = p.parseUShort();
-        var pairSet = [];
-        // Array of offsets to PairSet tables-from beginning of PairPos subtable-ordered by Coverage Index
-        var pairSetOffsets = p.parseOffset16List(pairSetCount);
+        var pairSetOffsets = p.parseOffset16List(pairSetCount);  // Array of offsets to PairSet tables-from beginning of PairPos subtable-ordered by Coverage Index
+        console.error("FORMAT==1: pairSetCount: " + pairSetCount);
+
+        for (var i=0; i<pairSetCount; i++){
+            p.relativeOffset = pairSetOffsets[i] + 0;
+            console.error("DEBUG pairSetOffsets["+i+"] = " + pairSetOffsets[i] + " HEXDUMP: " + p.hexdump(80));
+        }
+
+        var psets = [];
+        subTable.pairsets = [];
         for (var firstGlyph = 0; firstGlyph < pairSetCount; firstGlyph++) {
             var pairSetOffset = pairSetOffsets[firstGlyph];
-            var sharedPairSet = sharedPairSets[pairSetOffset];
+            var sharedPairSet = psets[pairSetOffset];
             if (!sharedPairSet) {
                 // Parse a pairset table in a pair adjustment subtable format 1
-                sharedPairSet = {};
+                sharedPairSet = {valueRecords: []};
                 p.relativeOffset = pairSetOffset;
                 var pairValueCount = p.parseUShort();
+                console.error("pairValueCount = " + pairValueCount + "\nhexdump:\n" + p.hexdump(4*5, 4));
                 for (; pairValueCount--;) {
-                    var secondGlyph = p.parseUShort();
-                    if (valueFormat1) value1 = p.parseShort();
-                    if (valueFormat2) value2 = p.parseShort();
-                    // We only support valueFormat1 = 4 and valueFormat2 = 0,
-                    // so value1 is the XAdvance and value2 is empty.
-                    sharedPairSet[secondGlyph] = value1;
+                    var value = {};
+                    value.secondGlyph = p.parseUShort();
+                    if (subTable.valueFormat1) value.v1 = p.parseShort();
+                    if (subTable.valueFormat2) value.v2 = p.parseShort();
+                    sharedPairSet.valueRecords.push(value);
+                    if (sharedPairSet.valueRecords.length < 5) console.error("VALUE: v1=" + value.v1 + " v2=" + value.v2 + " secondGlyph=" + value.secondGlyph);
                 }
+                psets[pairSetOffset] = sharedPairSet;
             }
 
-            pairSet[coverage[firstGlyph]] = sharedPairSet;
+            subTable.pairsets[subTable.coverage[firstGlyph]] = sharedPairSet;
         }
 
-        return function(leftGlyph, rightGlyph) {
-            var pairs = pairSet[leftGlyph];
-            if (pairs) return pairs[rightGlyph];
+/*
+        var psets = [];
+        subTable.pairsets = [];
+        for (var index = 0; index < subTable.coverage.length; index++) {
+            var firstGlyph = subTable.coverage[index];
+            var pairSetOffset = pairSetOffsets[firstGlyph];
+            var sharedPairSet = psets[pairSetOffset];
+            if (!sharedPairSet) {
+                // Parse a pairset table in a pair adjustment subtable format 1
+                sharedPairSet = {valueRecords: []};
+                p.relativeOffset = pairSetOffset;
+                var pairValueCount = p.parseUShort();
+                console.error("pairValueCount = " + pairValueCount + "\nhexdump:\n" + p.hexdump(4*5, 4));
+                for (; pairValueCount--;) {
+                    var value = {};
+                    value.secondGlyph = p.parseUShort();
+                    if (subTable.valueFormat1) value.v1 = p.parseShort();
+                    if (subTable.valueFormat2) value.v2 = p.parseShort();
+                    sharedPairSet.valueRecords.push(value);
+                    if (sharedPairSet.valueRecords.length < 5) console.error("VALUE: v1=" + value.v1 + " v2=" + value.v2 + " secondGlyph=" + value.secondGlyph);
+                }
+                psets[pairSetOffset] = sharedPairSet;
+            }
+
+            subTable.pairsets[index] = sharedPairSet;
+        }
+*/
+        subTable.getValue = function(leftGlyph, rightGlyph) {
+            var pairs = subTable.pairsets[leftGlyph];
+
+            // We only support valueFormat1 = 4 and valueFormat2 = 0,
+            // so value1 is the XAdvance and value2 is empty.
+            if (pairs) return pairs[rightGlyph].v1;
         };
+        return subTable;
     }
-    else if (format === 2) {
+    else if (subTable.format == 2) {
+        //console.error("FORMAT==2");
+
         // Pair Positioning Adjustment: Format 2
         var classDef1Offset = p.parseUShort();
         var classDef2Offset = p.parseUShort();
@@ -153,8 +217,8 @@ function parsePairPosSubTable(data, start) {
         for (var i = 0; i < class1Count; i++) {
             var kerningRow = kerningMatrix[i] = [];
             for (var j = 0; j < class2Count; j++) {
-                if (valueFormat1) value1 = p.parseShort();
-                if (valueFormat2) value2 = p.parseShort();
+                if (subTable.valueFormat1) value1 = p.parseShort();
+                if (subTable.valueFormat2) value2 = p.parseShort();
                 // We only support valueFormat1 = 4 and valueFormat2 = 0,
                 // so value1 is the XAdvance and value2 is empty.
                 kerningRow[j] = value1;
@@ -163,10 +227,11 @@ function parsePairPosSubTable(data, start) {
 
         // Convert coverage list to a hash
         var covered = {};
-        for (i = 0; i < coverage.length; i++) covered[coverage[i]] = 1;
+        for (i = 0; i < subTable.coverage.length; i++)
+            covered[subTable.coverage[i]] = 1;
 
         // Get the kerning value for a specific glyph pair.
-        return function(leftGlyph, rightGlyph) {
+        subTable.getValue = function(leftGlyph, rightGlyph) {
             if (!covered[leftGlyph]) return;
             var class1 = getClass1(leftGlyph);
             var class2 = getClass2(rightGlyph);
@@ -176,39 +241,100 @@ function parsePairPosSubTable(data, start) {
                 return kerningRow[class2];
             }
         };
+        return subTable;
     }
 }
 
+var LType = Object.freeze({
+      SINGLE_ADJUSTMENT: 1
+    , PAIR_ADJUSTMENT: 2
+    , CURSIVE_ADJUSTMENT: 3
+    , MARK_TO_BASE_ATTACHMENT: 4
+    , MARK_TO_LIGATURE_ATTACHMENT: 5
+    , MARK_TO_MARK_ATTACHMENT: 6
+    , CONTEXTUAL_POSITIONING: 7
+    , CHAINED_CONTEXTUAL_POSITIONING: 8
+    , EXTENSION_POSITIONING: 9
+});
+
 // Parse a LookupTable (present in of GPOS, GSUB, GDEF, BASE, JSTF tables).
 function parseLookupTable(data, start) {
+    console.error("== Parse Lookup Table ==");
+//    console.error("== start:" + start + " ==");
     var p = new parse.Parser(data, start);
-    var lookupType = p.parseUShort();
-    var lookupFlag = p.parseUShort();
-    var useMarkFilteringSet = lookupFlag & 0x10;
-    var subTableCount = p.parseUShort();
-    var subTableOffsets = p.parseOffset16List(subTableCount);
-    var table = {
-        lookupType: lookupType,
-        lookupFlag: lookupFlag,
-        markFilteringSet: useMarkFilteringSet ? p.parseUShort() : -1
-    };
-    // LookupType 2, Pair adjustment
-    if (lookupType === 2) {
-        var subtables = [];
-        for (var i = 0; i < subTableCount; i++) {
-            subtables.push(parsePairPosSubTable(data, start + subTableOffsets[i]));
+    console.error(">> hexdump:\n" + p.hexdump());
+
+    var lookupType = p.parseUShort()
+      , lookupFlag = p.parseUShort()
+      , useMarkFilteringSet = lookupFlag & 0x10
+      , subTableCount = p.parseUShort()
+      , subTableOffsets = p.parseOffset16List(subTableCount)
+      , table = {
+            lookupType: lookupType,
+            lookupFlag: lookupFlag,
+            subtables: [],
+            markFilteringSet: useMarkFilteringSet ? p.parseUShort() : -1
         }
-        // Return a function which finds the kerning values in the subtables.
-        table.getKerningValue = function(leftGlyph, rightGlyph) {
-            for (var i = subtables.length; i--;) {
-                var value = subtables[i](leftGlyph, rightGlyph);
-                if (value !== undefined) return value;
+      ;
+
+    console.error("lookupType: ", lookupType);
+    console.error("lookupFlag: ", lookupFlag);
+    console.error("subTableCount: ", subTableCount);
+
+    switch (lookupType){
+        case LType.SINGLE_ADJUSTMENT:
+            console.error("FIX-ME: lookup type SINGLE_ADJUSTMENT is not implemented!");
+            break;
+
+        case LType.PAIR_ADJUSTMENT:
+            console.error("PAIR_ADJUSTMENT start:", start);
+            for (var i = 0; i < subTableCount; i++) {
+                console.error("parsed subTableOffsets[i]:", subTableOffsets[i]);
+                table.subtables.push(parsePairPosSubTable(data, start + subTableOffsets[i]));
             }
+            break;
 
-            return 0;
-        };
+        case LType.CURSIVE_ADJUSTMENT:
+            console.error("FIX-ME: lookup type CURSIVE_ADJUSTMENT is not implemented!");
+            break;
+
+        case LType.MARK_TO_BASE_ATTACHMENT:
+            console.error("FIX-ME: lookup type MARK_TO_BASE_ATTACHMENT is not implemented!");
+            break;
+
+        case LType.MARK_TO_LIGATURE_ATTACHMENT:
+            console.error("FIX-ME: lookup type MARK_TO_LIGATURE_ATTACHMENT is not implemented!");
+            break;
+
+        case LType.MARK_TO_MARK_ATTACHMENT:
+            console.error("FIX-ME: lookup type MARK_TO_MARK_ATTACHMENT is not implemented!");
+            break;
+
+        case LType.CONTEXTUAL_POSITIONING:
+            console.error("FIX-ME: lookup type CONTEXTUAL_POSITIONING is not implemented!");
+            break;
+
+        case LType.CHAINED_CONTEXTUAL_POSITIONING:
+            console.error("FIX-ME: lookup type CHAINED_CONTEXTUAL_POSITIONING is not implemented!");
+            break;
+
+        case LType.EXTENSION_POSITIONING:
+            console.error("FIX-ME: lookup type EXTENSION_POSITIONING is not implemented!");
+            break;
+        default:
+            console.error("Invalid Lookup Type!");
     }
 
+    // Provide a function which finds the kerning values in the subtables.
+    table.getKerningValue = function(leftGlyph, rightGlyph) {
+        for (var i = table.subtables.length; i--;) {
+            var value = table.subtables[i].getValue(leftGlyph, rightGlyph);
+            if (value !== undefined) return value;
+        }
+
+        return 0;
+    };
+
     return table;
 }
 
@@ -216,24 +342,251 @@ function parseLookupTable(data, start) {
 // https://www.microsoft.com/typography/OTSPEC/gpos.htm
 function parseGposTable(data, start, font) {
     var p = new parse.Parser(data, start);
-    var tableVersion = p.parseFixed();
-    check.argument(tableVersion === 1, 'Unsupported GPOS table version.');
+
+    console.error("**********************************************************\nparseGposTable");
+//  console.error("hexdump:\n" + p.hexdump());
+
+    var gpos = {};
+    gpos.tableVersion = p.parseFixed();
+    check.argument(gpos.tableVersion === 1, 'Unsupported GPOS table version ('+gpos.tableVersion+').');
 
     // ScriptList and FeatureList - ignored for now
-    parseTaggedListTable(data, start + p.parseUShort());
     // 'kern' is the feature we are looking for.
-    parseTaggedListTable(data, start + p.parseUShort());
+    gpos.scriptList = parseTaggedListTable(data, start + p.parseUShort());
+    gpos.featureList = parseTaggedListTable(data, start + p.parseUShort());
 
     // LookupList
+    gpos.lookupList = Array();
     var lookupListOffset = p.parseUShort();
     p.relativeOffset = lookupListOffset;
     var lookupCount = p.parseUShort();
+
+    console.error("lookupCount:", lookupCount);
+
     var lookupTableOffsets = p.parseOffset16List(lookupCount);
     var lookupListAbsoluteOffset = start + lookupListOffset;
+    console.error("lookupListAbsoluteOffset: " + lookupListAbsoluteOffset);
     for (var i = 0; i < lookupCount; i++) {
+        console.error("lookupTableOffsets["+i+"]: " + lookupTableOffsets[i]);
         var table = parseLookupTable(data, lookupListAbsoluteOffset + lookupTableOffsets[i]);
         if (table.lookupType === 2 && !font.getGposKerningValue) font.getGposKerningValue = table.getKerningValue;
+        gpos.lookupList.push(table);
+    }
+    return gpos;
+}
+
+function encodeCoverageTable(t, subtable, PREFIX){
+    var size = 0;
+    t.fields.push({name: PREFIX+'_format', type: 'USHORT', value: subtable.coveragetable.format});
+    t.fields.push({name: PREFIX+'_count', type: 'USHORT', value: subtable.coveragetable.count});
+    size += 4;
+
+    switch (subtable.format){
+        case 1:
+            for (var i=0; i < subtable.coveragetable.count; i++){
+                t.fields.push({name: PREFIX+"_coverage_"+i, type: 'USHORT', value: subtable.coverage[i]});
+                size += 2;
+            }
+            break;
+        case 2:
+            check.argument(subtable.ranges.length === subtable.coveragetable.count, 'subtable.ranges.length=' + subtable.ranges.length + ' subtable.count=' + subtable.coveragetable.count);
+            var coverage = [];
+            for (var i=0; i < subtable.coveragetable.count; i++) {
+                var range = subtable.ranges[i];
+                t.fields.push({name: PREFIX+"_rage_begin_"+i, type: 'USHORT', value: range.begin});
+                t.fields.push({name: PREFIX+"_rage_end_"+i, type: 'USHORT', value: range.end});
+                t.fields.push({name: PREFIX+"_rage_index_"+i, type: 'USHORT', value: range.index});
+                size += 6;
+            }
+            break;
+        default:
+            console.error("wrong coverage subtable format (" + subtable.format + ")");
+    }
+
+    return size;
+}
+
+function encodePairSet(t, subtable, i){
+    var size = 0;
+    var pairset = subtable.pairsets[subtable.coverage[i]];
+    if (!pairset) console.error("encodePairSet: pairset is undefined! i="+i);
+    var pairValueCount = pairset.valueRecords.length;
+
+    t.push({name: "PairValueCount", type: 'USHORT', value: pairValueCount});
+    size += 2;
+    for (var firstGlyph = 0; firstGlyph < pairValueCount; firstGlyph++) {
+        var value = pairset.valueRecords[firstGlyph];
+        t.push({name: "value_secondGlyph", type: 'USHORT', value: value.secondGlyph});
+        size += 2;
+
+        if (subtable.valueFormat1) { t.push({name: "value_v1", type: 'USHORT', value: value.v1}); size += 2; }
+        if (subtable.valueFormat2) { t.push({name: "value_v2", type: 'USHORT', value: value.v2}); size += 2; }
+    }
+
+    return size;
+}
+
+function encodePairPosSubTable(t, subtable, i, prefix){
+    var size = 0;
+    var start = t.sizeOf();
+    var PREFIX = prefix + '_' + i;
+
+    t.fields.push({name: PREFIX+'_format', type: 'USHORT', value: subtable.format});
+    t.fields.push({name: PREFIX+'_coverageOffset', type: 'USHORT', value: 0});
+    t.fields.push({name: PREFIX+'_valueFormat1', type: 'USHORT', value: subtable.valueFormat1});
+    t.fields.push({name: PREFIX+'_valueFormat2', type: 'USHORT', value: subtable.valueFormat2});
+
+    switch (subtable.format){
+        case 1:
+            console.error("subtable.pairsets.length: " + subtable.pairsets.length);
+            t.fields.push({name: PREFIX+'_pairSetCount', type: 'USHORT', value: subtable.pairsets.length});
+
+            var pairSetOffsets = [];
+            var pairSets = [];
+            
+            var offset = t.sizeOf();
+            console.error("encodePairPosSubTable >>>>>>>>>>>>>>>>> subtable.coverage.length: " + subtable.coverage.length);
+            for (var j=0; j < subtable.coverage.length; j++){
+                pairSetOffsets.push({name: PREFIX+'_offset_'+j, type: 'USHORT', value: offset});
+                offset += encodePairSet(pairSets, subtable, j);
+            }
+
+            t.fields = t.fields.concat(pairSetOffsets);
+            t.fields = t.fields.concat(pairSets);
+            break;
+        case 2:
+            console.error("Not yet implemented: encodePairPosSubTable format=2");
+            break;
+        default:
+            console.error("Invalid subtable format: encodePairPosSubTable format=" + subtable.format);
+    }
+
+    var ct = new table.Table("Coverage", []);
+    encodeCoverageTable(ct, subtable, PREFIX);
+    t[PREFIX+'_coverageOffset'] = t.sizeOf() - start;
+    t.fields = t.fields.concat(ct.fields);
+
+    return t.sizeOf();
+}
+
+function encodeLookupEntry(t, gpos, i){
+    console.error("== Encode Lookup Entry ==");
+    var start = t.sizeOf();
+    var ltable = gpos.lookupList[i];
+    var PREFIX = 'lookup_' + i;
+    var lookupEntry = new table.Table('LookupEntry', [
+        {name: PREFIX+'_type', type: 'USHORT', value: ltable.lookupType}
+      , {name: PREFIX+'_flag', type: 'USHORT', value: ltable.lookupFlag}
+    ]);
+    var size = lookupEntry.sizeOf();
+
+    console.error("ltable.lookupType: " + ltable.lookupType);
+    console.error("ltable.lookupFlag: " + ltable.lookupFlag);
+
+    var offsets = [];
+    var subtable_data = new table.Table('DATA', []);
+
+    if (table.lookupFlag & 0x10){
+        lookupEntry.push({name: PREFIX+'_markFilteringSet', type: 'USHORT', value: ltable.markFilteringSet});
+        size += 2;
+    }
+
+    switch (ltable.lookupType){
+        case LType.SINGLE_ADJUSTMENT:
+            console.error("ERROR: Unimplemented Lookup Type: " + ltable.lookupType);
+            return 0;
+
+        case LType.PAIR_ADJUSTMENT: //Pair adjustment
+            for (var j = 0; j < ltable.subtables.length; j++) {
+                offsets.push(8+size); //why 8 ?! This probably should be calculated from the previous table header size...
+                size += encodePairPosSubTable(subtable_data, ltable.subtables[j], j, PREFIX);
+            }
+            break;
+
+        case LType.CURSIVE_ADJUSTMENT:
+        case LType.MARK_TO_BASE_ATTACHMENT:
+        case LType.MARK_TO_LIGATURE_ATTACHMENT:
+        case LType.MARK_TO_MARK_ATTACHMENT:
+        case LType.CONTEXTUAL_POSITIONING:
+        case LType.CHAINED_CONTEXTUAL_POSITIONING:
+        case LType.EXTENSION_POSITIONING:
+            console.error("ERROR: Unimplemented Lookup Type: " + ltable.lookupType);
+            return 0;
+        default:
+            console.error("Invalid Lookup Type: " + ltable.lookupType);
+            return 0;
+    }
+
+    t.fields = t.fields.concat(lookupEntry.fields);
+    t.fields.push({name: PREFIX+'_subtable_count', type: 'USHORT', value: offsets.length})
+    console.error("encoded subtable_count:" + offsets.length);
+
+    for (var i=0; i<offsets.length; i++){
+        console.error("encoded offsets[i]:" + offsets[i]);
+        t.fields.push({name: PREFIX+"_offset_"+i, type: 'USHORT', value: offsets[i]});
+    }
+
+    t.fields = t.fields.concat(subtable_data.fields);
+    return t.sizeOf() - start;
+}
+
+function makeScriptList(t, gpos){
+ /* ignored by parser */
+ // FIX-ME! For now this is only a void list:
+    var numEntries = 0;
+    t.fields.push({name: 'ScripitListNumEntries', type: 'USHORT', value: numEntries});
+}
+
+function makeFeatureList(t, gpos){
+ /* ignored by parser */
+ // FIX-ME! For now this is only a void list:
+    var numEntries = 0;
+    t.fields.push({name: 'FeatureListNumEntries', type: 'USHORT', value: numEntries});
+}
+
+function makeGposTable(font) {
+    var gpos = font.tables.gpos;
+    console.error("------------------------- MAKE GPOS TABLE -------------------------");
+    check.argument(gpos.tableVersion === 1, 'Encoding unsupported GPOS table version ('+gpos.tableVersion+').');
+
+    var t = new table.Table('GPOS', [
+        {name: 'version', type: 'FIXED', value: 0x00010000 /*gpos.tableVersion*/},
+        {name: 'scriptListOffset', type: 'USHORT', value: 0},
+        {name: 'featureListOffset', type: 'USHORT', value: 0},
+        {name: 'lookupListOffset', type: 'USHORT', value: 0},
+    ]);
+
+    t.scriptListOffset = t.sizeOf();
+    makeScriptList(t, gpos);
+
+    t.featureListOffset = t.sizeOf();
+    makeFeatureList(t, gpos);
+
+    console.error("makeGposTable(): gpos.lookupList.length = " + gpos.lookupList.length);
+
+    t.lookupListOffset = t.sizeOf();
+
+    var lookupOffsets = [];
+    var lookupEntries = new table.Table('LookupEntries', []);
+    var offset_in_table = 0;
+    for (var i = 0; i < gpos.lookupList.length; i++) {
+        var size = encodeLookupEntry(lookupEntries, gpos, i);
+        if (size>0){
+            console.error("encoded offset_in_table: ", offset_in_table);
+            lookupOffsets.push(offset_in_table);
+            offset_in_table += size;
+        }
+    }
+
+    console.error("encoded lookupOffsets.length: ", lookupOffsets.length);
+
+    t.fields.push({name: 'lookupCount', type: 'USHORT', value: lookupOffsets.length});
+    for (var i = 0; i < lookupOffsets.length; i++) {
+        t.fields.push({name: 'LookupOffset_'+i, type: 'USHORT', value: 2 + 2*lookupOffsets.length + lookupOffsets[i]});
     }
+    t.fields = t.fields.concat(lookupEntries.fields);
+    return t;
 }
 
 exports.parse = parseGposTable;
+exports.make = makeGposTable;
diff --git a/src/tables/kern.js b/src/tables/kern.js
index 0f7b046e..63850f96 100644
--- a/src/tables/kern.js
+++ b/src/tables/kern.js
@@ -12,7 +12,8 @@ function parseKernTable(data, start) {
     var pairs = {};
     var p = new parse.Parser(data, start);
     var tableVersion = p.parseUShort();
-    check.argument(tableVersion === 0, 'Unsupported kern table version.');
+    if (tableVersion !== 0) return;
+//    check.argument(tableVersion === 0, 'Unsupported kern table version.');
     // Skip nTables.
     p.skip('uShort', 1);
     var subTableVersion = p.parseUShort();
diff --git a/src/tables/sfnt.js b/src/tables/sfnt.js
index 4ca67ea2..e5c9d1ec 100644
--- a/src/tables/sfnt.js
+++ b/src/tables/sfnt.js
@@ -11,6 +11,7 @@ var table = require('../table');
 
 var cmap = require('./cmap');
 var cff = require('./cff');
+var gpos = require('./gpos');
 var head = require('./head');
 var hhea = require('./hhea');
 var hmtx = require('./hmtx');
@@ -192,6 +193,8 @@ function fontToSfntTable(font) {
     globals.ascender = font.ascender !== undefined ? font.ascender : globals.yMax;
     globals.descender = font.descender !== undefined ? font.descender : globals.yMin;
 
+    var gposTable = gpos.make(font);
+
     var headTable = head.make({
         unitsPerEm: font.unitsPerEm,
         xMin: globals.xMin,
@@ -270,7 +273,7 @@ function fontToSfntTable(font) {
         unitsPerEm: font.unitsPerEm
     });
     // Order the tables according to the the OpenType specification 1.4.
-    var tables = [headTable, hheaTable, maxpTable, os2Table, nameTable, cmapTable, postTable, cffTable, hmtxTable];
+    var tables = [headTable, hheaTable, maxpTable, os2Table, nameTable, cmapTable, postTable, cffTable, hmtxTable, gposTable];
 
     var sfntTable = makeSfntTable(tables);
 
diff --git a/test/opentypeSpec.js b/test/opentypeSpec.js
index 60ff6908..569ab10f 100644
--- a/test/opentypeSpec.js
+++ b/test/opentypeSpec.js
@@ -7,6 +7,7 @@ var it = mocha.it;
 var opentype = require('../src/opentype.js');
 
 describe('OpenType.js', function() {
+if (0){
     it('can load a TrueType font', function() {
         var font = opentype.loadSync('./fonts/Roboto-Black.ttf');
         assert.equal(font.familyName, 'Roboto Bk');
@@ -28,4 +29,59 @@ describe('OpenType.js', function() {
         assert.equal(aGlyph.unicode, 65);
         assert.equal(aGlyph.path.commands.length, 14);
     });
+
+    it('can generate an OpenType/CFF font', function() {
+        var font = opentype.loadSync('./fonts/FiraSansOT-Medium.otf');
+        assert.notEqual(font.tables.gpos, undefined);
+        assert.notEqual(font.tables.gpos.lookupList, undefined);
+        font.toBuffer();
+    });
+}
+
+    it('can preserve OTF GPOS table fields', function() {
+        //Load original font
+        var font = opentype.loadSync('./fonts/FiraSansOT-Medium.otf');
+        assert.notEqual(font.tables, undefined);
+        assert.notEqual(font.tables.gpos, undefined);
+        assert.notEqual(font.tables.gpos.lookupList, undefined);
+
+        //keep copies of the values of the fields we'll ckeck for persistance
+        var old_llist = font.tables.gpos.lookupList;
+
+        //export the font
+        var buffer = font.toBuffer();
+
+        //load the generated font
+        var newfont = opentype.parse(buffer);
+        assert.notEqual(newfont.tables, undefined);
+        assert.notEqual(newfont.tables.gpos, undefined);
+        assert.notEqual(newfont.tables.gpos.lookupList, undefined);
+
+        //verify if the regenearted tables still hold the correct values
+        var new_llist = newfont.tables.gpos.lookupList;
+
+        assert.equal(old_llist[1].lookupType,
+                     new_llist[0].lookupType);
+        assert.equal(old_llist[1].subtables.length,
+                     new_llist[0].subtables.length);
+        for (var j=0; j < new_llist[0].subtables.length; j++){
+            assert.equal(old_llist[1].subtables[j].pairSet.length,
+                         new_llist[0].subtables[j].pairSet.length);
+        }
+    });
+
+if (0){
+    it('can parse OpenType GPOS tables', function() {
+        var font = opentype.loadSync('./fonts/FiraSansOT-Medium_gpos.otf');
+        assert.notEqual(font.tables.gpos, undefined);
+        var llist = font.tables.gpos.lookupList;
+        assert.equal(llist.length, 2);
+        assert.equal(llist[0].lookupType, 1);
+
+        assert.equal(llist[1].lookupType, 2);
+        assert.equal(llist[1].subtables.length, 3);
+        var pairsets=llist[1].subtables[0].pairsets;
+        assert.equal(pairsets.length, 1145); //This looks wrong!
+    });
+}
 });