diff --git a/MachMgr.h b/MachMgr.h
index 7bc56c4..cf302b8 100644
--- a/MachMgr.h
+++ b/MachMgr.h
@@ -48,13 +48,14 @@ struct AxisBlock {
 
 //----------------------------------------------------------------------------
 struct MachineData {
+   string         sName ;
    Machine*       pMachine ;
    ToolsMgr*      pTsMgr ;
    MachiningsMgr* pMsMgr ;
    MachineData( void)
       : pMachine( nullptr), pTsMgr( nullptr), pMsMgr( nullptr) {}
-   MachineData( Machine* pM, ToolsMgr* pTM, MachiningsMgr* pMM)
-      { pMachine = pM ; pTsMgr = pTM ; pMsMgr = pMM ; }
+   MachineData( const string& sN, Machine* pM, ToolsMgr* pTM, MachiningsMgr* pMM)
+      { sName = sN ; pMachine = pM ; pTsMgr = pTM ; pMsMgr = pMM ; }
 } ;
 
 //----------------------------------------------------------------------------
diff --git a/MachMgrBasic.cpp b/MachMgrBasic.cpp
index e34eca2..e893662 100644
--- a/MachMgrBasic.cpp
+++ b/MachMgrBasic.cpp
@@ -69,17 +69,21 @@ MachMgr::Clear( void)
       delete m_pSimul ;
       m_pSimul = nullptr ;
    }
-  // pulisco le macchine
-   while ( ! m_vMachines.empty()) {
-      if ( m_vMachines.back().pMsMgr != nullptr)
-         delete m_vMachines.back().pMsMgr ;
-      if ( m_vMachines.back().pTsMgr != nullptr)
-         delete m_vMachines.back().pTsMgr ;
-      if ( m_vMachines.back().pMachine != nullptr)
-         delete m_vMachines.back().pMachine ;
-      m_vMachines.pop_back() ;
+  // pulisco le macchine (ma ne lascio intatto l'elencazione con il nome)
+   for ( size_t i = 0 ; i < m_vMachines.size() ; ++ i) {
+      if ( m_vMachines[i].pMsMgr != nullptr) {
+         delete m_vMachines[i].pMsMgr ;
+         m_vMachines[i].pMsMgr = nullptr ;
+      }
+      if ( m_vMachines[i].pTsMgr != nullptr) {
+         delete m_vMachines[i].pTsMgr ;
+         m_vMachines[i].pTsMgr = nullptr ;
+      }
+      if ( m_vMachines[i].pMachine != nullptr) {
+         delete m_vMachines[i].pMachine ;
+         m_vMachines[i].pMachine = nullptr ;
+      }
    }
-   m_nCurrMch = - 1 ;
 }
 
 //----------------------------------------------------------------------------
diff --git a/MachMgrDBMachinings.cpp b/MachMgrDBMachinings.cpp
index ef07701..24ebc1f 100644
--- a/MachMgrDBMachinings.cpp
+++ b/MachMgrDBMachinings.cpp
@@ -329,8 +329,9 @@ MachMgr::MdbSave( void) const
 bool
 MachMgr::MdbGetMachiningDir( string& sMchDir) const
 {
-   if ( GetCurrMachine() == nullptr)
+   string sMachineName ;
+   if ( ! GetCurrMachineName( sMachineName))
       return false ;
-   sMchDir = m_sMachinesDir + "\\" + GetCurrMachine()->GetMachineName() + "\\" + MACHININGS_DIR ;
+   sMchDir = m_sMachinesDir + "\\" + sMachineName + "\\" + MACHININGS_DIR ;
    return true ;
 }
diff --git a/MachMgrDBTools.cpp b/MachMgrDBTools.cpp
index 0dbd6cc..a8072ad 100644
--- a/MachMgrDBTools.cpp
+++ b/MachMgrDBTools.cpp
@@ -259,9 +259,10 @@ MachMgr::TdbSave( void) const
 bool
 MachMgr::TdbGetToolDir( string& sToolDir) const
 {
-   if ( GetCurrMachine() == nullptr)
+   string sMachineName ;
+   if ( ! GetCurrMachineName( sMachineName))
       return false ;
-   sToolDir = m_sMachinesDir + "\\" + GetCurrMachine()->GetMachineName() + "\\" + TOOLS_DIR ;
+   sToolDir = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLS_DIR ;
    return true ;
 }
 
@@ -269,8 +270,9 @@ MachMgr::TdbGetToolDir( string& sToolDir) const
 bool
 MachMgr::TdbGetToolHolderDir( string& sToolDir) const
 {
-   if ( GetCurrMachine() == nullptr)
+   string sMachineName ;
+   if ( ! GetCurrMachineName( sMachineName))
       return false ;
-   sToolDir = m_sMachinesDir + "\\" + GetCurrMachine()->GetMachineName() + "\\" + TOOLHOLDERS_DIR ;
+   sToolDir = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLHOLDERS_DIR ;
    return true ;
 }
diff --git a/MachMgrMachGroups.cpp b/MachMgrMachGroups.cpp
index 48e34c7..7e16492 100644
--- a/MachMgrMachGroups.cpp
+++ b/MachMgrMachGroups.cpp
@@ -100,9 +100,8 @@ MachMgr::AddMachGroup( const string& sName, const string& sMachineName)
   // se nome macchina vuoto, verifico esista una macchina corrente
    string sMachName ;
    if ( &sMachineName == nullptr  ||  sMachineName.empty()) {
-      if ( GetCurrMachine() == nullptr)
+      if ( ! GetCurrMachineName( sMachName))
          return GDB_ID_NULL ;
-      sMachName = GetCurrMachine()->GetMachineName() ;
    }
   // altrimenti, verifica ed eventuale caricamento della macchina
    else {
diff --git a/MachMgrMachines.cpp b/MachMgrMachines.cpp
index 7fd0a0d..0c93f6f 100644
--- a/MachMgrMachines.cpp
+++ b/MachMgrMachines.cpp
@@ -35,25 +35,14 @@ MachMgr::LoadMachine( const string& sMachineName)
   // se macchina giā caricata, non devo fare alcunchč
    if ( GetMachine( sMachineName) != - 1)
       return true ;
-  // creo gruppo ausiliario di base per le macchine
-   if ( ! CreateMachAux())
-      return false ;
-  // creo e carico la macchina
-   PtrOwner<Machine> pMch( new( nothrow) Machine) ;
-   if ( IsNull( pMch)  ||  ! pMch->Init( m_sMachinesDir, sMachineName, this))
-      return false ;
-  // creo e carico il DB utensili
-   PtrOwner<ToolsMgr> pTsMgr( new( nothrow) ToolsMgr) ;
-   string sToolsFile = m_sMachinesDir + "\\" + sMachineName + "\\" + TOOLS_DIR + "\\" + TOOLS_FILE ;
-   if ( IsNull( pTsMgr)  ||  ! pTsMgr->Load( sToolsFile))
-      return false ;
-  // creo e carico il DB lavorazioni
-   PtrOwner<MachiningsMgr> pMsMgr( new( nothrow) MachiningsMgr) ;
-   string sMachsFile = m_sMachinesDir + "\\" + sMachineName + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ;
-   if ( IsNull( pMsMgr)  ||  ! pMsMgr->Load( sMachsFile, pTsMgr))
+  // verifico esista il file mlde ( o mde) della macchina
+   string sMachineMlde = m_sMachinesDir + "\\" + sMachineName + "\\" + sMachineName + ".Mlde" ;
+   if ( ! ExistsFile( sMachineMlde))
+      sMachineMlde = ChangeFileExtension( sMachineMlde, ".Mde") ;
+   if ( ! ExistsFile( sMachineMlde))
       return false ;
   // salvo nel vettore
-   m_vMachines.emplace_back( Release( pMch), Release( pTsMgr), Release( pMsMgr)) ;
+   m_vMachines.emplace_back( sMachineName, nullptr, nullptr, nullptr) ;
    return true ;
 }
 
@@ -63,8 +52,7 @@ MachMgr::GetMachine( const string& sMachineName) const
 {
   // ciclo sulle macchine
    for ( size_t i = 0 ; i < m_vMachines.size() ; ++ i) {
-      if ( m_vMachines[i].pMachine != nullptr  &&
-           EqualNoCase( m_vMachines[i].pMachine->GetMachineName(), sMachineName))
+      if ( EqualNoCase( m_vMachines[i].sName, sMachineName))
          return int( i) ;
    }
    return - 1 ;
@@ -76,8 +64,7 @@ MachMgr::SetCurrMachine( const string& sMachineName)
 {
   // se č giā la macchina corrente, tutto bene
    if ( m_nCurrMch >= 0  &&  m_nCurrMch < int( m_vMachines.size())  &&
-        m_vMachines[m_nCurrMch].pMachine != nullptr  &&
-        EqualNoCase( m_vMachines[m_nCurrMch].pMachine->GetMachineName(), sMachineName))
+        EqualNoCase( m_vMachines[m_nCurrMch].sName, sMachineName))
       return true ;
   // se c'č macchinata corrente, non posso cambiare la macchina
    if ( m_nCurrMGrpId != GDB_ID_NULL)
@@ -87,8 +74,6 @@ MachMgr::SetCurrMachine( const string& sMachineName)
       return false ;
   // imposto i dati della macchina corrente
    m_nCurrMch = GetMachine( sMachineName) ;
-  // nascondo la macchina
-   m_pGeomDB->SetStatus( GetCurrMachineId(), GDB_ST_OFF) ;
    return true ;
 }
 
@@ -96,10 +81,11 @@ MachMgr::SetCurrMachine( const string& sMachineName)
 bool
 MachMgr::GetCurrMachineName( string& sMachineName) const
 {
-   Machine* pMch = GetCurrMachine() ;
-   if ( pMch == nullptr)
+  // verifico validitā indice macchina corrente
+   if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
       return false ;
-   sMachineName = pMch->GetMachineName() ;
+  // assegno il nome
+   sMachineName = m_vMachines[m_nCurrMch].sName ;
    return true ;
 }
 
@@ -107,8 +93,25 @@ MachMgr::GetCurrMachineName( string& sMachineName) const
 Machine*
 MachMgr::GetCurrMachine( void) const
 {
+  // verifico validitā indice macchina corrente
    if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
       return nullptr ;
+  // se gestore macchina non esiste, provo a crearlo e caricarlo
+   if ( m_vMachines[m_nCurrMch].pMachine == nullptr) {
+     // creo gruppo ausiliario di base per le macchine
+      if ( ! const_cast<MachMgr*>(this)->CreateMachAux())
+         return nullptr ;
+     // creo e carico la macchina
+      PtrOwner<Machine> pMch( new( nothrow) Machine) ;
+      if ( IsNull( pMch)  ||  ! pMch->Init( m_sMachinesDir, m_vMachines[m_nCurrMch].sName, const_cast<MachMgr*>(this)))
+         return nullptr ;
+     // nascondo la macchina
+      if ( m_pGeomDB != nullptr)
+         m_pGeomDB->SetStatus( pMch->GetMachineId(), GDB_ST_OFF) ;
+     // salvo nel vettore
+      const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pMachine = Release( pMch) ;
+   }
+  // restituisco il gestore macchina
    return m_vMachines[m_nCurrMch].pMachine ;
 }
 
@@ -116,8 +119,19 @@ MachMgr::GetCurrMachine( void) const
 ToolsMgr*
 MachMgr::GetCurrToolsMgr( void) const
 {
+  // verifico validitā indice macchina corrente
    if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
       return nullptr ;
+  // se DB utensili non esiste, provo a crearlo e caricarlo
+   if ( m_vMachines[m_nCurrMch].pTsMgr == nullptr) {
+      PtrOwner<ToolsMgr> pTsMgr( new( nothrow) ToolsMgr) ;
+      string sToolsFile = m_sMachinesDir + "\\" + m_vMachines[m_nCurrMch].sName + "\\" + TOOLS_DIR + "\\" + TOOLS_FILE ;
+      if ( IsNull( pTsMgr)  ||  ! pTsMgr->Load( sToolsFile))
+         return nullptr ;
+     // salvo nel vettore
+      const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pTsMgr = Release( pTsMgr) ;
+   }
+  // restituisco il gestore DB utensili
    return m_vMachines[m_nCurrMch].pTsMgr ;
 }
 
@@ -125,8 +139,19 @@ MachMgr::GetCurrToolsMgr( void) const
 MachiningsMgr*
 MachMgr::GetCurrMachiningsMgr( void) const
 {
+  // verifico validitā indice macchina corrente
    if ( m_nCurrMch < 0  ||  m_nCurrMch >= int( m_vMachines.size()))
       return nullptr ;
+  // se DB lavorazioni non esiste, provo a crearlo e caricarlo
+   if ( m_vMachines[m_nCurrMch].pMsMgr == nullptr) {
+      PtrOwner<MachiningsMgr> pMsMgr( new( nothrow) MachiningsMgr) ;
+      string sMachsFile = m_sMachinesDir + "\\" + m_vMachines[m_nCurrMch].sName + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ;
+      if ( IsNull( pMsMgr)  ||  ! pMsMgr->Load( sMachsFile, GetCurrToolsMgr()))
+         return nullptr ;
+     // salvo nel vettore
+      const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pMsMgr = Release( pMsMgr) ;
+   }
+  // restituisco il gestore DB lavorazioni
    return m_vMachines[m_nCurrMch].pMsMgr ;
 }