INTRODUCTION

Any program can only be really useful if it complies with the Unix philosophy. Web browsers (and other tools that work with HTML, such as feed readers) are frequent violators of this principle:

The Uzbl project was started as an attempt to resolve this.

EDITIONS

"Uzbl" is an umbrella project consisting of different flavors. In the future more things may come, but for now:

uzbl-core: main component meant for integration with other tools and scripts

uzbl-browser: a complete browser experience based on uzbl-core

uzbl-tabbed: wraps around uzbl-browser and multiplexes it

Throughout the documentation, when referring to uzbl we mean uzbl-core, unless otherwise specified.

CONFIGURATION / CONTROL:

The general idea is that Uzbl by default is very bare bones. You can send it commands to update settings and perform actions, through various interfaces. There is a limited default configuration. Please see config.h to see what it contains. By default, there are no keybinds defined at all. (Default keybinds would work counterproductive when you try to customize). For examples of the possibilities what you can do, please see the sample config(s), and uzbl wiki page.

There are several interfaces to interact with Uzbl:

When uzbl forks a new instance (eg "open in new window") it will use the same command line arguments (eg the same --config <file>), except --uri and --name. If you made changes to the configuration at runtime, these are not passed on to the child.

Uzbl-browser

Uzbl-tabbed

COMMAND SYNTAX

Uzbl will read commands via standard input, named FIFO pipe (if fifo_dir is set) and Unix socket (when socket_dir is set). For convenience, uzbl can also be instructed to read commands from a file on startup by using the --config option. Indeed, the config file is nothing more than a list of commands.

Each command starts with the name of a command or a uzbl variable that expands to it. A command is terminated by a newline. Empty lines and lines that start with the hash sign are ignored by the parser. Command names are always written in lowercase.

The following commands are recognized:

VARIABLES AND CONSTANTS

Uzbl has a lot of internal variables and constants. You can get the values (using the print command, see above), and for variables you can also change the value at runtime. Some of the values can be passed at start up through commandline arguments, others need to be set by using commands (eg in config file).

Variables

Constants (not dumpable or writeable)

VARIABLE EXPANSION AND COMMAND / JAVASCRIPT SUBSTITUTION

Variable expansion works pretty much as known from shell interpreters (sh, bash, etc.). This means you can construct strings with uzbl variables in them and have uzbl replace the variable name with its contents.

In order to let uzbl know what to expand you'll need to prepend @ to the variable name:

print The variable \@show_status contains @show_status

The above example demonstrates two things:

Command substitution will launch any commands and substitute the call with the return value of the command. There are two methods:

This method allows you to use POSIX shell syntax in your commands.

This example will execute uname directly.

Note that you can access any uzbl variable from within a command substitution:

print @(echo -n 'Accessing the show_status var from an external script, value: @show_status')@

JavaScript substitution works in the exact same way as command substitution but you will need to enclose the JavaScript in @< >@.

print The currently viewed document contains @<document.links.length>@ links

The @<>@ substitution can also load JavaScript from a file, syntax: @<+filename>@

print JS return value from file: @<+/path/to/file.js>@

Variable expansion also works within a JavaScript substitution.

When a piece of text needs to be XML escaped after it is expanded (for example, in the status bar format), you can use @[ ]@ substitution:

print This text is XML escaped: @[<&>]@

# prints: This text is XML escaped: &lt;&amp;&gt;

NOTE: If you need to use literal @ or \ characters you will need to escape them:

print At sign: \@  and backslash: \\

TITLE AND STATUS BAR EVALUATION

The contents of the status bar can be customized by setting the status_format variable. The contents of the window title can be customized by setting the title_format_short variable (which is used when the status bar is displayed) and the title_format_long variable (which is used when the status bar is not displayed). Their values can be set using the expansion and substitution techniques described above.

These variables are expanded in multiple stages; once when the variable is set, and again every time that the status bar or window title are updated. Expansions that should be evaluated on every update need to be escaped:

set title_format_short = @(date)@
# this expansion will be evaluated when the variable is set.
# the title will stay constant with the date that the variable was set.

set title_format_short = \@(date)\@
# this expansion will be evaluated when the window title is updated.
# the date in the title will change when you change pages, for example.

set title_format_short = \\\@(date)\\\@
# the title will stay constant as a literal "@(date)@"

The status_format variable can contain Pango markup . In the status_format, variables that might contain characters like <, & and >, should be wrapped in a @[ ]@ substitution so that they don't interfere with the status bar's markup; see the sample config for examples.

EXTERNAL SCRIPTS

You can use external scripts with Uzbl the following ways:

Have a look at the sample configs and scripts!

Handler scripts that are called by uzbl are passed the following arguments:

The script specific arguments are:

Custom, userdefined scripts (spawn foo bar) get first the arguments as specified in the config and then the above 7 are added at the end.

HTTP/BASIC AUTHENTICATION

You can use the authentication_handler variable to denote how http authentication should be handled. If this variable is:

Example:

set authenticationhandler = syncspawn /patch/to/your/script

Script will be executed on each authentication request. It will receive four auth-related parameters:

$8 authentication zone unique identifier (may be used as 'key')
$9 domain part of URL that requests authentication
$10 authentication realm
$11 FALSE if this is the first attempt to authenticate, TRUE otherwise

Script is expected to print exactly two lines of text on stdout (that means its output must contain exactly two '\n' bytes). The first line contains username, the second one - password. If authentication fails, script will be executed again (with $11 = TRUE). Non-interactive scripts should handle this case and do not try to authenticate again to avoid loops. If number of '\n' characters in scripts output does not equal 2, authentication will fail. That means 401 error will be displayed and uzbl won't try to authenticate anymore.

The simplest example of authentication handler script is:

!/bin/sh

[ "$11" == "TRUE ] && exit echo alice echo wonderland

This script tries to authenticate as user alice with password wonderland once and never retries authentication. See examples for more sofisticated, interactive authentication handler.

JAVASCRIPT HELPER OBJECT DISABLED BECAUSE OF SECURITY LEAK

JavaScript code run from uzbl is given a special object in the global namespace which gives special privileges to these scripts. This object is called Uzbl, and it is added and removed before and after the script execution so that it is hidden to web JavaScript code (there is no race condition, since all the JavaScript code runs in a single thread).

Currently, the Uzbl object provides only one function:

EVENTS

Unlike commands, events are not handled in uzbl itself, but are propagated (dispatched) asynchronously through a text stream on stdout and/or through a socket. You'll usually use uzbl by piping it's output to a so-called "event manager" (EM), or by having the EM listen to a socket.

The EM allows:

Note: Cookie events are not sent to an event handler but handled internally through the cookie handler because of their synchronous nature. Cookie events are really something completely different from all other events. Maybe someday we'll use HTTP proxies or synchronous events (which also have other nice use cases), but for now we still use the handler code.

Events have this format:

 EVENT [uzbl_instance_name] EVENT_NAME event_details

Reported events

Events/requests which the EM and its plugins listens for

COMMAND LINE ARGUMENTS

uzbl is invoked as

uzbl-(core|browser|tabbed) [ arguments ] [ uri ]

where arguments and uri are both optional. arguments can be:

uzbl-core scheme://address will work as you expect. If you don't provide the scheme:// part, it will check if the argument is an existing file in the filesystem, if it is, it will prepend file://, if not, it will prepend http://.

BUGS

Please report new issues to the Uzbl bugtracker.