diff --git a/biomeidentifier.cpp b/biomeidentifier.cpp
index 41781626..be47517b 100644
--- a/biomeidentifier.cpp
+++ b/biomeidentifier.cpp
@@ -196,6 +196,11 @@ BiomeIdentifier::~BiomeIdentifier() {
   }
 }
 
+BiomeIdentifier& BiomeIdentifier::Instance() {
+  static BiomeIdentifier singleton;
+  return singleton;
+}
+
 BiomeInfo &BiomeIdentifier::getBiome(int biome) {
   QList<BiomeInfo*> &list = biomes[biome];
   // search backwards for priority sorting to work
diff --git a/biomeidentifier.h b/biomeidentifier.h
index 52112e06..9275a18a 100644
--- a/biomeidentifier.h
+++ b/biomeidentifier.h
@@ -44,13 +44,21 @@ class BiomeInfo {
 
 class BiomeIdentifier {
  public:
-  BiomeIdentifier();
-  ~BiomeIdentifier();
+  // singleton: access to global usable instance
+  static BiomeIdentifier &Instance();
+
   int addDefinitions(JSONArray *, int pack = -1);
   void enableDefinitions(int id);
   void disableDefinitions(int id);
   BiomeInfo &getBiome(int id);
- private:
+
+private:
+  // singleton: prevent access to constructor and copyconstructor
+  BiomeIdentifier();
+  ~BiomeIdentifier();
+  BiomeIdentifier(const BiomeIdentifier &);
+  BiomeIdentifier &operator=(const BiomeIdentifier &);
+
   QHash<int, QList<BiomeInfo*>> biomes;
   QList<QList<BiomeInfo*> > packs;
 };
diff --git a/blockidentifier.cpp b/blockidentifier.cpp
index 64ecdab8..067628fd 100644
--- a/blockidentifier.cpp
+++ b/blockidentifier.cpp
@@ -80,6 +80,11 @@ bool BlockInfo::biomeFoliage() { return foliage; }
 void BlockInfo::setBiomeGrass(bool value)   { grass = value; }
 void BlockInfo::setBiomeFoliage(bool value) { foliage = value; }
 
+
+// --------- --------- --------- ---------
+// BlockIdentifier
+// --------- --------- --------- ---------
+
 BlockIdentifier::BlockIdentifier() {
   for (int i = 0; i < 16; i++)
     unknownBlock.colors[i] = 0xff00ff;
@@ -94,6 +99,11 @@ BlockIdentifier::~BlockIdentifier() {
   }
 }
 
+BlockIdentifier& BlockIdentifier::Instance() {
+  static BlockIdentifier singleton;
+  return singleton;
+}
+
 BlockInfo &BlockIdentifier::getBlockInfo(uint hid) {
   // first apply the mask
   if (blocks.contains(hid)) {
diff --git a/blockidentifier.h b/blockidentifier.h
index 234625e5..bc5590e3 100644
--- a/blockidentifier.h
+++ b/blockidentifier.h
@@ -68,13 +68,21 @@ class BlockInfo {
 
 class BlockIdentifier {
  public:
-  BlockIdentifier();
-  ~BlockIdentifier();
+  // singleton: access to global usable instance
+  static BlockIdentifier &Instance();
+
   int addDefinitions(JSONArray *, int pack = -1);
   void enableDefinitions(int id);
   void disableDefinitions(int id);
   BlockInfo &getBlockInfo(uint hid);
- private:
+
+private:
+  // singleton: prevent access to constructor and copyconstructor
+  BlockIdentifier();
+  ~BlockIdentifier();
+  BlockIdentifier(const BlockIdentifier &);
+  BlockIdentifier &operator=(const BlockIdentifier &);
+
   void parseDefinition(JSONObject *block, BlockInfo *parent, int pack);
   QMap<uint, BlockInfo*> blocks;
   QList<QList<BlockInfo*> > packs;
diff --git a/chunk.cpp b/chunk.cpp
index 48f16fd3..c06d501a 100644
--- a/chunk.cpp
+++ b/chunk.cpp
@@ -6,7 +6,7 @@
 #include "./flatteningconverter.h"
 
 quint16 getBits(const unsigned char *data, int pos, int n) {
-  quint16 result = 0;
+//  quint16 result = 0;
   int arrIndex = pos/8;
   int bitIndex = pos%8;
   quint32 loc =
diff --git a/definitionmanager.cpp b/definitionmanager.cpp
index cf9425b4..d38254ff 100644
--- a/definitionmanager.cpp
+++ b/definitionmanager.cpp
@@ -24,8 +24,12 @@
 DefinitionManager::DefinitionManager(QWidget *parent) :
     QWidget(parent),
     isUpdating(false),
+    dimensionManager(DimensionIdentifier::Instance()),
+    blockManager(BlockIdentifier::Instance()),
+    biomeManager(BiomeIdentifier::Instance()),
     entityManager(EntityIdentifier::Instance()),
-    flatteningConverter(FlatteningConverter::Instance()) {
+    flatteningConverter(FlatteningConverter::Instance())
+{
   setWindowFlags(Qt::Window);
   setWindowTitle(tr("Definitions"));
 
@@ -67,10 +71,6 @@ DefinitionManager::DefinitionManager(QWidget *parent) :
   emit packSelected(false);
   setLayout(layout);
 
-  dimensionManager = new DimensionIdentifier;
-  blockManager = new BlockIdentifier;
-  biomeManager = new BiomeIdentifier;
-
   QSettings settings;
   sorted = settings.value("packs").toList();
 
@@ -97,21 +97,8 @@ DefinitionManager::DefinitionManager(QWidget *parent) :
   refresh();
 }
 
-DefinitionManager::~DefinitionManager() {
-  delete dimensionManager;
-  delete blockManager;
-  delete biomeManager;
-}
+DefinitionManager::~DefinitionManager() {}
 
-BlockIdentifier *DefinitionManager::blockIdentifier() {
-  return blockManager;
-}
-BiomeIdentifier *DefinitionManager::biomeIdentifier() {
-  return biomeManager;
-}
-DimensionIdentifier *DefinitionManager::dimensionIdentifer() {
-  return dimensionManager;
-}
 
 void DefinitionManager::refresh() {
   table->clearContents();
@@ -154,21 +141,21 @@ void DefinitionManager::toggledPack(bool onoff) {
     switch (def.type) {
       case Definition::Block:
         if (onoff)
-          blockManager->enableDefinitions(def.id);
+          blockManager.enableDefinitions(def.id);
         else
-          blockManager->disableDefinitions(def.id);
+          blockManager.disableDefinitions(def.id);
         break;
       case Definition::Biome:
         if (onoff)
-          biomeManager->enableDefinitions(def.id);
+          biomeManager.enableDefinitions(def.id);
         else
-          biomeManager->disableDefinitions(def.id);
+          biomeManager.disableDefinitions(def.id);
         break;
       case Definition::Dimension:
         if (onoff)
-          dimensionManager->enableDefinitions(def.id);
+          dimensionManager.enableDefinitions(def.id);
         else
-          dimensionManager->disableDefinitions(def.id);
+          dimensionManager.disableDefinitions(def.id);
         break;
       case Definition::Entity:
         if (onoff)
@@ -178,14 +165,14 @@ void DefinitionManager::toggledPack(bool onoff) {
         break;
       case Definition::Pack:
         if (onoff) {
-          blockManager->enableDefinitions(def.blockid);
-          biomeManager->enableDefinitions(def.biomeid);
-          dimensionManager->enableDefinitions(def.dimensionid);
+          blockManager.enableDefinitions(def.blockid);
+          biomeManager.enableDefinitions(def.biomeid);
+          dimensionManager.enableDefinitions(def.dimensionid);
           entityManager.enableDefinitions(def.entityid);
         } else {
-          blockManager->disableDefinitions(def.blockid);
-          biomeManager->disableDefinitions(def.biomeid);
-          dimensionManager->disableDefinitions(def.dimensionid);
+          blockManager.disableDefinitions(def.blockid);
+          biomeManager.disableDefinitions(def.biomeid);
+          dimensionManager.disableDefinitions(def.dimensionid);
           entityManager.disableDefinitions(def.entityid);
         }
         break;
@@ -401,15 +388,15 @@ void DefinitionManager::loadDefinition(QString path) {
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Converter;
     } else if (type == "flatblock") {
-      d.id = blockManager->addDefinitions(
+      d.id = blockManager.addDefinitions(
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Block;
     } else if (type == "biome") {
-      d.id = biomeManager->addDefinitions(
+      d.id = biomeManager.addDefinitions(
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Biome;
     } else if (type == "dimension") {
-      d.id = dimensionManager->addDefinitions(
+      d.id = dimensionManager.addDefinitions(
           dynamic_cast<JSONArray*>(def->at("data")));
       d.type = Definition::Dimension;
     } else if (type == "entity") {
@@ -455,13 +442,13 @@ void DefinitionManager::loadDefinition(QString path) {
 //        d.blockid = flatteningConverter->addDefinitions(
 //            dynamic_cast<JSONArray*>(def->at("data")), d.blockid);
       } else if (type == "flatblock") {
-          d.blockid = blockManager->addDefinitions(
+          d.blockid = blockManager.addDefinitions(
               dynamic_cast<JSONArray*>(def->at("data")), d.blockid);
       } else if (type == "biome") {
-        d.biomeid = biomeManager->addDefinitions(
+        d.biomeid = biomeManager.addDefinitions(
             dynamic_cast<JSONArray*>(def->at("data")), d.biomeid);
       } else if (type == "dimension") {
-        d.dimensionid = dimensionManager->addDefinitions(
+        d.dimensionid = dimensionManager.addDefinitions(
             dynamic_cast<JSONArray*>(def->at("data")), d.dimensionid);
       } else if (type == "entity") {
         d.entityid = entityManager.addDefinitions(
@@ -480,21 +467,21 @@ void DefinitionManager::removeDefinition(QString path) {
   if (def.path == path) {
     switch (def.type) {
       case Definition::Block:
-        blockManager->disableDefinitions(def.id);
+        blockManager.disableDefinitions(def.id);
         break;
       case Definition::Biome:
-        biomeManager->disableDefinitions(def.id);
+        biomeManager.disableDefinitions(def.id);
         break;
       case Definition::Dimension:
-        dimensionManager->disableDefinitions(def.id);
+        dimensionManager.disableDefinitions(def.id);
         break;
       case Definition::Entity:
         entityManager.disableDefinitions(def.id);
         break;
       case Definition::Pack:
-        blockManager->disableDefinitions(def.blockid);
-        biomeManager->disableDefinitions(def.biomeid);
-        dimensionManager->disableDefinitions(def.dimensionid);
+        blockManager.disableDefinitions(def.blockid);
+        biomeManager.disableDefinitions(def.biomeid);
+        dimensionManager.disableDefinitions(def.dimensionid);
         entityManager.disableDefinitions(def.entityid);
         break;
     }
diff --git a/definitionmanager.h b/definitionmanager.h
index bca62f75..62e3237e 100644
--- a/definitionmanager.h
+++ b/definitionmanager.h
@@ -43,9 +43,6 @@ class DefinitionManager : public QWidget {
   QSize minimumSizeHint() const;
   QSize sizeHint() const;
 
-  BlockIdentifier *blockIdentifier();
-  BiomeIdentifier *biomeIdentifier();
-  DimensionIdentifier *dimensionIdentifer();
   void autoUpdate();
 
  signals:
@@ -74,10 +71,10 @@ class DefinitionManager : public QWidget {
   void removeDefinition(QString path);
   void refresh();
   QHash<QString, Definition> definitions;
-  BiomeIdentifier *biomeManager;  // todo: migrate to reference to singleton
-  BlockIdentifier *blockManager;  // todo: migrate to reference to singleton
-  DimensionIdentifier *dimensionManager;  // todo: migrate to reference to singleton
-  EntityIdentifier &entityManager;
+  BiomeIdentifier     &biomeManager;
+  BlockIdentifier     &blockManager;
+  DimensionIdentifier &dimensionManager;
+  EntityIdentifier    &entityManager;
   FlatteningConverter &flatteningConverter;
   QString selected;
   QList<QVariant> sorted;
diff --git a/dimensionidentifier.cpp b/dimensionidentifier.cpp
index 0f46a538..7c4f330f 100644
--- a/dimensionidentifier.cpp
+++ b/dimensionidentifier.cpp
@@ -15,6 +15,11 @@ class DimensionDef {
   bool enabled;
 };
 
+
+// --------- --------- --------- ---------
+// DimensionIdentifier
+// --------- --------- --------- ---------
+
 DimensionIdentifier::DimensionIdentifier() {
   group = NULL;
 }
@@ -25,6 +30,12 @@ DimensionIdentifier::~DimensionIdentifier() {
   }
 }
 
+DimensionIdentifier& DimensionIdentifier::Instance() {
+  static DimensionIdentifier singleton;
+  return singleton;
+}
+
+
 void DimensionIdentifier::enableDefinitions(int pack) {
   if (pack < 0) return;
   int len = packs[pack].length();
@@ -85,6 +96,7 @@ void DimensionIdentifier::removeDimensions(QMenu *menu) {
     group = NULL;
   }
 }
+
 void DimensionIdentifier::getDimensions(QDir path, QMenu *menu,
                                         QObject *parent) {
   // first get the currently selected dimension so it doesn't change
diff --git a/dimensionidentifier.h b/dimensionidentifier.h
index 2df49e40..49b7bac6 100644
--- a/dimensionidentifier.h
+++ b/dimensionidentifier.h
@@ -27,8 +27,9 @@ class DimensionIdentifier : public QObject {
   Q_OBJECT
 
  public:
-  DimensionIdentifier();
-  ~DimensionIdentifier();
+  // singleton: access to global usable instance
+  static DimensionIdentifier &Instance();
+
   int addDefinitions(JSONArray *, int pack = -1);
   void enableDefinitions(int id);
   void disableDefinitions(int id);
@@ -42,6 +43,12 @@ class DimensionIdentifier : public QObject {
   void viewDimension();
 
  private:
+  // singleton: prevent access to constructor and copyconstructor
+  DimensionIdentifier();
+  ~DimensionIdentifier();
+  DimensionIdentifier(const DimensionIdentifier &);
+  DimensionIdentifier &operator=(const DimensionIdentifier &);
+
   void addDimension(QDir path, QString dir, QString name, int scale,
                     QObject *parent);
   QList<QAction *> items;
diff --git a/entityidentifier.cpp b/entityidentifier.cpp
index c776010e..5578dd24 100644
--- a/entityidentifier.cpp
+++ b/entityidentifier.cpp
@@ -12,6 +12,11 @@ EntityInfo::EntityInfo(QString name, QString category, QColor brushColor,
 static EntityInfo entityDummy("Name unknown", "Others",  // Name Category
                               Qt::black, Qt::black);     // Black circle with Black border
 
+
+// --------- --------- --------- ---------
+// EntityIdentifier
+// --------- --------- --------- ---------
+
 EntityIdentifier::EntityIdentifier() {}
 EntityIdentifier::~EntityIdentifier() {}
 
diff --git a/flatteningconverter.cpp b/flatteningconverter.cpp
index eaf79d9e..423ef9cc 100644
--- a/flatteningconverter.cpp
+++ b/flatteningconverter.cpp
@@ -23,14 +23,14 @@ BlockData * FlatteningConverter::getPalette() {
   return palette;
 }
 
-void FlatteningConverter::enableDefinitions(int pack) {
+void FlatteningConverter::enableDefinitions(int /*pack*/) {
 //  if (pack < 0) return;
 //  int len = packs[pack].length();
 //  for (int i = 0; i < len; i++)
 //    packs[pack][i]->enabled = true;
 }
 
-void FlatteningConverter::disableDefinitions(int pack) {
+void FlatteningConverter::disableDefinitions(int /*pack*/) {
 //  if (pack < 0) return;
 //  int len = packs[pack].length();
 //  for (int i = 0; i < len; i++)
diff --git a/mapview.cpp b/mapview.cpp
index 5547d59a..4413a306 100644
--- a/mapview.cpp
+++ b/mapview.cpp
@@ -52,8 +52,6 @@ void MapView::attach(DefinitionManager *dm) {
   this->dm = dm;
   connect(dm, SIGNAL(packsChanged()),
           this, SLOT(redraw()));
-  this->blocks = dm->blockIdentifier();
-  this->biomes = dm->biomeIdentifier();
 }
 
 void MapView::setLocation(double x, double z) {
@@ -436,7 +434,7 @@ void MapView::renderChunk(Chunk *chunk) {
       uchar r = 0, g = 0, b = 0;
       double alpha = 0.0;
       // get Biome
-      auto &biome = biomes->getBiome(chunk->biomes[offset]);
+      auto &biome = BiomeIdentifier::Instance().getBiome(chunk->biomes[offset]);
       int top = depth;
       if (top > chunk->highest)
         top = chunk->highest;
@@ -453,7 +451,7 @@ void MapView::renderChunk(Chunk *chunk) {
         //int data = section->getData(offset, y);
 
         // get BlockInfo from block value
-        BlockInfo &block = blocks->getBlockInfo(section->getBlockData(offset, y).hid);
+        BlockInfo &block = BlockIdentifier::Instance().getBlockInfo(section->getBlockData(offset, y).hid);
         if (block.alpha == 0.0) continue;
 
         // get light value from one block above
@@ -523,10 +521,10 @@ void MapView::renderChunk(Chunk *chunk) {
           if (sectionB) {
             blidB = sectionB->getBlockData(offset, y-1).hid;
           }
-          BlockInfo &block2 = blocks->getBlockInfo(blid2);
-          BlockInfo &block1 = blocks->getBlockInfo(blid1);
+          BlockInfo &block2 = BlockIdentifier::Instance().getBlockInfo(blid2);
+          BlockInfo &block1 = BlockIdentifier::Instance().getBlockInfo(blid1);
           BlockInfo &block0 = block;
-          BlockInfo &blockB = blocks->getBlockInfo(blidB);
+          BlockInfo &blockB = BlockIdentifier::Instance().getBlockInfo(blidB);
           int light0 = section->getBlockLight(offset, y);
 
            // spawn check #1: on top of solid block
@@ -588,7 +586,7 @@ void MapView::renderChunk(Chunk *chunk) {
           // get data value
           // int data = section->getData(offset, y);
           // get BlockInfo from block value
-          BlockInfo &block = blocks->getBlockInfo(section->getBlockData(offset, y).hid);
+          BlockInfo &block = BlockIdentifier::Instance().getBlockInfo(section->getBlockData(offset, y).hid);
           if (block.transparent) {
             cave_factor -= caveshade[cave_test];
           }
@@ -636,11 +634,11 @@ void MapView::getToolTip(int x, int z) {
       name = bdata.name;
       // in case of fully transparent blocks (meaning air)
       // -> we continue downwards
-      auto & block = blocks->getBlockInfo(bdata.hid);
+      auto & block = BlockIdentifier::Instance().getBlockInfo(bdata.hid);
       if (block.alpha == 0.0) continue;
       break;
     }
-    auto &bi = biomes->getBiome(chunk->biomes[(x & 0xf) + (z & 0xf) * 16]);
+    auto &bi = BiomeIdentifier::Instance().getBiome(chunk->biomes[(x & 0xf) + (z & 0xf) * 16]);
     biome = bi.name;
 
     // count Entity of each display type
diff --git a/mapview.h b/mapview.h
index 2061d866..e0debb08 100644
--- a/mapview.h
+++ b/mapview.h
@@ -97,8 +97,6 @@ class MapView : public QWidget {
   ChunkCache cache;
   QImage image;
   DefinitionManager *dm;
-  BlockIdentifier *blocks;
-  BiomeIdentifier *biomes;
   uchar placeholder[16 * 16 * 4];  // no chunk found placeholder
   QSet<QString> overlayItemTypes;
   QMap<QString, QList<QSharedPointer<OverlayItem>>> overlayItems;
diff --git a/minutor.cpp b/minutor.cpp
index 36a8ed4e..2a51a543 100644
--- a/minutor.cpp
+++ b/minutor.cpp
@@ -38,7 +38,7 @@ Minutor::Minutor() {
   mapview->attach(dm);
   connect(dm,   SIGNAL(packsChanged()),
           this, SLOT(updateDimensions()));
-  dimensions = dm->dimensionIdentifer();
+  DimensionIdentifier *dimensions = &DimensionIdentifier::Instance();
   connect(dimensions, SIGNAL(dimensionChanged(const DimensionInfo &)),
           this, SLOT(viewDimension(const DimensionInfo &)));
   settings = new Settings(this);
@@ -206,7 +206,7 @@ void Minutor::closeWorld() {
   players.clear();
   jumpMenu->setEnabled(false);
   // clear dimensions menu
-  dimensions->removeDimensions(dimMenu);
+  DimensionIdentifier::Instance().removeDimensions(dimMenu);
   // clear overlays
   mapview->clearOverlayItems();
   // clear other stuff
@@ -304,7 +304,7 @@ void Minutor::about() {
 }
 
 void Minutor::updateDimensions() {
-  dimensions->getDimensions(currentWorld, dimMenu, this);
+  DimensionIdentifier::Instance().getDimensions(currentWorld, dimMenu, this);
 }
 
 void Minutor::createActions() {
@@ -644,7 +644,7 @@ void Minutor::loadWorld(QDir path) {
   }
 
   // show dimensions
-  dimensions->getDimensions(path, dimMenu, this);
+  DimensionIdentifier::Instance().getDimensions(path, dimMenu, this);
   emit worldLoaded(true);
   mapview->setLocation(locations.first().x, locations.first().z);
   toggleFlags();
diff --git a/minutor.h b/minutor.h
index 52e6ac36..ae6b66a7 100644
--- a/minutor.h
+++ b/minutor.h
@@ -115,7 +115,7 @@ private slots:
   DefinitionManager *dm;
   Settings *settings;
   JumpTo *jumpTo;
-  DimensionIdentifier *dimensions;
+//  DimensionIdentifier *dimensions;
   QDir currentWorld;
 
   QSet<QString> overlayItemTypes;