diff --git a/gi/importer.py b/gi/importer.py
index f283a41..6eff264 100644
--- a/gi/importer.py
+++ b/gi/importer.py
@@ -26,10 +26,11 @@ import sys
 import gobject
 
 from ._gi import Repository, RepositoryError
-from .module import DynamicModule
+from .module import DynamicModule, ModuleProxy
 
 
 repository = Repository.get_default()
+modules = {}
 
 
 class DynamicImporter(object):
@@ -39,17 +40,6 @@ class DynamicImporter(object):
     def __init__(self, path):
         self.path = path
 
-    def _create_module(self, module_type, name, namespace):
-        module = module_type.__new__(module_type)
-        module.__dict__ = {
-            '__file__': '<%s>' % name,
-            '__name__': name,
-            '__namespace__': namespace,
-            '__loader__': self
-        }
-        module.__init__()
-        return module
-
     def find_module(self, fullname, path=None):
         if not fullname.startswith(self.path):
             return
@@ -75,23 +65,20 @@ class DynamicImporter(object):
             sys.modules[fullname] = gobject
             return gobject
 
-        module_type = DynamicModule
-        module = self._create_module(module_type, fullname, namespace)
-        sys.modules[fullname] = module
+        dynamic_module = DynamicModule(namespace)
+        modules[namespace] = dynamic_module
 
-        # Look for an overrides module
-        overrides_name = 'gi.overrides.%s' % namespace
-        overrides_type_name = '%sModule' % namespace
         try:
-
-            overrides_module = __import__(overrides_name, fromlist=[overrides_type_name])
-            module_type = getattr(overrides_module, overrides_type_name)
+            overrides_modules = __import__('gi.overrides', fromlist=[namespace])
+            overrides_module = getattr(overrides_modules, namespace)
         except ImportError, e:
-            pass
+            overrides_module = None
+
+        module_proxy = ModuleProxy(fullname, namespace, [overrides_module, dynamic_module])
+        module_proxy.__file__ = '<%s>' % fullname
+        module_proxy.__loader__ = self
 
-        if module_type is not DynamicModule:
-            module = self._create_module(module_type, fullname, namespace)
-            sys.modules[fullname] = module
+        sys.modules[fullname] = module_proxy
 
-        return module
+        return module_proxy
 
diff --git a/gi/module.py b/gi/module.py
index 1a54971..b7086bf 100644
--- a/gi/module.py
+++ b/gi/module.py
@@ -75,18 +75,13 @@ def get_interfaces_for_object(object_info):
 
 class DynamicModule(object):
 
-    def __str__(self):
-        path = repository.get_typelib_path(self.__namespace__)
-        return "<dynamic module %r from %r>" % (self.__name__,  path)
+    def __init__(self, namespace):
+        self.__namespace__ = namespace
 
     def __getattr__(self, name):
-        if self.__dict__.has_key(name):
-            return self.__dict__[name]
-
         info = repository.find_by_name(self.__namespace__, name)
         if not info:
-            raise AttributeError("%r object has no attribute %r" % (
-                    self.__class__.__name__, name))
+            raise AttributeError
 
         if isinstance(info, EnumInfo):
             g_type = info.get_g_type()
@@ -158,10 +153,32 @@ class DynamicModule(object):
         self.__dict__[name] = value
         return value
 
-    @property
-    def __members__(self):
-        r = []
-        for type_info in repository.get_infos(self.__namespace__):
-            r.append(type_info.get_name())
-        return r
+    def __repr__(self):
+        path = repository.get_typelib_path(self.__namespace__)
+        return "<DynamicModule %r from %r>" % (self.__namespace__, path)
+
+
+class ModuleProxy(object):
+
+    def __init__(self, name, namespace, modules):
+        self.__name__ = name
+        self.__namespace__ = namespace
+        self.__modules__ = modules
+
+    def __getattr__(self, name):
+        attribute = None
+        for module in self.__modules__:
+            if hasattr(module, name):
+                attribute = getattr(module, name)
+                break
+
+        if attribute is None:
+            raise AttributeError("%r object has no attribute %r" % (
+                    self.__class__.__name__, name))
+
+        self.__dict__[name] = attribute
+        return attribute
+
+    def __str__(self):
+        return "<ModuleProxy %r>" % self.__name__
 
diff --git a/gi/overrides/Gdk.py b/gi/overrides/Gdk.py
index e3e2d29..7d3eed2 100644
--- a/gi/overrides/Gdk.py
+++ b/gi/overrides/Gdk.py
@@ -1,21 +1,32 @@
-import sys
 
-from ..module import DynamicModule
+from ..types import override
+
+from ..importer import modules
+
+Gdk = modules['Gdk']
+
+del modules
+
+
+@override
+class Rectangle(Gdk.Rectangle):
+
+    def __init__(self, x, y, width, height):
+        super(self, Rectangle).__init__()
+        self.x = x
+        self.y = y
+        self.width = width
+        self.height = height
+
+
+import sys
 
-class GdkModule(DynamicModule):
+initialized, argv = Gdk.init_check(sys.argv)
+if not initialized:
+    raise RuntimeError("Gdk couldn't be initialized")
 
-    def __init__(self):
-        super(GdkModule, self).__init__()
+del initialized, argv, sys
 
-        initialized, argv = self.init_check(tuple(sys.argv))
-        if not initialized:
-            raise RuntimeError("Gdk couldn't be initialized")
 
-    def rectangle_new(self, x, y, width, height):
-        rectangle = self.Rectangle()
-        rectangle.x = x
-        rectangle.y = y
-        rectangle.width = width
-        rectangle.height = height
-        return rectangle
+del Gdk
 
diff --git a/gi/types.py b/gi/types.py
index e32bb72..7f4f0ba 100644
--- a/gi/types.py
+++ b/gi/types.py
@@ -164,3 +164,7 @@ class StructMeta(type, MetaClassHelper):
         cls._setup_methods()
         cls._setup_constructors()
 
+
+def override(type_):
+    # TODO: register the type as the wrapper for the GType
+    return type_
