Skip to content
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
243 lines (187 sloc) 8.77 KB

Next Developer Readme

Developer Installation with Guix

Install Guix and follow the instructions in ../build-scripts/guix.scm.

Generic Developer Installation

Next is written in Common Lisp. It can be built with any standard Common Lisp implementation. Currently, only SBCL support is tested.

It is designed to be cross-platform, cross-engine compatible. Next is available in both WebKit and WebEngine flavors. Support for graphics and OS integration is provided via:

  • macOS: Qt
  • GNU/Linux: Qt or GTK

Installing SBCL

You can obtain SBCL from your package manager or by downloading it directly from the SBCL repository.

To install SBCL from source, Download SBCL:, full installation instructions can be found here:

Installing Quicklisp (optional)

Quicklisp is downloaded and installed automatically by the Makefile. If you wish to install it manually, system-wide, the official Quicklisp website can provide updated links to downloads, and instructions:

To install Quicklisp:

  • Download
  • Execute lisp --load quicklisp.lisp to load Quicklisp.
  • Evaluate in the REPL (quicklisp-quickstart:install) to install.
  • Evaluate in the REPL (ql:add-to-init-file) to add Quicklisp to your Lisp init file.

GNU/Linux specific dependencies

  • WebKitGTK+ also known as webkit2gtk (make sure to use the most recent version for security reasons – Debian Stable won’t do)
  • SQLite
  • glib-networking (for WebKitGTK+)
  • gsettings-desktop-schemas (for WebKitGTK+)
  • libfixposix
  • gstreamer, gst-plugins-* (for HTML audio/video)
  • xclip (for clipboard support)

If your distribution does not install libraries in a FHS-expected location, you have to let know your Lisp compiler where to find them. To do so, add the library directories to cffi:*foreign-library-directories* list. For instance, if you are running Guix you may want to expose ~/.guix-profile/lib to the compiler by adding the following snippet to ~/.sbclrc:

(require "asdf")

(let ((guix-profile (format nil "~a/.guix-profile/lib/" (uiop:getenv "HOME"))))
  (when (and (probe-file guix-profile)
             (ignore-errors (asdf:load-system "cffi")))
    (push guix-profile
          (symbol-value (find-symbol (string '*foreign-library-directories*)
                                     (find-package 'cffi))))))

Install the WebKitGTK+ package of your distribution that provides (the shared library for WebKitGTK+).

  • For most Debian-based systems (including Ubuntu) this package is libwebkit2gtk-4.0-dev. Debian Stable is not supported. Debian users are advised to use more up-to-date packages from Debian Testing at least.
  • For Arch Linux this package is webkit2gtk.

A note of caution about installing WebKit via your package manager: Your distribution supplied version of WebKit may not provide up-to-date versions of WebKit including the latest security patches. WebKitGTK+ tries to do the best job possible with maintaining security patches upstream, but it is also additionally up to the the distribution provider to update their packages to take advantage of these fixes.

macOS specific dependencies

  • Qt
  • D-Bus
  • libfixposix
  • PyQt
  • Python 3.6
  • SQLite (available by default)


Next consists of two standalone executables: the Lisp core and the platform port. There are two ways to build Next depending on if you want to use Roswell.

Compile Image with a Lisp Implementation

The following command will build both Lisp core and the platform port. On macOS this will produce an application bundle which you can copy into your /Applications folder. Before you can run Next on macOS, you may have to modify the #!/path/to/your/python/installation at the top of

  • GNU/Linux:
make all
  • macOS:
make all

Inside the Makefile you’ll find many options you can specify. You can specify to use your Lisp’s init file, to use your global installation of Quicklisp, or to automatically download and install a separate Quicklisp installation for Next. Run make to display some documentation. Please see the Makefile for more details.

Compile with Roswell

Roswell can be used to build the Lisp core. This method uses the existing systems installed on your system.

A Roswell script is provided under the ./build-scripts/. You have to make sure that this project can be found by Roswell (Quicklisp). You may create a symbolic link of this project in the ~/.roswell/local-projects/ directory to do so.

In order to compile the Lisp core, simply run:

ros build build-scripts/next.ros

An executable file named ./build-scripts/next will be generated under the project root.

Afterwards, you need to build the platform port:

make install-gtk-webkit

You may simply type make to display documentation.

Please refer to the next section to make the two parts work together.


The compilation must have produced two executables:

  • next in the root folder.
  • A platform port executable in the appropriate ports/ subfolder.

For next to work, it must find the platform port. There are a few options:

  • Either specify the path in your Next config file (~/.config/next/init.lisp):
    (in-package :next)
    ;; Use development platform port.
    (setf (get-default 'port 'path)
          (format nil "~a/common-lisp/next/ports/gtk-webkit/next-gtk-webkit"
                  (uiop:getenv "HOME")))
    ;; ...
  • Or add the appropriate platform-port folder (e.g. the GTK or Qt platform-port application) to your $PATH. For instance you can add
    export PATH=$PATH:/path/to/next/ports/gtk-webkit

    to your user initialization file.

  • Or install the platform-port executable into an well known $PATH folder, for instance /usr/local/bin.

Now go ahead and start path/to/next/next!

Run from Source

If you are developing Next, you might prefer to run Next directly from source so that you can skip the compilation step and iterate faster.

First, make sure the platform port is properly installed as explained in the previous section.

Second, make sure that Quicklisp is set up as explained in the Quicklisp section.

Then in a shell execute the following:

  1. $LISP to create a new Lisp REPL (replace $LISP with sbcl or any supported Common Lisp compiler).
  2. Execute (ql:quickload "trivial-features").
  3. Execute (require :asdf) if ASDF is not already loaded.
  4. Execute (asdf:load-asd "/full/path/to/next.asd") to load the Next system definition (you can not use relative pathnames).
  5. Execute (ql:quickload :next) to load the Next system into your Lisp image.
  6. Make sure the platform port can be bound by Next, as described in the previous section.
  7. Execute (next:start) to open your first Next window.

Update local Lisp libraries

When you need to update the local quicklisp libraries, located in the quicklisp/ directory of the next project, run the following:

make quicklisp-update

Help & Community

There are several ways to ask for help from the community. The first and easiest one is to simply open up an issue with whatever problem you have. Feel free to open issues for any task, suggestion or conversation you wish to have.


To contribute, please find a task within document that has a TASK label affixed. Upon finding a task that you’d like to work on, ideally, ensure that it is not already being worked on.

After you have found a TASK item that is available:

  • make a fork of the repository,
  • add your changes,
  • make a pull request.

IRC Channel

You can find Next on Freenode IRC at #next-browser.

You can’t perform that action at this time.