diff --git a/downloads/discovery/luna/modeling.xmi b/downloads/discovery/luna/modeling.xmi
index a964d69..09ec753 100755
--- a/downloads/discovery/luna/modeling.xmi
+++ b/downloads/discovery/luna/modeling.xmi
@@ -113,7 +113,7 @@
         description="EEF (Extended Editing Framework) is a presentation framework for EMF models. "
         license="EPL"
         image32="images/eef.png"
-        visible="false">
+        visible="true">
       <sitesURLS>http://download.eclipse.org/releases/luna/</sitesURLS>
       <overview
           summary="The Extended Editing Framework aims at giving another way to improve the EMF model creation phase by providing new services dedicated to editing and using more appealing editing elements. The way to obtain these services and elements is based on a generative approach similar to the EMF.Edit one. The framework provides advanced editing components for the properties of EMF elements and a default generation based on standard metamodels using these components."
