Skip to content
Branch: master
Find file Copy path
Find file Copy path
2 contributors

Users who have contributed to this file

@Ambrevar @jmercouris
509 lines (480 sloc) 21.9 KB

Release Timeline

Next uses Semantic Versioning. In short, given a version number MAJOR.MINOR.PATCH, we increment the:

  • MAJOR version when we make incompatible API changes,
  • MINOR version when we add functionality in a backwards-compatible manner, and
  • PATCH version when we make backwards-compatible bug fixes.

1.4.0 (Upcoming)

Smart searching across all tabs

  • You should be able to search all tabs simultaneously and see a list of completion candidates in the minibuffer

Jump to heading across all tabs

  • Add a jump to heading command that works across all open tabs

Package manager

  • There should be a package manager/repository where creators of packages can publish, and users can download
  • This technology will probably be built ontop of Quicklisp

Per tab isolation

  • Add support for per-tab Proxy and Tor support

Improve macOS performance

  • Rewrite the Qt port from Python to C++ to improve performance, additionally enabling a host of features not offered by the Python port
  • Fix some issues with strange keys emitted on macOS from the keyboard

Improve macOS distribution

  • Create a standalone application bundle that macOS users can simply double click and run

ECL, CCL, and EQL compatibility

  • Broaden support for different Lisp implementations by removing SBCL specific code when possible

Password manager

  • Add an integrated password manager

Add built-in editor

  • Add simple built-in editor capabilities so that you can easily script Next without opening up an external editor
  • Also use the editor for text-field input on the internet

Add support for external editor

  • Allow Next to call out to an external editor to fill in the contents of a particular text field

Extend bookmark support

  • Switch from SQLite to an s-exp based text file.
  • Bookmarks can have tags, a shortcut string, a timestamp.
  • Bookmarks and search engines can be merged.
  • Proposed format:
    (:url "" :title "Wikipedia, the free encyclopedia" :shortcut "wiki" :search "" :time "Sat Jul 14 09:41:56 2018" :tags '("encyclopedia" "knowledge" "wiki"))

    Minibuffer usage:

    • wiki: Open the main page.
    • wiki elephant: search Wikipedia for “elephant”.
  • Support user-defined filters to avoid duplicating bookmarks. For instance detect duplicates http://foo and https://foo.
  • Support user-define read/write hooks so that bookmarks can be automatically imported, say, from Firefox, or exported to a SQLite database or a custom text format.


PyQt/Webengine platform port

QtWebengine is based off Blink (the renderer of Chrome). A PyQt platform port would have the benefits of being cross-platform while offering an alternative web renderer.

Because of WKWebKit library limitations, the cocoa-webkit platform port misses some features such as proxy support, per-buffer cookie file, network resource interception. To address these limitations, the PyQt platform port could become the default for macOS.

VI bindings

Ad-blocking support

Only host-based for now and uses Easylist by default.

Fix search implementation

It now displays search hints properly and search within iframes too.

Add initial download support

Support multiple modes per buffer

Add proxy-mode

This makes it possible to use Next over Tor among others.

Add noscript-mode to disable JavaScript

Use D-Bus for inter-process communication

This increases security and should also improve performance, notably on *BSD systems.

Remove define-parenstatic macro

define-parenscript supersedes it.

Smarter start up logic

Next will try harder to “do the right thing” when starting. A simple (next:start) from the REPL should be enough in most cases.

Improve minibuffer fuzzy-matching to support permutations and typos

Extended bindings

  • C-w copies any candidate
  • TAB inserts the candidate in the minibuffer.
  • C-v and M-v scroll pages up and down.
  • C-x C-k deletes the current buffer.
  • C-left, C-right, C-Page_Up and C-Page_Down go to previous/next buffer.

Fix init file location guessing

It used to be hard-coded, now it’s found in ~/.config/next/init.lisp.

Display a help buffer on startup

This does not require an Internet connection.

Add Roswell build script (thanks to Danny YUE)

Fix the “blank buffer” issue with the gtk-webkit platform port

Fix the minibuffer size with the gtk-webkit platform port

Display current URL or URL at point in the echo area

Add the about command to display list of campaign backers

Rename add-search-hints to search-buffer

Rename kill to quit

Rename *anchor* commands to *hint*


Use authenticated RPC to mitigate remote-execution vulnerability

Cocoa-webkit support has been dropped

The WKWebKit library is too poor for our use in Next. Cocoa-webkit will be replaced with a QtWebengine platform port in a coming version.

Fix C-[ and C-] bindings with gtk-webkit

Allow loading HTML files specified with relative path

Properly terminate platform port on SIGTERM

Support multiple expressions in command-evaluate

Fix delete-buffer command

Properly fall back to default search engine on invalid URI


Improve next-gtk-webkit stability

In particular, removes a race condition that would often hang the browser on key presses.

Make almost everything stateless but interface

Most globals are gone. Everything is properly initialized just-in-time so that it won’t fail if the user forgets to initialize something manually. (next:start) can safely be run multiple times in a row while producing the same result.

Improve search engine support (thanks to wednesday)

Fall back to a search engine query if input is not a URI. Add support for multiple search engines.

Sort history by number of visits (thanks to wednesday)

Add support for local HTML (file:// protocol)

Add experimental proxy support

Due to limitations in the WKWebview API, the Cocoa version lacks proxy support.

Add mouse support

Intercept all network events

This makes it possible to implement, for instance, ad-blocking, fully from the Lisp side.

Due to limitations in the WKWebview API, the Cocoa version lacks the ability to do any processing on a per URI resource basis. The consequence of this means no Adblocking, no Downloads.

Input events (e.g. key presses, mouse buttons) can be generated programatically

Move platform-specific key translation to the platform port

Clean up on exit

Catch SIGTERM (C-c in a shell), kill the interface on exit, etc.

Don’t give up so easily on startup

Next will now try to find free ports automatically. It will find the platform ports automatically if run from source. Platform port polling is only done for a limited time to avoid hung processes.

Add experimental Clozure Common Lisp (CCL) support

Improve logging and error reporting

In particular, some errors are reporting in the echo area.

Save platform port log to XDG_DATA_HOME/next/

Add experimental support for next-gtk-webkit on macOS

Though it works on macOS, WebkitGTK+ is very slow since it does not utilize the native graphical frameworks/libraries. Users can see our Macports subtree to install WebkitGTK+ and compile Next manually.

Rename execute-extended-command to execute-command

Rename reload-init to load-init-file

Remove define-parenstatic macro

Both macros are merged into define-parenscript.

Rename mode to root-mode

Replace the - in XML-RPC method names with .

As per the specifications, - is not a valid XML-RPC character in method names.

Prefix all RPC calls with %% in the Lisp core


Add RELOAD-CURRENT-BUFFER command and bind it to C-r

Add NEXT-VERSION command

It reports the commit hash if it was not built on a tag version.

Add cookie support

GTK implementation has per-buffer cookie support.

Due to limitations in the WKWebview API, the Cocoa version lacks the ability to specify a per-buffer or application-wide cookies directory.

Report page load status to echo area

Add COPY-TITLE command and bind it to M-w

Add COPY-ANCHOR-URL command and bind it to C-x C-w

Add COPY-URL command and bind it to C-w

Add PASTE command to minibuffer and bind it to C-v and C-y

Add common movement commands to minibuffer

For instance cursor-forwards-word is bound to M-f by default.

Add “echo area” to display status messaages

Set window title dynamically

Embed/Replace build dependencies in the Cocoa port

It now builds out of the box, with no need for external libraries.

Add commandline arguments to the Cocoa platform port

Report user configuration errors

Save platform logs to tmp/next-$USER


Overhaul start-up and exit processes

Add –init-file command line parameter

Fix a number of issues with GTK-WebKit

Enhance logging with GTK-WebKit

See /tmp/next-webkit-gtk.log by default. Debug message can be included by exporting the G_MESSAGES_DEBUG=all environement variable.

Add recipe for Guix

Scroll selection in minibuffer


GNU/Linux Frontend

  • Create frontend that renders the new Next GUI

MacOS Frontend

  • Create frontend that renders the new Next GUI

Lisp Core Remote Backend

  • Create abstract interface for controlling frontends.
  • Interface must be asynchronous
  • Interface should be connection agnostic, should support BSD style sockets for first iteration, and Unix domain sockets for second iteration


Execute Extended Command

Allow the user to run M-x to execute any extended command.

Hydra Functionality

  • Implement functionality similar to the famous Hydra package by Oleh Krehel

Add Hook System

Add ability to inspect commands

Continuation Passing Style Input

  • Allow user to use a (input* ()) type binding in which they can prompt the user for input rather than the current style which involves setting the input handling as part of the lambda registered in the keybinding
  • Convert existing functions to use continuation passing style input


  • Implement define-command macro with overhaul for how keybindings are set/handled in functions
  • Convert all user invokable functions to use define-command

Support XDG Configuration


GTK Port

  • Create GNU/Linux GTK Port


Fix Compilation

  • Compilation loading of Quicklisp should check both ~/.quicklisp as well as ~/quicklisp and load whichever it finds first

User Customization Example

  • Create an example in the Documents directory that details the creation of a simple mode, and a way of customizing Next

Jump to Heading

  • Implement something akin to ijump which allows you to jump to any heading on a given page represented by H1 H2 H3 tag etc

Search within Buffer

  • Add ability to search within the buffer

Add Search Function

  • Minibuffer should allow searching via a search engine

Buffer contains list of modes

  • The buffer should contain a list of all of the modes that have been applied to it, so that no memory is lost when switching modes

Add Slime Support

  • Add slime support to the compiled version of Next

Reload Init Function

  • Allow function to reload init

Add Help System

  • Add basic help system that can be extended
  • Add the ability to look up global variables

Extend Bookmark Support

  • Allow user to manually enter the bookmark URL into the minibuffer directly
  • Allow the user to create a bookmark from a link-hint anchor


Minibuffer selection

  • Should be able to move up and down through candidates using C-n and C-p
  • Minibuffer should return actual object in question instead of doing strange magic with strings

Minibuffer set text

  • Allow the setting of the Minibuffer text
  • Setup the automatic clearing of the Minibuffer previous text

Add Link Hints

  • user should be able to navigate all links entirely by keyboard
  • user should be able to open link hints in a new buffer with focus
  • user should be able to open link hints in a new buffer without focus

Fix keybindings within repl

  • Allow keybinding invocation within repl overriding ccl cocoa IDE


  • History will be stored in a DB (possibly sqlite)

History is searchable

  • History has a query language that can be used to look for different things (e.g. date, include exclude regex, etc)
  • Because history is stored in sqlite DB, user can create queries against their history

Set-url history suggestion

  • History should be suggested by set-url
  • Minibuffer input should be able to handle different use cases for different input methods

Update Manual

  • Update manual with latest capabilities and changes to codebase


Isolate backend QT Code

  • Break apart QT code into separate file
  • Remove all top-level side effects
  • Modularize GUI backend

Write Cocoa backend

  • Use CCL Cocoa Library to use native WebKit backend


  • Bookmarks will be stored in a DB (possibly sqlite) with information about them, they’ll be navigable via a completion buffer


Write Manual Base

  • Write basic information and configuration within the manual as a “users” guide

Improve in Code Documentation & Architecture

  • Create much clearer picture of how everything functions together, make cleaner architecture diagrams showing how everything links together
  • Document all functions

OSX Compilation

  • Modify make.lisp script to create a binary that grabs all of the dependencies and creates a executable that can be deployed on OSX
  • Use `macdeployqt` to copy the core qt libraries to ``
  • Use `otool -L` to find the linked frameworks that are not located in ``, manually copy them to ``
  • Use install_name_tool to update the now copied frameworks in ``
  • For more info please see:

Kill Buffer

  • Add function to kill buffer, bind to C-k


History Tree Mode

  • Create a mode that allows traversal of the tree created in the history of a document-mode buffer

Cancel Within Minibuffer mode

Within document-mode the history will be represented as a tree

  • forwards and backwards navigation creating new nodes and

traversals. This will allow for all points in history to be reachable, and a future expansion designed to recreate the functionality offered by undo-tree:

Ability to navigate forward and backward in history

  • using the key binding M-f, and M-b for forward and backward respectively
  • should only work if there is one child

Forward navigation with more than one child prompts mini-buffer selection

  • If a user tries to navigate forward but there is more than one possible destination available, show the possibilities as an auto-completable list in the minibuffer


  • Convert struct usage to CLOS


  • The ability to scroll up and down within a document
    • using C-n to scroll down
    • using C-p to scroll up


This version describes the minimum usability as a basic browser, with the following features:
  • Implementation of document-mode, the major-mode that all modes extend
  • Ability to set key bindings for major modes
  • Ability to browse and change buffers using C-x b


Buffer: All documents are contained in an object type called a buffer. As an example, a document on the web located at can be contained in a buffer with a similar name. A buffer is composed of all elements (text, bitmaps, etc) necessary to render a single document.

Mode-map: A keyboard hot-key to function mapping.

Minibuffer: A special buffer dedicated to interacting with Next commands in progress. This buffer appears at the bottom of the screen and is collapsed when not in use.

Major-mode: A major mode is defined as the primary mode of interacting with a particular buffer. A mode defines a set of key bindings, hooks for actions, and presentation details for a given view. At any given time, there may only be one major mode for a buffer. All major modes are composed of entirely lower case alpha with dashes used as a separator. Every major mode has a keyboard mapping that follows this pattern: document-mode, will have a mode map called document-mode-map.

Minor-mode: A minor mode is a secondary mode of modifying a buffer’s behavior and content. There can be an infinite amount of minor modes applied to a given buffer. All minor modes are composed of entirely lower case alpha with dashes used as a separator.

Major mode: document-mode

All major modes inherit from document mode. Document mode provides the basic framework for mapping global commands and defining general behavior.

Document-mode will be the basic major mode for opening documents on the web. document-mode will extend document-mode, and thus will inherit all of its key bindings. If there is a conflict of key bindings, the lowest scope key binding will be prioritized. As a concrete example, all bindings defined in a minor mode will override any defined in document-mode. In the first release, document-mode will support the following key bindings and features:

For the first release, document-mode must have:

Ability to open a new html document with the key binding C-l

Opening of new pages in the same buffer can be invoked by the key binding C-l. This key binding will open up the Minibuffer and prompt the user to enter the url which they would like to visit.

Ability to open new buffers with the key-binding M-l

Opening of new buffers by invoking M-l will open the Minibuffer. Within the Minibuffer, the user will be presented with a prompt in which they can enter in the url they would like to visit in a new buffer.
  • May possibly switch implementation to “hide” rather than “close” widgets, possibly using a widget pool as well for memory performance

Ability to set Key bindings

The following syntax should be used to set a key binding:

(define-key x-mode-map (key “C-h”) ‘function)

Where x-mode-map is a keymap relating to a mode (major or minor).

Where ‘function is a function that is passed to define-key to trigger a function upon a key press.

(key “C-h”) defines that the keyboard sequence Control + h is represented. For the keyboard syntax, the following keys are described:

  • S = super key (windows/command key)
  • C = control key
  • M = meta key (alt key)

A chain of key bindings may be set in the following manner:

(key “C-x C-s”) will denote the following key presses, Ctrl + x, followed by Ctrl + s immediately thereafter.

Upon the definition of a “chained” keyboard binding, any elements in the chain may not be used individually. For example, binding “C-x C-s”, will prohibit the binding of “C-x” by itself. This is because there would be ambiguity in regards to which key binding is intended to be invoked.

Ability to browse and change buffers

The user will be able to invoke the key binding C-x b to bring up a menu in the Minibuffer in which they will be able to select a new buffer to bring to focus.

Minibuffer Completion

Switch buffer should demonstrate an example of minibuffer completion candidates

Compilation OSX

  • One “click” build system for deployment on OSX
  • Organization of build systems into lisp files, no shell scripts
You can’t perform that action at this time.