diff --git a/CLAUDE.md b/CLAUDE.md
index 6390bf1..4af1904 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -111,8 +111,9 @@ happens. A probe sent to explain a black screen must not be able to cause one.
 
 ### The start-page harness
 
-Any change to `Store` or `HomePage` — what gets saved as a visit or favourite, and
-the page built from it — is exercised off-device first:
+Any change to `Store`, `HomePage` or `StartPage` — what gets saved as a visit or
+favourite, the page built from it, and which of the three things the browser opens
+at launch — is exercised off-device first:
 
 ```sh
 tools/startpage/run.sh
@@ -123,7 +124,10 @@ a row, recording each the way the NUI engine reports it (a `data:` URL carrying
 page). Issue #53 was that loop with no guard: the start screen recorded itself as a
 visit on every launch, roughly doubled each time, and after nine launches was past
 the 2 MB Chromium will load — a black screen with no line anywhere, on a view that
-was fine. Needs only the .NET 6 SDK under `~/.dotnet-local`.
+was fine. It also holds `StartPage` (issue #79) to the three states, to "where I
+left off" landing on the last real visit and never on the start screen, and to an
+install made before the mode existed still opening where it always did. Needs only
+the .NET 6 SDK under `~/.dotnet-local`.
 
 ### The site-rules harness
 
diff --git a/README.md b/README.md
index 8bc6473..a57b2ac 100644
--- a/README.md
+++ b/README.md
@@ -89,6 +89,43 @@ browser simply won't start. Newer sets don't have this restriction.
 Not every remote sends the colour buttons, and the slim ones have none. **Switch
 site** is the second row of the menu, so hold OK and it is one press away.
 
+Every digit is spoken for, so these live in the menu only (**hold OK**):
+
+| Menu row | What it does |
+| --- | --- |
+| **Keep an address…** | Type a URL and keep *that* as a tile, without going to it |
+| **Open where I left off** | Launch straight back into the last page you were on |
+| **Forget this site's settings** | Take a site back to your everywhere settings |
+| **Pointer style** | Who draws the pointer — Overscan (keeps up) or the page (an arrow) |
+| **Ad blocking on/off** | 2025+ package only |
+
+### Keeping a page you can't land on
+
+**Keep an address…** in the menu is for URLs that redirect. `https://www.instagram.com/reel`
+sends you to one particular reel, so pressing `8` there would save that clip
+for ever; type the address instead and the tile is the address. It's prefilled
+with wherever you are, so it's usually a matter of deleting the end of it.
+
+### Where it opens
+
+By default, the start screen. Two ways to change that:
+
+- **Open where I left off** in the menu — it launches back into the last page you
+  were on.
+- On the keyboard, **start** makes whatever you typed the fixed opening page. Press
+  it with nothing typed to go back to the start screen.
+
+Turning "where I left off" off again returns to your fixed address if you set one,
+so you never have to type it twice.
+
+### The pointer
+
+On a heavy site the pointer used to slow down, because it was drawn *by the page*
+and could only move as fast as the page would let it. Overscan now draws it itself
+on the 2025+ package, so it keeps up whatever the site is doing. **Pointer style**
+in the menu (key **2** on the older packages) switches back to the page-drawn
+arrow, which looks nicer and is only as quick as the page.
+
 ### Each site keeps its own settings
 
 Images and identity are remembered **for the site you set them on**. Turn images
diff --git a/docs/INTERNALS.md b/docs/INTERNALS.md
index dea794b..441b65e 100644
--- a/docs/INTERNALS.md
+++ b/docs/INTERNALS.md
@@ -1232,6 +1232,55 @@ Details that matter:
   `input`/`change`, otherwise React-style frameworks ignore it. Enter is sent as
   real key events, falling back to `form.requestSubmit()`.
 
+### A pointer inside the page moves at the page's speed
+
+The same reporter again, in #78: "if we load a heavy site cursor start to become
+less responsive, when we load light site it is faster, default browser cursor
+perform same on all sites." It was ours, not the engine's.
+
+Everything above describes a pointer that *lives in the page*, and the bill for
+that had never been read. Each D-pad step was one script evaluation, and the
+script it ran did an `elementFromPoint` and dispatched a `mousemove` — a forced
+layout plus whatever the site's own move handlers do, which on Instagram or
+Spotify is a great deal. So the pointer could only move as fast as the page's main
+thread was willing to run our script, and that thread is the busiest object on the
+television. The TV's own browser draws its pointer in the compositor, which is why
+his comparison holds and why it always would have.
+
+Two halves, and neither is sufficient alone:
+
+- **The app draws the pointer.** DALi views over the web view on NUI, Evas
+  rectangles on ElmSharp, positioned from the same viewport fraction the script
+  was being sent. The ElmSharp build has had this behind key `2` since early on
+  and it was nobody's default; NUI never had it at all, and its old header said an
+  overlay "would need to track scroll and zoom itself". That was simply wrong —
+  the position is a fraction of the *viewport*, and the viewport is the view's own
+  rectangle, which is the entire reason it is kept as a fraction rather than as a
+  document point.
+- **The page hears about it once a tick, not once a key press.** Both builds
+  already run a 150 ms timer, so a move marks itself pending and the tick flushes
+  it. A held key that used to be twenty hover updates is now six, and none of them
+  is in front of the drawing.
+
+The rule the second half must not break is that **the page and the pointer agree at
+the moment of a click**. `PageScript.click()` hit-tests wherever `move()` last left
+it, so a click that overtook its own pending move would land where the pointer used
+to be. Both builds therefore put the pending move *into the click's own script*,
+one evaluation, rather than sending it as a call before — two evaluations are two
+chances for that ordering to be wrong, and the failure would be a click that
+occasionally hits the wrong thing, which is the worst kind to be sent from a sofa.
+
+What this costs is up to 150 ms of hover lag behind the drawn pointer, and the
+arrow: neither toolkit draws a triangle, so the app-drawn pointer is the ringed dot
+the ElmSharp build has always used for its native style, while the page's arrow is
+CSS borders. A dot that keeps up beats an arrow that does not, so **NUI defaults to
+drawing it itself** and a menu row switches back. **The ElmSharp default is
+unchanged**: #78 is a report from a 2025 set, the ewk packages are the ones where a
+change cannot be tested before somebody installs it, and `src/nui` not being able
+to break them is the whole reason the source is split this way. They get the
+coalescing, which is the half that is safe everywhere, and key `2` was already
+there for the rest.
+
 ### The one thing a script cannot click: another origin's frame
 
 `elementFromPoint` stops at an `<iframe>`, and a click dispatched on the frame
@@ -1503,16 +1552,60 @@ issue #15.
 
 ### Where the browser opens
 
-`startupUrl` in `settings.tsv`, set by the keyboard's `start` key: type an address,
-press `start` instead of `GO`, and that is what the app loads at launch. Pressing
-`start` with an empty entry clears it and the generated start screen comes back.
+Three states, and `StartPage` owns which: the generated start screen, one fixed
+address, or wherever the last session got to.
 
-It lives on the keyboard rather than on a remote key because every digit was
-already taken, and because the thing being saved is exactly what you have just
-typed. `Store.Init` therefore has to run **before** the keyboard is constructed —
+The fixed address came from issue #15 and is set by the keyboard's `start` key:
+type an address, press `start` instead of `GO`, and that is what the app loads at
+launch; press `start` with an empty entry and the start screen comes back. It
+lives on the keyboard rather than on a remote key because every digit was already
+taken, and because the thing being saved is exactly what you have just typed.
+`Store.Init` therefore has to run **before** the keyboard is constructed —
 `KeyboardLayouts` resolves its remembered layout the first time it is touched, and
-both builds used to initialise the store afterwards, silently discarding the user's
-layout choice.
+both builds used to initialise the store afterwards, silently discarding the
+user's layout choice.
+
+**"Open where I left off" is issue #79**, and it is one menu row because there was
+no key left. It resolves to the first entry of the history, which is the right
+answer only because of what `Store.RecordVisit` already refuses: this app's own
+generated pages in both shapes (#53) and the sign-in steps a flow passes through
+(#53's follow-up). Without those two guards "where I left off" would be the start
+screen you closed the app from, or the captcha you went through an hour earlier.
+An empty history resolves to the start screen, which is a fresh install saying so
+rather than a blank page.
+
+Three things about the shape of it:
+
+- **The mode is stored beside the address, not inside it.** A sentinel URL meaning
+  "not a URL" reads fine on the day it is written and becomes a site nobody can
+  visit the first time it turns up in somebody's history.
+- **An install from before #79 has no mode key**, so the mode is derived from
+  whether an address was ever set — which is exactly what those builds did. Nobody's
+  start page moves under them on upgrade, and the harness holds that.
+- **Turning "where I left off" off goes back to the address**, if one was ever set,
+  rather than to the start screen. The address is still in the file and making
+  somebody retype it on a remote to get it back would be its own small cruelty.
+
+### Keeping an address you cannot land on
+
+Issue #80: "i like to set `https://www.instagram.com/reel` as favourite but when i
+go to the url it opens a reel so it saves url of reel instead when open it plays
+same reel always."
+
+Key `8` keeps *the page you are on*, which is the whole vocabulary the favourites
+had, and it has no answer for an address that redirects. The fix is a third
+`KeyboardTarget` — `Favourite` — so the same on-screen keyboard can finish into
+`Store.ToggleFavourite` instead of into `Navigate`. It is prefilled with the
+current address, because what somebody wants to keep is usually what they are
+looking at with a few segments taken off the end, and the entry line says
+`Keep as a tile` rather than `Go to`, since the keyboard is otherwise identical
+whichever of the three it was opened for and that is not a mistake anybody should
+make silently.
+
+Two details worth keeping: it **toggles**, exactly as `8` does, and says which of
+the two it just did — from a sofa, "kept" and "removed" are the same screen
+otherwise. And the tile's name is the site's own name (`SiteRules.KeyFor`), because
+there is no page title to take from a page nobody opened.
 
 ## Settings that belong to a site, not to the browser
 
@@ -2444,6 +2537,21 @@ the one its report has to come from. The state is:
   answers #75 either way, so a button that never arrives is not a reason to hold
   the issue open.
 
+- **The pointer, the start page and keeping an address — #78, #79 and #80, built
+  together.** All three arrived the day after `build-d526114`, and all three are
+  what a browser gets asked for once it has stopped breaking. #78 is the one with
+  a fault behind it: the pointer lived in the page, so it moved at the page's
+  speed, and NUI now draws it itself and tells the page where it is once a tick
+  instead of once a key press — see *A pointer inside the page moves at the
+  page's speed* above. #79 adds "open where I left off" beside the fixed address
+  from #15, and #80 lets an address be kept as a tile without going to it, which
+  is the only way to keep one that redirects. **Waiting on:** his report from the
+  build that ships them. The one that decides something is #78 — whether the
+  pointer keeps up on Instagram and Spotify now. If it does not, the `pointer`
+  line on the report says which of the two is drawing it, and the answer that
+  would matter is "drawn by Overscan and still slow", because that is the one
+  saying the lag was never our script.
+
 Five things about that set are settled and should not be re-derived: **key `5` is
 his, not ours** — the engine's overlay path is the only one that gives him a
 picture, so a report of black or silent video is the in-page path failing and not a
diff --git a/src/common/CursorVisual.cs b/src/common/CursorVisual.cs
new file mode 100644
index 0000000..3a96b67
--- /dev/null
+++ b/src/common/CursorVisual.cs
@@ -0,0 +1,23 @@
+namespace Overscan
+{
+    /// <summary>
+    /// Who draws the D-pad pointer. Shared because both builds now offer the
+    /// choice and it means the same thing in each — see <see cref="NuiCursor"/>
+    /// for what issue #78 made of it.
+    /// </summary>
+    internal enum CursorVisual
+    {
+        /// <summary>
+        /// Drawn by the injected page script, as an arrow. Better looking, and only
+        /// as quick as the page's main thread is willing to be.
+        /// </summary>
+        Dom,
+
+        /// <summary>
+        /// Drawn by the app, over the web view. A ringed dot rather than an arrow,
+        /// because neither toolkit will draw a triangle, and it owes the page
+        /// nothing at all.
+        /// </summary>
+        Native,
+    }
+}
diff --git a/src/common/KeyboardTarget.cs b/src/common/KeyboardTarget.cs
index 17e927f..d7b044b 100644
--- a/src/common/KeyboardTarget.cs
+++ b/src/common/KeyboardTarget.cs
@@ -8,5 +8,14 @@ internal enum KeyboardTarget
 
         /// <summary>Type the text into whatever field the page has focused.</summary>
         PageField,
+
+        /// <summary>
+        /// Keep the typed address as a favourite without going to it (issue #80).
+        /// The reporter wanted `instagram.com/reel` in his tiles, and that address
+        /// redirects to one particular reel the moment it is opened — so the only
+        /// favourite he could make was of the reel, which then played the same clip
+        /// for ever. An address you cannot land on has no other way in.
+        /// </summary>
+        Favourite,
     }
 }
diff --git a/src/common/RemoteMenu.cs b/src/common/RemoteMenu.cs
index 68a2172..4e604e7 100644
--- a/src/common/RemoteMenu.cs
+++ b/src/common/RemoteMenu.cs
@@ -43,6 +43,8 @@ public Item(string id, string label, string shortcut)
         public const string ActionAddress = "address";
         public const string ActionHome = "home";
         public const string ActionBookmark = "bookmark";
+        public const string ActionKeepAddress = "keepaddress";
+        public const string ActionResumeLast = "resumelast";
         public const string ActionIdentity = "identity";
         public const string ActionSwitchSite = "switchsite";
         public const string ActionForgetSite = "forgetsite";
diff --git a/src/common/StartPage.cs b/src/common/StartPage.cs
new file mode 100644
index 0000000..7bb0f5f
--- /dev/null
+++ b/src/common/StartPage.cs
@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+
+namespace Overscan
+{
+    /// <summary>
+    /// What the browser opens when it launches.
+    ///
+    /// Issue #15 gave this one answer — a fixed address, set from the keyboard's
+    /// <c>start</c> key — because opening on the generated start screen means
+    /// typing the same address on a remote control every evening. Issue #79 asked
+    /// for the other one: "set start page as the last page we left off". Both are
+    /// the same setting with three states, so they live here rather than as two
+    /// flags in two apps that could disagree about which of them wins.
+    ///
+    /// The mode is stored beside the address rather than encoded into it. A
+    /// sentinel URL meaning "not a URL" is the kind of thing that reads fine on
+    /// the day it is written and turns into a site nobody can visit the first time
+    /// somebody's history contains it.
+    /// </summary>
+    internal static class StartPage
+    {
+        /// <summary>The generated start screen — favourites and recent tiles.</summary>
+        public const string Home = "home";
+
+        /// <summary>Wherever the last session got to.</summary>
+        public const string Last = "last";
+
+        /// <summary>One fixed address, set from the keyboard's <c>start</c> key.</summary>
+        public const string Url = "url";
+
+        private const string ModeKey = "startupMode";
+        private const string UrlKey = "startupUrl";
+
+        /// <summary>
+        /// The mode in force. An install from before #79 has no mode key at all, so
+        /// it is derived from whether an address was ever set — which is exactly
+        /// what those builds did, and means nobody's start page changes under them
+        /// on upgrade.
+        /// </summary>
+        public static string Mode()
+        {
+            string stored = Store.Get(ModeKey, null);
+            if (stored == Home || stored == Last || stored == Url)
+            {
+                return stored;
+            }
+
+            return string.IsNullOrEmpty(Address) ? Home : Url;
+        }
+
+        /// <summary>The fixed address, or empty when none was set.</summary>
+        public static string Address
+        {
+            get { return Store.Get(UrlKey, string.Empty) ?? string.Empty; }
+        }
+
+        /// <summary>
+        /// Remembers a fixed address, and switches to it. An empty address goes
+        /// back to the start screen, which is what pressing <c>start</c> with
+        /// nothing typed has always done.
+        /// </summary>
+        public static void SetAddress(string url)
+        {
+            if (string.IsNullOrEmpty(url))
+            {
+                Store.Set(UrlKey, string.Empty);
+                Store.Set(ModeKey, Home);
+                return;
+            }
+
+            Store.Set(UrlKey, url);
+            Store.Set(ModeKey, Url);
+        }
+
+        /// <summary>
+        /// Turns "open where I left off" on and off. Off goes back to the fixed
+        /// address if one was ever set and to the start screen otherwise — so the
+        /// address somebody chose is still there when they change their mind, and
+        /// nobody has to type it again to get it back.
+        /// </summary>
+        public static bool ToggleLast()
+        {
+            bool on = Mode() != Last;
+            Store.Set(ModeKey, on ? Last : (string.IsNullOrEmpty(Address) ? Home : Url));
+            return on;
+        }
+
+        /// <summary>
+        /// The address to open at launch, or null for the start screen.
+        ///
+        /// The history is most-recent-first and already refuses this app's own
+        /// generated pages and the sign-in steps a flow passes through
+        /// (<see cref="Store.RecordVisit"/>), so its first entry is the last page
+        /// the user was actually on — not the start screen they closed the app
+        /// from, and not the captcha they went through an hour earlier.
+        /// </summary>
+        public static string Resolve(IList<Bookmark> history)
+        {
+            switch (Mode())
+            {
+                case Url:
+                    string url = Address;
+                    return string.IsNullOrEmpty(url) ? null : url;
+
+                case Last:
+                    // No history is a fresh install, or one whose history was
+                    // cleared. The start screen is the honest answer, and it is
+                    // the screen that lists what there is.
+                    return history != null && history.Count > 0 ? history[0].Url : null;
+
+                default:
+                    return null;
+            }
+        }
+
+        /// <summary>What the diagnostics report says about all this.</summary>
+        public static string Describe(IList<Bookmark> history)
+        {
+            switch (Mode())
+            {
+                case Url:
+                    return "fixed address — " + Address;
+
+                case Last:
+                    string last = Resolve(history);
+                    return "where you left off — " +
+                           (last ?? "(nothing visited yet, so the start screen)");
+
+                default:
+                    return "the start screen";
+            }
+        }
+    }
+}
diff --git a/src/elm/BrowserApp.cs b/src/elm/BrowserApp.cs
index f627fbb..1a5ccc6 100644
--- a/src/elm/BrowserApp.cs
+++ b/src/elm/BrowserApp.cs
@@ -247,7 +247,10 @@ protected override void OnCreate()
 
             _viewportFix = Store.GetBool("viewportFix", false);
             _hintsWanted = Store.GetBool("hints", true);
-            _startupUrl = Store.Get("startupUrl", null);
+
+            // Three states, not two, since issue #79: the start screen, a fixed
+            // address, or wherever the last session got to. StartPage owns which.
+            _startupUrl = StartPage.Resolve(Store.RecentHistory);
             ShowHints(_hintsWanted);
             if (Store.GetInt("cursorVisual", 0) == 1)
             {
@@ -688,6 +691,14 @@ private bool OnTick()
                 UpdateStatus();
             }
 
+            // Where a held D-pad key turns into one hover update instead of twenty
+            // — see VirtualCursor and issue #78. Cheap when nothing moved, and a
+            // no-op unless the pointer is the natively drawn one.
+            if (_cursor != null)
+            {
+                _cursor.FlushPending();
+            }
+
             // The menu is on the list because arrowing through it is pointer keys,
             // which no longer keep the bar alive; without this it would time out
             // underneath an open menu.
@@ -834,6 +845,8 @@ private void BuildMenu()
                 new RemoteMenu.Item(RemoteMenu.ActionSwitchSite, "Switch site", "A"),
                 new RemoteMenu.Item(RemoteMenu.ActionHome, "Start screen", "9"),
                 new RemoteMenu.Item(RemoteMenu.ActionBookmark, "Keep this page", "8"),
+                new RemoteMenu.Item(RemoteMenu.ActionKeepAddress, "Keep an address…", string.Empty),
+                new RemoteMenu.Item(RemoteMenu.ActionResumeLast, "Open where I left off", string.Empty),
                 new RemoteMenu.Item(RemoteMenu.ActionTypeInField, "Type in a field…", "5"),
                 new RemoteMenu.Item(RemoteMenu.ActionIdentity, "Identify as…", "1"),
                 new RemoteMenu.Item(RemoteMenu.ActionKeysToPage, "Send keys to page", "4"),
@@ -995,6 +1008,18 @@ private void RunAction(string id)
                     ToggleFavourite();
                     break;
 
+                case RemoteMenu.ActionKeepAddress:
+                    // Prefilled with where we are, because the address somebody
+                    // wants to keep is usually the one they are looking at with a
+                    // few segments taken off the end (issue #80).
+                    _keyboard.Open(KeyboardTarget.Favourite,
+                                   _atHome || _cachedUrl == "-" ? string.Empty : _cachedUrl);
+                    break;
+
+                case RemoteMenu.ActionResumeLast:
+                    ToggleResumeLast();
+                    break;
+
                 case RemoteMenu.ActionTypeInField:
                     _keyboard.Open(KeyboardTarget.PageField, string.Empty);
                     break;
@@ -1765,6 +1790,47 @@ private void ToggleFavourite()
             Flash(kept ? "Kept this page" : "Removed from favourites");
         }
 
+        /// <summary>
+        /// Keeps a typed address as a favourite without going to it — issue #80.
+        ///
+        /// Key 8 keeps <em>the page you are on</em>, which is no help at all when
+        /// the address you want is one that redirects: the reporter wanted
+        /// <c>instagram.com/reel</c> in his tiles, and opening it hands you one
+        /// particular reel, so the tile he could make played the same clip for
+        /// ever. There was no way to keep an address you cannot land on.
+        ///
+        /// It toggles, exactly as key 8 does, so typing one that is already kept
+        /// takes it out again — and says which of the two happened, because
+        /// otherwise the two are indistinguishable from the sofa.
+        /// </summary>
+        private void KeepAddress(string text)
+        {
+            string url = Urls.Normalize(text);
+
+            // No title to take from a page nobody opened, so the site's own name is
+            // the honest one. The tiles are named by this.
+            string title = SiteRules.KeyFor(url) ?? url;
+            bool kept = Store.ToggleFavourite(url, title);
+            DiagLog.Add((kept ? "kept address " : "removed address ") + url);
+            Flash(kept ? "Kept " + title : "Removed " + title + " from favourites");
+        }
+
+        /// <summary>
+        /// Turns "open where I left off" on and off — issue #79. Off goes back to
+        /// the fixed address if one was ever set, so nobody has to type it again to
+        /// get it back; see <see cref="StartPage.ToggleLast"/>.
+        /// </summary>
+        private void ToggleResumeLast()
+        {
+            bool on = StartPage.ToggleLast();
+            DiagLog.Add("start page mode: " + StartPage.Mode());
+            Flash(on
+                ? "Opens where you left off"
+                : "Opens at " + (string.IsNullOrEmpty(StartPage.Address)
+                    ? "the start screen"
+                    : StartPage.Address));
+        }
+
         /// <summary>
         /// Briefly replaces the status text. There is no notification surface on a TV,
         /// and an action with no feedback feels broken.
@@ -1784,6 +1850,12 @@ private void OnKeyboardCommitted(string text, KeyboardTarget target)
                 return;
             }
 
+            if (target == KeyboardTarget.Favourite)
+            {
+                KeepAddress(text);
+                return;
+            }
+
             // Type + Enter in one script: see the NUI build's note about a single
             // pending result handler; keeping it to one call is simply safer.
             try
@@ -1833,14 +1905,14 @@ private void OnStartPageSet(string text)
             if (string.IsNullOrEmpty((text ?? string.Empty).Trim()))
             {
                 _startupUrl = null;
-                Store.Set("startupUrl", string.Empty);
+                StartPage.SetAddress(null);
                 DiagLog.Add("start page cleared");
                 Flash("Start page cleared");
                 return;
             }
 
             _startupUrl = Urls.Normalize(text);
-            Store.Set("startupUrl", _startupUrl);
+            StartPage.SetAddress(_startupUrl);
             DiagLog.Add("start page = " + _startupUrl);
             Flash("Opens here from now on");
             Navigate(_startupUrl);
@@ -2119,7 +2191,7 @@ private string DiagnosticsText(bool full)
                    "vp fix    : " + (_viewportFix ? "ON" : "off") + "  (key 6)\n" +
                    "last click: " + _lastClick + "\n" +
                    "frame click: " + NativeMouse.LastResult + "\n" +
-                   "start page: " + (string.IsNullOrEmpty(_startupUrl) ? "(start screen)" : _startupUrl) + "\n" +
+                   "opens at  : " + StartPage.Describe(Store.RecentHistory) + "\n" +
                    "site rules: " + (SiteRules.For(_cachedUrl) == null
                        ? "nothing remembered for this site"
                        : "in force for " + SiteRules.For(_cachedUrl).Site) + "\n" +
diff --git a/src/elm/ElmKeyboard.cs b/src/elm/ElmKeyboard.cs
index a29d69e..63853dc 100644
--- a/src/elm/ElmKeyboard.cs
+++ b/src/elm/ElmKeyboard.cs
@@ -332,7 +332,7 @@ private void Press(string label)
 
         private void Paint()
         {
-            string prompt = Target == KeyboardTarget.Address ? "Go to" : "Type into page";
+            string prompt = Prompt(Target);
             _entry.Text =
                 Theme.Text(prompt + "   ", 24, Theme.Accent, true) +
                 Theme.Text(_text.Length == 0 ? "|" : _text + "|", 34, Theme.Ink, true);
@@ -379,6 +379,22 @@ private static Color FillFor(string key)
         /// symbol key wears the page it switches *to* — the phone idiom, so it is
         /// never ambiguous which way it goes.
         /// </summary>
+        /// <summary>
+        /// What the entry line calls itself. The keyboard looks the same whatever
+        /// it was opened for, so this is the only thing on screen that says which
+        /// of the three it is — and "keep" and "go to" are not a mistake anybody
+        /// should be able to make silently.
+        /// </summary>
+        private static string Prompt(KeyboardTarget target)
+        {
+            switch (target)
+            {
+                case KeyboardTarget.Address: return "Go to";
+                case KeyboardTarget.Favourite: return "Keep as a tile";
+                default: return "Type into page";
+            }
+        }
+
         private static string Label(string key, bool selected)
         {
             string text = KeyText(key);
diff --git a/src/elm/VirtualCursor.cs b/src/elm/VirtualCursor.cs
index 19bd8df..99defa4 100644
--- a/src/elm/VirtualCursor.cs
+++ b/src/elm/VirtualCursor.cs
@@ -5,15 +5,6 @@
 
 namespace Overscan
 {
-    internal enum CursorVisual
-    {
-        /// <summary>Cursor drawn by the injected page script (survives page scroll).</summary>
-        Dom,
-
-        /// <summary>Cursor drawn as an Evas overlay above the web view.</summary>
-        Native,
-    }
-
     /// <summary>
     /// D-pad driven pointer. Position is kept as a fraction of the viewport so the
     /// native side never has to know the page's CSS pixel size, zoom or DPR — the
@@ -41,6 +32,19 @@ internal sealed class VirtualCursor
         private int _lastDx;
         private int _lastDy;
 
+        /// <summary>
+        /// A move the page has not been told about yet, flushed on the app's tick.
+        ///
+        /// Issue #78 was reported against the NUI build, and the cause is shared:
+        /// telling the page where the pointer is makes it hit-test and dispatch a
+        /// mousemove, so doing it once per repeat of a held key puts the pointer at
+        /// the mercy of whatever else the page's main thread is doing. Only used
+        /// while the pointer is drawn natively — with the page drawing it, a
+        /// deferred move is a pointer that visibly stops moving, which is worse
+        /// than a slow one. Key 2 is what chooses between those.
+        /// </summary>
+        private bool _movePending;
+
         public VirtualCursor(Window window, WebView web, string bridgeName)
         {
             _web = web;
@@ -83,6 +87,10 @@ public void Reinstall()
         {
             Eval(PageScript.Install(_bridge));
             Apply();
+
+            // A page that has just been replaced knows nothing about where the
+            // pointer is, so this one telling does not wait for a tick.
+            FlushPending();
         }
 
         public void Move(int dx, int dy)
@@ -110,12 +118,37 @@ public void Center()
 
         public void Click()
         {
+            // A pending move rides along in front of the click, in the same script:
+            // click() hit-tests wherever move() last left the page, so a click that
+            // overtook its own move would land where the pointer used to be.
+            string move = string.Empty;
+            if (_movePending)
+            {
+                _movePending = false;
+                move = "window." + PageScript.Namespace + ".move(" + F(_x) + "," + F(_y) + ");";
+            }
+
             // The click result comes back over the message bridge instead of a
             // return value: ewk's script-execute is fire-and-forget on API 5.
-            Eval("try{window." + _bridge + ".postMessage('click\\u0001'+window." +
+            Eval("try{" + move + "window." + _bridge + ".postMessage('click\\u0001'+window." +
                  PageScript.Namespace + ".click());}catch(e){}");
         }
 
+        /// <summary>
+        /// Tells the page where the pointer is, if it has not been told since the
+        /// last move. Called from the app's 150 ms tick — see <see cref="_movePending"/>.
+        /// </summary>
+        public void FlushPending()
+        {
+            if (!_movePending)
+            {
+                return;
+            }
+
+            _movePending = false;
+            MoveInPage();
+        }
+
         public void ScrollPage(int direction)
         {
             Eval("try{window." + PageScript.Namespace + ".page(" +
@@ -136,15 +169,18 @@ private void Apply()
             {
                 Eval("try{window." + PageScript.Namespace + ".hide();}catch(e){}");
                 PlaceNative();
-                // Still report the position so hover states and the click target
-                // stay in sync with what is drawn.
-                MoveInPage();
+
+                // The position still has to reach the page — hover states and the
+                // click target come from it — but it is drawn already, so the page
+                // can hear about it on the next tick instead of on this key press.
+                _movePending = true;
             }
             else
             {
                 _ring.Hide();
                 _dot.Hide();
                 _core.Hide();
+                _movePending = false;
                 MoveInPage();
             }
         }
diff --git a/src/nui/NuiBrowserApp.cs b/src/nui/NuiBrowserApp.cs
index ebda0c7..393acd9 100644
--- a/src/nui/NuiBrowserApp.cs
+++ b/src/nui/NuiBrowserApp.cs
@@ -280,7 +280,10 @@ protected override void OnCreate()
 
             _viewportFix = Store.GetBool("viewportFix", false);
             _hintsWanted = Store.GetBool("hints", true);
-            _startupUrl = Store.Get("startupUrl", null);
+
+            // Three states, not two, since issue #79: the start screen, a fixed
+            // address, or wherever the last session got to. StartPage owns which.
+            _startupUrl = StartPage.Resolve(Store.RecentHistory);
             ShowHints(_hintsWanted);
 
             _defaultPresetIndex = Math.Min(Store.GetInt("uaPreset", 0), _presets.Length - 1);
@@ -540,8 +543,19 @@ private bool TryStartEngine()
 
                 WatchTheEngine();
 
-                _cursor = new NuiCursor(_web);
+                // A rebuild brings us here with the previous view's pointer still
+                // parented to the window; without this the set collects one more
+                // pointer per recovery.
+                if (_cursor != null)
+                {
+                    _cursor.Remove();
+                }
+
+                _cursor = new NuiCursor(_window, _web);
                 _cursor.Clicked += OnPageClicked;
+                _cursor.SetVisual(Store.GetInt("cursorVisual", 1) == 1
+                    ? CursorVisual.Native
+                    : CursorVisual.Dom);
                 Breadcrumbs.Drop("engine ready");
 
                 return true;
@@ -857,6 +871,13 @@ private bool OnTick()
                 UpdateStatus();
             }
 
+            // Where a held D-pad key turns into one hover update instead of twenty
+            // — see NuiCursor and issue #78. Cheap when nothing moved.
+            if (_cursor != null)
+            {
+                _cursor.FlushPending();
+            }
+
             NoteMemory();
 
             // Deliberately here and not in the load-finished callback: the engine
@@ -1289,6 +1310,8 @@ private void BuildMenu()
                 new RemoteMenu.Item(RemoteMenu.ActionSwitchSite, "Switch site", "A"),
                 new RemoteMenu.Item(RemoteMenu.ActionHome, "Start screen", "9"),
                 new RemoteMenu.Item(RemoteMenu.ActionBookmark, "Keep this page", "8"),
+                new RemoteMenu.Item(RemoteMenu.ActionKeepAddress, "Keep an address…", string.Empty),
+                new RemoteMenu.Item(RemoteMenu.ActionResumeLast, "Open where I left off", string.Empty),
                 new RemoteMenu.Item(RemoteMenu.ActionTypeInField, "Type in a field…", "2"),
                 new RemoteMenu.Item(RemoteMenu.ActionIdentity, "Identify as…", "1"),
                 new RemoteMenu.Item(RemoteMenu.ActionKeysToPage, "Send keys to page", "4"),
@@ -1297,6 +1320,7 @@ private void BuildMenu()
                 new RemoteMenu.Item(RemoteMenu.ActionAdBlock, "Ad blocking on/off", string.Empty),
                 new RemoteMenu.Item(RemoteMenu.ActionForgetSite, "Forget this site's settings", string.Empty),
                 new RemoteMenu.Item(RemoteMenu.ActionVideoPath, "Video: in page / overlay", "5"),
+                new RemoteMenu.Item(RemoteMenu.ActionPointer, "Pointer style", string.Empty),
                 new RemoteMenu.Item(RemoteMenu.ActionHints, "Remote card on/off", "7"),
                 new RemoteMenu.Item(RemoteMenu.ActionDiagnostics, "Diagnostics", "3"),
                 new RemoteMenu.Item(RemoteMenu.ActionQuit, "Close Overscan", string.Empty),
@@ -1441,6 +1465,18 @@ private void RunAction(string id)
                     ToggleFavourite();
                     break;
 
+                case RemoteMenu.ActionKeepAddress:
+                    // Prefilled with where we are, because the address somebody
+                    // wants to keep is usually the one they are looking at with a
+                    // few segments taken off the end (issue #80).
+                    _keyboard.Open(KeyboardTarget.Favourite,
+                                   _atHome || _cachedUrl == "-" ? string.Empty : _cachedUrl);
+                    break;
+
+                case RemoteMenu.ActionResumeLast:
+                    ToggleResumeLast();
+                    break;
+
                 case RemoteMenu.ActionTypeInField:
                     _keyboard.Open(KeyboardTarget.PageField, string.Empty);
                     break;
@@ -1460,10 +1496,34 @@ private void RunAction(string id)
                 case RemoteMenu.ActionKeysToPage:
                     _keysToPage = !_keysToPage;
                     DiagLog.Add(_keysToPage ? "keys -> page" : "keys -> cursor");
+
+                    // The pointer goes with the keys. It used to stay on screen
+                    // under the page's own drawing, where it was merely odd; drawn
+                    // by us it would sit over the page as a thing that no longer
+                    // moves, which reads as a freeze.
+                    if (_keysToPage)
+                    {
+                        _cursor.Hide();
+                    }
+                    else
+                    {
+                        _cursor.Show();
+                    }
+
                     Flash(_keysToPage ? "keys go to the page" : "keys move the pointer");
                     UpdateStatus();
                     break;
 
+                case RemoteMenu.ActionPointer:
+                    _cursor.SetVisual(_cursor.Visual == CursorVisual.Native
+                        ? CursorVisual.Dom
+                        : CursorVisual.Native);
+                    Store.Set("cursorVisual", _cursor.Visual == CursorVisual.Native ? 1 : 0);
+                    Flash(_cursor.Visual == CursorVisual.Native
+                        ? "Pointer drawn by Overscan — keeps up on heavy pages"
+                        : "Pointer drawn by the page — an arrow, but only as quick as the page");
+                    break;
+
                 case RemoteMenu.ActionFitPage:
                     _viewportFix = !_viewportFix;
                     Store.Set("viewportFix", _viewportFix);
@@ -1906,14 +1966,14 @@ private void OnStartPageSet(string text)
             if (string.IsNullOrEmpty((text ?? string.Empty).Trim()))
             {
                 _startupUrl = null;
-                Store.Set("startupUrl", string.Empty);
+                StartPage.SetAddress(null);
                 DiagLog.Add("start page cleared");
                 Flash("Start page cleared");
                 return;
             }
 
             _startupUrl = Urls.Normalize(text);
-            Store.Set("startupUrl", _startupUrl);
+            StartPage.SetAddress(_startupUrl);
             DiagLog.Add("start page = " + _startupUrl);
             Flash("Opens here from now on");
             Navigate(_startupUrl);
@@ -1927,6 +1987,12 @@ private void OnKeyboardCommitted(string text, KeyboardTarget target)
                 return;
             }
 
+            if (target == KeyboardTarget.Favourite)
+            {
+                KeepAddress(text);
+                return;
+            }
+
             // One evaluation, not two: NUI keeps a single pending result handler, so
             // overlapping calls deliver both replies to the last one registered.
             try
@@ -2276,6 +2342,47 @@ private void ToggleFavourite()
             Flash(kept ? "Kept this page" : "Removed from favourites");
         }
 
+        /// <summary>
+        /// Keeps a typed address as a favourite without going to it — issue #80.
+        ///
+        /// Key 8 keeps <em>the page you are on</em>, which is no help at all when
+        /// the address you want is one that redirects: the reporter wanted
+        /// <c>instagram.com/reel</c> in his tiles, and opening it hands you one
+        /// particular reel, so the tile he could make played the same clip for
+        /// ever. There was no way to keep an address you cannot land on.
+        ///
+        /// It toggles, exactly as key 8 does, so typing one that is already kept
+        /// takes it out again — and says which of the two happened, because
+        /// otherwise the two are indistinguishable from the sofa.
+        /// </summary>
+        private void KeepAddress(string text)
+        {
+            string url = Urls.Normalize(text);
+
+            // No title to take from a page nobody opened, so the site's own name is
+            // the honest one. The tiles are named by this.
+            string title = SiteRules.KeyFor(url) ?? url;
+            bool kept = Store.ToggleFavourite(url, title);
+            DiagLog.Add((kept ? "kept address " : "removed address ") + url);
+            Flash(kept ? "Kept " + title : "Removed " + title + " from favourites");
+        }
+
+        /// <summary>
+        /// Turns "open where I left off" on and off — issue #79. Off goes back to
+        /// the fixed address if one was ever set, so nobody has to type it again to
+        /// get it back; see <see cref="StartPage.ToggleLast"/>.
+        /// </summary>
+        private void ToggleResumeLast()
+        {
+            bool on = StartPage.ToggleLast();
+            DiagLog.Add("start page mode: " + StartPage.Mode());
+            Flash(on
+                ? "Opens where you left off"
+                : "Opens at " + (string.IsNullOrEmpty(StartPage.Address)
+                    ? "the start screen"
+                    : StartPage.Address));
+        }
+
         private void Flash(string message)
         {
             ShowChrome();
@@ -2429,6 +2536,10 @@ private string Report()
                   "video rect: " + NuiVideoRect.LastBox + "\n" +
                   "blank view: " + _blankState + "\n" +
                   "start page: " + _startPageState + "\n" +
+                  "opens at  : " + StartPage.Describe(Store.RecentHistory) + "\n" +
+                  "pointer   : " + (_cursor == null
+                      ? "(not built)"
+                      : (_cursor.Visual == CursorVisual.Native ? "drawn by Overscan" : "drawn by the page")) + "\n" +
                   "site rules: " + (SiteRules.For(_cachedUrl) == null
                       ? "nothing remembered for this site"
                       : "in force for " + SiteRules.For(_cachedUrl).Site) + "\n" +
diff --git a/src/nui/NuiCursor.cs b/src/nui/NuiCursor.cs
index ab01447..a9a3a48 100644
--- a/src/nui/NuiCursor.cs
+++ b/src/nui/NuiCursor.cs
@@ -1,19 +1,47 @@
 using System;
 using System.Globalization;
+using Tizen.NUI;
 using Tizen.NUI.BaseComponents;
 
 namespace Overscan
 {
     /// <summary>
-    /// D-pad pointer for the NUI build. Same idea as <see cref="VirtualCursor"/>:
-    /// the position is a fraction of the viewport and the injected page script
-    /// (<see cref="PageScript"/>) does the hit-testing and event dispatch, so this
-    /// class only has to translate key presses into script calls.
-    ///
-    /// The cursor is drawn by the page here — no Evas-overlay variant — because
-    /// NUI composites the web view as a texture and an overlay View would need to
-    /// track scroll and zoom itself.
+    /// D-pad pointer for the NUI build. The position is a fraction of the
+    /// viewport; the injected page script (<see cref="PageScript"/>) does the
+    /// hit-testing and event dispatch, and this class translates key presses into
+    /// script calls.
     /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Issue #78: "if we load a heavy site cursor start to become less responsive,
+    /// when we load light site it is faster, default browser cursor perform same
+    /// on all sites." That is exactly right, and it was ours. Every D-pad step used
+    /// to be one <c>EvaluateJavaScript</c>, and the script it ran did an
+    /// <c>elementFromPoint</c> and a <c>mousemove</c> dispatch — so the pointer
+    /// could only move as fast as the page's main thread was willing to run our
+    /// script, and on Instagram or Spotify that thread is the busiest thing on the
+    /// television. The TV's own browser draws its pointer in the compositor, which
+    /// is why his comparison holds.
+    /// </para>
+    /// <para>
+    /// Two changes, and both are needed. **The pointer is drawn by us**, as DALi
+    /// views over the web view, so where it appears owes the page nothing. And
+    /// **the page is told where it is at most once a tick** rather than once a key
+    /// press, because the hover the page does on being told is the expensive half
+    /// and doing it twenty times during one held key press helps nobody. What the
+    /// page loses by this is up to 150 ms of hover lag behind the drawn pointer;
+    /// what it must never lose is agreement at the moment of a click, which is why
+    /// <see cref="Click"/> flushes a pending move in the same evaluation.
+    /// </para>
+    /// <para>
+    /// The old header said an overlay would have to track scroll and zoom itself.
+    /// It would not: the position is a fraction of the *viewport*, and the viewport
+    /// is the view's own rectangle, which is the whole reason it is kept as a
+    /// fraction. The drawn shape is a ringed dot rather than the page script's
+    /// arrow, because an Evas or DALi view has no triangle and the arrow is drawn
+    /// out of CSS borders. A dot that keeps up beats an arrow that does not.
+    /// </para>
+    /// </remarks>
     internal sealed class NuiCursor
     {
         // A fraction of the viewport, so on a 1920x1080 set the smallest step is
@@ -28,7 +56,21 @@ internal sealed class NuiCursor
         private const double StepGrowth = 1.50;
         private static readonly TimeSpan RepeatWindow = TimeSpan.FromMilliseconds(220);
 
+        /// <summary>
+        /// The drawn pointer, outside-in: a dark ring so it survives a white page,
+        /// a light body, an accent centre small enough to aim with. The same three
+        /// shapes and sizes the ElmSharp build has drawn since it gained a native
+        /// pointer, so the two builds look like one product.
+        /// </summary>
+        private const int RingSize = 30;
+        private const int BodySize = 22;
+        private const int CoreSize = 8;
+
         private readonly WebView _web;
+        private readonly Window _window;
+        private readonly View _ring;
+        private readonly View _body;
+        private readonly View _core;
 
         private double _x = 0.5;
         private double _y = 0.5;
@@ -37,9 +79,85 @@ internal sealed class NuiCursor
         private int _lastDx;
         private int _lastDy;
 
-        public NuiCursor(WebView web)
+        /// <summary>
+        /// A move the page has not been told about yet. Cleared by
+        /// <see cref="FlushPending"/> on the app's tick, or by a click, whichever
+        /// comes first.
+        /// </summary>
+        private bool _movePending;
+
+        /// <summary>Whether the pointer is drawn at all — see <see cref="Hide"/>.</summary>
+        private bool _visible = true;
+
+        /// <summary>
+        /// Whether the views were built at all. False leaves the page's own arrow
+        /// in place and every decision below with only one answer.
+        /// </summary>
+        private readonly bool _built;
+
+        private CursorVisual _visual = CursorVisual.Native;
+
+        public NuiCursor(Window window, WebView web)
         {
             _web = web;
+            _window = window;
+
+            try
+            {
+                _ring = Blob(RingSize, new Color(0f, 0f, 0f, 0.88f));
+                _body = Blob(BodySize, NuiTheme.Ink);
+                _core = Blob(CoreSize, NuiTheme.Accent);
+                _built = true;
+            }
+            catch (Exception ex)
+            {
+                // Best-effort like everything else past the managed surface. A
+                // pointer we cannot draw is not a browser that cannot run: the page
+                // script keeps its own arrow and the app behaves as it did before.
+                DiagLog.Add("native pointer unavailable, using the page's own: " + ex.Message);
+                _built = false;
+            }
+        }
+
+        /// <summary>Who is drawing the pointer at the moment.</summary>
+        public CursorVisual Visual
+        {
+            get { return _built && _visual == CursorVisual.Native ? CursorVisual.Native : CursorVisual.Dom; }
+        }
+
+        /// <summary>
+        /// Swaps the page's arrow for ours and back. Native is the default and the
+        /// answer to issue #78; the way back exists because the arrow is the better
+        /// looking of the two and on a light page somebody may prefer it.
+        /// </summary>
+        public void SetVisual(CursorVisual visual)
+        {
+            _visual = visual;
+            Apply();
+            DiagLog.Add("pointer drawn by " + (Visual == CursorVisual.Native ? "the app" : "the page"));
+        }
+
+        /// <summary>
+        /// Puts the current choice on the screen and on the page: exactly one of the
+        /// two pointers is ever showing, and the position is re-sent either way.
+        /// </summary>
+        private void Apply()
+        {
+            if (Visual == CursorVisual.Native)
+            {
+                Eval("try{window." + PageScript.Namespace + ".hide();}catch(e){}");
+                Place();
+            }
+            else
+            {
+                ShowViews(false);
+
+                // The page's arrow is put back by install(), which is idempotent
+                // and is the only call that sets it visible again.
+                Eval(PageScript.Install("sbnative"));
+            }
+
+            MoveInPage();
         }
 
         /// <summary>
@@ -70,7 +188,13 @@ public void Reinstall()
             // results back through EvaluateJavaScript callbacks, so the name is
             // only used for the (unused) postMessage path.
             Eval(PageScript.Install("sbnative"));
-            MoveInPage();
+
+            // A load put the page's own arrow back. Two pointers on one screen is
+            // worse than either, and the page's is the one that lags.
+            // Not deferred: the page has just been replaced and knows nothing about
+            // where the pointer is, so the first telling is worth a call of its own.
+            _movePending = false;
+            Apply();
         }
 
         public void Move(int dx, int dy)
@@ -86,13 +210,53 @@ public void Move(int dx, int dy)
 
             _x = Clamp(_x + (dx * _step));
             _y = Clamp(_y + (dy * _step));
-            MoveInPage();
+
+            // Drawn now, told later. This is the whole of issue #78: the drawing is
+            // ours and costs the page nothing, and the page hears about it on the
+            // next tick instead of on every repeat of a held key.
+            Mark();
         }
 
         public void Center()
         {
             _x = 0.5;
             _y = 0.5;
+            Mark();
+        }
+
+        /// <summary>
+        /// Draws the pointer where it now is and notes that the page has not been
+        /// told. With the page drawing it there is nothing to draw and nothing to
+        /// wait for, so the telling happens at once — the delay only buys anything
+        /// when something else is already showing the user where they are.
+        /// </summary>
+        private void Mark()
+        {
+            if (Visual == CursorVisual.Native)
+            {
+                Place();
+                _movePending = true;
+            }
+            else
+            {
+                _movePending = false;
+                MoveInPage();
+            }
+        }
+
+        /// <summary>
+        /// Tells the page where the pointer is, if it has not been told since the
+        /// last move. Called from the app's 150 ms tick, which is what turns a burst
+        /// of key repeats into one hover update.
+        /// </summary>
+        public void FlushPending()
+        {
+            if (!_movePending)
+            {
+                return;
+            }
+
+            _movePending = false;
             MoveInPage();
         }
 
@@ -100,8 +264,21 @@ public void Click()
         {
             try
             {
+                // A pending move rides along in the same evaluation rather than
+                // being sent as a call before it. The script's click() hit-tests at
+                // the position move() left behind, so a click that overtook its own
+                // move would land wherever the pointer used to be — and two
+                // evaluations would be two chances for that ordering to go wrong.
+                string move = string.Empty;
+                if (_movePending)
+                {
+                    _movePending = false;
+                    move = "window." + PageScript.Namespace + ".move(" + F(_x) + "," + F(_y) + ");";
+                }
+
                 _web.EvaluateJavaScript(
-                    "String(window." + PageScript.Namespace + " && window." + PageScript.Namespace + ".click())",
+                    "(function(){if(!window." + PageScript.Namespace + "){return 'no page script';}" +
+                    move + "return String(window." + PageScript.Namespace + ".click());})()",
                     result =>
                     {
                         DiagLog.Add("click -> " + (result ?? "(null)"));
@@ -160,6 +337,139 @@ public void ReportNativeWitness(int delayMilliseconds, Action<string> report)
             });
         }
 
+        /// <summary>
+        /// Takes the pointer off the screen entirely — both drawings of it. Used
+        /// when the remote's keys are handed to the page (key 4), where there is no
+        /// pointer to aim.
+        /// </summary>
+        public void Hide()
+        {
+            _visible = false;
+            ShowViews(false);
+            Eval("try{window." + PageScript.Namespace + ".hide();}catch(e){}");
+        }
+
+        /// <summary>Brings it back after <see cref="Hide"/>.</summary>
+        public void Show()
+        {
+            _visible = true;
+            Apply();
+        }
+
+        /// <summary>
+        /// One circle of the drawn pointer. Sensitive is cleared for the same
+        /// reason the chrome clears it: DALi delivers a fed touch to the front-most
+        /// sensitive actor, and the frame-click path feeds touches at exactly the
+        /// point this sits on — a pointer that could swallow its own click would be
+        /// a very hard evening to explain.
+        /// </summary>
+        private View Blob(int size, Color colour)
+        {
+            var view = new View
+            {
+                Size2D = new Size2D(size, size),
+                BackgroundColor = colour,
+                CornerRadius = size / 2f,
+                Sensitive = false,
+            };
+            _window.Add(view);
+            view.Hide();
+            return view;
+        }
+
+        private void Place()
+        {
+            if (!_built || !_visible)
+            {
+                return;
+            }
+
+            try
+            {
+                Size2D screen = _window.WindowSize;
+                int cx = (int)Math.Round(_x * screen.Width);
+                int cy = (int)Math.Round(_y * screen.Height);
+
+                Centre(_ring, cx, cy, RingSize);
+                Centre(_body, cx, cy, BodySize);
+                Centre(_core, cx, cy, CoreSize);
+                ShowViews(true);
+            }
+            catch (Exception ex)
+            {
+                DiagLog.Add("could not place the pointer: " + ex.Message);
+            }
+        }
+
+        private static void Centre(View view, int cx, int cy, int size)
+        {
+            if (view != null)
+            {
+                view.Position2D = new Position2D(cx - (size / 2), cy - (size / 2));
+            }
+        }
+
+        private void ShowViews(bool visible)
+        {
+            if (!_built)
+            {
+                return;
+            }
+
+            try
+            {
+                foreach (View view in new[] { _ring, _body, _core })
+                {
+                    if (view == null)
+                    {
+                        continue;
+                    }
+
+                    if (visible)
+                    {
+                        view.Show();
+                        view.RaiseToTop();
+                    }
+                    else
+                    {
+                        view.Hide();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                DiagLog.Add("could not show the pointer: " + ex.Message);
+            }
+        }
+
+        private void Detach(View view)
+        {
+            try
+            {
+                if (view != null)
+                {
+                    _window.Remove(view);
+                    view.Dispose();
+                }
+            }
+            catch (Exception ex)
+            {
+                DiagLog.Add("could not remove the pointer: " + ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Takes the drawn pointer off the screen and out of the window. Called when
+        /// the view it sits over is being replaced, so a rebuilt view does not end
+        /// up with a second pointer over it.
+        /// </summary>
+        public void Remove()
+        {
+            Detach(_ring);
+            Detach(_body);
+            Detach(_core);
+        }
+
         public void ScrollPage(int direction)
         {
             // Reported back, unlike the fire-and-forget Eval: without this there is
diff --git a/src/nui/NuiKeyboard.cs b/src/nui/NuiKeyboard.cs
index 3ef05c0..2f7766a 100644
--- a/src/nui/NuiKeyboard.cs
+++ b/src/nui/NuiKeyboard.cs
@@ -280,6 +280,22 @@ private static Color FillFor(string key)
         /// The layout key wears the name of the layout it is showing, and the
         /// symbol key wears the page it switches *to*.
         /// </summary>
+        /// <summary>
+        /// What the entry line calls itself. The keyboard looks the same whatever
+        /// it was opened for, so this is the only thing on screen that says which
+        /// of the three it is — and "keep" and "go to" are not a mistake anybody
+        /// should be able to make silently.
+        /// </summary>
+        private static string Prompt(KeyboardTarget target)
+        {
+            switch (target)
+            {
+                case KeyboardTarget.Address: return "Go to";
+                case KeyboardTarget.Favourite: return "Keep as a tile";
+                default: return "Type into page";
+            }
+        }
+
         private static string LabelFor(string key)
         {
             switch (key)
@@ -293,8 +309,7 @@ private static string LabelFor(string key)
 
         private void Paint()
         {
-            _entry.Text = (Target == KeyboardTarget.Address ? "Go to   " : "Type into page   ") +
-                          (_text.Length == 0 ? "|" : _text + "|");
+            _entry.Text = Prompt(Target) + "   " + (_text.Length == 0 ? "|" : _text + "|");
 
             for (int r = 0; r < _keys.Length; r++)
             {
diff --git a/tools/startpage/Program.cs b/tools/startpage/Program.cs
index 1bfec25..486cb72 100644
--- a/tools/startpage/Program.cs
+++ b/tools/startpage/Program.cs
@@ -155,6 +155,70 @@ private static int Main(string[] args)
             Check(DiagLog.Lines.Exists(l => l.Contains("dropped 2 sign-in")),
                   "the log says how many: " + string.Join(" | ", DiagLog.Lines));
 
+            // 6. Where the browser opens — three states, not two (issue #79).
+            //    The one that has to keep working is the upgrade: an install made
+            //    before this existed has an address and no mode, and its start page
+            //    must not change under it.
+            string openDir = Path.Combine(dir, "opens-at");
+            Directory.CreateDirectory(openDir);
+            Store.Init(openDir);
+            Check(StartPage.Mode() == StartPage.Home && StartPage.Resolve(Store.RecentHistory) == null,
+                  "a fresh install opens on the start screen");
+
+            StartPage.SetAddress("https://open.spotify.com/");
+            Check(StartPage.Mode() == StartPage.Url &&
+                  StartPage.Resolve(Store.RecentHistory) == "https://open.spotify.com/",
+                  "an address set with the start key is what opens");
+
+            StartPage.SetAddress(null);
+            Check(StartPage.Mode() == StartPage.Home && StartPage.Resolve(Store.RecentHistory) == null,
+                  "clearing it goes back to the start screen");
+
+            // "Open where I left off" with nothing ever visited is the start screen,
+            // not a blank page and not a crash.
+            Check(StartPage.ToggleLast() && StartPage.Resolve(Store.RecentHistory) == null,
+                  "left off with an empty history is still the start screen");
+
+            Store.RecordVisit("https://www.instagram.com/", "Instagram");
+            Store.RecordVisit("https://open.spotify.com/album/1", "Spotify");
+            Check(StartPage.Resolve(Store.RecentHistory) == "https://open.spotify.com/album/1",
+                  "otherwise it is the last page actually visited");
+
+            // The start screen recorded between the two would be the last visit if
+            // Store let it in. It does not (check 1), and this is that guarantee
+            // seen from the other end — #53 and #79 share the same history.
+            Store.RecordVisit(AsEngineUrl(HomePage.Build(Store.AllFavourites, Store.RecentHistory, "https://x/")), "Overscan");
+            Check(StartPage.Resolve(Store.RecentHistory) == "https://open.spotify.com/album/1",
+                  "and never this app's own start screen");
+
+            // Turning it back off returns to the address, which is still there.
+            StartPage.SetAddress("https://example.com/");
+            StartPage.ToggleLast();
+            Check(StartPage.Mode() == StartPage.Last, "the toggle turns back on over an address");
+            Check(!StartPage.ToggleLast() && StartPage.Mode() == StartPage.Url &&
+                  StartPage.Resolve(Store.RecentHistory) == "https://example.com/",
+                  "and off again lands on the address, not the start screen");
+
+            // The upgrade. settings.tsv written by a build that had no mode key.
+            string oldDir = Path.Combine(dir, "upgrade");
+            Directory.CreateDirectory(oldDir);
+            File.WriteAllLines(Path.Combine(oldDir, "settings.tsv"), new[]
+            {
+                "startupUrl\thttps://www.instagram.com/",
+                "images\t1",
+            });
+            Store.Init(oldDir);
+            Check(StartPage.Mode() == StartPage.Url &&
+                  StartPage.Resolve(Store.RecentHistory) == "https://www.instagram.com/",
+                  "an install from before the mode existed still opens on its address");
+
+            string bareDir = Path.Combine(dir, "upgrade-bare");
+            Directory.CreateDirectory(bareDir);
+            File.WriteAllLines(Path.Combine(bareDir, "settings.tsv"), new[] { "images\t0" });
+            Store.Init(bareDir);
+            Check(StartPage.Mode() == StartPage.Home && StartPage.Resolve(Store.RecentHistory) == null,
+                  "and one that never set an address still opens on the start screen");
+
             Console.WriteLine();
             Console.WriteLine(_failures == 0 ? "startpage: all checks passed" : "startpage: FAILED (" + _failures + ")");
             return _failures == 0 ? 0 : 1;
diff --git a/tools/startpage/run.sh b/tools/startpage/run.sh
index 3b3ec81..e723384 100755
--- a/tools/startpage/run.sh
+++ b/tools/startpage/run.sh
@@ -22,7 +22,11 @@
 #   4. a sign-in waypoint (a captcha, a code entry, an OAuth step, a URL too long
 #      to be anything but a token) is passed through and not recorded, while a
 #      host or a fragment that merely contains one of those words is kept;
-#   5. a history file with waypoints in it is healed on load, favourites untouched.
+#   5. a history file with waypoints in it is healed on load, favourites untouched;
+#   6. where the browser opens (issue #79): the three states, "where I left off"
+#      landing on the last real visit and never on this app's own start screen,
+#      the toggle going back to the address somebody set rather than losing it,
+#      and an install made before the mode existed still opening where it did.
 # Number 3 is the bug itself: against the Store.cs before this fix it fails on
 # the second screen. Numbers 4 and 5 are the same reporter's next report: six
 # recent tiles, two of them 3 KB recaptcha pages nobody can go back to.
@@ -52,6 +56,8 @@ cat > "$work/startpage.csproj" <<CSPROJ
     <Compile Include="Program.cs" />
     <Compile Include="$PWD/../../src/common/Store.cs" />
     <Compile Include="$PWD/../../src/common/HomePage.cs" />
+    <Compile Include="$PWD/../../src/common/SiteRules.cs" />
+    <Compile Include="$PWD/../../src/common/StartPage.cs" />
   </ItemGroup>
 </Project>
 CSPROJ