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.
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
- 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
- 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 "https://en.wikipedia.org/wiki/Main_Page" :title "Wikipedia, the free encyclopedia" :shortcut "wiki" :search "http://en.wikipedia.org/wiki/Special:Search?search=%s" :time "Sat Jul 14 09:41:56 2018" :tags '("encyclopedia" "knowledge" "wiki"))
wiki: Open the main page.
wiki elephant: search Wikipedia for “elephant”.
- Support user-defined filters to avoid duplicating bookmarks.
For instance detect duplicates
- 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.
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
This makes it possible to use Next over Tor among others.
Use D-Bus for inter-process communication
This increases security and should also improve performance, notably on *BSD systems.
define-parenscript supersedes it.
Smarter start up logic
Next will try harder to “do the right thing” when starting.
(next:start) from the REPL should be enough in most cases.
Improve minibuffer fuzzy-matching to support permutations and typos
- 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
about command to display list of campaign backers
*anchor* commands to
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
Properly fall back to default search engine on invalid URI
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
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.
Both macros are merged into
- 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
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
Add recipe for Guix
Scroll selection in minibuffer
- Create frontend that renders the new Next GUI
- 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
Allow the user to run M-x to execute any extended command. Execute Extended Command
- Implement functionality similar to the famous Hydra package by Oleh Krehel
Add Hook System
- Model Hook system similar to the Emacs style hooks (https://www.gnu.org/software/emacs/manual/html_node/emacs/Hooks.html)
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
- Based on the spec here: https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
- Create GNU/Linux GTK Port
- 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
- 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 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
- 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 `Next.app/Contents/Frameworks`
- Use `otool -L Next.app/Contents/MacOS/next` to find the linked frameworks that are not located in `Next.app/Contents/Frameworks`, manually copy them to `Next.app/Contents/Frameworks`
- Use install_name_tool to update the now copied frameworks in `Next.app/Contents/Frameworks`
- For more info please see: http://doc.qt.io/qt-5/osx-deployment.html
- 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: https://www.emacswiki.org/emacs/UndoTree
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: 0.01
- 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 http://www.url.com 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.
All major modes inherit from document mode. Document mode provides the basic framework for mapping global commands and defining general behavior. Major mode: document-mode
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:
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 a new html document with the key binding C-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. Ability to open new buffers with the key-binding M-l
- May possibly switch implementation to “hide” rather than “close” widgets, possibly using a widget pool as well for memory performance
The following syntax should be used to set a key binding: Ability to set Key bindings
(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.
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. Ability to browse and change buffers
Switch buffer should demonstrate an example of minibuffer completion candidates Minibuffer Completion
- One “click” build system for deployment on OSX
- Organization of build systems into lisp files, no shell scripts