You can now configure new search engines directly in the Glide config, for example:

glide.search_engines.add({
  name: "Discogs",
  keyword: "disc",
  search_url:
    "https://www.discogs.com/search/?q={searchTerms}",

  // optional
  favicon_url: "https://www.discogs.com/favicon.ico",
  is_default: false,
});

  
  

With this example you could search using Discogs by focusing the address bar and typing disc<space>!

The glide.search_engines.add() function takes the same arguments as the chrome_settings_overrides.search_provider web extension manifest v2 object.

• Bumped Firefox from 147.0b3 to 147.0b8
• Improved type inference for glide.content.execute() params
  • Thanks @TomerAberbach for the contribution!
• Added support for hiding the native tab bar with glide.o.native_tabs = "hide", or with "autohide" to show the tab bar on hover on Linux
  • Thanks @45Hnri for the contribution!
• Added glide.styles.has()
• Added glide.styles.get()
• Added support for overwriting existing styles with glide.styles.add('css', { id: '...', overwrite: true })
• Added :tab_pin and :tab_unpin commands
  • Thanks @suveshmoza for the contribution!
• Updated :config_reload to apply across all open windows
• Updated the commandline to show suggested commands first
  • Thanks @jyn514 for the contribution!
• Updated hint generation to clear previous "No hints found" notifications when hints are eventually found
  • Thanks @suveshmoza for the contribution!
• Removed Perplexity as a default search engine
• Fixed usage of the browser API on privileged pages
• Fixed permissions error when creating or updating tabs with a privileged URI, e.g. browser.tabs.create({ url: "resource://glide-docs/index.html" })
• Fixed glide.bo.hint_size so that it correctly applies the styling for the current buffer
• Fixed i sending an unnecessary <left> key event
• Fixed serialisation of the browser.contentScripts.register() return value. You can now access it, and call script.unregister().
• Misc
  • Many thanks to @jyn514 for updating lots of docs and improving the contributing experience!
  • Set up a Zulip chat for realtime discussion
  • Reduced the number of redundant DOM mutations inside the commandline
    • Thanks @suveshmoza for the contribution!

The action and pick callbacks are now executed in the main process, not the content process. This change was made so that you can access the glide API in the callbacks, making them much more useful.

For example, only selecting the hint with the largest width:

// before
glide.hints.show({
  pick: (hints) => {
    let biggest_hint = hints[0]!;
    let biggest_width = hints[0]!.element.offsetWidth;
    for (let i = 1; i < hints.length; i++) {
      const hint = hints[i]!;
      const width = hint.element.offsetWidth;
      if (width > biggest_width) {
        biggest_hint = hint;
        biggest_width = width;
      }
    }
    return [biggest_hint];
  },
});

// after
glide.hints.show({
  pick: async ({ hints, content }) => {
    const widths = await content.map((element) =>
      element.offsetWidth
    );
    let biggest_hint = hints[0]!;
    let biggest_width = widths[0]!;
    for (let i = 1; i < hints.length; i++) {
      const hint = hints[i]!;
      const width = widths[i]!;
      if (width > biggest_width) {
        biggest_hint = hint;
        biggest_width = width;
      }
    }
    return [biggest_hint];
  },
});

  
  

For the action function:

// before
glide.hints.show({
  action: (element) => {
    element.click();
  },
});

// after
glide.hints.show({
  action: async ({ content }) => {
    await content.execute((element) => element.click());
  },
});

  
  

Previously calls to APIs like glide.fs.read() with relative paths would resolve relative to the config file instead of the current file.

For example:

// <config>/glide.ts
glide.unstable.include("foo/bar/stuff.glide.ts");

// <config>/foo/bar/stuff.glide.ts
glide.fs.read("data.json");

  
  

0.1.55a would read <config>/data.json

0.1.56a will now read <config>/foo/bar/data.json

You can now override label generation for hints to use whatever strategy you'd like.

For example, a very naive implementation for using the first two characters of the element text as the label:

glide.hints.show({
  label_generator: async ({ content }) => {
    const texts = await content.map((element) =>
      element.textContent!
    );
    return texts.map((text) => text.slice(0, 2));
  },
});

  
  

Thanks to @peff for the contribution!

• Bumped Firefox from 146.0b9 to 147.0b3
• Added support for nested glide.unstable.include() calls
• Added glide.modes.list()
• Added glide.commandline.is_active()
• Added support for overriding commandline custom option matching so you can bring your own fuzzy finder
• Added <CR> keymapping to accept the hint with typed label
  • This is helpful for custom label generator functions that may define labels with the same prefix
  • Thanks to @peff for the contribution!
• Added support for DOM.create_element() in the content process
• Fixed glide.o.switch_mode_on_focus disabling certain non-focus mode changes
• Fixed keymap types to correctly allow <leader>-, <<, < and other similar sequences
  • Thanks to @suveshmoza for the contribution!
• Fixed repeated glide.styles.remove() calls with the same ID
• Fixed glide.styles.add() erroneously adding duplicate styles
• Fixed static properties / methods on builtin classes not being accessible, e.g. URL.canParse()
• Fixed GlideProcessError not being exposed to the sandbox
• Fixed glide.hints.show() with auto_activate: true not respecting action: () => ...
• Fixed elements returned by commandline options render() functions from being needlessly duplicated, and breaking references

You can now use the commandline as a picker for arbitrary options.

For example, creating a basic version of :tab that only shows bookmarks:

glide.keymaps.set("normal", "<leader>o", async () => {
  const bookmarks = await browser.bookmarks.getRecent(10);

  glide.commandline.show({
    title: "bookmarks",
    options: bookmarks.map((bookmark) => ({
      label: bookmark.title,
      async execute() {
        const tab = await glide.tabs.get_first({
          url: bookmark.url,
        });
        if (tab) {
          await browser.tabs.update(tab.id, {
            active: true,
          });
        } else {
          await browser.tabs.create({
            active: true,
            url: bookmark.url,
          });
        }
      },
    })),
  });
}, { description: "Open the bookmarks picker" });

  
  

You can also customise how each option is displayed by providing a render() function on each option that returns a HTMLElement:

{
  label: bookmark.title,
  render() {
    return DOM.create_element("div", {
      style: {
        display: "flex",
        alignItems: "center",
        gap: "8px",
      },
      children: [
        DOM.create_element("span", [bookmark.title]),
        DOM.create_element("span", [bookmark.url], {
          style: { color: "#777", fontSize: "0.9em" },
        }),
      ],
    });
  },
};

  
  

See the full commandline docs for more information.

Firefox has work in progress support for split views, so you can view multiple tabs at the same time.

You can now manage split views directly from the Glide config with glide.unstable.split_views, for example:

glide.keymaps.set(
  "normal",
  "<C-w>v",
  async ({ tab_id }) => {
    const all_tabs = await glide.tabs.query({});
    const current_index = all_tabs.findIndex((t) =>
      t.id === tab_id
    );
    const other = all_tabs[current_index + 1];
    if (!other) {
      throw new Error("No next tab");
    }
    glide.unstable.split_views.create([tab_id, other]);
  },
  {
    description:
      "Create a split view with the tab to the right",
  },
);

glide.keymaps.set(
  "normal",
  "<C-w>q",
  async ({ tab_id }) => {
    glide.unstable.split_views.separate(tab_id);
  },
  {
    description: "Close the split view for the current tab",
  },
);

  
  

• Bumped Firefox from 146.0b4 to 146.0b9
• Added gU keymapping to go to the root of the current URL hierarchy
• Added gu keymapping to go up the URL hierarchy
• Added CommandLineExit autocmd
• Added glide.commandline.show()
• Added support for removing autocmds with glide.autocmds.remove()
• Added glide.content.fn() for marking callbacks as executing in the content process, currently supported in glide.keymaps.set() and glide.excmds.create()
• Added glide.o.switch_mode_on_focus for disabling automatic mode switching
• Added children syntax sugar to DOM.create_element() so you can now do DOM.create_element('div', ['child'], { ...props })
• Made the glide.o type extensible
• Fixed glide.keys.send() potentially resulting in out-of-order key events
• Fixed the glide.o.yank_highlight type to allow rgb(255, 255, 255) strings

Page navigation keys (h, j, k, l, <C-u>, <C-d>, gg, and G) are now translated into equivalent standard keys:

• hjkl to arrow keys
• <C-u> to <PageUp>
• <C-d> to <PageDown>
• gg to <D-Up> on macOS, and <C-Home> on Linux
• G to <D-Down> on macOS, and <C-End> on Linux

For example, when you press j, Glide will now send an <ArrowDown> event to the web page.

This change was made for a couple reasons:

1. We get to leverage Firefox's smooth scrolling implementation.
2. The aforementioned keys are now more likely to just work as you'd expect. Scrolling in PDFs now works; websites with their own scrolling behaviour will now work, as long as they support standard navigation keys.

There is a notable behaviour change here now that navigation keys send key events to the web page; websites can now intercept those key events and function differently. This may or may not be desirable depending on the website you are using.

If this behaviour is worse for you, please open a discussion, and if needed you can revert to the previous implementation with:

glide.o.scroll_implementation = "legacy";

  
  

Smooth scrolling is now supported, and enabled by default.

If you want to keep instant scrolling you can use this config:

glide.prefs.set("general.smoothScroll", false);

  
  

Note that this also changes the scroll behaviour when using arrow keys directly.

• Bumped Firefox from 145.0b6 to 146.0b3
• Added I motion support
• Added <C-,> to move focus out of the currently active element
• Added :copy excmd for smoother integration with excmds like :profile_dir
• Added support for removing browser styles with glide.styles.remove()
• Added opt-in support for hinting elements with click listeners
  • See #110 for more information
• Added glide.ctx.version for accessing the current Glide version
• Added glide.ctx.firefox_version for accessing the Firefox version that Glide is based off of
• Added opt-in JPEG XL support
  • Thanks to @SED4906 for the contribution!
• Removed relative path limitations in glide.unstable.include(), you can now pass absolute paths
• Fixed scrolling while editable elments are focused, e.g. <C-d> will now actually scroll the page down.
• Fixed org.mozilla references in DBus names on Linux, we now use app.glide_browser instead
  • Thanks @thomascft for the contribution!
• Fixed a case where Glide would automatically exit ignore mode when switching tabs
• Fixed keymappings conflicting with browser UI modals, e.g. <D-q> on macOS / <C-S-w> on Linux
• Updated :clear to also dismiss app menu notifications, e.g. the "New update available" notification
• Disabled more AI prefs
• We now store the previous Glide versions you've used in the profile directory

You can now install addons directly from the Glide config:

glide.addons.install(
  "https://addons.mozilla.org/firefox/downloads/file/4598854/ublock_origin-1.67.0.xpi",
);

This will install the uBlock Origin addon, if it isn't already installed. If you want to install the addon even if it's installed already, use glide.addons.install('...', { force: true }).

glide.addons.install() expects a URL for an XPI file, you can obtain the XPI URL from an addons.mozilla.org page by right clicking on "Add to Firefox", and selecting "Copy link".

You can now easily inject custom CSS into the browser UI directly from the Glide config:

glide.styles.add(css`
  #TabsToolbar {
    visibility: collapse !important;
  }
`);

  
  

This particular example hides the horizontal native tabs toolbar, but you can customise essentialy anything in the browser UI with this method.

Note that prior to this release you could inject custom CSS yourself but it was slower and would be persisted between config reloads.

glide.autocmds.create("WindowLoaded", () => {
  document.head!.appendChild(DOM.create_element("style", {
    textContent: css`
      #TabsToolbar {
        visibility: collapse !important;
      }
    `,
  }));
});