diff --git a/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp b/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp
index 68df1e4b617a2961ecfd023f8b0986c39a01b4d9..a9b165fb371f6a9adaf12f9793e585c57bbd58ca 100644
--- a/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp
+++ b/src/libRender/RadiumNBR/Gui/NodeGraphControllerGui.cpp
@@ -27,8 +27,12 @@ buildNodeGraphControllerGui( NodeBasedRenderer* renderer,
 
     // TODO: find a way to refresh the main window when a widget gets updated instead of
     // when the mouse moves
+
+    /*
     nodeEditor->connections.push_back(
-        QObject::connect( nodeEditor, &RenderGraphEditorView::mouseMoved, appUpdateCallback ) );
+        QObject::connect( nodeEditor, &RenderGraphEditorView::needUpdate, appUpdateCallback ) );
+    */
+    QObject::connect( nodeEditor, &RenderGraphEditorView::needUpdate, appUpdateCallback );
 
     auto loadGraph = [nodeEditor, renderer, appUpdateCallback]() {
         QString fileName = QFileDialog::getOpenFileName(
@@ -38,6 +42,7 @@ buildNodeGraphControllerGui( NodeBasedRenderer* renderer,
             QFile file( fileName );
             if ( file.open( QIODevice::ReadOnly ) )
             {
+                nodeEditor->disconnectAll();
                 nodeEditor->scene->clearScene();
                 renderer->getRenderGraph()->clearNodes();
                 QByteArray wholeFile = file.readAll();
@@ -48,6 +53,7 @@ buildNodeGraphControllerGui( NodeBasedRenderer* renderer,
                                                 .c_str() );
                 renderer->setJsonFilePath( fileName.toStdString() );
                 nodeEditor->scene->setSceneName( fileName );
+                nodeEditor->connectAll();
                 appUpdateCallback();
             }
         }
@@ -91,23 +97,29 @@ buildNodeGraphControllerGui( NodeBasedRenderer* renderer,
         nodeEditor->setWindowTitle( std::string( "RenderGraph Node Editor - " +
                                                  renderer->getRendererName() + " - New graph" )
                                         .c_str() );
-
+        nodeEditor->disconnectAll();
         nodeEditor->scene->clearScene();
+        nodeEditor->connectAll();
         renderer->setJsonFilePath( "" );
         appUpdateCallback();
     };
-
-    nodeEditor->connections.push_back(
-        QObject::connect( nodeEditor->openAction, &QAction::triggered, loadGraph ) );
-
-    nodeEditor->connections.push_back(
-        QObject::connect( nodeEditor->saveAsAction, &QAction::triggered, saveGraphAs ) );
-
-    nodeEditor->connections.push_back(
-        QObject::connect( nodeEditor->saveAction, &QAction::triggered, saveGraph ) );
-
-    nodeEditor->connections.push_back(
-        QObject::connect( nodeEditor->newAction, &QAction::triggered, newGraph ) );
+    /*
+        nodeEditor->connections.push_back(
+            QObject::connect( nodeEditor->openAction, &QAction::triggered, loadGraph ) );
+
+        nodeEditor->connections.push_back(
+            QObject::connect( nodeEditor->saveAsAction, &QAction::triggered, saveGraphAs ) );
+
+        nodeEditor->connections.push_back(
+            QObject::connect( nodeEditor->saveAction, &QAction::triggered, saveGraph ) );
+
+        nodeEditor->connections.push_back(
+            QObject::connect( nodeEditor->newAction, &QAction::triggered, newGraph ) );
+    */
+    QObject::connect( nodeEditor->openAction, &QAction::triggered, loadGraph );
+    QObject::connect( nodeEditor->saveAsAction, &QAction::triggered, saveGraphAs );
+    QObject::connect( nodeEditor->saveAction, &QAction::triggered, saveGraph );
+    QObject::connect( nodeEditor->newAction, &QAction::triggered, newGraph );
 
     auto show_hideNodeEditor = [renderer, nodeEditor]() {
         if ( !nodeEditor->isVisible() )
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp
index d14cf9be6b22ac110893d17baf366640c549f879..e6b98cafcb6e0c5157cf1e55b942c7f27e5c0833 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.cpp
@@ -6,7 +6,6 @@
 #include <nodes/ConnectionStyle>
 #include <nodes/NodeData>
 
-
 #include <RadiumNBR/NodeBasedRenderer.hpp>
 
 #include <RadiumNBR/Gui/RenderGraphEditor/NodeAdapterModel.hpp>
@@ -16,7 +15,6 @@
 
 #include <RadiumNBR/NodeGraph/PremadeNodes/PremadeNodesIncludes.hpp>
 
-
 RenderGraphEditorView::RenderGraphEditorView( QWidget* parent ) : QWidget( parent, Qt::Window ) {
     QtNodes::ConnectionStyle::setConnectionStyle(
         R"(
@@ -63,10 +61,13 @@ RenderGraphEditorView::RenderGraphEditorView( QWidget* parent ) : QWidget( paren
     l->setContentsMargins( 0, 0, 0, 0 );
     l->setSpacing( 0 );
 
-    QCoreApplication::instance()->installEventFilter( this );
-
     // Create widgets
     WidgetFactory::initializeWidgetFactory();
+
+    /* Connect to signals */
+    // QCoreApplication::instance()->installEventFilter( this );
+
+    connectAll();
 }
 
 namespace NodeGraphQtEditor {
@@ -140,39 +141,25 @@ std::shared_ptr<DataModelRegistry> initializeNodeRegistry( RenderGraph* renderGr
     ret->registerModel<NodeAdapterModel<DisplaySinkNode>>(
         NodeCreator<NodeAdapterModel<DisplaySinkNode>>( renderGraph ), "Sinks" );
 
-
     ret->registerModel<NodeAdapterModel<DifferenceNode>>(
-        NodeCreator<NodeAdapterModel<DifferenceNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<DifferenceNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<SumNode>>(
-        NodeCreator<NodeAdapterModel<SumNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<SumNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<MultiplyNode>>(
-        NodeCreator<NodeAdapterModel<MultiplyNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<MultiplyNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<OneMinusNode>>(
-        NodeCreator<NodeAdapterModel<OneMinusNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<OneMinusNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<MaxNode>>(
-        NodeCreator<NodeAdapterModel<MaxNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<MaxNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<MinNode>>(
-        NodeCreator<NodeAdapterModel<MinNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<MinNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<MoreThanThresholdNode>>(
-        NodeCreator<NodeAdapterModel<MoreThanThresholdNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<MoreThanThresholdNode>>( renderGraph ), "Compositing" );
     ret->registerModel<NodeAdapterModel<LessThanThresholdNode>>(
-        NodeCreator<NodeAdapterModel<LessThanThresholdNode>>( renderGraph ),
-        "Compositing" );
+        NodeCreator<NodeAdapterModel<LessThanThresholdNode>>( renderGraph ), "Compositing" );
 
     ret->registerModel<NodeAdapterModel<FXAANode>>(
-        NodeCreator<NodeAdapterModel<FXAANode>>( renderGraph ),
-        "Anti Aliasing" );
-
-
-
-
+        NodeCreator<NodeAdapterModel<FXAANode>>( renderGraph ), "Anti Aliasing" );
 
     return ret;
 }
diff --git a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp
index ebdb44729dd8e43dc4997e9ea234af4449c095e8..72473c09e9018e0bf77272b5223f5a36b6683b17 100644
--- a/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp
+++ b/src/libRender/RadiumNBR/Gui/RenderGraphEditor/RenderGraphEditorView.hpp
@@ -31,15 +31,50 @@ class NodeBasedRenderer_LIBRARY_API RenderGraphEditorView : public QWidget
         connections.clear();
     }
 
+    void connectAll() {
+
+        /*
+            // This connection is not needed
+            //connections.push_back(QObject::connect(scene, &QtNodes::FlowScene::nodeHoverLeft,
+           this, &RenderGraphEditorView::needUpdate));
+
+            connections.push_back(QObject::connect(scene, &QtNodes::FlowScene::nodeDeleted, this,
+           &RenderGraphEditorView::needUpdate)); connections.push_back(QObject::connect(scene,
+           &QtNodes::FlowScene::connectionCreated, this, &RenderGraphEditorView::needUpdate));
+            connections.push_back(QObject::connect(scene, &QtNodes::FlowScene::connectionDeleted,
+           this, &RenderGraphEditorView::needUpdate));
+        */
+        connections.push_back(
+            QObject::connect( scene, &QtNodes::FlowScene::nodeHoverLeft, [this]() {
+                std::cout << "QtNodes::FlowScene::nodeHoverLeft\n";
+                emit needUpdate();
+            } ) );
+
+        connections.push_back( QObject::connect( scene, &QtNodes::FlowScene::nodeDeleted, [this]() {
+            std::cout << "QtNodes::FlowScene::nodeDeleted\n";
+            emit needUpdate();
+        } ) );
+        connections.push_back(
+            QObject::connect( scene, &QtNodes::FlowScene::connectionCreated, [this]() {
+                std::cout << "QtNodes::FlowScene::connectionCreated\n";
+                emit needUpdate();
+            } ) );
+        connections.push_back(
+            QObject::connect( scene, &QtNodes::FlowScene::connectionDeleted, [this]() {
+                std::cout << "QtNodes::FlowScene::connectionDeleted\n";
+                emit needUpdate();
+            } ) );
+    }
+
   public slots:
     bool eventFilter( QObject* object, QEvent* event ) {
         if ( event->type() == QEvent::MouseMove || event->type() == QEvent::KeyPress )
-        { emit mouseMoved(); }
+        { emit needUpdate(); }
         return false;
     };
 
   Q_SIGNALS:
-    void mouseMoved();
+    void needUpdate();
 
   public:
     QMenuBar* menuBar{ nullptr };
diff --git a/src/libRender/RadiumNBR/NodeBasedRenderer.cpp b/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
index ad8705966d19cedb40b13121ffabcec5c42f7cba..15eef954c7b327cbb5b6dcb056f5461dd077a145 100644
--- a/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
+++ b/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
@@ -36,9 +36,12 @@ static NodeBasedRenderer::RenderControlFunctor noOpController;
 NodeBasedRenderer::NodeBasedRenderer() : Renderer(), m_controller{ noOpController } {}
 
 NodeBasedRenderer::NodeBasedRenderer( NodeBasedRenderer::RenderControlFunctor& controller ) :
-    Renderer(), m_controller{ controller }, m_name{ m_controller.getRendererName() } {}
+    Renderer(), m_controller{ controller }, m_name{ m_controller.getRendererName() } {
+    setDisplayNode( m_originalRenderGraph.getDisplayNode() );
+}
 
 NodeBasedRenderer::~NodeBasedRenderer() {
+    m_displaySinkNode->detach( m_displayObserverId );
     m_originalRenderGraph.destroy();
 }
 
@@ -77,24 +80,16 @@ void NodeBasedRenderer::loadFromJson( const std::string& jsonFilePath ) {
     {
         m_originalRenderGraph.loadFromJson( jsonFilePath );
         m_originalRenderGraph.init();
-        m_displayObserverId=-1;
-        setDisplayNode( m_originalRenderGraph.getDisplayNode() );
     }
     else
     { std::cerr << "No Json was given to load a render graph." << std::endl; }
 }
 
-void NodeBasedRenderer::reloadRenderGraph() {
-    // TODO : no need to compile, init will do this !!!
-    // m_originalRenderGraph.compile();
-
+void NodeBasedRenderer::compileRenderGraph() {
+    std::cout << "NodeBasedRenderer::compileRenderGraph\n";
     m_originalRenderGraph.init();
-    m_displayObserverId = -1;
-    setDisplayNode( m_originalRenderGraph.getDisplayNode() );
     m_originalRenderGraph.resize( m_width, m_height );
-
     buildAllRenderTechniques();
-
     m_displayedTexture = m_fancyTexture.get();
 }
 
@@ -111,10 +106,7 @@ void NodeBasedRenderer::reloadRenderGraphFromJson() {
         // Reload
         m_originalRenderGraph.loadFromJson( m_jsonFilePath );
         m_originalRenderGraph.init();
-        m_displayObserverId = -1;
-        setDisplayNode( m_originalRenderGraph.getDisplayNode() );
         m_originalRenderGraph.resize( m_width, m_height );
-
         buildAllRenderTechniques();
 
         // Reset displayed texture
@@ -184,7 +176,6 @@ void NodeBasedRenderer::resizeInternal() {
 void NodeBasedRenderer::renderInternal( const ViewingParameters& renderData ) {
     // Run the render graph
     m_originalRenderGraph.execute();
-
 }
 
 // Draw debug stuff, do not overwrite depth map but do depth testing
@@ -325,7 +316,7 @@ void NodeBasedRenderer::updateStepInternal( const ViewingParameters& renderData
 
     if ( m_originalRenderGraph.m_recompile )
     {
-        reloadRenderGraph();
+        compileRenderGraph();
         m_originalRenderGraph.m_recompile = false;
     }
 
@@ -345,17 +336,17 @@ void NodeBasedRenderer::updateStepInternal( const ViewingParameters& renderData
     m_originalRenderGraph.update();
 }
 
-void NodeBasedRenderer::setDisplayNode( DisplaySinkNode* displayNode) {
-    if ( m_displayObserverId != -1 ) {
-        m_displaySinkNode->detach(m_displayObserverId);
-    }
+void NodeBasedRenderer::setDisplayNode( DisplaySinkNode* displayNode ) {
     m_displaySinkNode = displayNode;
-    m_displayObserverId = m_displaySinkNode->attachMember(this, &NodeBasedRenderer::observeDisplaySink);
+    m_displayObserverId =
+        m_displaySinkNode->attachMember( this, &NodeBasedRenderer::observeDisplaySink );
 }
 
-void NodeBasedRenderer::observeDisplaySink(const std::vector<NodeTypeTexture*>& graphOutput) {
-    // TODO : find a way to make the renderer observable to manage ouput texture in the applicaiton gui if needed
-    std::cout << "NodeBasedRenderer::observeDisplaySink - connected textures (" << graphOutput.size() << ") : \n";
+void NodeBasedRenderer::observeDisplaySink( const std::vector<NodeTypeTexture*>& graphOutput ) {
+    // TODO : find a way to make the renderer observable to manage ouput texture in the applicaiton
+    // gui if needed
+    std::cout << "NodeBasedRenderer::observeDisplaySink - connected textures ("
+              << graphOutput.size() << ") : \n";
     /*
     for ( const auto t : graphOutput )
     {
diff --git a/src/libRender/RadiumNBR/NodeBasedRenderer.hpp b/src/libRender/RadiumNBR/NodeBasedRenderer.hpp
index 77b6166106190c785d23ce4f7c96792955b93abb..c0d3b0652b77b57dc30cf1b2a6451afa840a4c14 100644
--- a/src/libRender/RadiumNBR/NodeBasedRenderer.hpp
+++ b/src/libRender/RadiumNBR/NodeBasedRenderer.hpp
@@ -41,7 +41,8 @@ extern int NodeBasedRendererMagic;
  *
  * @see rendering.md for description of the renderer
  */
-class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rendering::Renderer{
+class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rendering::Renderer
+{
 
   public:
     /**
@@ -109,7 +110,7 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
     void setJsonFilePath( const std::string& jsonFilePath ) { m_jsonFilePath = jsonFilePath; }
 
     /// Reloads the render graph
-    void reloadRenderGraph();
+    void compileRenderGraph();
 
     /// Reloads the render graph according to the current Json file
     void reloadRenderGraphFromJson();
@@ -136,7 +137,7 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
     virtual void initResources();
 
     /// The render graph used to start the rendering
-    RenderGraph m_originalRenderGraph{ "Original Render Graph" };
+    RenderGraph m_originalRenderGraph{ "Render Graph" };
 
     /// The JSON file to read to create the render graph
     std::string m_jsonFilePath{ "" };
@@ -144,9 +145,9 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
     /// The display sink node used to get the secondary textures
     DisplaySinkNode* m_displaySinkNode{ nullptr };
     /// ObserverId for displaySink;
-    int m_displayObserverId{-1};
+    int m_displayObserverId{ -1 };
 
-    void observeDisplaySink(const std::vector<NodeTypeTexture*>&);
+    void observeDisplaySink( const std::vector<NodeTypeTexture*>& );
 
   public:
     inline std::map<std::string, std::shared_ptr<Ra::Engine::Data::Texture>>& sharedTextures() {
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.cpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.cpp
index 6c7d03f82a716070a716bbc442dea458647b1849..a6cb6802a526e08314d6b60097e8adbde598e56a 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.cpp
@@ -6,11 +6,19 @@ DisplaySinkNode::DisplaySinkNode( const std::string& name ) : Node( name, getTyp
     for ( size_t i = 0; i < MAX_DISPLAY_INPUTS; i++ )
     {
         auto portIn = new PortIn<NodeTypeTexture>( "inTexture" + std::to_string( i ), this );
-        portIn->attachMember(this, &DisplaySinkNode::observeConnection);
+        portIn->attachMember( this, &DisplaySinkNode::observeConnection );
         addInput( portIn );
     }
 }
 
+void DisplaySinkNode::disconnectInputs() {
+    for ( size_t i = 0; i < MAX_DISPLAY_INPUTS; i++ )
+    {
+        if ( m_inputs[i]->isLinked() ) { m_inputs[i]->disconnect(); }
+    }
+    m_firstRun = true;
+}
+
 void DisplaySinkNode::init() {
 #ifdef GRAPH_CALL_TRACE
     std::cout << "\e[31m\e[1mDisplaySinkNode\e[0m \"" << m_name << "\": initialization."
@@ -23,19 +31,20 @@ void DisplaySinkNode::update() {
 #endif
 }
 void DisplaySinkNode::execute() {
-    if( m_firstRun) {
+    if ( m_firstRun )
+    {
         m_firstRun = false;
         m_textures.clear();
         for ( size_t i = 0; i < MAX_DISPLAY_INPUTS; i++ )
         {
             if ( m_inputs[i]->isLinked() )
             {
-                auto input               = dynamic_cast<PortIn<NodeTypeTexture>*>( m_inputs[i].get() );
+                auto input = dynamic_cast<PortIn<NodeTypeTexture>*>( m_inputs[i].get() );
                 NodeTypeTexture* texture = &input->getData();
                 if ( texture ) { m_textures.push_back( texture ); }
             }
         }
-        this->notify(m_textures);
+        this->notify( m_textures );
     }
 #ifdef GRAPH_CALL_TRACE
     std::cout << "\e[31m\e[1mDisplaySinkNode\e[0m \"" << m_name << "\": execute." << std::endl;
@@ -58,14 +67,17 @@ const std::vector<NodeTypeTexture*>& DisplaySinkNode::getTextures() {
     return m_textures;
 }
 
-void DisplaySinkNode::observeConnection(const std::string& name, const PortIn<NodeTypeTexture>& port, bool connected) {
+void DisplaySinkNode::observeConnection( const std::string& name,
+                                         const PortIn<NodeTypeTexture>& port,
+                                         bool connected ) {
     // manage textures
     // Right now, naive management of textures (erase and fill again).
     // TODO : only update the texture sets
     m_textures.clear();
     for ( size_t i = 0; i < MAX_DISPLAY_INPUTS; i++ )
     {
-        if (!connected && m_inputs[i]->getName() == name) {
+        if ( !connected && m_inputs[i]->getName() == name )
+        {
             // this port is disconnected
             continue;
         }
@@ -76,7 +88,5 @@ void DisplaySinkNode::observeConnection(const std::string& name, const PortIn<No
             if ( texture ) { m_textures.push_back( texture ); }
         }
     }
-    if  (!m_firstRun ) {
-        this->notify(m_textures);
-    }
+    if ( !m_firstRun ) { this->notify( m_textures ); }
 }
diff --git a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.hpp b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.hpp
index e17da0d0a5079e6396ddfa3c4d420bf611aec366..30f67951620a76fa38a90f9d148aa44e2f76664a 100644
--- a/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.hpp
+++ b/src/libRender/RadiumNBR/NodeGraph/PremadeNodes/Sinks/DisplaySinkNode.hpp
@@ -1,7 +1,9 @@
 #pragma once
 #include <RadiumNBR/NodeGraph/Node.hpp>
 
-class NodeBasedRenderer_LIBRARY_API DisplaySinkNode : public Node, public Ra::Core::Utils::Observable<const std::vector<NodeTypeTexture*>&>
+class NodeBasedRenderer_LIBRARY_API DisplaySinkNode
+    : public Node,
+      public Ra::Core::Utils::Observable<const std::vector<NodeTypeTexture*>&>
 {
   public:
     explicit DisplaySinkNode( const std::string& name );
@@ -16,6 +18,8 @@ class NodeBasedRenderer_LIBRARY_API DisplaySinkNode : public Node, public Ra::Co
 
     const std::vector<NodeTypeTexture*>& getTextures();
 
+    void disconnectInputs();
+
   protected:
     void toJsonInternal( nlohmann::json& data ) const override {}
     void fromJsonInternal( const nlohmann::json& data ) override {}
@@ -24,7 +28,9 @@ class NodeBasedRenderer_LIBRARY_API DisplaySinkNode : public Node, public Ra::Co
     std::vector<NodeTypeTexture*> m_textures;
 
     // the observer method
-    void observeConnection(const std::string& name, const PortIn<NodeTypeTexture>& port, bool connected);
+    void observeConnection( const std::string& name,
+                            const PortIn<NodeTypeTexture>& port,
+                            bool connected );
 
-    bool m_firstRun{true};
+    bool m_firstRun{ true };
 };
diff --git a/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp b/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp
index a20338d9ecd695197f925635bfca11629a323fa9..f6ed666e5b7a03e04419f7084ed5cd6d23b3887f 100644
--- a/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp
+++ b/src/libRender/RadiumNBR/NodeGraph/RenderGraph.cpp
@@ -506,7 +506,6 @@ bool RenderGraph::compile() {
         // Find all sources
         if ( n->getInputs().empty() )
         {
-            // std::cout << "Source : " << n->getName() << std::endl;
             //  Use the info nodes map to find the successors
             if ( infoNodes.find( n.get() ) != infoNodes.end() )
             {
@@ -514,9 +513,6 @@ bool RenderGraph::compile() {
                 {
                     infoNodes[successor].first =
                         std::max( infoNodes[successor].first, infoNodes[n.get()].first + 1 );
-                    // std::cout << n->getName() << "(" << infoNodes[n.get()].first << ")" << "->"
-                    // << successor->getName() << "(" << infoNodes[successor].first << ")" <<
-                    // std::endl;
                     maxLevel = std::max( maxLevel,
                                          std::max( infoNodes[successor].first,
                                                    goThroughGraph( successor, infoNodes ) ) );
@@ -572,6 +568,7 @@ bool RenderGraph::compile() {
 }
 
 void RenderGraph::clearNodes() {
+
     for ( size_t i = 0; i < m_nodesByLevel.size(); i++ )
     {
         m_nodesByLevel[i].clear();
@@ -579,19 +576,12 @@ void RenderGraph::clearNodes() {
     }
     m_nodesByLevel.clear();
     m_nodesByLevel.shrink_to_fit();
-    m_nodes.clear();
+    // Remove only non permanent nodes
+    // disconnect sink
+    getDisplayNode()->disconnectInputs();
+    // remove node
+    m_nodes.erase( m_nodes.begin() + 4, m_nodes.end() );
     m_nodes.shrink_to_fit();
-
-    // Why reallocating these ???
-    // TODO Check the need of reallocating nodes and modify the observers mathod on these.
-    auto renderObjects = new DataNode<NodeTypeRenderObject>( "renderObjects" );
-    addNode( renderObjects );
-    auto lights = new DataNode<NodeTypeLight>( "lights" );
-    addNode( lights );
-    auto cameras = new DataNode<NodeTypeCamera>( "cameras" );
-    addNode( cameras );
-    auto display = new DisplaySinkNode( "display" );
-    addNode( display );
 }
 
 void RenderGraph::backtrackGraph(