diff --git a/data/magCursors/default-cursor.xpm b/data/magCursors/default-cursor.xpm
new file mode 100644
index 0000000..d71f4c1
--- /dev/null
+++ b/data/magCursors/default-cursor.xpm
@@ -0,0 +1,64 @@
+/* XPM */
+static char* Normal[] = {
+"48 58 3 1 0 0",
+"  c None",
+"! c #ffffff",
+"# c #000000",
+"!!                                              ",
+"!#!                                             ",
+"!##!                                            ",
+"!###!                                           ",
+"!####!                                          ",
+"!#####!                                         ",
+"!######!                                        ",
+"!#######!                                       ",
+"!########!                                      ",
+"!#########!                                     ",
+"!##########!                                    ",
+"!###########!                                   ",
+"!############!                                  ",
+"!#############!                                 ",
+"!##############!                                ",
+"!###############!                               ",
+"!################!                              ",
+"!#################!                             ",
+"!##################!                            ",
+"!###################!                           ",
+"!####################!                          ",
+"!#####################!                         ",
+"!######################!                        ",
+"!#######################!                       ",
+"!########################!                      ",
+"!#########################!                     ",
+"!##########################!                    ",
+"!###########################!                   ",
+"!############################!                  ",
+"!################!!!!!!!!!!!!!                  ",
+"!################!                              ",
+"!################!!                             ",
+"!#################!                             ",
+"!########!!#######!!                            ",
+"!#######!  !#######!                            ",
+"!######!   !#######!!                           ",
+"!#####!     !#######!                           ",
+"!####!      !#######!!                          ",
+"!###!        !#######!                          ",
+"!##!         !#######!!                         ",
+"!#!           !#######!                         ",
+"!!            !#######!!                        ",
+"!              !#######!                        ",
+"               !#######!!                       ",
+"                !#######!                       ",
+"                !#######!!                      ",
+"                 !#######!                      ",
+"                 !#######!                      ",
+"                  !######!                      ",
+"                   !!!!!!!                      ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                ",
+"                                                "};
diff --git a/js/ui/altTab.js b/js/ui/altTab.js
index 3ed39f8..053b846 100644
--- a/js/ui/altTab.js
+++ b/js/ui/altTab.js
@@ -59,7 +59,7 @@ AltTabPopup.prototype = {
         // the switcher appears underneath the current pointer location
         this._disableHover();
 
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
     },
 
     show : function(backward) {
diff --git a/js/ui/appIcon.js b/js/ui/appIcon.js
index 5202a1d..fd882b6 100644
--- a/js/ui/appIcon.js
+++ b/js/ui/appIcon.js
@@ -323,7 +323,7 @@ AppIconMenu.prototype = {
         }));
         source.actor.connect('destroy', Lang.bind(this, function () { this.actor.destroy(); }));
 
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
     },
 
     _getPreferredWidth: function(actor, forHeight, alloc) {
diff --git a/js/ui/chrome.js b/js/ui/chrome.js
index 2e57456..9257104 100644
--- a/js/ui/chrome.js
+++ b/js/ui/chrome.js
@@ -21,7 +21,7 @@ Chrome.prototype = {
     _init: function() {
         // The group itself has zero size so it doesn't interfere with DND
         this.actor = new Clutter.Group({ width: 0, height: 0 });
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
         this.nonOverviewActor = new Clutter.Group();
         this.actor.add_actor(this.nonOverviewActor);
 
diff --git a/js/ui/dnd.js b/js/ui/dnd.js
index 9188cad..8e4b60e 100644
--- a/js/ui/dnd.js
+++ b/js/ui/dnd.js
@@ -5,6 +5,7 @@ const Gtk = imports.gi.Gtk;
 const Lang = imports.lang;
 const Signals = imports.signals;
 const Tweener = imports.ui.tweener;
+const Main = imports.ui.main;
 
 const SNAP_BACK_ANIMATION_TIME = 0.25;
 
@@ -16,7 +17,7 @@ function _getEventHandlerActor() {
         eventHandlerActor = new Clutter.Rectangle();
         eventHandlerActor.width = 0;
         eventHandlerActor.height = 0;
-        global.stage.add_actor(eventHandlerActor);
+        Main.uiGroup.add_actor(eventHandlerActor);
         // We connect to 'event' rather than 'captured-event' because the capturing phase doesn't happen
         // when you've grabbed the pointer.
         eventHandlerActor.connect('event',
diff --git a/js/ui/lookingGlass.js b/js/ui/lookingGlass.js
index 5aad6e4..314d6b3 100644
--- a/js/ui/lookingGlass.js
+++ b/js/ui/lookingGlass.js
@@ -266,7 +266,7 @@ Inspector.prototype = {
         eventHandler.connect('notify::allocation', Lang.bind(this, function () {
             eventHandler.x = primary.x + Math.floor((primary.width - eventHandler.width) / 2);
         }));
-        global.stage.add_actor(eventHandler);
+        Main.uiGroup.add_actor(eventHandler);
         let displayText = new St.Label();
         eventHandler.add(displayText, { expand: true });
 
@@ -380,7 +380,7 @@ LookingGlass.prototype = {
                       Lang.bind(this, this._updateFont));
         this._updateFont();
 
-        global.stage.add_actor(this.actor);
+        Main.uiGroup.add_actor(this.actor);
 
         let toolbar = new St.BoxLayout({ name: "Toolbar" });
         this.actor.add_actor(toolbar);
diff --git a/js/ui/magnifier.js b/js/ui/magnifier.js
new file mode 100755
index 0000000..49b95cb
--- /dev/null
+++ b/js/ui/magnifier.js
@@ -0,0 +1,544 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const DBus = imports.dbus;
+const Gtk = imports.gi.Gtk;
+const Gdk = imports.gi.Gdk;
+const Clutter = imports.gi.Clutter;
+const Shell = imports.gi.Shell;
+const Big = imports.gi.Big;
+const Lang = imports.lang;
+const Mainloop = imports.mainloop;
+const Main = imports.ui.main;
+const MagnifierDBus = imports.ui.magnifierDBus;
+
+const ScreenPosition =
+    { NONE: 0, FULL_SCREEN: 1, TOP_HALF: 2, BOTTOM_HALF: 3, LEFT_HALF: 4, RIGHT_HALF: 5, DOCKED: 6 };
+
+// Default settings
+const DEFAULT_X_MAGFACTOR = 2;
+const DEFAULT_Y_MAGFACTOR = 2;
+const DEFAULT_MOUSE_POLL_FREQUENCY = 50;
+const DEFAULT_LENS_MODE = false;
+const DEFAULT_SCREEN_POSITION = ScreenPosition.BOTTOM_HALF;
+
+const BORDER_WIDTH = 8;
+
+let magDBusService = null;
+
+function Magnifier(options) {
+    this._init(options);
+}
+
+Magnifier.prototype = {
+    _init: function() {
+        // The root actor for the magnifier is a Big.Box with a frame around it.
+        const BORDER_COLOR = new Clutter.Color();
+        BORDER_COLOR.from_pixel(0x800000ff);
+        this._magView = new Big.Box({
+            border: BORDER_WIDTH,
+            border_color: BORDER_COLOR
+        });
+
+        // Append a Clutter.Group to clip the contents of the magnified vew.
+        // Note:  if the size is not initialized to something, the height is
+        // not properly clipped when added to _magView.  Setting width and
+        // height temporarily to anything fixes this.
+        let aGroup = new Clutter.Group({
+            clip_to_allocation: true,
+            width: 0,
+            height: 0
+        });
+        this._magView.append(aGroup, Big.BoxPackFlags.EXPAND);
+
+        // Add a background for when the magnified uiGroup is scrolled
+        // out of view (don't want to see desktop showing through).
+        let background = new Clutter.Rectangle({ color: Main.DEFAULT_BACKGROUND_COLOR });
+        aGroup.add_actor(background);
+
+        // Clone the group that contains all of UI on the screen.  This is the
+        // chrome, the windows, etc.
+        this._uiGroupClone = new Clutter.Clone({ source: Main.uiGroup });
+        aGroup.add_actor(this._uiGroupClone);
+        Main.uiGroup.set_size(global.screen_width, global.screen_height);
+        background.set_size(global.screen_width, global.screen_height);
+        this._uiGroupClone.set_size(global.screen_width, global.screen_height);
+
+        this.setMouseCursor("default-cursor.xpm");
+        this._uiGroupClone.set_scale(DEFAULT_X_MAGFACTOR, DEFAULT_Y_MAGFACTOR);
+        this.setScreenPosition(DEFAULT_SCREEN_POSITION);
+        this.setLensMode(DEFAULT_LENS_MODE);
+        this._clampScrollingAtEdges = false;
+        this.startTrackingMouse();
+        this._magView.hide();
+        global.stage.add_actor(this._magView);
+
+        // Export to dbus.
+        magDBusService = new MagnifierDBus.ShellMagnifier();
+    },
+
+    /**
+     * setActive:
+     * @activate:   Boolean to activate or de-activate the magnifier.
+     */
+    setActive: function(activate) {
+        if (activate)
+          this._magView.show();
+        else
+          this._magView.hide();
+    },
+
+    /**
+     * isActive:
+     * @return  Whether the magnifier is active (boolean).
+     */
+    isActive: function() {
+        return this._magView.visible;
+    },
+
+    /**
+     * setMagFactor:
+     * @xMagFactor:     The power to set the horizontal magnification factor to
+     *                  of the magnified view.  A value of 1.0 means no
+     *                  magnification.  A value of 2.0 doubles the size.
+     * @yMagFactor:     The power to set the vertical magnification factor to
+     *                  of the magnified view.
+     */
+    setMagFactor: function(xMagFactor, yMagFactor) {
+        xMagFactor = xMagFactor < 1 ? 1 : xMagFactor;
+        yMagFactor = yMagFactor < 1 ? 1 : yMagFactor;
+        this._uiGroupClone.set_scale(xMagFactor, yMagFactor);
+    },
+
+    /**
+     * getMagFactor:
+     * @return  an array, [xMagFactor, yMagFactor], containing the horizontal
+     *          and vertical magnification powers.  A value of 1.0 means no
+     *          magnification.  A value of 2.0 means the contents are doubled
+     *          in size, and so on.
+     */
+    getMagFactor: function() {
+        return this._uiGroupClone.get_scale();
+    },
+
+    /**
+     * setSize:
+     * @width:    The width to set the magnified view to.
+     * @height:   The height to set the magnified view to.
+     */
+    setSize: function(width, height) {
+        this._magView.set_size(width, height);
+
+        // Reposition the mouse to the centre.
+        let [xCenter, yCenter] = this.getCenter();
+        this._cursorActor.set_position(xCenter, yCenter);
+    },
+
+    /**
+     * getSize:
+     * @return  an array, [width, height], that specifies the size of the
+     *          magnified view.
+     */
+    getSize: function() {
+        return this._magView.get_size();
+    },
+
+    /**
+     * setPosition:
+     * Position the magnified view at the given coordinates.
+     * @x:    The x-coord of the new position.
+     * @y:    The y-coord of the new position.
+     */
+    setPosition: function(x, y) {
+        let [width, height] = this._magView.get_size();
+        if (this._clampScrollingAtEdges) {
+            // Restrict positioning so view doesn't go beyond any edge of the
+            // screen.
+            if (x < 0)
+                x = 0;
+            if (x + width > global.screen_width)
+                x = global.screen_width - width;
+            if (y < 0)
+                y = 0;
+            if (y + height > global.screen_height)
+                y = global.screen_height - height;
+        }
+        this._magView.set_position(x, y);
+    },
+
+    /**
+     * getPosition:
+     * @return  an array, [x, y], that gives the position of the
+     *          magnified view on screen.
+     */
+    getPosition: function() {
+        return this._magView.get_position();
+    },
+
+    /**
+     * getCenter:
+     * @return  an array, [x, y], that is half the width and height of the
+     *          magnified view (the center of the magnified view).
+     */
+    getCenter: function() {
+        let [width, height] = this._magView.get_size();
+        return [width / 2, height / 2];
+    },
+
+    /**
+     * isFullScreenMode:
+     * Does the magnified view occupy the whole screen?
+     */
+    isFullScreenMode: function() {
+        let [x, y] = this._magView.get_position();
+        if (x != 0 || y != 0)
+            return false;
+        [width, height] = this._magView.get_size();
+        if (width != global.screen_width || height != global.screen_height)
+            return false;
+        return true;
+    },
+
+    /**
+     * scrollToPosition:
+     * Center the contents of the magnified view to the given screen
+     * (non-magnifed) coordinates.
+     * @x:          The x-coord of the position to scroll to.
+     * @y:          The y-coord of the position to scroll to.
+     * @hideMouse:  Option: Hide the magnified mouse cursor after the move.  The
+     *              default is to show the mouse.
+     */
+    scrollToPosition: function(x, y, hideMouse) {
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+        let xMagnified = x * xMagFactor;
+        let yMagnified = y * yMagFactor;
+
+        let [xCenterMagView, yCenterMagView] = this.getCenter();
+        let newX = xCenterMagView - xMagnified;
+        let newY = yCenterMagView - yMagnified;
+
+        if (this._clampScrollingAtEdges) {
+            let [contentWidth, contentHeight] = this._uiGroupClone.get_size();
+            let [viewWidth, viewHeight] = this.getSize();
+
+            // The point (rightStop, bottomStop) is the top left point of
+            // _uiGroupClone when its right and bottom edges are coincident
+            // with the right and bottom edges of _magView.
+            let rightStop = viewWidth - (contentWidth * xMagFactor);
+            let bottomStop = viewHeight - (contentHeight * yMagFactor);
+
+            if (newX > 0)
+                newX = 0;
+            else if (newX < rightStop)
+                newX = rightStop;
+            if (newY > 0)
+                newY = 0;
+            else if (newY < bottomStop)
+                newY = bottomStop;
+            this._uiGroupClone.set_position(newX, newY);
+            this._updateMousePosition(rightStop, bottomStop);
+        }
+        else
+            this._uiGroupClone.set_position(newX, newY);
+
+        // If in lens mode, move the magnified view such that it is centered
+        // over the actual mouse. However, in full screen mode, the "lens" is 
+        // the size of the screen -- pointless to move such a large lens around.
+        if (this._lensMode && !this.isFullScreenMode())
+            this.setPosition(x - xCenterMagView, y - yCenterMagView);
+
+        if (hideMouse)
+            this._cursorActor.hide();
+        else
+            this._cursorActor.show();
+    },
+
+    /**
+     * _updateMousePosition:
+     * If the actual mouse is near one of the top, left, bottom, or right edges,
+     * move the magnified mouse cursor image away from the center of the
+     * magnfied view to the position corresponding to the actual mouse.
+     * @rightStop:  The x-coord of the left edge of the magnified contents such
+     *              its right edge is coincident with the magnified view's right
+     *              edge.
+     * @bottomStop: The y-ccord of the top edge of the magnified contents such
+     *              its bottom edge is the same as the mangnified view's bottom
+     *              edge.
+     */
+     _updateMousePosition: function(rightStop, bottomStop) {
+        let [x, y] = this._uiGroupClone.get_position();
+        let [xCenterMagView, yCenterMagView] = this.getCenter();
+        let [objUnder, xMouse, yMouse, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+
+        let xMagMouse = xCenterMagView;
+        let yMagMouse = yCenterMagView;
+        if (x == 0)
+            xMagMouse = xMouse * xMagFactor;
+        else if (x == rightStop)
+            xMagMouse = (xMouse * xMagFactor) + rightStop;
+
+        if (y == 0)
+            yMagMouse = yMouse * yMagFactor;
+        else if (y == bottomStop)
+            yMagMouse = (yMouse * yMagFactor) + bottomStop;
+
+        this._cursorActor.set_position(xMagMouse, yMagMouse);
+    },
+
+    /**
+     * getROI:
+     * Retrieves the "region of interest" -- the rectangular bounds of that part
+     * of the desktop that the magnified view is showing (x, y, width, height).
+     * The bounds are given in non-magnified coordinates.
+     * @return  an array, [x, y, width, height], representing the bounding
+     *          rectangle of what is shown in the magnified view.
+     */
+    getROI: function() {
+        let [xMagnified, yMagnified] = this._uiGroupClone.get_position();
+        let [xMagFactor, yMagFactor] = this.getMagFactor();
+        let [width, height] = this.getSize();
+        let x = (0 - xMagnified) / xMagFactor;
+        let y = (0 - yMagnified) / yMagFactor;
+        return [x, y, width / xMagFactor, height / yMagFactor];
+    },
+
+    /**
+     * setMouseCursor:
+     * Set the magnified mouse cursor.
+     * @filename:   The name of the file containing the cursor image.  It is
+     *              assumed to reside in
+     *              <code>global.imagedir/magCursors</code>.
+     */
+    setMouseCursor: function(filename) {
+        let uri = "file://" + global.imagedir + "magCursors/" + filename;
+        let cursorImg = Shell.TextureCache.get_default().load_uri_sync(
+            Shell.TextureCachePolicy.FOREVER, uri, 64, 64
+        );
+        let cursorActor = new Big.Box();
+        cursorActor.append(cursorImg, Big.BoxPackFlags.EXPAND);
+        this._cursorActor = cursorActor;
+        this._magView.add_actor(this._cursorActor);
+        let [xCenter, yCenter] = this.getCenter();
+        this._cursorActor.set_position(xCenter, yCenter);
+    },
+
+    /**
+     * setLensMode:
+     * Turn lens mode on/off.  In full screen mode, lens mode is alway off since
+     * a lens the size of the screen is pointless.
+     * @lensMode:   A boolean to set the sense of lens mode.
+     */
+    setLensMode: function(lensMode) {
+        let fullScreen = this.isFullScreenMode();
+        this._lensMode = (lensMode && !fullScreen);
+        if (!this._lensMode && !fullScreen)
+            this.setScreenPosition (this._screenPosition);
+    },
+
+    /**
+     * isLensMode:
+     * Is lens mode on or off?
+     * @return  The lens mode state as a boolean.
+     */
+    isLensMode: function() {
+        return this._lensMode;
+    },
+
+    /**
+     * setClampScrollingAtEdges:
+     * Stop or allow scrolling of the magnified contents when they scroll beyond
+     * the edges of the screen.  Also, insure that the magnified mouse cursor is
+     * recentered within the magnified view when clamping is removed, as it may
+     * be off-center if near a screen edge with clamping on.
+     * @clamp:   Boolean to turn on/off clamping.
+     */
+    setClampScrollingAtEdges: function(clamp) {
+        this._clampScrollingAtEdges = clamp;
+        if (!clamp) {
+            let [xCenter, yCenter] = this.getCenter();
+            this._cursorActor.set_position(xCenter, yCenter);
+        }
+    },
+
+    /**
+     * setTopHalf:
+     * Magnifier view occupies the top half of the screen.
+     */
+    setTopHalf: function() {
+        this.setPosition(0, 0);
+        this.setSize(global.screen_width, global.screen_height/2);
+        this._screenPosition = ScreenPosition.TOP_HALF;
+    },
+
+    /**
+     * setBottomHalf:
+     * Magnifier view occupies the bottom half of the screen.
+     */
+    setBottomHalf: function() {
+        this.setPosition(0, global.screen_height/2);
+        this.setSize(global.screen_width, global.screen_height/2);
+        this._screenPosition = ScreenPosition.BOTTOM_HALF;
+    },
+
+    /**
+     * setLeftHalf:
+     * Magnifier view occupies the left half of the screen.
+     */
+    setLeftHalf: function() {
+        this.setPosition(0, 0);
+        this.setSize(global.screen_width/2, global.screen_height);
+        this._screenPosition = ScreenPosition.LEFT_HALF;
+    },
+
+    /**
+     * setRightHalf:
+     * Magnifier view occupies the right half of the screen.
+     */
+    setRightHalf: function() {
+        this.setPosition(global.screen_width/2, 0);
+        this.setSize(global.screen_width/2, global.screen_height);
+        this._screenPosition = ScreenPosition.RIGHT_HALF;
+    },
+
+    /**
+     * setDocked:
+     * Magnifier view occupies a certain percentage of the screen.
+     */
+    setDocked: function() {
+        this.setSize(global.screen_width / 2, global.screen_height / 3);
+        this.setPosition(0, global.screen_height * 2 / 3);
+        this._screenPosition = ScreenPosition.DOCKED;
+    },
+
+    /**
+     * getScreenPosition:
+     * Tell the outside world what the current mode is -- magnifiying the
+     * top half, bottom half, etc.
+     * @return:  the current mode.
+     */
+     getScreenPosition: function() {
+        return this._screenPosition;
+     },
+
+    /**
+     * startTrackingMouse:
+     * Turn on mouse tracking, if not already doing so.
+     */
+    startTrackingMouse: function() {
+        // initialize previous mouse coord to undefined.
+        let prevCoord = { x: NaN, y: NaN };
+        if (!this._mouseTrackingId)
+            this._mouseTrackingId = Mainloop.timeout_add(
+                DEFAULT_MOUSE_POLL_FREQUENCY,
+                Lang.bind(this, this.scrollToMousePos, prevCoord)
+            );
+    },
+
+    /**
+     * stopTrackingMouse:
+     * Turn off mouse tracking, if not already doing so.
+     */
+    stopTrackingMouse: function() {
+        if (this._mouseTrackingId)
+            Mainloop.source_remove(this._mouseTrackingId);
+        this._mouseTrackingId = null;
+    },
+
+    /**
+     * isTrackingMouse:
+     * Is the magnifier tracking the mouse currently?
+     */
+    isTrackingMouse: function() {
+        return this._mouseTrackingId == null;
+    },
+
+    /**
+     * scrollToMousePos:
+     * Centre the magnified view to the position of the mouse.
+     * @prevCoord:  The previous mouse coordinates.  Used for stop scrolling if
+     *              the new position is the same as the last one (optional).
+     * @return      true.
+     */
+    scrollToMousePos: function(prevCoord) {
+        let [objUnder, mouseX, mouseY, mask] =
+            Gdk.Screen.get_default().get_root_window().get_pointer();
+        if (!prevCoord)
+            this.scrollToPosition(mouseX, mouseY);
+        else if (prevCoord.x != mouseX || prevCoord.y != mouseY) {
+            prevCoord.x = mouseX;
+            prevCoord.y = mouseY;
+            this.scrollToPosition(mouseX, mouseY);
+        }
+        return true;
+    },
+
+    /**
+     * setFullScreenMode:
+     * Set the Magnifier to full-screen mode.
+     * Note:  disallows lens mode.
+     */
+    setFullScreenMode: function() {
+        if (!this.isFullScreenMode()) {
+            this.setPosition(0, 0);
+            this.setSize(global.screen_width, global.screen_height);
+            this.setLensMode(false);
+        }
+    },
+
+    /**
+     * setScreenPosition:
+     * Positions the magnifier to one of the enumerated positions on the
+     * screen.
+     * @position:   one of Magnifier.FULL_SCREEN, Magnifier.TOP_HALF,
+     *              Magnifier.BOTTOM_HALF,Magnifier.LEFT_HALF,
+     *              Magnifier.RIGHT_HALF, or Magnifier.DOCKED.
+     */
+    setScreenPosition: function(inPosition) {
+        switch (inPosition) {
+            case ScreenPosition.FULL_SCREEN:
+                this.setFullScreenMode();
+                break;
+            case ScreenPosition.TOP_HALF:
+                this.setTopHalf();
+                break;
+            case ScreenPosition.BOTTOM_HALF:
+                this.setBottomHalf();
+                break;
+            case ScreenPosition.LEFT_HALF:
+                this.setLeftHalf();
+                break;
+            case ScreenPosition.RIGHT_HALF:
+                this.setRightHalf();
+                break;
+            case ScreenPosition.DOCKED:
+                this.setDocked();
+                break;
+        }
+    },
+
+    /**
+     * moveCenterTo:
+     * Move the magnified view such it is centred on the given point.
+     * @x:      The x-coord of the point to centre on.
+     * @y:      The y-coord of the point to centre on.
+     * @return  the old position [x, y].
+     */
+    moveCenterTo: function(x, y) {
+        let [xCenter, yCenter] = this.getCenter();
+        this.setPosition(x - xCenter, y - yCenter);
+    },
+
+    /**
+     * scrollContentsTo:
+     * Shift the contents of the magnified view such it is centered on the given
+     * coordinate.  Also, hide the magnified mouse image in the process.
+     * @x:      The x-coord of the point to center on.
+     * @y:      The y-coord of the point to center on.
+     * @return  The new position of the UI group clone.
+     */
+    scrollContentsTo: function(x, y) {
+        return this.scrollToPosition(x, y, true);
+    }
+}
+
diff --git a/js/ui/magnifierDBus.js b/js/ui/magnifierDBus.js
new file mode 100755
index 0000000..c61605d
--- /dev/null
+++ b/js/ui/magnifierDBus.js
@@ -0,0 +1,160 @@
+/* -*- mode: js2; js2-basic-offset: 4; indent-tabs-mode: nil -*- */
+
+const DBus = imports.dbus;
+const Main = imports.ui.main;
+
+const MAG_SERVICE_NAME = 'org.freedesktop.Magnifier';
+const MAG_SERVICE_PATH = '/org/freedesktop/Magnifier';
+
+const MagnifierIface = {
+    name: MAG_SERVICE_NAME,
+    methods: [{ name: "setActive",
+                inSignature: "b",
+                outSignature: ""
+              },
+              { name: "isActive",
+                inSignature: "",
+                outSignature: "b"
+              },
+              { name: "setScreenPosition",
+                inSignature: "i",
+                outSignature: ""
+              },
+              { name: "getMagFactor",
+                inSignature: "",
+                outSignature: "dd"
+              },
+              { name: "setMagFactor",
+                inSignature: "dd",
+                outSignature: ""
+              },
+              { name: "shiftContentsTo",
+                inSignature: "ii",
+                outSignature: ""
+              },
+              { name: "getROI",
+                inSignature: "",
+                outSignature: "(iiii)"
+              },
+              { name: "setClampScrollingAtEdges",
+                inSignature: "b",
+                outSignature: ""
+              },
+              {
+                name: "fullScreenCapable",
+                inSignature: "",
+                outSignature: "b"
+              }
+             ],
+    signals: [],
+    properties: []
+};
+
+function ShellMagnifier() {
+    this._init();
+}
+
+ShellMagnifier.prototype = {
+    _init: function() {
+        DBus.session.exportObject(MAG_SERVICE_PATH, this);
+    },
+
+    /**
+     * setActive:
+     * @activate:   Boolean to activate or de-activate the magnifier.
+     */
+    setActive: function(activate) {
+        Main.magnifier.setActive(activate);
+    },
+
+    /**
+     * isActive:
+     * @return  Whether the magnifier is active (boolean).
+     */
+    isActive: function() {
+        return Main.magnifier.isActive();
+    },
+
+    /**
+     * setScreenPosition:
+     * Positions the magnifier to one of the enumerated positions on the
+     * screen.
+     * @position:   one of Magnifier.FULL_SCREEN, Magnifier.TOP_HALF,
+     *              Magnifier.BOTTOM_HALF,Magnifier.LEFT_HALF,
+     *              Magnifier.RIGHT_HALF, or Magnifier.DOCKED.
+     */
+    setScreenPosition: function(position) {
+        Main.magnifier.setScreenPosition(position)
+    },
+
+    /**
+     * getMagFactor:
+     * @return  an array, [xMagFactor, yMagFactor], containing the horizontal
+     *          and vertical magnification powers.  A value of 1.0 means no
+     *          magnification.  A value of 2.0 means the contents are doubled
+     *          in size, and so on.
+     */
+    getMagFactor: function() {
+        return Main.magnifier.getMagFactor();
+    },
+
+    /**
+     * setMagFactor:
+     * @xMagFactor:     The power to set the horizontal magnification factor to
+     *                  of the magnified view.  A value of 1.0 means no
+     *                  magnification.  A value of 2.0 doubles the size.
+     * @yMagFactor:     The power to set the vertical magnification factor to
+     *                  of the magnified view.
+     */
+    setMagFactor: function(xMagFactor, yMagFactor) {
+        Main.magnifier.setMagFactor(xMagFactor, yMagFactor)
+    },
+
+    /**
+     * getROI:
+     * Retrieves the "region of interest" -- the rectangular bounds of that part
+     * of the desktop that the magnified view is showing (x, y, width, height).
+     * The bounds are given in non-magnified coordinates.
+     * @return  an array, [x, y, width, height], representing the bounding
+     *          rectangle of what is shown in the magnified view.
+     */
+    getROI: function() {
+        return Main.magnifier.getROI();
+    },
+
+    /**
+     * shiftContentsTo:
+     * Shift the contents of the magnified view such it is centered on the given
+     * non-magnified coordinate.
+     * @x:      x-coordinate to scroll to.
+     * @y:      y-coordinate to scroll to.
+     */
+    shiftContentsTo: function(x, y) {
+        Main.magnifier.scrollContentsTo(x,y);
+    },
+
+    /**
+     * setClampScrollingAtEdges:
+     * Stop or allow scrolling of the magnified contents when they scroll beyond
+     * the edges of the screen.  Also, insure that the magnified mouse cursor is
+     * recentered within the magnified view when clamping is removed, as it may
+     * be off-center if near a screen edge with clamping on.
+     * @clamp:   Boolean to turn on/off clamping.
+     */
+    setClampScrollingAtEdges: function(clamp) {
+        Main.magnifier.setClampScrollingAtEdges(clamp);
+    },
+
+    /**
+     * fullScreenCapable:
+     * Consult if the Magnifier can apply colorblind image filters.  This is
+     * here to match the old Corba and future DBus interface for gnome-mag
+     * (http://live.gnome.org/GnomeMag).
+     * @return  Always return true.
+     */
+    fullScreenCapable: function() {
+        return true;
+    }
+};
+
+DBus.conformExport(ShellMagnifier.prototype, MagnifierIface);
diff --git a/js/ui/main.js b/js/ui/main.js
index ed24fc3..8f61fe5 100644
--- a/js/ui/main.js
+++ b/js/ui/main.js
@@ -22,6 +22,7 @@ const LookingGlass = imports.ui.lookingGlass;
 const ShellDBus = imports.ui.shellDBus;
 const Sidebar = imports.ui.sidebar;
 const WindowManager = imports.ui.windowManager;
+const Magnifier = imports.ui.magnifier;
 
 const DEFAULT_BACKGROUND_COLOR = new Clutter.Color();
 DEFAULT_BACKGROUND_COLOR.from_pixel(0x2266bbff);
@@ -38,6 +39,8 @@ let recorder = null;
 let shellDBusService = null;
 let modalCount = 0;
 let modalActorFocusStack = [];
+let uiGroup = null;
+let magnifier = null;
 let _errorLogStack = [];
 let _startDate;
 
@@ -106,6 +109,12 @@ function start() {
        getRunDialog().open();
     });
 
+    // Set up stage hierarchy to group all UI actors under one container.
+    uiGroup = new Clutter.Group();
+    global.window_group.reparent(uiGroup);
+    global.overlay_group.reparent(uiGroup);
+    global.stage.add_actor(uiGroup);
+
     placesManager = new PlaceDisplay.PlacesManager();
     overview = new Overview.Overview();
     chrome = new Chrome.Chrome();
@@ -137,6 +146,9 @@ function start() {
 
     global.stage.connect('captured-event', _globalKeyPressHandler);
 
+    // Install magnifier.
+    magnifier = new Magnifier.Magnifier();
+
     _log('info', 'loaded at ' + _startDate);
 
     Mainloop.idle_add(_removeUnusedWorkspaces);
diff --git a/js/ui/runDialog.js b/js/ui/runDialog.js
index 487aeb1..eeceea1 100644
--- a/js/ui/runDialog.js
+++ b/js/ui/runDialog.js
@@ -65,7 +65,7 @@ RunDialog.prototype = {
                                           y: 0,
                                           width: global.screen_width,
                                           height: global.screen_height });
-        global.stage.add_actor(this._group);
+        Main.uiGroup.add_actor(this._group);
 
         let lightbox = new Lightbox.Lightbox(this._group);
 
diff --git a/src/shell-global.c b/src/shell-global.c
old mode 100644
new mode 100755
index a36753e..f142495
--- a/src/shell-global.c
+++ b/src/shell-global.c
@@ -26,6 +26,7 @@
 #endif
 
 #define SHELL_DBUS_SERVICE "org.gnome.Shell"
+#define MAGNIFIER_DBUS_SERVICE "org.freedesktop.Magnifier"
 
 static void grab_notify (GtkWidget *widget, gboolean is_grab, gpointer user_data);
 
@@ -699,6 +700,20 @@ shell_global_grab_dbus_service (ShellGlobal *global)
           exit (1);
         }
     }
+
+  /* ...and the org.freedesktop.Magnifier service.
+   */
+  if (!dbus_g_proxy_call (bus, "RequestName", &error,
+                          G_TYPE_STRING, MAGNIFIER_DBUS_SERVICE,
+                          G_TYPE_UINT, 0,
+                          G_TYPE_INVALID,
+                          G_TYPE_UINT, &request_name_result,
+                          G_TYPE_INVALID))
+    {
+      g_print ("failed to acquire %s: %s\n", MAGNIFIER_DBUS_SERVICE, error->message);
+      /* Failing to acquire the magnifer service is not fatal.  Log the error,
+       * but keep going. */
+    }
   g_object_unref (bus);
 }
 
