diff --git a/papers/format.md b/papers/format.md
index a58193be..dd58170e 100644
--- a/papers/format.md
+++ b/papers/format.md
@@ -1229,7 +1229,7 @@ chips which aren't on this list don't have any flags.
 
 ## 0x05: PC Engine
 
-- bit 1: clockSel (int)
+- bit 0: clockSel (int)
   - 0: NTSC
   - 1: pseudo-PAL
 - bit 2: chipType (int)
@@ -1289,6 +1289,7 @@ chips which aren't on this list don't have any flags.
   - 2: Sunsoft 5B
   - 3: AY-3-8914
 - bit 6: stereo (bool)
+- bit 7: halfClock (bool)
 - bit 8-15: stereoSep (int)
 
 ## 0x81: Amiga
@@ -1454,6 +1455,7 @@ chips which aren't on this list don't have any flags.
   - 11: double NTSC
   - 12: 3.6MHz
 - bit 6: stereo (bool)
+- bit 7: halfClock (bool)
 - bit 8-15: stereoSep (int)
 
 ## 0x9d: VRC7
@@ -1556,4 +1558,4 @@ chips which aren't on this list don't have any flags.
 ## 0xe0: QSound
 
 - bit 0-11: echoDelay (int)
-- bit 12-19: echoFeedback (int)
\ No newline at end of file
+- bit 12-19: echoFeedback (int)
diff --git a/src/engine/config.cpp b/src/engine/config.cpp
index 6270bdfa..84fdd1ff 100644
--- a/src/engine/config.cpp
+++ b/src/engine/config.cpp
@@ -105,7 +105,7 @@ bool DivConfig::loadFromMemory(const char* buf) {
   return true;
 }
 
-bool DivConfig::getConfBool(String key, bool fallback) {
+bool DivConfig::getBool(String key, bool fallback) {
   try {
     String val=conf.at(key);
     if (val=="true") {
@@ -118,7 +118,7 @@ bool DivConfig::getConfBool(String key, bool fallback) {
   return fallback;
 }
 
-int DivConfig::getConfInt(String key, int fallback) {
+int DivConfig::getInt(String key, int fallback) {
   try {
     String val=conf.at(key);
     int ret=std::stoi(val);
@@ -129,7 +129,7 @@ int DivConfig::getConfInt(String key, int fallback) {
   return fallback;
 }
 
-float DivConfig::getConfFloat(String key, float fallback) {
+float DivConfig::getFloat(String key, float fallback) {
   try {
     String val=conf.at(key);
     float ret=std::stof(val);
@@ -140,7 +140,7 @@ float DivConfig::getConfFloat(String key, float fallback) {
   return fallback;
 }
 
-double DivConfig::getConfDouble(String key, double fallback) {
+double DivConfig::getDouble(String key, double fallback) {
   try {
     String val=conf.at(key);
     double ret=std::stod(val);
@@ -151,7 +151,7 @@ double DivConfig::getConfDouble(String key, double fallback) {
   return fallback;
 }
 
-String DivConfig::getConfString(String key, String fallback) {
+String DivConfig::getString(String key, String fallback) {
   try {
     String val=conf.at(key);
     return val;
@@ -160,7 +160,7 @@ String DivConfig::getConfString(String key, String fallback) {
   return fallback;
 }
 
-void DivConfig::setConf(String key, bool value) {
+void DivConfig::set(String key, bool value) {
   if (value) {
     conf[key]="true";
   } else {
@@ -168,22 +168,30 @@ void DivConfig::setConf(String key, bool value) {
   }
 }
 
-void DivConfig::setConf(String key, int value) {
+void DivConfig::set(String key, int value) {
   conf[key]=fmt::sprintf("%d",value);
 }
 
-void DivConfig::setConf(String key, float value) {
+void DivConfig::set(String key, float value) {
   conf[key]=fmt::sprintf("%f",value);
 }
 
-void DivConfig::setConf(String key, double value) {
+void DivConfig::set(String key, double value) {
   conf[key]=fmt::sprintf("%f",value);
 }
 
-void DivConfig::setConf(String key, const char* value) {
+void DivConfig::set(String key, const char* value) {
   conf[key]=String(value);
 }
 
-void DivConfig::setConf(String key, String value) {
+void DivConfig::set(String key, String value) {
   conf[key]=value;
 }
+
+bool DivConfig::remove(String key) {
+  return conf.erase(key);
+}
+
+void DivConfig::clear() {
+  conf.clear();
+}
diff --git a/src/engine/config.h b/src/engine/config.h
index 0d3fdc41..15ded011 100644
--- a/src/engine/config.h
+++ b/src/engine/config.h
@@ -34,19 +34,25 @@ class DivConfig {
     bool save(const char* path);
 
     // get a config value
-    bool getConfBool(String key, bool fallback);
-    int getConfInt(String key, int fallback);
-    float getConfFloat(String key, float fallback);
-    double getConfDouble(String key, double fallback);
-    String getConfString(String key, String fallback);
+    bool getBool(String key, bool fallback);
+    int getInt(String key, int fallback);
+    float getFloat(String key, float fallback);
+    double getDouble(String key, double fallback);
+    String getString(String key, String fallback);
 
     // set a config value
-    void setConf(String key, bool value);
-    void setConf(String key, int value);
-    void setConf(String key, float value);
-    void setConf(String key, double value);
-    void setConf(String key, const char* value);
-    void setConf(String key, String value);
+    void set(String key, bool value);
+    void set(String key, int value);
+    void set(String key, float value);
+    void set(String key, double value);
+    void set(String key, const char* value);
+    void set(String key, String value);
+
+    // remove a config value
+    bool remove(String key);
+
+    // clear config
+    void clear();
 };
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/engine/configEngine.cpp b/src/engine/configEngine.cpp
index df93cc95..5589e064 100644
--- a/src/engine/configEngine.cpp
+++ b/src/engine/configEngine.cpp
@@ -118,45 +118,45 @@ bool DivEngine::loadConf() {
 }
 
 bool DivEngine::getConfBool(String key, bool fallback) {
-  return conf.getConfBool(key,fallback);
+  return conf.getBool(key,fallback);
 }
 
 int DivEngine::getConfInt(String key, int fallback) {
-  return conf.getConfInt(key,fallback);
+  return conf.getInt(key,fallback);
 }
 
 float DivEngine::getConfFloat(String key, float fallback) {
-  return conf.getConfFloat(key,fallback);
+  return conf.getFloat(key,fallback);
 }
 
 double DivEngine::getConfDouble(String key, double fallback) {
-  return conf.getConfDouble(key,fallback);
+  return conf.getDouble(key,fallback);
 }
 
 String DivEngine::getConfString(String key, String fallback) {
-  return conf.getConfString(key,fallback);
+  return conf.getString(key,fallback);
 }
 
 void DivEngine::setConf(String key, bool value) {
-  conf.setConf(key,value);
+  conf.set(key,value);
 }
 
 void DivEngine::setConf(String key, int value) {
-  conf.setConf(key,value);
+  conf.set(key,value);
 }
 
 void DivEngine::setConf(String key, float value) {
-  conf.setConf(key,value);
+  conf.set(key,value);
 }
 
 void DivEngine::setConf(String key, double value) {
-  conf.setConf(key,value);
+  conf.set(key,value);
 }
 
 void DivEngine::setConf(String key, const char* value) {
-  conf.setConf(key,value);
+  conf.set(key,value);
 }
 
 void DivEngine::setConf(String key, String value) {
-  conf.setConf(key,value);
-}
\ No newline at end of file
+  conf.set(key,value);
+}
diff --git a/src/engine/engine.h b/src/engine/engine.h
index 895a89ea..089add32 100644
--- a/src/engine/engine.h
+++ b/src/engine/engine.h
@@ -47,8 +47,8 @@
 #define BUSY_BEGIN_SOFT softLocked=true; isBusy.lock();
 #define BUSY_END isBusy.unlock(); softLocked=false;
 
-#define DIV_VERSION "dev118"
-#define DIV_ENGINE_VERSION 118
+#define DIV_VERSION "dev119"
+#define DIV_ENGINE_VERSION 119
 // for imports
 #define DIV_VERSION_MOD 0xff01
 #define DIV_VERSION_FC 0xff02
@@ -442,6 +442,8 @@ class DivEngine {
   void reset();
   void playSub(bool preserveDrift, int goalRow=0);
 
+  void convertOldFlags(unsigned int oldFlags, DivConfig& newFlags, DivSystem sys);
+
   bool loadDMF(unsigned char* file, size_t len);
   bool loadFur(unsigned char* file, size_t len);
   bool loadMod(unsigned char* file, size_t len);
diff --git a/src/engine/fileOps.cpp b/src/engine/fileOps.cpp
index e6e97fff..d05ad1e1 100644
--- a/src/engine/fileOps.cpp
+++ b/src/engine/fileOps.cpp
@@ -977,11 +977,586 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) {
   return true;
 }
 
+void DivEngine::convertOldFlags(unsigned int oldFlags, DivConfig& newFlags, DivSystem sys) {
+  newFlags.clear();
+
+  switch (sys) {
+    case DIV_SYSTEM_SMS:
+      switch (oldFlags&0xff03) {
+        case 0x0000:
+          newFlags.set("clockSel",0);
+          break;
+        case 0x0001:
+          newFlags.set("clockSel",1);
+          break;
+        case 0x0002:
+          newFlags.set("clockSel",2);
+          break;
+        case 0x0003:
+          newFlags.set("clockSel",3);
+          break;
+        case 0x0100:
+          newFlags.set("clockSel",4);
+          break;
+        case 0x0101:
+          newFlags.set("clockSel",5);
+          break;
+        case 0x0102:
+          newFlags.set("clockSel",6);
+          break;
+      }
+      switch (oldFlags&0xcc) {
+        case 0x00:
+          newFlags.set("chipType",0);
+          break;
+        case 0x04:
+          newFlags.set("chipType",1);
+          break;
+        case 0x08:
+          newFlags.set("chipType",2);
+          break;
+        case 0x0c:
+          newFlags.set("chipType",3);
+          break;
+        case 0x40:
+          newFlags.set("chipType",4);
+          break;
+        case 0x44:
+          newFlags.set("chipType",5);
+          break;
+        case 0x48:
+          newFlags.set("chipType",6);
+          break;
+        case 0x4c:
+          newFlags.set("chipType",7);
+          break;
+        case 0x80:
+          newFlags.set("chipType",8);
+          break;
+        case 0x84:
+          newFlags.set("chipType",9);
+          break;
+      }
+      if (oldFlags&16) newFlags.set("noPhaseReset",true);
+      break;
+    case DIV_SYSTEM_GB:
+      newFlags.set("chipType",(int)(oldFlags&3));
+      if (oldFlags&8) newFlags.set("noAntiClick",true);
+      break;
+    case DIV_SYSTEM_PCE:
+      newFlags.set("clockSel",(int)(oldFlags&1));
+      newFlags.set("chipType",(oldFlags&4)?1:0);
+      if (oldFlags&8) newFlags.set("noAntiClick",true);
+      break;
+    case DIV_SYSTEM_NES:
+    case DIV_SYSTEM_VRC6:
+    case DIV_SYSTEM_FDS:
+    case DIV_SYSTEM_MMC5:
+    case DIV_SYSTEM_SAA1099:
+    case DIV_SYSTEM_OPZ:
+      switch (oldFlags) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_C64_6581:
+    case DIV_SYSTEM_C64_8580:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_YM2610:
+    case DIV_SYSTEM_YM2610_EXT:
+    case DIV_SYSTEM_YM2610_FULL:
+    case DIV_SYSTEM_YM2610_FULL_EXT:
+    case DIV_SYSTEM_YM2610B:
+    case DIV_SYSTEM_YM2610B_EXT:
+      switch (oldFlags&0xff) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_AY8910:
+    case DIV_SYSTEM_AY8930:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+        case 4:
+          newFlags.set("clockSel",4);
+          break;
+        case 5:
+          newFlags.set("clockSel",5);
+          break;
+        case 6:
+          newFlags.set("clockSel",6);
+          break;
+        case 7:
+          newFlags.set("clockSel",7);
+          break;
+        case 8:
+          newFlags.set("clockSel",8);
+          break;
+        case 9:
+          newFlags.set("clockSel",9);
+          break;
+        case 10:
+          newFlags.set("clockSel",10);
+          break;
+        case 11:
+          newFlags.set("clockSel",11);
+          break;
+        case 12:
+          newFlags.set("clockSel",12);
+          break;
+        case 13:
+          if (sys==DIV_SYSTEM_AY8910) newFlags.set("clockSel",13);
+          break;
+        case 14:
+          if (sys==DIV_SYSTEM_AY8910) newFlags.set("clockSel",14);
+          break;
+      }
+      if (sys==DIV_SYSTEM_AY8910) switch ((oldFlags>>4)&3) {
+        case 0:
+          newFlags.set("chipType",0);
+          break;
+        case 1:
+          newFlags.set("chipType",1);
+          break;
+        case 2:
+          newFlags.set("chipType",2);
+          break;
+        case 3:
+          newFlags.set("chipType",3);
+          break;
+      }
+      if (oldFlags&64) newFlags.set("stereo",true);
+      if (oldFlags&128) newFlags.set("halfClock",true);
+      newFlags.set("stereoSep",(int)((oldFlags>>8)&255));
+      break;
+    case DIV_SYSTEM_AMIGA:
+      if (oldFlags&1) newFlags.set("clockSel",1);
+      if (oldFlags&2) newFlags.set("chipType",1);
+      if (oldFlags&4) newFlags.set("bypassLimits",true);
+      newFlags.set("stereoSep",(int)((oldFlags>>8)&127));
+      break;
+    case DIV_SYSTEM_YM2151:
+      switch (oldFlags&255) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_YM2612:
+    case DIV_SYSTEM_YM2612_EXT:
+    case DIV_SYSTEM_YM2612_FRAC:
+    case DIV_SYSTEM_YM2612_FRAC_EXT:
+      switch (oldFlags&0x7fffffff) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+        case 4:
+          newFlags.set("clockSel",4);
+          break;
+      }
+      if (oldFlags&0x80000000) newFlags.set("ladderEffect",true);
+      break;
+    case DIV_SYSTEM_TIA:
+      newFlags.set("clockSel",(int)(oldFlags&1));
+      switch ((oldFlags>>1)&3) {
+        case 0:
+          newFlags.set("mixingType",0);
+          break;
+        case 1:
+          newFlags.set("mixingType",1);
+          break;
+        case 2:
+          newFlags.set("mixingType",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_VIC20:
+      newFlags.set("clockSel",(int)(oldFlags&1));
+      break;
+    case DIV_SYSTEM_SNES:
+      newFlags.set("volScaleL",(int)(oldFlags&127));
+      newFlags.set("volScaleR",(int)((oldFlags>>8)&127));
+      break;
+    case DIV_SYSTEM_OPLL:
+    case DIV_SYSTEM_OPLL_DRUMS:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+      }
+      switch (oldFlags>>4) {
+        case 0:
+          newFlags.set("patchSet",0);
+          break;
+        case 1:
+          newFlags.set("patchSet",1);
+          break;
+        case 2:
+          newFlags.set("patchSet",2);
+          break;
+        case 3:
+          newFlags.set("patchSet",3);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_N163:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+      }
+      newFlags.set("channels",(int)((oldFlags>>4)&7));
+      if (oldFlags&128) newFlags.set("multiplex",true);
+      break;
+    case DIV_SYSTEM_OPN:
+    case DIV_SYSTEM_OPN_EXT:
+      switch (oldFlags&31) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+        case 4:
+          newFlags.set("clockSel",4);
+          break;
+        case 5:
+          newFlags.set("clockSel",5);
+          break;
+      }
+      switch ((oldFlags>>5)&3) {
+        case 0:
+          newFlags.set("prescale",0);
+          break;
+        case 1:
+          newFlags.set("prescale",1);
+          break;
+        case 2:
+          newFlags.set("prescale",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_PC98:
+    case DIV_SYSTEM_PC98_EXT:
+      switch (oldFlags&31) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+      }
+      switch ((oldFlags>>5)&3) {
+        case 0:
+          newFlags.set("prescale",0);
+          break;
+        case 1:
+          newFlags.set("prescale",1);
+          break;
+        case 2:
+          newFlags.set("prescale",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_OPL:
+    case DIV_SYSTEM_OPL2:
+    case DIV_SYSTEM_Y8950:
+    case DIV_SYSTEM_OPL_DRUMS:
+    case DIV_SYSTEM_OPL2_DRUMS:
+    case DIV_SYSTEM_Y8950_DRUMS:
+    case DIV_SYSTEM_YMZ280B:
+      switch (oldFlags&0xff) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+        case 4:
+          newFlags.set("clockSel",4);
+          break;
+        case 5:
+          newFlags.set("clockSel",5);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_OPL3:
+    case DIV_SYSTEM_OPL3_DRUMS:
+      switch (oldFlags&0xff) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+        case 4:
+          newFlags.set("clockSel",4);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_PCSPKR:
+      newFlags.set("speakerType",(int)(oldFlags&3));
+      break;
+    case DIV_SYSTEM_RF5C68:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+      }
+      switch (oldFlags>>4) {
+        case 0:
+          newFlags.set("chipType",0);
+          break;
+        case 1:
+          newFlags.set("chipType",0);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_VRC7:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_SFX_BEEPER:
+      newFlags.set("clockSel",(int)(oldFlags&1));
+      break;
+    case DIV_SYSTEM_SCC:
+    case DIV_SYSTEM_SCC_PLUS:
+      switch (oldFlags&63) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_MSM6295:
+      switch (oldFlags&63) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+        case 4:
+          newFlags.set("clockSel",4);
+          break;
+        case 5:
+          newFlags.set("clockSel",5);
+          break;
+        case 6:
+          newFlags.set("clockSel",6);
+          break;
+        case 7:
+          newFlags.set("clockSel",7);
+          break;
+        case 8:
+          newFlags.set("clockSel",8);
+          break;
+        case 9:
+          newFlags.set("clockSel",9);
+          break;
+        case 10:
+          newFlags.set("clockSel",10);
+          break;
+        case 11:
+          newFlags.set("clockSel",11);
+          break;
+        case 12:
+          newFlags.set("clockSel",12);
+          break;
+        case 13:
+          newFlags.set("clockSel",13);
+          break;
+        case 14:
+          newFlags.set("clockSel",14);
+          break;
+      }
+      if (oldFlags&128) newFlags.set("rateSel",true);
+      break;
+    case DIV_SYSTEM_MSM6258:
+      switch (oldFlags) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+        case 3:
+          newFlags.set("clockSel",3);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_OPL4:
+    case DIV_SYSTEM_OPL4_DRUMS:
+      switch (oldFlags&0xff) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+        case 2:
+          newFlags.set("clockSel",2);
+          break;
+      }
+      break;
+    case DIV_SYSTEM_X1_010:
+      switch (oldFlags&15) {
+        case 0:
+          newFlags.set("clockSel",0);
+          break;
+        case 1:
+          newFlags.set("clockSel",1);
+          break;
+      }
+      if (oldFlags&16) newFlags.set("stereo",true);
+      break;
+    case DIV_SYSTEM_SOUND_UNIT:
+      newFlags.set("clockSel",(int)(oldFlags&1));
+      if (oldFlags&4) newFlags.set("echo",true);
+      if (oldFlags&8) newFlags.set("swapEcho",true);
+      newFlags.set("sampleMemSize",(int)((oldFlags>>4)&1));
+      if (oldFlags&32) newFlags.set("pdm",true);
+      newFlags.set("echoDelay",(int)((oldFlags>>8)&63));
+      newFlags.set("echoFeedback",(int)((oldFlags>>16)&15));
+      newFlags.set("echoResolution",(int)((oldFlags>>20)&15));
+      newFlags.set("echoVol",(int)((oldFlags>>24)&255));
+      break;
+    case DIV_SYSTEM_PCM_DAC:
+      newFlags.set("rate",(int)((oldFlags&0xffff)+1));
+      newFlags.set("outDepth",(int)((oldFlags>>16)&15));
+      if (oldFlags&0x100000) newFlags.set("stereo",true);
+      break;
+    case DIV_SYSTEM_QSOUND:
+      newFlags.set("echoDelay",(int)(oldFlags&0xfff));
+      newFlags.set("echoFeedback",(int)((oldFlags>>12)&255));
+      break;
+    default:
+      break;
+  }
+}
+
 bool DivEngine::loadFur(unsigned char* file, size_t len) {
   unsigned int insPtr[256];
   unsigned int wavePtr[256];
   unsigned int samplePtr[256];
   unsigned int subSongPtr[256];
+  unsigned int sysFlagsPtr[32];
   std::vector<int> patPtr;
   int numberOfSubSongs=0;
   char magic[5];
@@ -1235,7 +1810,7 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) {
 
     // system props
     for (int i=0; i<32; i++) {
-      ds.systemFlagsOld[i]=reader.readI();
+      sysFlagsPtr[i]=reader.readI();
     }
 
     // handle compound systems
@@ -1587,6 +2162,40 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) {
       ds.autoSystem=true;
     }
 
+    // read system flags
+    if (ds.version>=119) {
+      logD("reading chip flags...");
+      for (int i=0; i<32; i++) {
+        if (sysFlagsPtr[i]==0) continue;
+
+        if (!reader.seek(sysFlagsPtr[i],SEEK_SET)) {
+          logE("couldn't seek to chip %d flags!",i+1);
+          lastError=fmt::sprintf("couldn't seek to chip %d flags!",i+1);
+          ds.unload();
+          delete[] file;
+          return false;
+        }
+
+        reader.read(magic,4);
+        if (strcmp(magic,"FLAG")!=0) {
+          logE("%d: invalid flag header!",i);
+          lastError="invalid flag header!";
+          ds.unload();
+          delete[] file;
+          return false;
+        }
+        reader.readI();
+
+        String data=reader.readString();
+        ds.systemFlags[i].loadFromMemory(data.c_str());
+      }
+    } else {
+      logD("reading old chip flags...");
+      for (int i=0; i<ds.systemLen; i++) {
+        convertOldFlags(sysFlagsPtr[i],ds.systemFlags[i],ds.system[i]);
+      }
+    }
+
     // read subsongs
     if (ds.version>=95) {
       for (int i=0; i<numberOfSubSongs; i++) {
@@ -3605,11 +4214,12 @@ struct PatToWrite {
 SafeWriter* DivEngine::saveFur(bool notPrimary) {
   saveLock.lock();
   std::vector<int> subSongPtr;
+  std::vector<int> sysFlagsPtr;
   std::vector<int> insPtr;
   std::vector<int> wavePtr;
   std::vector<int> samplePtr;
   std::vector<int> patPtr;
-  size_t ptrSeek, subSongPtrSeek, blockStartSeek, blockEndSeek;
+  size_t ptrSeek, subSongPtrSeek, sysFlagsPtrSeek, blockStartSeek, blockEndSeek;
   size_t subSongIndex=0;
   DivSubSong* subSong=song.subsong[subSongIndex];
   warnings="";
@@ -3733,8 +4343,10 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
     w->writeC(song.systemPan[i]);
   }
 
+  // chip flags (we'll seek here later)
+  sysFlagsPtrSeek=w->tell();
   for (int i=0; i<32; i++) {
-    w->writeI(song.systemFlagsOld[i]);
+    w->writeI(0);
   }
 
   // song name
@@ -3933,6 +4545,27 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
     w->seek(0,SEEK_END);
   }
 
+  /// CHIP FLAGS
+  for (int i=0; i<song.systemLen; i++) {
+    String data=song.systemFlags[i].toString();
+    if (data.empty()) {
+      sysFlagsPtr.push_back(0);
+      continue;
+    }
+
+    sysFlagsPtr.push_back(w->tell());
+    w->write("FLAG",4);
+    blockStartSeek=w->tell();
+    w->writeI(0);
+
+    w->writeString(data,false);
+
+    blockEndSeek=w->tell();
+    w->seek(blockStartSeek,SEEK_SET);
+    w->writeI(blockEndSeek-blockStartSeek-4);
+    w->seek(0,SEEK_END);
+  }
+
   /// INSTRUMENT
   for (int i=0; i<song.insLen; i++) {
     DivInstrument* ins=song.ins[i];
@@ -4050,14 +4683,18 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
     w->writeI(i);
   }
 
-  /// SUBSONG POINTERS
-  w->seek(subSongPtrSeek,SEEK_SET);
-
   // subsong pointers
+  w->seek(subSongPtrSeek,SEEK_SET);
   for (size_t i=0; i<(song.subsong.size()-1); i++) {
     w->writeI(subSongPtr[i]);
   }
 
+  // flag pointers
+  w->seek(sysFlagsPtrSeek,SEEK_SET);
+  for (size_t i=0; i<sysFlagsPtr.size(); i++) {
+    w->writeI(sysFlagsPtr[i]);
+  }
+
   saveLock.unlock();
   return w;
 }
diff --git a/src/gui/sysConf.cpp b/src/gui/sysConf.cpp
index b951765c..e032c447 100644
--- a/src/gui/sysConf.cpp
+++ b/src/gui/sysConf.cpp
@@ -20,6 +20,9 @@
 #include "gui.h"
 
 void FurnaceGUI::drawSysConf(int chan, DivSystem type, unsigned int& flags, bool modifyOnChange) {
+  ImGui::Text("temporarily unavailable!");
+  return;
+  /*
   bool restart=settings.restartOnFlagChange && modifyOnChange;
   bool sysPal=flags&1;
   unsigned int copyOfFlags=flags;
@@ -797,4 +800,5 @@ void FurnaceGUI::drawSysConf(int chan, DivSystem type, unsigned int& flags, bool
       flags=copyOfFlags;
     }
   }
+  */
 }