diff --git a/Process.lua b/Process.lua
index 310c05b..8147f6a 100644
--- a/Process.lua
+++ b/Process.lua
@@ -13,7 +13,7 @@ EgtEnableDebug( true)
 EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua')
 -- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
 EgtAddToPackagePath( BEAM.BASEDIR .. '\\Strategies\\Standard\\?.lua')
-EgtAddToPackagePath( BEAM.BASEDIR .. '\\Strategies\\Core\\?.lua')
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\StrategyLibs\\?.lua')
 
 -- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
 local sMachDir = EgtGetCurrMachineDir()
@@ -43,7 +43,6 @@ _G.package.loaded.FeatureLib = nil
 _G.package.loaded.FaceData = nil
 _G.package.loaded.MachiningLib = nil
 _G.package.loaded.DiceCut = nil
-_G.package.loaded.StrategyLib = nil
 _G.package.loaded.Logs = nil
 -- strategie di base sempre presenti
 _G.package.loaded['HEADCUT\\HEADCUT'] = nil
@@ -66,7 +65,7 @@ for i = 1, 9999 do
       _G.package.loaded[sLibraryConfigToReload] = nil
    end
 end
-local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\Strategies\\Core\\*.lua')
+local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\StrategyLibs\\*.lua')
 for i = 1, #vtCoreStrategiesNames do
    local sCurrentName = EgtSplitString( vtCoreStrategiesNames[i], '.')[1]
    if _G.package.loaded[sCurrentName] then
diff --git a/Strategies/Standard/TAILCUT/TAILCUT.lua b/Strategies/Standard/TAILCUT/TAILCUT.lua
index 2b4aa1e..f4a9a4b 100644
--- a/Strategies/Standard/TAILCUT/TAILCUT.lua
+++ b/Strategies/Standard/TAILCUT/TAILCUT.lua
@@ -7,7 +7,7 @@
 local BeamLib = require( 'BeamLib')
 local BeamData = require( 'BeamData')
 local MachiningLib = require( 'MachiningLib')
-local StrategyLib = require( 'StrategyLib')
+local SPLITCUT = require( 'SPLITCUT')
 local DiceCut = require( 'DiceCut')
 
 -- Tabella per definizione modulo
@@ -38,13 +38,13 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
 
    -- se devo fare split perchè c'è un grezzo da scaricare o un altro pezzo
    if Strategy.bSplit then
-      Strategy.SplitStrategy, Strategy.Result = StrategyLib.SplitStrategy.Get( Proc, Part, Strategy.Parameters)
+      Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetStrategy( Proc, Part, Strategy.Parameters)
 
    -- se devo rimuovere tutto il restante
    else
       -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
       if Strategy.Parameters.bExecutePreCut then
-         Strategy.SplitStrategy, Strategy.Result = StrategyLib.SplitStrategy.Get( Proc, Part, Strategy.Parameters)
+         Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetStrategy( Proc, Part, Strategy.Parameters)
       -- se non faccio tagli PRECUT, imposto tabella Result direttamente. Non serve verificare che riesca a rimuovere il materiale extra 
       else
          Strategy.Result.sStatus = 'Completed'
@@ -67,16 +67,18 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       -- se devo fare split perchè c'è un grezzo da scaricare o un altro pezzo
       if Strategy.bSplit then
          Strategy.dOffset = 0
-         MachiningsToAdd = StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
+         MachiningsToAdd = SPLITCUT.Execute( Proc, Part, Strategy)
       -- se devo rimuovere tutto il restante
       else
          -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
          if Strategy.Parameters.bExecutePreCut then
             Strategy.dOffset = Part.dRestLength
-            MachiningsToAdd = StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
+            MachiningsToAdd = SPLITCUT.Execute( Proc, Part, Strategy)
          end
-         -- rimuovo tutto il restante
-         -- table.insert( MachiningsToAdd, StrategyLib.BladeToWasteOneFace( Proc, Part))
+
+         -- TODO: funzione che calcola tagli data una faccia
+         -- BladeToWaste( Proc, Part)
+
          local Faces = {}
          local Face1 = {}
          local Face2 = {}
diff --git a/Strategies/Core/FACEBYBLADE.lua b/StrategyLibs/FACEBYBLADE.lua
similarity index 100%
rename from Strategies/Core/FACEBYBLADE.lua
rename to StrategyLibs/FACEBYBLADE.lua
diff --git a/Strategies/Core/SLOTBYBLADE.lua b/StrategyLibs/SLOTBYBLADE.lua
similarity index 100%
rename from Strategies/Core/SLOTBYBLADE.lua
rename to StrategyLibs/SLOTBYBLADE.lua
diff --git a/Strategies/Core/SLOTBYCHAINSAW.lua b/StrategyLibs/SLOTBYCHAINSAW.lua
similarity index 100%
rename from Strategies/Core/SLOTBYCHAINSAW.lua
rename to StrategyLibs/SLOTBYCHAINSAW.lua
diff --git a/LuaLibs/StrategyLib.lua b/StrategyLibs/SPLITCUT.lua
similarity index 90%
rename from LuaLibs/StrategyLib.lua
rename to StrategyLibs/SPLITCUT.lua
index 221df6a..ad38747 100644
--- a/LuaLibs/StrategyLib.lua
+++ b/StrategyLibs/SPLITCUT.lua
@@ -1,8 +1,8 @@
--- StrategyLib.lua by Egalware s.r.l. 2024/04/02
+-- SPLITCUT.lua by Egalware s.r.l. 2024/04/02
 -- Libreria di supporto a strategie con funzioni comune a strategie diverse.
 
 -- Tabella per definizione modulo
-local StrategyLib = {}
+local SPLITCUT = {}
 
 -- Include
 require( 'EgtBase')
@@ -14,14 +14,13 @@ local MachiningLib = require( 'MachiningLib')
 -- strategie di base
 local FaceByBlade = require('FACEBYBLADE')
 
-EgtOutLog( ' StrategyLib started', 1)
+EgtOutLog( ' SPLITCUT started', 1)
 
 -----------------------------------------------------------------------------------
 ---------------------- FUNZIONI DI SPLIT ------------------------------------------
 -----------------------------------------------------------------------------------
 
-StrategyLib.SplitStrategy = {}
-function StrategyLib.SplitStrategy.Get( Proc, Part, OptionalParameters)
+function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
    local Machining = {}
    local Result = {}
    -- sTypeMachining = BladeSideSingle\ BladeSideDouble\ BladeHorizontalSingle\ BladeHorizontalDouble\ ChainSawHorizontal\ ChainSawSideSingle\ ChainSawSideDouble\ ChainSawPlusBlade\ Mill\ None
@@ -183,7 +182,7 @@ function StrategyLib.SplitStrategy.Get( Proc, Part, OptionalParameters)
  end
 
 -------------------------------------------------------------------------------------------------------------
-function StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, vtEdge)
+function SPLITCUT.GetEdgeToMachine( Proc, vtEdge)
    local Edge
    for i = 1, #Proc.Faces[1].Edges do
       if AreSameVectorApprox( Proc.Faces[1].Edges[i].Norm, vtEdge) then
@@ -194,7 +193,7 @@ function StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, vtEdge)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+function SPLITCUT.CalculateLeadInOut( EdgeToMachine)
 
    local LeadIn = {}
    local LeadOut = {}
@@ -223,7 +222,7 @@ function StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
 end
 
 -----------------------------------------------------------------------------------
-function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
+function SPLITCUT.Execute( Proc, Part, Strategy)
    local Machinings = {}
 
    -- applico le lavorazioni
@@ -241,9 +240,9 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
 
       Machining.AuxiliaryData.bIsSplitOrCut = true
 
-      local EdgeToMachine = StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, -Y_AX())
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
       -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
       Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
       table.insert( Machinings, Machining)
 
@@ -261,9 +260,9 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
       OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
       OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')
 
-      local EdgeToMachine = StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, -Y_AX())
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
       -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
       Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
       table.insert( Machinings, Machining)
 
@@ -281,9 +280,9 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
 
       Machining.AuxiliaryData.bIsSplitOrCut = true
 
-      EdgeToMachine = StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, Y_AX())
+      EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Y_AX())
       -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
       Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
       table.insert( Machinings, Machining)
   ----------------------------------------------------------------------------------
@@ -301,9 +300,9 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
 
       Machining.AuxiliaryData.bIsSplitOrCut = true
 
-      local EdgeToMachine = StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, Z_AX())
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Z_AX())
       -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
       Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
       table.insert( Machinings, Machining)
   ----------------------------------------------------------------------------------
@@ -322,9 +321,9 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
       OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')
 
 
-      local EdgeToMachine = StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, Z_AX())
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Z_AX())
       -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
       Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
       table.insert( Machinings, Machining)
 
@@ -342,9 +341,9 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
 
       Machining.AuxiliaryData.bIsSplitOrCut = true
 
-      EdgeToMachine = StrategyLib.SplitStrategy.GetEdgeToMachine( Proc, -Z_AX())
+      EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Z_AX())
       -- approccio e retrazione
-      OptionalParameters.LeadIn, OptionalParameters.LeadOut = StrategyLib.SplitStrategy.CalculateLeadInOut( EdgeToMachine)
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
       Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
       table.insert( Machinings, Machining)
   ----------------------------------------------------------------------------------
@@ -365,4 +364,4 @@ function StrategyLib.SplitStrategy.Execute( Proc, Part, Strategy)
 end
 
 -------------------------------------------------------------------------------------------------------------
-return StrategyLib
+return SPLITCUT