Next browser: Be productive Emacs webfeeder.el 2019-11-15T15:30:24+00:00 Next release 1.3.4 Atlas

Next release 1.3.4

We are happy to announce the release of Next version 1.3.4!

This is a minor bug-fix release:

  • Display number of (marked) candidates in minibuffer.

  • Improve fuzzy search performance and relevance.

  • Swap C-x k and C-x C-k bindings to match Emacs' behaviour.

  • Fix platform port lookup failure on startup when looked up in PATH.

  • Fix default-hostlist path in pre-compiled binaries.

  • Fix compound tags lookup for bookmarks.

  • Fix history update on Javascript-loaded pages (e.g. GitHub).

About Next

Next is a keyboard-oriented, extensible web-browser designed for power users. The application has familiar key-bindings ( Emacs, VI), is fully configurable and extensible in Lisp, and has powerful features for productive professionals.

Download it here!

]]> 2019-10-05T00:00:00+00:00
Next release 1.3.3: multiple selection, git clone and more Atlas

Next release 1.3.3: multiple selection, git clone and more

After another short but intense development cycle, we are happy to announce the availability of Next version 1.3.3!

This version brings outstanding and unique features (again!). It is also easier to install on GNU/Linux thanks to a Debian package. Please see all installation options on the download page.

New features

Multiple input selection

Until now, Next's prompt was able to ask the user for one choice among a list (with fuzzy completion). Now, for commands that support it, the user can select multiple candidates and apply an action on all of them (for example, to delete many buffers at once). We can filter and narrow the selection with a text input, and we can select all the visible candidates or unselect the current ones.

The default bindings are:

  • C-SPACE to toggle the mark of an entry.

  • M-a to mark all visible entries.

  • M-u to unmark all visible entries.

Furthermore, when the input is changed and the candidates are re-filtered, the selection is not altered, even if the marked elements are not visible. We can add-up the selections.

For example, if we have several Wikipedia and Stack Overflow pages open, and we want to close them, we can do the following:

  • Press C-x k (Emacs bindings) or d (vim bindings) or call M-x delete-buffer.

  • In the list of current buffers, type "wikip" and witness the list will shrink down. Type M-a to mark all the Wikipedia buffers.

  • Erase the input and filter with stack, press M-a again.

  • Press Enter.

How efficient is that!?

Of course should you wish, you always have the possibility to write your own delete-lots-of-buffers command :-)

Bookmarks, tags and compound queries

Now with Next, you can tag your bookmarks and filter them with compound selectors.

When you bookmark a new page ( C-m s or m M vi-mode or M-x bookmark-page), you are asked for a list of space-separated tags.

When about to open a bookmark ( C-m o, m o, M-x set-url-from-bookmark), you can fuzzy-filter the list and also filter them with tag selectors: use +, - or start a compound selector with ( in which you can use and, or and not.


 +lisp -blog
+blog (or lisp emacs)
+foo -bar (or (and john doe) (not (and tic tac)))

Additionally, the bookmarks are now saved in text format, more precisely, in s-expressions. You can easily read and edit them with another tool of your choice. In fact, we have a user who syncs them to a Github repository already.

Password manager

Next 1.3.3 provides a password manager interface to KeepassXC or Pass.

See the commands save-new-password and copy-password.

Credits go to Solomon Bloch ( @noogie13).

Session persistence

The user session is now automatically persisted. Close Next, and find all your buffers open on subsequent starts.

You can also quit without saving it with M-x quit-after-clearing-session, or program Next to adapt it to your liking. Maybe with hooks this time.

Clone Git repositories

Next 1.3.3 introduces the vcs-clone (alias git-clone) command to clone Git repositories to disk. It asks for the destination and then runs asynchronously. It has a few configuration options, see the manual.

We see this new command as a simple preview of what is possible with Next, as we can interface with the host system rather easily. We are excited to work more on developer helpers in the future, and to see what you'll come up with.

Download videos

Another utility is the new download-video command, which will download the video at the current URL. It is at the moment a wrapper around the youtube-dl program, which you must first install.

After the download, you can open your video with the open-file command ( C-x C-f).

See the manual for more documentation and configuration options.

Reopen closed tabs

The new command reopen-buffer (bound to C-/, or u with VI bindings) will ask for a buffer from the most recently closed ones. It supports multiple selection. And reopen-last-buffer will work without a prompt.

Credits go to 4t0m.

Faster and improved fuzzy completion

Our minibuffer can now match against typos and has much improved performance (no more hang after some 15 input characters…).

The rules are as follows:

  • When any of the input strings does not match any candidate, Next will try to match against possible typos.

  • When any of the input strings matches exactly

Example in execute-command ( M-x):

  • buffer would filter out all commands that don't contain the string "buffer".

  • swt buffer would do as above, then try its best to guess which of the remaining commands matches "swt" more.

View the buffer history (as a tree)

Early versions of Next have supported tree based history. However, until now, visualizing the whole history tree has been difficult.

Next 1.3.3 introduces the command buffer-history-tree to view it in HTML:

The keys C-b and C-f ( history-backwards and history-forwards) are the "usual" ones. M-b and M-f ( history-backwards-query and history-forwards-query) show the buffer history and ask for an url.

There is also history-all-query ( C-M-b) that is self-explanatory and history-forwards-maybe-query that will "do the right thing", that is, ask for input only if there is ambiguity.

New command line argument: –no-init

The command line argument --no-init or -Q will allow you to start Next without loading your init file.

Changes in configuration settings (alias "functional configuration system")

A new style of configuration is available allowing for a "functional" style of configuration. To know more about it, check out our discussion on GitHub.

What's next ?

We have a ton of ideas, as you certainly will the second you try Next. We worked on it full time on our own resources for the last few months, however, they are limited. We might need to look for a real job. We don't see ourselves doing so much again if we can only devote a fraction of our time to it. That's why we launched the Indiegogo campaign. You are warmly invited to join in to make it a success (even with a small donation, the number of participants is also meaningful to us). Thank you!

If you'd like to become a sponsor, or if you need some help to getting started hacking in Next, you can contact us at

Find out more about Next:

]]> 2019-10-02T00:00:00+00:00
Only 10 days left to back the Next browser crowdfunding campaign! Atlas

Only 10 days left to back the Next browser crowdfunding campaign!

Next is a productivity focused, infinitely extensible power-browser. It comes with Emacs / VI bindings and is completely programmable. You can transform it any way you like!

In just the last months, we've released three new versions! Lots of exciting features, from hooks to continuous improvements to the "minibuffer" (a.k.a. the "power bar") to empower the users in a never-ending quest to fuzzy-searching everything!

The project has been seriously taking off these last couple of weeks. We would like to thank our 27 contributors, and all the users and testers that asked for new features, suggested improvements or reported bugs. Thanks!

So what exactly can you do with Next?

  • Go blazing fast when browsing the web! For starters, Next is keyboard driven and has fuzzy-completion everywhere.

  • You can write new commands for anything you want. You have the full power of the programming language at hand, without restricting you to a browser's API. Some examples: You can git-clone the current URL's repository, download Youtube videos and fuzzy-search for local files with open-file.

  • You can write hooks to extend your browsing experience. Write a function that is called when a given network event happens, or slightly modify the behaviour of built-in commands to fit your needs – perfectly.

  • Every tab history is saved as a tree, meaning you don't lose any page when going back. Want an outlook of your whole history? Call the buffer-history-tree command!

  • Press the M-. key to get a list of the page headers, fuzzy-search them and go straight to them.

And much more, as you would expect from your daily driver: adblocking, proxy and Tor support, Javascript blocker, etc.

We need your support!

Next is being developed by a small team of computer scientists with a passion for changing the world of browsers. We rely on your support to keep development going!

Last month we started a crowdfunding campaign so that we can get to work on the next version. The campaign is ending on Friday, October 4th, and we've still got a long way to go. Only your support can help us go forward, every $1 helps!

We are also actively looking for people who would like to sponsor/be sponsored by us. If you are interested, get in touch by writing at

Interested in what's coming next?

  • Per-domain CSS (e.g. a Dark Mode)

  • Bluring the lines between a browser, a text editor and a file manager

  • A sandboxed REPL for online code snippets

  • Overpowered bookmarks

  • A widget library for third-party authors

  • Explorable features thanks to embedded documentation and live introspection

  • Minibuffer multiselection (or "delete fuzzy-matched buffers in one go", etc.)

  • Seamless integration with decentralized internet protocols such as IPFS, Dat and Zeronet

  • WebKitGTK sandboxing

  • Session persistence (or "reopen previously open buffers on restart")

  • Enhanced and configurable adblocking

  • Status bar

  • Third-party / User extension support

  • More programmable hooks for everything!

  • Improved macOS support

Thank you for reading, and thanks in advance for your support! ;)

]]> 2019-09-25T00:00:00+00:00
Next release 1.3.1 Atlas

Next release 1.3.1

We are happy to announce the release of Next version 1.3.1!

This version includes important bug fixes, an improved minibuffer experience, better support for various platforms (D-Bus should be handled properly), not forgetting that Next is back to the official Guix repository! (This should make it easier to install Next on any OS running a Linux kernel.)

A screenshot of the minibuffer with fuzzy-matching on the URLs and titles of the buffers:

On the community level, we've overhauled our article/blog page, with the aim of regularly publishing articles on our progress, along various Next hacks and configuration tips.

We've also added a news feed where you can follow us:


Rest of the change log

  • Print page title in buffer list.

    And the title is matched when fuzzy-searching a buffer!

  • Improved minibuffer performance: it now shows up instantly.

  • Open external links in new buffer by default.

    This can be configured by setting (open-external-link-in-new-window-p *interface*) to the desired boolean.

  • Return to last created buffer when deleting buffer.

    When killing the last created buffer, we were brought back to the first one, so usually the help buffer. This is now fixed, we stay at the previous last created buffer, as expected.

  • Minibuffer M-backspace improvements.
    • In the minibuffer, using M-backspace to delete a word didn't respect white spaces. It is fixed.
    • Its behaviour was also too different than other common tools, like Firefox. Now:
      • it deletes the trailing word delimiter;
      • it removes all trailing delimiters plus one word.
  • Add keypad bindings

  • Next is back to the Guix official channel

    The Next Guix channel can be safely removed from your ~/.config/guix/channels.scm before running a guix pull.

  • Mouse button2 (middle click) opens a URL in a new buffer/window.

  • Automatically fall back to a local D-Bus session if none can be used.

  • Fix platform port log file path on Guix.

    It is now properly set to ~/.local/share/next/next-gtk-webkit.log by default.

  • Fix ignored search engine prefix in minibuffer input.

  • Fix browsed URLs not being added to history.

    Yes, this is better for a daily usage :)

  • Fix crash when proxy-mode was added to the list of default modes.

    You can now add this to your ~/.config/next/init.lisp to open pages in proxy-mode by default:

    Thanks to @MasterCsquare.

  • More bug fixes (special thanks to Solomon Bloch, @goose121, Sean Farley, @glacambre).

  • Developer changes:

    • The Makefile automatically updates the Quicklisp distribution.

      Next uses its own installation path for the Quicklisp dependencies, it doesn't mesh with your existing ~/quicklisp/local-projects. Now you can follow git master without the surprise of a library missing a function.

    • Remove cl-string-match and cl-strings dependencies.

      Now we mostly rely on str and cl-ppcre.

What's next?

We have many new and exciting features in the pipeline that we should release shortly:

  • a password manager,
  • a kill ring,
  • the possibility to quickly open any file with fuzzy search,
  • new minibuffer improvements, such as multi-selection,
  • session persistence,
  • hooks (for modes, commands, startup, network events, etc.) allowing per-domain customization.

Thanks for reading!

About Next

Next is a keyboard-oriented, extensible web-browser designed for power users. The application has familiar key-bindings ( Emacs, VI), is fully configurable and extensible in Lisp, and has powerful features for productive professionals.

Download it here!

]]> 2019-09-19T00:00:00+00:00
Next release 1.3.2 Atlas

Next release 1.3.2

We are happy to announce the release of Next version 1.3.2!

This version includes several cool new features:

  • "Hooks" let you insert your own code before of after network events and commands, such as automatic download of Youtube videos or auto-switch to! To read more about hooks, see our updated article here:

  • A new open-file command. This allows you to open up any file locally on your machine.

  • A paste-from-ring command that allows you to fuzzy-search and paste from the clipboard ring of all previously copied/pasted text.

Last month we started a crowdfunding campaign, so if you like what we are doing feel free to support us by chipping in!

Thanks for reading and supporting us! You can read the full change log here.

What's next?

We have many new and exciting features in the pipeline that we could release shortly!

  • A high quality macOS port, with complete GTK parity(!), for improved performance, distribution, and stability. This means a single app bundle that you can simply download and run.

  • Minibuffer multi-selection (or "delete fuzzy-matched buffers in one go", etc.).

  • Session persistence (or "reopen previously open buffers up restart").

  • Status bar.

  • WebKitGTK native sandboxing.

  • Per-domain CSS (e.g. a Dark Mode).

  • Smart searching across all tabs.

  • Jump to heading all tabs.

  • Package manager.

  • Add support for per-tab proxy and Tor support.

  • Add an integrated password manager.

  • Add built-in editor.

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

  • Switch from SQLite to a text based format, allowing bookmarks to be viewed and synced more easily with any external tool.

Thanks for reading!

About Next

Next is a keyboard-oriented, extensible web-browser designed for power users. The application has familiar key-bindings ( Emacs, VI), is fully configurable and extensible in Lisp, and has powerful features for productive professionals.

Download it here!

]]> 2019-09-19T00:00:00+00:00
Emacs Hacks Atlas

Emacs Hacks

Next interfaces

Next can be controlled from an external program via SWANK. For instance, Emacs with SLIME makes it possible to hack Next while it's running.

But what about the other way around? Can we use Next to manipulate other programs? Sure we can! Next is a full-blown Common Lisp program that can leverage all of Common Lisp power to interact with foreign programs via Unix sockets, XML-RPC, you name it.

An interesting example is that of Emacs, since it can be hacked live with Elisp, a language very similar to Common Lisp. In the following article, Next will generate Elisp code to hack Emacs live!

Youtube-dl with Emacs

Youtube-dl is a great program for downloading audio and video files from a ridiculous number of websites.

That said, we would like to make it more convenient than constantly copy-pasting to a shell. Besides, naively calling youtube-dl from Next is not so convenient since we lack feedback or interactivity with the running subprocess.

We could derive our own Youtube-dl extension for Next so that we would have a buffer showing progress of multiple downloads and allowing for interactivity. However, until someone works on the extension, let's see what others have been doing so far.

Chris Wellon wrote a great Emacs extension, which sadly, only works for Youtube. This won't stop us! Here is our poor man's universal interface to Youtube-dl to supplement the aforementioned extension:

The above snippet opens a dedicated *youtube-dl* Eshell buffer so that we can track download progress from there, as well as stack multiple video downloads.

With that set up, now we can add the following snippet to our next/init.lisp:

We define a helper function eval-in-emacs which sends a bunch of formatted s-expressions to Emacs. This requires the Emacs daemon, either by starting Emacs with emacs --daemon or by running M-x server-start from an Emacs instance.

The youtube-dl-current-page command tests whether the current URL is Youtube, in which case we use Chris Wellons' youtube-dl extension, or else we rely on the Eshell version we wrote in our Emacs config.

Org-mode and Org-capture

Org-mode is a great extension for Emacs for note taking (and so much more). It has a feature called "org-capture" which, on a key press, will store some contextual information to your agenda, so that later Org will remind you to refer to it again.

This can be useful for a web browser: You'd like to mark this page and let Org remind you to read it later? Nothing easier! And off we go to add the following snippet to our Emacs init file:

The above snippet does quite a few things, so let's analyze it carefully:

  • The first "w" is the key binding to insert a web link when Org mode asks which capture to perform. You can add several capture templates with different key bindings to perform different actions.

  • (file+headline ,(car org-agenda-files) "Links") tells Org where to insert to result. Here we chose the "Links" headline in our first agenda file.

  • %a is the Org URL of the page we are going to pass from Next.

  • The rest is arbitrary. Here we schedule the reading to the day after ( +1d in the time-stamp).

See org-capture-templates documentation for more details.

Now to our next/init.lisp:

This is similar to the example in the previous section. Note that we are passing multiple s-expressions to Emacs, they will all be wrapped into a single (progn ...) and Emacs will evaluate everything in one go.

Happy hacking!

]]> 2018-12-16T00:00:00+00:00
Technical Design Atlas

Technical Design

Requirements of a browser

A web browser is made of a few major components:

  • A graphical user interface (GUI), written in, say Cocoa or GTK.
  • A renderer (e.g. Gecko or WebKit).
  • A controller (the glue code, which includes user configuration and interaction).

The current landscape of browsers

The graphical user interface can be a prominent part of the experience for browsers targeting a larger audience like Firefox or Safari. On the contrary, browsers targeting power-users tend to make minimal use of the toolkit, leaving most of the screen real-estate to the renderer.

A renderer can be extremely difficult to write, so most browsers end up reusing an existing one, mostly without change. WebKit knows some success among power-user browsers.

Last but not least, the controllers are mostly divided into two groups that correlate those of the graphical user interfaces: when predominantly "user-friendly", the controller will often be an obscure, unhackable blackbox; when targeting power users, it will often be configurable with INI-style config files, or sometimes even an interpreted language such as Python or Lua.

The poor state of language bindings for GUI toolkits

Initially, Next was 100% written in Common Lisp, which means that the GUI toolkit had to be driven by language bindings.

Indeed, the most common GUI toolkits are written in C or a variant of C, and as such if we want to use a different language, we need some form of translation between our language and the library language. Those language bindings can be tedious and difficult to write. For the ones that are developed to the point of being stable enough to be useful, they might not fully cover the library nonetheless, which means that some important features will be missing.

Common Lisp has a rather complete Cocoa-binding library, but it mostly works with Clozure CL and not so well with other Common Lisp compilers.

Sadly, the GTK bindings are not in a shape that is enough to fulfill our needs. We've tried to get Next running with CL-CFFI-GTK on GNU/Linux for many months, to no avail.

It turns out that this is not an isolated issue. Because of the complexity of GUI toolkits and how challenging it is to write bindings for various languages, there might not be a single language out there in which we can program complex graphical user interfaces that works well enough on all platforms.

Split-process design: A cure for portable interfaces

Next is all about the controller. Its selling point is to be infinitely extensible, so we really needed to write it in Lisp.

The GUI toolkit and the renderer are only secondary. If we can't get all three components to work together in Lisp, then couldn't we just get the GUI and the renderer to work in a separate piece of software written in their native language?

Then we would have only one thing left: the controller, manipulating the GUI and the renderer via some RPC protocols. This way, we would get both the GUI and the renderer out of the way and solve both the language and the portability issue once and for all.

Choosing an RPC protocol

We chose XML-RPC, mostly because we had to choose one of the many options. XML-RPC is simple, wildly supported, old and stable.

It operates very simply: the server registers a set of callbacks to execute when receiving a method name. The client sends an HTTP request whose body is a simple XML document with just two entries: the method name and its parameters, if any.

While XML is more verbose (and arguably uglier) than JSON, it does not matter much because even from a developer's perspective we never get to look at the XML part. It's all handled by the XML-RPC clients and servers.

XML-RPC can be used over HTTP sockets, and this is what we do. This comes with a nice side effect: we don't even need to run the separate parts on the same machine, they can be connected remotely over the Internet!

Implementation: The platform port and the Lisp core

We've implemented two processes:

  • The Lisp core which is a regular Common Lisp application firing up an XML-RPC server on startup.

  • The "platform port", which does three things:

    • all the GUI parts,
    • all the web rendering,
    • and it also fires up its own XML-RPC server which responds to a set of specific requests.

The Lisp core and the platform port are both XML-RPC clients and servers, because they both independently need to send messages to the other party.

For instance, whenever the user presses a key, say C-l, it is intercepted by the GUI toolkit and sent over to the Lisp core. From there, the Lisp core checks whether it knows the binding or not. If not, it sends a response to the GUI telling it to forward the binding the other handlers in the application (a key like space would then scroll the page in the web view). If the binding is recognized, then the Lisp core calls the associated function, which in turn might send a new message to the GUI (in the case of C-l, it would tell the GUI to open the minibuffer).

The platform port is very minimalist, it only needs to know how to perform a few simple tasks such as making a new window, instantiating rendering views and, importantly, evaluate JavaScript. Thanks to this last feature, it is possible to query arbitrary information from a web page (e.g. its title), manipulate it (e.g. add link hints), but also generate user interface elements, such as a prompt with completion, a status bar, etc.

Since the Lisp core can generate JavaScript (with a Lisp syntax thanks to Parenscript) and parse the result, possibilities become endless for the Lisp core, without even having to add features to the platform port.

Indeed, once a platform port has been made to work, there is no more need to touch its code base. All future development can happen on the Lisp side!

Benefits of a split-process design

High-level browser library

In the end, the platform port is just a graphical user interface and some web rendering queries grouped together. That's it. For less than 1000 lines of C or Objective-C code, we have a fully working browser interface.

Which means that from a programmer's point of view, this is possibly the simplest working example of a fully-functional web browser interface with a clear, minimal list of all the features required by the controller.

Native look & feel

A nice consequence of the separation between the platform port and the controller is that it allows us to provides excellent user experience on any possible platform.

Multiple renderer support

Another cool side effect of this approach and that it is by design very natural to add support for extra web renderers.

For the initial release, we've opted for WebKit for a few reasons:

  • It's easy enough to embed into a project, possibly more than Gecko or Blink.

  • It works well on all platforms and has both Cocoa and GTK support.

  • In 2018, it's a call against the pressing monopoly of Blink. We wouldn't be too happy, would Internet ever become driven by a unique renderer whose development is not particularly community-oriented, while being subject to some arbitrary corporate policies.

Robustness and security

Because the platform port is so minimal, it is much easier to maintain and to fix bugs.

The security-sensitive part, i.e. the renderer, is contained into a relatively simple executable. It's possible to start this executable within a container, so that security issues with the renderer (or, who knows, with the GUI toolkit) won't ever reach beyond the boundaries of the RPC calls.

Resistance to web renderer API breakages

Last but not least, our design means that the web renderer is no longer a critical dependency.

Many times in the past, it happened that a web renderer API would break the backward compatibility, thus breaking all web browsers depending on it in the process.

When WebKit 2.0 came out, many WebKit-1-based browsers became obsolete. Rewriting them was so much work that many of them were simply abandoned.

More recently, it happened again with Firefox' extensions when XUL was dropped. Not only the extensions, but also Conkeror, which was a full-fledged browser written in XUL and became obsolete from one day to the next.

With our split-process design, should a web renderer break, we would only have to update or rewrite a platform port. Thus we get the guarantee that the Lisp core and all the community-written extensions will never break.

]]> 2018-12-04T00:00:00+00:00
The Next Thesis Atlas

The Next Thesis

Why should I care? Who is Next for?

  • Have you ever felt frustrated looking for a tab?
  • Have you ever been annoyed at the default, unchangable behavior of your browser?
  • Have you ever felt that your work-flows could greatly benefit from some simple keyboard macros or automation?
  • Do all web browsers feel the same?
  • Are you interested in optimizing and being more efficient?

If any of the above resonates with you, you should know that it doesn't have to be this way. We believe that you should be able to:

  1. Find the information you need, and find it quickly.
  2. Work efficiently, focus on the task at hand instead of navigating some dumbed-down point and click UI.
  3. Adjust every single detail and nuance of your web browser to suit your work-flow.
  4. Have unlimited power over your environment.

What is Next? What is the solution?

Next is a new type of web browser that gives the user full control over its behavior. Literally any part of Next is reprogrammable. You can fire up a compiled version of Next, drop into a REPL, and immediately begin hacking and changing the behavior of your browser.

Out of the box Next ships with extensions that are designed to make you faster at navigating the Internet. For instance, consider a task that you do hundreds of times per day- switching tabs. In a normal browser, you have to go through your tabs one by one until you find what you need. In Next, simply type a fuzzy search string describing the tab you are looking for, and Next will let you jump to it instantly.

All the source code for Next is available to you under a BSD-3 clause license. Do with it whatever you want, inspect it, modify it, and make Next your own.

What is the mission of Next?

The mission of Next is to enable people to be as productive as possible. We don't place barriers upon the users of Next. We allow people to get stuff done, their way.

Next is about freedom. You should have the freedom to modify and change the tool you use to adapt to your particular needs, to enable yourself to be more productive.

Modern day scientists, engineers, philosophers, artists, and others spend increasingly more time on the Internet. Current tools hinder access to Internet-based resources. Next, instead of hindering, empowers. In turn, this hopefully makes the world a better place.

What's the problem with current browsers?

The problem with current browsers is that they are engaged in what is known as the browser war. The browser war is one of focusing entirely on performance, and attaining the largest user base possible.

How to get a large user base? Make a product that is as simple as possible. That is why major browsers today are constraind in their UI designs by paradigms invented by Netscape and Internet Explorer in the late 90s.

Why do browsers care about market share?

Market share is power. If Chrome unilaterally decided to implement a new standard, other, smaller browsers would be forced to follow suite. Otherwise, their users would get messages such as "Sorry, this website doesn't support your browser, please download Chrome".

Furthermore, the business models of browsers, particularly Chrome, is centered around gathering and selling your data. That is why they want as many users as possible. They don't care about you, they just want your data to sell to advertisers.

How can I participate?

You can try Next now by visiting the download page linked above! We hope you enjoy it and you'll join us on our mission! Thanks for reading :)

]]> 2018-12-04T00:00:00+00:00
Command Line Programs Atlas

Command Line Programs

Running Programs in Next

Next gives you the power to extend its capabilities by invoking other programs. This allows you to chain Lisp functions and operations with any programs of your choosing.

A Practical Example: Download Youtube Videos

Let's consider the following situation: you are watching a Youtube video, but wait! You have somewhere to be! Why not download the video so you can watch it on the train where your internet access will be limited? Sounds good right? Let's see what options there are.

A quick search on the internet reveals a very convenient program called youtube-dl. Youtube-dl is invoked via the command line like this: youtube-dl "url-to-download". Of course there are other flags and arguments, but let's consider the simplest case.

You could simply copy the URL and paste it into the terminal. That's not really cool though. Let's automate it:

Just like that! Instant Youtube downloader script. If you want, bind it to a keybinding:

Now whenever you want to download a Youtube video simply "C-c d" and you'll have it on your computer!

"Shell" Mode

That was cool, but it doesn't really show the true power of Next. An example that is more illustrative is a very basic "shell" implementation. It is not really a shell because it doesn't have variables, piping, or anything else a shell really has, but it can run programs.

Simply put: shell mode is an extension for running simple one-liner shell commands and seeing the output. There is no history or variables. Use C-x s to enter *shell-mode* and c to enter a command and k to clear the command output.

Within 40 lines of Lisp we've managed to make a completely new mode that allows us to execute commands, view the output on screen, and even clear the screen.

The Take Away

Next can be extended with any program of any type as long as it accepts some form of IPC. This means that you can chain any process you want on your computer. Of course, this application has bounds of reason, you shouldn't imagine that Next will turn into your system shell, process manager- even though it could.

Thanks for reading!

]]> 2018-10-19T00:00:00+00:00
Hooks Atlas


Using Hooks to Smart Program Your Browser

Hooks are a great way to extend a workflow by triggering actions upon events. Simply put, a hook is a variable that holds a list of functions, which are called at a precisely defined point in the program.

In the world of a web browser, there are a ton of events: page loaded, DOM available, page rendered, etc. In addition to the events fired off by normal processing of web pages there are a large set of events which include actions by the user: tab deleted, page bookmarked, command called, etc.

All these are not normally hookable, but in Next, they are.

Hooking into the events fired off by the browser or by the user allows the creation of extendable and optimized workflows.

The Next Hook System

Many hooks are as such executed at different points in Next:

  • global hooks, such as the load-hook hook, which is run after the URL to be visited was parsed, but not yet loaded,
  • window and buffer related hooks (before and after creation, before and after the page is loaded, etc),
  • modes hooks (before and after a mode is enabled or disabled),
  • "before" and "after" command hooks.

For the full list, see the manual.

Practical examples

So what can we do with hooks?

If you want to force the redirection of a domain to another, you can use the load-hook, change the url and return a new one. In the example below, we make sure we always visit instead of the new interface:

You can ask Next to automatically enable or disable modes depending on the URL, for instance, you can toggle the proxy mode per domain, which can be very convenient if you would like to, say, disable Tor for some resource intensive domains:

Another cool example would be automatically downloading any YouTube video we see:

Adjust it to your taste!

All user commands have hooks

One feature that makes Next unique is the ability to extend commands exposed to the user.

Because the Common Lisp language allows it, one could replace a command definition by another function. This is however not the recommended approach, most notably because it could break the built-in behavior.

We can then use the before and after hooks to extend the built-in commands. It is as simple as defining a new function with no parameters:

and adding it to the list of hooks:

and voila!


Hooks can be a great way to extend your browser. There are of course downsides to hooks. For example, consider a hooked function that gets its input from the execution of another hooked function, how do we ensure that they execute in the correct order?

In summary, hooks present a very simple and effective mechanism to chain behavior in your workflows. We are looking forward to seeing what you can create with them!

Thanks for reading!

]]> 2018-10-19T00:00:00+00:00