Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
VIMB(1)				  Vimb Manual			       VIMB(1)

       Vimb  -	Vim Browser - A	modal web browser based	on WebKit, inspired by
       Vim: the	great editor.

       vimb [OPTIONS] [URI|file|-]

       Vimb is a WebKit	based web browser that	behaves	 like  the  Vimperator
       plugin  for Firefox and has usage paradigms from	the great editor, Vim.
       The goal	of Vimb	is to build a  completely  keyboard-driven,  efficient
       and pleasurable browsing-experience.

       If  no  URI  or file is given, Vimb will	open the configured home-page.
       If URI is '-', Vimb reads the HTML to display from stdin.

       Mandatory arguments to long options are	mandatory  for	short  options

       -C, --cmd CMD
	      Run  CMD	as  ex	command	 line  right  before the first page is
	      loaded.  If the flag is used more	than one  time,	 the  commands
	      are called in order they are given.  You could also pass several
	      ex commands in one CMD, if they are separated by "|".

	      vimb --cmd "set dark-mode=on|set header=Referer,DNT=1"

       -c, --config FILE
	      Use custom configuration given as	FILE.  This will also  be  ap-
	      plied on new spawned instances.

       -e, --embed WINID
	      WINID  of	an XEmbed-aware	application, that Vimb will use	as its

       -i, --incognito
	      Start an instance	with user data read-only (see FILES section).

       -h, --help
	      Show help	options.

       -p, --profile PROFILE-NAME
	      Create or	open specified configuration  profile.	 Configuration
	      data for the profile is stored in	a directory named PROFILE-NAME
	      under default directory for configuration	data.

       -v, --version
	      Print build and version information and then quit.

	      Do no attempt to maximize	window.

	      Prints information about used libraries for bug reports and then

       Vimb is modal and has the following main	modes:

       Normal Mode
	      The default mode.	 Pressing Escape always	enter normal mode.

       Input Mode
	      Used for editing text elements in	a webpage.

       Command Mode
	      Execute `ex` commands from the builtin inputbox (commandline).

       Pass-Through Mode
	      In  Pass-Through	mode  only the `<Esc>` and `<C-[>` keybindings
	      are interpreted by Vimb, all other keystrokes are	given  to  the
	      webview to handle	them.  This allows the use of a	website's con-
	      figured keybindings, that	might otherwise	be swallowed by	Vimb.

       Some of the Normal Model	Commands can have a numeric count to  multiply
       the  effect  of	the  command.  If a command supports the count this is
       shown as	[N].

       :      Start Command Mode and print `:' to the input box.

       gi     Set cursor to the	first editable element in the page and	switch
	      to Input Mode.

       CTRL-Z Switch Vimb into Pass-Through Mode.

       gf     Open  the	 configured editor (`editor-command') with the current
	      page's content.

       gF     Open the Web Inspector for the current page.

       CTRL-V Pass the next key	press directly to GTK.

       CTRL-Q Quit the browser if there	are no running downloads.

       o      Start Command Mode and print `:open ' to the input box.

       O      Start Command Mode and print `:open URI' to the input box.

       t      Start Command Mode and print `:tabopen ' to the input box.

       T      Start Command Mode and print `:tabopen URI' to the input box.

       gh     Open the configured home-page.

       gH     Open the configured home-page in a new window.

       u      Open the last closed page.

       U      Open the last closed page	in a new window.

       CTRL-P Open the oldest entry from the read it later queue in  the  cur-
	      rent browser window.

       ["x]p  Open  the	 URI  out of the register x or,	if not given, from the

       ["x]P  Open the URI out of the register x or, if	not  given,  from  the
	      clipboard	in a new window.

	      Go back N	steps in the browser history.

	      Go forward N steps in the	browser	history.

       [N]gu  Go to the	Nth descendent directory of the	current	opened URI.

       gU     Go to the	domain of the current opened page.

       r      Reload the website.

       R      Reload the website without using caches.

       CTRL-C Stop loading the current page.

	      Scroll N pages down.

	      Scroll N pages up.

	      Scroll N half pages down.

	      Scroll N half pages up.

       [N]gg  Scroll  to  the top of the current page.	Or if N	is given to N%
	      of the page.

       [N]G   Scroll to	the bottom of the current page.	 Or if N is  given  to
	      N% of the	page.

       0, ^   Scroll  to  the absolute left of the document.  Unlike in	Vim, 0
	      and ^ work exactly the same way.

       $      Scroll to	the absolute right of the document.

       [N]h   Scroll N steps to	the left of page.

       [N]l   Scroll N steps to	the right of page.

       [N]j   Scroll page N steps down.

       [N]k   Scroll page N steps up.

       m{a-z} Set a page mark {a-z} at the current position on the page.  Such
	      set marks	are only available on the current page;	if the page is
	      left, all	marks will be removed.

       '{a-z} Jump to the mark {a-z} on	the current page.

       ''     Jumps to the position before the latest jump, or where the  last
	      "m'" command was given.

       Hinting	in Vimb	is how you accomplish the tasks	that you would do with
       the mouse in common mouse-driven	browsers: open a URI, yank a URI, save
       a page and so on. When hinting is started, the relevant elements	on the
       page will be marked by labels generated	from  configured  `hint-keys'.
       Hints  can be selected by using <Tab>, <C-I> or <C-Tab>,	<C-O>, by typ-
       ing the chars of	the label, or filtering	the elements by	some text that
       is  part	 of  the hinted	element	(like URI, link	text, button label) or
       any combination of these	methods.  If <enter> is	pressed,  the  current
       active  hint  will  be  fired.  If only one possible hint remains, this
       will be fired automatically.

       Syntax: ;{mode}{hint}

       Start Hints mode.  Different elements depending on mode are highlighted
       and `numbered'.	Elements can be	selected either	by typing their	label,
       or by typing part of their text (hint) to narrow	down the result.  When
       an  element has been selected, it is automatically clicked or used (de-
       pending on mode)	and hint mode ends.

       The filtering of	hints by text splits the query at ' ' and use the sin-
       gle  parts as separate queries to filter	the hints.  This is useful for
       hints that have a lot of	filterable chars in common and many chars  are
       required	 to  make  a  distinct selection.  For example ';over tw' will
       easily select the second	hint out of {'very long	link text one',	 'very
       long link text two'}.

       The following keys have special meanings	in Hints modes:
       <CR>   Selects the first	highlighted element, or	the current focused.
       <Tab>  Moves the	focus to the next hint element.
	      Moves the	focus to the previous hint element.
       <Esc>, CTRL-C, CTRL-[
	      Exits Hints mode without selecting an element.

       Hint modes:
	      f	     Is	an alias for the ;o hint mode.
	      F	     Is	an alias for the ;t hint mode.
	      ;o     Open hint's location in the current window.
	      ;t     Open hint's location in a new window.
	      ;s     Saves  the	hint's destination under the configured	`down-
	      ;O     Generate an `:open' prompt	with hint's URI.
	      ;T     Generate an `:tabopen' prompt with	hint's URI.
	      ;e     Open the configured editor	 (`editor-command')  with  the
		     hinted  form element's content.  If the file in editor is
		     saved and the editor is closed, the file content will  be
		     put back in the form field.
	      ;i     Open hinted image in the current window.
	      ;I     Open hinted image in a new	window.
	      ;p     Push the hint's URI to the	end of the Read	It Later queue
		     like the `:qpush' command.	 This  is  only	 available  if
		     Vimb was compiled with the	QUEUE feature.
	      ;P     Push the hint's URI to the	beginning of the Read It Later
		     queue like	the `:qunshift'	command.  This is only	avail-
		     able if Vimb was compiled with the	QUEUE feature.
	      ;x     Hints like	;o, but	instead	of opening the hinted URI, the
		     `x-hint-command' is run in	Vimb.
	      ["x];y Yank hint's destination location into  primary  and  sec-
		     ondary clipboard and into the register x.
	      ["x];Y Yank  hint's  text	 description or	form text into primary
		     and secondary clipboard and into the register x.

       Syntax: g;{mode}{hint}
	      Start an extended	hints mode  and	 stay  there  until  <Esc>  is
	      pressed.	 Like  normal hinting, except that after a hint	is se-
	      lected, hints remain visible so that another one can be selected
	      with  the	same action as the first.  Note	that the extended hint
	      mode can only be combined	with the following hint	modes I	o p  P
	      s	t y Y.

	      Motions commands are like	those for normal mode except that CTRL
	      is used as modifier.  But	they can not be	used together  with  a

	      CTRL-F Scroll one	page down.
	      CTRL-B Scroll one	page up.
	      CTRL-D Scroll half page down.
	      CTRL-U Scroll half page up.
	      CTRL-J Scroll one	step down.
	      CTRL-K Scroll one	step up.

       /QUERY, ?QUERY
	      Start  searching	for QUERY in the current page.	/ start	search
	      forward, ? in backward direction.

       *, #   Start searching for the current selected text, or	if no text  is
	      selected	for the	content	of the primary or secondary clipboard.
	      *	start the search in forward direction and # in backward	direc-

	      Note  that  these	commands will yank the text selection into the
	      clipboard	and may	remove other content from there!

       [N]n   Search for Nnth next search result depending on  current	search

       [N]N   Search  for  Nnth	 previous  search  result depending on current

       <CR>   Perform a	click on element containing  the  current  highlighted
	      search result.  direction.

       [N]zi  Zoom-In the text of the page by N	steps.

       [N]zo  Zoom-Out the text	of the page by N steps.

       [N]zI  Full-Content Zoom-In the page by N steps.

       [N]zO  Full-Content Zoom-Out the	page by	N steps.

       zz     Reset Zoom.

       ["x]y  Yank the URI or current page into	register x and clipboard.

       ["x]Y  Yank the current selection into register x and clipboard.

       Commands	 that  are  listed below are ex-commands like in Vim, that are
       typed into the inputbox (the command line of vimb).  The	 commands  may
       vary  in	 their	syntax or in the parts they allow, but in general they
       follow a	simple syntax.

       Syntax: :[:| ][N]cmd[name][!][ lhs][ rhs]

       Where lhs (left hand side) must not contain any unescaped  space.   The
       syntax of the rhs (right	hand side) if this is available	depends	on the
       command.	 At the	moment the count parts [N] of commands is parsed,  but
       currently there is no command that uses the count.

       Commands	that are typed interactivly are	normally recorded into command
       history and register.  To avoid this, the commands can be  prefixed  by
       one or more additional `:' or whitespace.

       Multiple	 commands, separated by	a `|' can be given in a	single command
       line and	will be	executed consecutively.	 The pipe can be  included  as
       an argument to a	command	by escaping it with a backslash.
       Following  commands  process  the entire	command-line string literally.
       These commands will include any `|' as part of  their  argument	string
       and so can not be followed by another command.

       - autocmd
       - cmap, cnoremap, imap, inoremap, nmap, nnoremap
       - eval
       - normal
       - open, tabopen
       - shellcmd

   Command Line	Editing
       <Esc>, CTRL-[, CTRL-C
	      Ignore all typed content and switch back to normal mode.

       <CR>   Submit the entered `ex` command or search	query to run it.

       CTRL-H Deletes the char before the cursor.

       CTRL-W Deletes the last word before the cursor.

       CTRL-U Remove everything	between	cursor and prompt.

       CTRL-B Moves the	cursor directly	behind the prompt `:'.

       CTRL-E Moves the	cursor after the prompt	in inputbox.

       CTRL-V Pass the next key	press directly to GTK.

       CTRL-R {a-z"%:/;}
	      Insert  the  content  of given register at cursor	position.  See
	      also section about `:reg[ister]' command.

   Command Line	History
       <Tab>  Start completion of the content in the inputbox in  forward  di-

	      Start  completion	of the content in the inputbox in backward di-

       <Up>   Step backward in the command history.

       <Down> Step forward in the command history.  Yank the current selection
	      into register x and clipboard.

       :o[pen] [URI]
	      Open  the	 give URI in the current window.  If URI is empty, the
	      configured 'home-page' is	opened.

       :t[abopen] [URI]
	      Open the give URI	in a new window.  If URI is empty, the config-
	      ured 'home-page' is opened.

   Key Mapping
       Key mappings allow users	to alter the actions of	key presses.  Each key
       mapping is associated with a mode and only has effect when the mode  is
       active.	 The  following	 commands allow	the user to substitute one se-
       quence of key presses by	another.

       Syntax: :{m}map {lhs} {rhs}

       Note that the lhs ends with the first found space.  If you want to  use
       space  also  in the {lhs} you have to escape this with a	single `\', as
       shown in	the examples.

       The rhs starts with the first non-space char. If	you want  a  rhs  that
       starts with a space, you	have to	use "<Space>".

       Standard	key mapping commands are provided for these modes m:
       n      Normal mode: when	browsing normally.
       i      Insert mode: when	interacting with text fields on	a website.
       c      Command Line mode: when typing into Vimb's command line.

       Most keys in key	sequences are represented simply by the	character that
       you see on the screen when you type them.   However,  as	 a  number  of
       these  characters  have	special	meanings, and a	number of keys have no
       visual representation, a	special	notation is required.

       As special key names have the format _..._.  The	following special keys
       can  be used: <Left>, <Up>, <Right>, <Down> for the cursor keys,	<Tab>,
       <Esc>, <CR>, <Space>, <BS>, <F1>-<F12> and <C-A>-<C-Z>.

       :nm[ap] {lhs} {rhs}
       :im[ap] {lhs} {rhs}
       :cm[ap] {lhs} {rhs}
	      Map the key sequence lhs to rhs for the modes where the map com-
	      mand  applies.   The  result,  including	rhs,  is  then further
	      scanned for mappings.  This allows for nested and	recursive  use
	      of mappings.

	      :cmap <C-G>h /home/user/downloads/
		     Adds  a keybind to	insert a file path into	the input box.
		     This could	be useful for the `:save' command  that	 could
		     be	used as	":save ^Gh".
	      :nmap <F1> :set scripts=on<CR>:open !glib<Tab><CR>
		     This  will	enable scripts and lookup the first bookmarked
		     URI with the tag `glib' and open it immediately if	F1 key
		     is	pressed.
	      :nmap \ \	 50G
		     Example which maps	two spaces to go to 50%	of the page.
       :nn[oremap] {lhs} {rhs}
       :ino[remap] {lhs} {rhs}
       :cno[remap] {lhs} {rhs}
	      Map  the key sequence lhs	to rhs for the mode where the map com-
	      mand applies.  Disallow mapping of rhs, to avoid nested and  re-
	      cursive mappings.	 Often used to redefine	a command.
       :nu[nmap] {lhs}
       :iu[nmap] {lhs}
       :cu[nmap] {lhs}
	      Remove the mapping of lhs	for the	applicable mode.

       :bma [tags]
	      Save the current opened URI with tags to the bookmark file.

       :bmr [URI]
	      Removes  all  bookmarks for given	URI or,	if not given, the cur-
	      rent opened page.

       Handlers	allow specifying external scripts to  handle  alternative  URI

       :handler-add handler=cmd
	      Adds a handler to	direct handler links to	the external cmd.  The
	      cmd can contain one placeholder `%s` that	will be	filled by  the
	      full URI given when the command is called.

	      :handler-add mailto=urxvt	-e mutt	%s
		     to	start email client for mailto links.
	      :handler-add magnet=xdg-open %s
		     to	open magnet links with xdg-open.
	      :handler-add ftp=urxvt -e	wget %s	-P ~/ftp-downloads
		     to	handle ftp downloads via wget.

       :handler-remove handler
	      Remove the handler for the given URI handler.

       Shortcuts  allow	 the  opening of an URI	built up from a	named template
       with additional parameters.  If a shortcut named	'dd' is	 defined,  you
       can  use	 it  with  `:open dd list of parameters' to open the generated

       Shortcuts are convenient	to use with search engines where  the  URI  is
       standardised and	a single parameter is user defined.

       :shortcut-add shortcut=URI
	      Adds a shortcut with the shortcut	and URI	template.  The URI can
	      contain multiple placeholders $0-$9 that will be filled  by  the
	      parameters  given	 when  the shortcut is called.	The parameters
	      given when the shortcut is called	will be	split into as many pa-
	      rameters like the	highest	used placeholder.

	      To  use  spaces  within  the  parameters,	 the parameters	can be
	      grouped by surrounding  them  with  single-or  double  quotes-as
	      shown in example shortcut	`map'.

	      :shortcut-add dl=$0
		     to	 setup a search	engine.	 Can be	called by `:open dl my
		     search phrase'.
	      :shortcut-add gh=$0/$1
		     to	build URIs  from  given	 parameters.   Can  be	called
		     `:open gh fanglingsu vimb'.
	      :shortcut-add map=$0&daddr=$1
		     to	search for a route, all	but the	last parameter must be
		     quoted if they contain spaces like	`:open map "city hall,
		     London" railway station, London'

       :shortcut-remove	shortcut
	      Remove the search	engine to the given shortcut.

       :shortcut-default shortcut
	      Set  the shortcut	for given shortcut as the default, that	is the
	      shortcut to be used if no	shortcut is given and  the  string  to
	      open is not an URI. It doesn't matter if the shortcut is already
	      in use or	not to be able to set it.

       :se[t] var=value
	      Set configuration	values named by	var.  To set boolean  variable
	      you  should  use	'on', 'off' or 'true' and 'false'.  Colors are
	      given as hexadecimal value like '#f57700'. Spaces	or more	equals
	      signs  in	 value	just  work  without quotes: for	example, ":set
	      sans-serif-font=Some Sans	Font".

       :se[t] var+=value
	      Add the value to a number	option,	 or  append  the  value	 to  a
	      string  option.	When  the  option is a comma separated list, a
	      comma is added, unless the value was empty.

       :se[t] var^=value
	      Multiply the value to a number option, or	prepend	the value to a
	      string  option.	When  the  option is a comma separated list, a
	      comma is added, unless the value was empty.

       :se[t] var-=value
	      Subtract the value from a	number option,	or  remove  the	 value
	      from  a  string  option,	if  it is there.  When the option is a
	      comma separated list, a comma is deleted,	unless the option  be-
	      comes empty.

       :se[t] var?
	      Show the current set value of variable.  VAR.

       :se[t] var!
	      Toggle the value of boolean variable var and display the new set

       The queue allows	the marking of URIs for	later reading.	This  list  is
       shared between the single instances of Vimb.

       :qpu[sh]	[URI]
	      Push  URI	 or,  if  not given, the current URI to	the end	of the

       :qun[shift] [URI]
	      Push URI or, if not given, the current URI to the	 beginning  of
	      the queue.

	      Open  the	 oldest	 queue entry in	the current browser window and
	      remove it	from the queue.

	      Removes all entries from queue.

   Automatic commands
       An autocommand is a command that	is executed automatically in  response
       to  some	event, such as a URI being opened.  Autocommands are very pow-
       erful.  Use them	with care and they will	help  you  avoid  typing  many

       Autocommands are	built with following properties.

       group  When  the	 [group]  argument is not given, Vimb uses the current
	      group as defined with ':augroup',	otherwise, Vimb	uses the group
	      defined  with  [group].	Groups	are  useful to remove multiple
	      grouped autocommands.

       event  You can specify a	comma separated	list of	event names.  No white
	      space can	be used	in this	list.

		     Fired  before  a new page is going	to be opened.  No data
		     has been sent or received yet, the	load  may  still  fail
		     for transport issues.
		     Fired  if	a new page is going to be opened.  No data has
		     been received yet,	the load may still fail	for  transport
		     Fired  if	first data chunk has arrived, meaning that the
		     necessary transport requirements are established, and the
		     load is being performed.  This is the right event to tog-
		     gle content related setting like 'scripts', 'plugins' and
		     such things.
		     Fires when	everything that	was required to	display	on the
		     page has been loaded.
		     Fired right after a download is started.
		     Fired if a	Vimb managed download is finished.
		     Fired if a	Vimb managed download failed.

       pat    Comma separated list of patterns,	matches	in order to check if a
	      autocommand  applies  to the URI associated to an	event.	To use
	      ',' within the single patterns this must be escaped as '\,'.

	      *	     Matches any sequence of characters.  This	includes  also
		     '/' in contrast to	shell patterns.
	      ?	     Matches any single	character except of '/'.
		     Matches 'one' or 'two'.  Any '{', ',' and '}' within this
		     pattern must be escaped by	a '\'.	'*' and	 '?'  have  no
		     special meaning within the	curly braces.
	      \	     Use backslash to escape the special meaning of '?*{},' in
		     the pattern or pattern list.

       cmd    Any `ex` command vimb understands.  The leading ':' is  not  re-
	      quired.  Multiple	commands can be	separated by '|'.

       :au[tocmd] [group] {event} {pat}	{cmd}
	      Add cmd to the list of commands that Vimb	will execute automati-
	      cally on event for a URI matching	 pat  autocmd-patterns.	  Vimb
	      always adds the cmd after	existing autocommands, so that the au-
	      tocommands are executed in the order in which they were given.

       :au[tocmd]! [group] {event} {pat} {cmd}
	      Remove all autocommands associated with event and	which  pattern
	      match  pat,  and	add the	command	cmd.  Note that	the pattern is
	      not matches literally to find autocommands to remove,  like  Vim
	      does.   Vimb  matches  the  autocommand  pattern	with  pat.  If
	      [group] is not given, deletes autocommands in current group,  as
	      noted above.

       :au[tocmd]! [group] {event} {pat}
	      Remove  all autocommands associated with event and which pattern
	      matches pat in given group (current group	by default).

       :au[tocmd]! [group] * {pat}
	      Remove all autocommands  with  patterns  matching	 pat  for  all
	      events in	given group (current group by default).

       :au[tocmd]! [group] {event}
	      Remove  all autocommands for event in given group	(current group
	      by default).

       :au[tocmd]! [group]
	      Remove all autocommands in given group  (current	group  by  de-

       :aug[roup] {name}
	      Define  the autocmd group	name for the following ":autocmd" com-
	      mands.  The name "end" selects the default group.

       :aug[roup]! {name}
	      Delete the autocmd group name.

       :aug github
       :  au LoadCommitted * set scripts=off|set cookie-accept=never
       :  au LoadCommitted http{s,}://* set scripts=on
       :aug end

       :cl[eardata] [dataTypes]	[timespan]
	      Asynchronously clears the	website	data  of  the  given  list  of
	      dataTypes	  modified  in	the  past  timespan.   Note  that  the
	      dataTypes	must not contain spaces.  If timespan  is  not	given,
	      all  website  data  will be removed.  Note that this effects all
	      running instances	of vimb.

	      The dataTypes is a comma separated list of following types.
		     Memory cache.
		     HTTP disk cache.
		     Offline web application cache.
		     Session storage data.
		     Local storage data.
		     IndexedDB databases.
		     Plugin data.
		     Cookies. Note that	the cookies are	not cleared in case  a
		     timespan is given.
		     HTTP Strict Transport Security cache.
	      -	     Can  be  used  to	clear  all  known data types in	case a
		     timespan is used.

	      The timespan is given as sequence	of  '[multiplier]unit'	tupels
	      with following units.
	      y	     year (365 days)
	      w	     week (7 days)
	      d	     day
	      h	     hour
	      m	     minute
	      s	     second

		     to	 clear all known website data types without any	times-
		     pan restriction.
	      :cleardata - 5m
		     to	clear all known	website	data  types  modified  in  the
		     last 5 minutes.
	      :cleardata local-storage,session-storage,cookies
		     to	completely clear the cookies, local- and session-stor-
		     age without time restrictions.
	      :cleardata disk-cache 2d4h
		     to	clear the disk cache that was modified in the past two
		     days and four hours.

       :sh[ellcmd]! cmd
	      Like :sh[ellcmd] but asynchronous.

	      :sh! /bin/sh -c 'echo "`date` $VIMB_URI" >> myhistory.txt'

       :sh[ellcmd] cmd
	      Runs  the	 given shell cmd syncron and print the output into in-
	      putbox.  The following patterns in  cmd  are  expanded:  '~user-
	      name',  '~/',  '$VAR' and	'${VAR}'.  A '\' before	these patterns
	      disables the expansion.

	      The following environment	variables are  set  for	 called	 shell
		     This  variable  is	 set  by  Vimb everytime a new page is
		     opened to the URI of the page.
		     Contains the title	of the current opened page.
		     Contains the pid of the running Vimb instance.
		     Holds the X-Window	id of the Vimb window or of the	embed-
		     ding window if Vimb is started with the -e	option.
       :sh[ellcmd]! cmd
	      Like :sh[ellcmd] but asynchronous.

	      :sh! /bin/sh -c 'echo "`date` $VIMB_URI" >> myhistory.txt'
       :s[ave] [path]
	      Download current opened page into	configured download directory.
	      If path is given,	download under this file name or  path.	  path
	      is expanded and can therefore contain '~/', '${ENV}' and '~user'
       :so[urce] [file]
	      Read ex commands from file.
	      Close the	browser.  This will be refused if  there  are  running
	      Close the	browser	independent from an running download.
	      Display the contents of all registers.
	      "a -- "z
		     26	 named registers "a to "z.  Vimb fills these registers
		     only when you say so.
	      ":     Last executed `ex`	command.
	      ""     Last yanked content.
	      "%     Curent opened URI.
	      "/     Last search phrase.
	      ";     Contains the last hinted URL.

       :e[val] javascript
	      Runs the given javascript	in the current page  and  display  the
	      evaluated	value.

	      Example: :eval document.cookie

       :e[val]!	javascript
	      Like :eval, but there is nothing print to	the input box.

       :no[rmal] [cmds]
	      Execute  normal  mode  commands cmds.  This makes	it possible to
	      execute normal mode commands typed on the	input box.

	      cmds cannot start	with a space.  Put a count of 1	 (one)	before
	      it, "1 " is one space.

	      Example: :set scripts!|no! R

       :no[rmal]! [cmds]
	      Like :normal, but	no mapping is applied to cmds.

	      Print  current document.	Open a GUI dialog where	you can	select
	      the printer, number of copies, orientation, etc.

       <Esc>, CTRL-[
	      Switch back to normal mode.

       CTRL-O Executes the next	command	as normal mode command and  return  to
	      input mode.

       CTRL-T Open configured editor with content of current form field.

       CTRL-V Pass the next key	press directly to WebKit.

       CTRL-Z Enter the	pass-through mode.

       The  completions	 are triggered by pressing `<Tab>` or `<S-Tab>`	in the
       activated inputbox.  Depending of the current inserted content  differ-
       ent  completions	 are  started.	 The completion	takes additional typed
       chars to	filter the completion list that	is shown.

	      The completion for commands are started when  at	least  `:`  is
	      shown in the inputbox.  If initial chars are passed, the comple-
	      tion will	lookup those commands that begin with the given	chars.

	      The setting name completion is started if	at least  `:set	 `  is
	      shown  in	inputbox and does also match settings that begins with
	      already typed setting prefix.

	      The history of URIs is shown for the `:open `  and  `:tabopen  `
	      commands.	 This completion looks up every	given word in the his-
	      tory URI and titles.  Only those history items are shown,	 where
	      the title	or URI contains	all tags.

	      :open foo	bar<Tab>
		     will  complete  only  URIs	that contain the words foo and

	      The bookmark completion is similar to  the  history  completion,
	      but  does	 match	only  the tags of the bookmarks.  The bookmark
	      completion is started by `:open !`, `:tabopen !` or `:bmr	`  and
	      does a prefix search for all given words in the bookmark tags.

	      :open !foo ba
		     will  match  all  bookmarks  that have tags starting with
		     "foo" and "ba".  If the bookmark does not have  any  tags
		     set, the URL is split on `.' and `/' into tags.

	      :bmr tag
		     will  match  all  bookmarks  that have tags starting with

       bookmark	tags
	      The bookmark tag completion allows the insertion of already used
	      bookmarks	for the	`:bma `	commands.

       search The  search  completion  allows  a filtered list of already done
	      searches.	 This completion starts	by `/` or `?` in inputbox  and
	      performs a prefix	comparison for further typed chars.

       All settings listed below can be	set with the `:set' command.  See Set-
       tings under COMMAND MODE	for syntax.

	      Enable or	disable	accelerated 2D canvas.	 When  accelerated  2D
	      canvas  is enabled, WebKit may render some 2D canvas content us-
	      ing hardware accelerated drawing operations.

	      Indicates	whether	file access is allowed from file URLs.	By de-
	      fault,  when  something is loaded	using a	file URI, cross	origin
	      requests to other	file resources are not allowed.

	      Indicates	whether	or not JavaScript running in the context of  a
	      file  scheme  URL	 should	 be allowed to access content from any
	      origin.  By default, when	something is loaded in a using a  file
	      scheme  URL, access to the local file system and arbitrary local
	      storage is not allowed.

	      Whether to enable	accessibility enhanced keyboard	navigation.

       cookie-accept (string)
	      Cookie accept policy {`always', `never',	`origin'  (accept  all
	      non-third-party cookies)}.

       closed-max-items	(int)
	      Maximum  number of stored	last closed URLs.  If closed-max-items
	      is set to	0, closed URLs will not	be stored.

       completion-css (string)
	      CSS style	applied	to the inputbox	completion list	items.

       completion-hover-css (string)
	      CSS style	applied	to the inputbox	completion list	item  that  is
	      currently	hovered	by the mouse.

       completion-selected-css (string)
	      CSS  style  applied to the inputbox completion list item that is
	      currently	selected.

       cursiv-font (string)
	      The font family used as the default for  content	using  cursive

       dark-mode (bool)
	      Whether  to  enable  dark	 mode.	Websites can use the `prefers-
	      color-scheme' media query	to adjust styles according to this op-

       default-charset (string)
	      The  default text	charset	used when interpreting content with an
	      unspecified charset.

       default-font (string)
	      The font family to use as	the default for	content	that does  not
	      specify a	font.

       default-zoom (int)
	      Default Full-Content zoom	level in percent. Default is 100.

       dns-prefetching (bool)
	      Indicates	if Vimb	prefetches domain names.

       download-command	(string)
	      A	command	with placeholder '%s' that will	be invoked to download
	      a	URI in case 'download-use-external' is enabled.

	      The following additional environment variable are	available:
		     The URI of	the current opened  page,  normally  the  page
		     where  the	 download was started from, also known as ref-
		     Setting value of 'download-path' which would be used nor-
		     mally for downloads.

	      :set  download-command=/bin/sh  -c  "cd '$VIMB_DOWNLOAD_PATH' &&
	      curl -sLJOC - -e '$VIMB_URI' %s"

       download-path (string)
	      Path to the default download directory.  If no  download	direc-
	      tory  is	set,  download will be written into current directory.
	      The following pattern  will  be  expanded	 if  the  download  is
	      started '~/', '~user', '$VAR' and	'${VAR}'.

       download-use-external (bool)
	      Indicates	 if  the  external download tool set as	'download-com-
	      mand' should be used to handle downloads.	 If this  is  disabled
	      Vimb will	handle the download.

       editor-command (string)
	      Command  with  placeholder  '%s'	called if form field is	opened
	      with $EDITOR to spawn the	 editor-like  `x-terminal-emulator  -e
	      vim  %s'.	  To use Gvim as the editor, it's necessary to call it
	      with `-f'	to run it in the foreground.

       font-size (int)
	      The default font size used to display text.

       frame-flattening	(bool)
	      Whether to enable	the Frame Flattening.  With this setting  each
	      subframe is expanded to its contents, which will flatten all the
	      frames to	become one scrollable page.

       fullscreen (bool)
	      Show the current window full-screen.

       hardware-acceleration-policy (string)
	      This setting decides how to enable and disable hardware acceler-
		     enables  the  hardware acceleration when the web contents
		     request it, disabling it again when no longer needed.
	      always enforce hardware acceleration to be enabled.
	      never  disables it completely.  Note that	disabling hardware ac-
		     celeration	 might	cause some websites to not render cor-
		     rectly or consume more CPU.

       header (list)
	      Comma separated list of headers  that  replaces  default	header
	      sent  by	WebKit or new headers.	The format for the header list
	      elements is `name[=[value]]'.

	      Note that	these headers will replace already  existing  headers.
	      If  there	 is  no	 '='  after the	header name, then the complete
	      header will be removed from the request, if the '='  is  present
	      means that the header value is set to empty value.

	      Note  that webkit	reused already set headers in case of a	reload
	      of a page.  So if	there are headers removed  that	 where	previ-
	      ously  use  to access a certain page and the page	is reloaded or
	      opened via back/forward history the header will still  be	 sent.
	      To  apply	 the  new header setting properly it's required	to re-
	      quest another page or to open current page new by	`O<Cr>`.

	      To use '=' within	a header value the value must be  quoted  like
	      shown in Example for the Cookie header.

	      :set header=DNT=1,User-Agent,Cookie='name=value'
		     Send  the 'Do Not Track' header with each request and re-
		     move the User-Agent Header	completely from	request.

       hint-follow-last	(bool)
	      If on, vimb automatically	follows	the last remaining hint	on the
	      page.  If	off hints are fired only if enter is pressed.

       hint-keys-same-length (bool)
	      If  on,  all  hint labels	will have the same length, so no hints
	      will be ambiguous.

       hint-timeout (int)
	      Timeout before automatically following  a	 non-unique  numerical
	      hint.  To	disable	auto fire of hints, set	this value to 0.

       hint-keys (string)
	      The  keys	 used  to  label  and  select hints.  With its default
	      value, each hint has a unique label which	can be typed to	select
	      it, while	all other characters are used to filter	hints based on
	      their text.  With	a value	such as	asdfg;lkjh, each hint is  `la-
	      beled' based on the characters of	the home row.

	      If  the  hint-keys string	starts with a '0' the keys are consid-
	      ered to follow the rules of numeric labeling. So that the	 ifrst
	      char of the label	will never start with the '0'.

	      Note  that the hint matching by label built of hint-keys is case
	      sensitive.  In this vimb differs from some other	browsers  that
	      show hint	labels in upper	case, but match	them lowercase.

	      To  have	upper case hint	labels,	it's possible to add following
	      css to the `style.css' file in vimb's configuration directory.

	      "span[vimbhint="label"] {text-transform: uppercase !important;}"

       hint-match-element (bool)
	      If this is set to	'true' typed chars that	are not	 part  of  the
	      set  'hint-keys' are used	to filter hinted DOM elements by their
	      text value.  If 'hint-keys' are set to chars instead of  numbers
	      it might be useful to disable matching of	the elements by	'hint-

       history-max-items (int)
	      Maximum number of	unique items stored in search-,	command	or URI
	      history.	 If  history-max-items	is  set	to 0, the history file
	      will not be changed.  This  setting  has	no  effect  if	option
	      --incognito is set.

       home-page (string)
	      Homepage that vimb opens if started without a URI.

       html5-database (bool)
	      Whether  to  enable  HTML5  client-side  SQL  database  support.
	      Client-side SQL database allows web pages	 to  store  structured
	      data  and	 be  able  to  use  SQL	 to manipulate that data asyn-

       html5-local-storage (bool)
	      Whether to enable	HTML5 localStorage support.  localStorage pro-
	      vides simple synchronous storage access.

       hyperlink-auditing (bool)
	      Enable or	disable	support	for <a ping>.

       images (bool)
	      Determines whether images	should be automatically	loaded or not.

       incsearch (bool)
	      While  typing  a search command, show where the pattern typed so
	      far matches.

       input-autohide (bool)
	      If enabled the inputbox will be hidden whenever it  contains  no

       input-css (string)
	      CSS style	applied	to the inputbox	in normal state.

       input-error-css (string)
	      CSS style	applied	to the inputbox	in case	of displayed error.

       javascript-can-access-clipboard (bool)
	      Whether JavaScript can access the	clipboard.

       javascript-can-open-windows-automatically (bool)
	      Whether  JavaScript can open popup windows automatically without
	      user interaction.

       geolocation (string)
	      Controls	website	 access	 to  the  geolocation  API  {`always',
	      `never', `ask' (display a	prompt each time)}

       media-playback-allows-inline (bool)
	      Whether media playback is	full-screen only or inline playback is
	      allowed.	Setting	it to false allows specifying that media play-
	      back should be always fullscreen.

       media-playback-requires-user-gesture (bool)
	      Whether  a user gesture (such as clicking	the play button) would
	      be required to start media playback or load media.   Setting  it
	      on  requires a gesture by	the user to start playback, or to load
	      the media.

       media-stream (bool)
	      Enable or	disable	support	for MediaSource	on pages.  MediaSource
	      is  an  experimental  proposal which extends HTMLMediaElement to
	      allow JavaScript to generate media streams for playback.

       mediasource (bool)
	      Enable or	disable	support	for MediaSource	on pages.  MediaSource
	      is  an  experimental  proposal which extends HTMLMediaElement to
	      allow JavaScript to generate media streams for playback.

       minimum-font-size (int)
	      The minimum font size used to display text.

       monospace-font (string)
	      The font family used as the default for content using  monospace

       monospace-font-size (int)
	      Default font size	for the	monospace font.

       offline-cache (bool)
	      Whether  to  enable HTML5	offline	web application	cache support.
	      Offline web application cache allows  web	 applications  to  run
	      even when	the user is not	connected to the network.

       print-backgrounds (bool)
	      Whether background images	should be drawn	during printing.

       plugins (bool)
	      Determines whether or not	plugins	on the page are	enabled.

       prevent-newwindow (bool)
	      Whether to open links, that would	normally open in a new window,
	      in the current window.  This option does not affect links	 fired
	      by hinting.

       sans-serif-font (string)
	      The font family used as the default for content using sans-serif

       scripts (bool)
	      Determines whether or not	JavaScript executes within a page.

       scroll-step (int)
	      Number of	pixel vimb scrolls if 'j' or 'k' is used.

       serif-font (string)
	      The font family used as the  default  for	 content  using	 serif

       show-titlebar (bool)
	      Determines  whether  the titlebar	is shown (on systems that pro-
	      vide window decoration).	Defaults to true.

       site-specific-quirks (bool)
	      Enables the site-specific	compatibility workarounds.

       smooth-scrolling	(bool)
	      Enable or	disable	support	for smooth scrolling.

       spacial-navigation (bool)
	      Whether to enable	the Spatial Navigation.	 This feature consists
	      in  the  ability to navigate between focusable elements in a Web
	      page, such as hyperlinks	and  form  controls,  by  using	 Left,
	      Right,  Up  and Down arrow keys.	For example, if	a user presses
	      the Right	key, heuristics	determine whether there	is an  element
	      they  might  be  trying to reach towards the right, and if there
	      are multiple elements, which element they	probably want.

       spell-checking (bool)
	      Enable or	disable	the spell checking feature.

       spell-checking-languages	(string)
	      Set comma	separated list of spell	checking languages to be  used
	      for spell	checking.
	      The  locale  string typically is in the form lang_COUNTRY, where
	      lang is an ISO-639 language code,	and  COUNTRY  is  an  ISO-3166
	      country code. For	instance, sv_FI	for Swedish as written in Fin-
	      land or pt_BR for	Portuguese as written in Brazil.

       status-bar (bool)
	      Indicates	if the status bar should be shown.

       status-css (string)
	      CSS style	applied	to the status bar on none https	pages.

       status-ssl-css (string)
	      CSS style	applied	to the status bar on https pages with  trusted

       status-ssl-invalid-css (string)
	      CSS  style  applied  to  the  status bar on https	pages with un-
	      trusted certificate.

       strict-ssl (bool)
	      If 'on', vimb will not load a untrusted https site.

       stylesheet (bool)
	      If 'on' the user defined styles-sheet is used.

       tabs-to-links (bool)
	      Whether the Tab key cycles through elements on the page.

	      If true, pressing	the Tab	key will focus the next	element	in the
	      web  view.   Otherwise,  the  web	 view  will  interpret Tab key
	      presses as normal	key presses.  If the selected element  is  ed-
	      itable, the Tab key will cause the insertion of a	Tab character.

       timeoutlen (int)
	      The time in milliseconds that is waited for a key	code or	mapped
	      key sequence to complete.

       user-agent (string)
	      The user-agent string used by WebKit.

       user-scripts (bool)
	      If 'on' the user scripts are injected into every page.

       webaudio	(bool)
	      Enable or	disable	support	for WebAudio on	pages.	WebAudio is an
	      experimental  proposal  for allowing web pages to	generate Audio
	      WAVE data	from JavaScript.

       webgl (bool)
	      Enable or	disable	support	for WebGL on pages.

       webinspector (bool)
	      Determines whether or not	developer tools, such as the  Web  In-
	      spector, are enabled.

       x-hint-command (string)
	      Command  used  if	hint mode ;x is	fired.	The command can	be any
	      vimb command string.  Note that the command is run  through  the
	      mapping  mechanism  of  vimb so it might change the behaviour by
	      adding or	changing mappings.

	      :set x-hint-command=:sh! curl -e <C-R>% <C-R>;
		     This fills	the inputbox with the prefilled	download  com-
		     mand  and replaces	`<C-R>%' with the current URI and `<C-
		     R>;' with the URI of the hinted element.

       xss-auditor (bool)
	      Whether to enable	the XSS	auditor.  This	feature	 filters  some
	      kinds of reflective XSS attacks on vulnerable web	sites.

	      Directory	 for  configuration data.  If executed with -p PROFILE
	      parameter, configuration is read from this subdirectory.
	      config Configuration file	to set WebKit setting, some GUI	styles
		     and keybindings.
		     Sqlite  cookie storage.  This file	will not be touched if
		     option --incognito	is set.
	      closed Holds the URIs of last closed browser windows.  This file
		     will not be touched if option --incognito is set.
		     This  file	holds the history of unique opened URIs.  This
		     file will not be touched if option	--incognito is set.
		     This file holds the list of bookmarked URIs with tags.
		     This file	holds  the  history  of	 commands  and	search
		     queries  performed	 via input box.	 This file will	not be
		     touched if	option --incognito is set.
	      queue  Holds the read it later queue filled by `qpush'.
	      search This file holds the history of search queries.  This file
		     will not be touched if option --incognito is set.
		     This  file	 can be	used to	run user scripts, that are in-
		     jected into every page that is opened.
		     File for userdefined CSS styles.  These file is  used  if
		     the config	variable `stylesheet' is enabled.

       There are also some sample scripts installed together with Vimb under

       http_proxy, HTTP_PROXY
	      If  either environment variable is non-empty, the	specified host
	      and optional port	is  used  to  tunnel  requests.	 For  example:

       Report  bugs  to	 the  main  project  page  on
       or      on      the	mailing	      list	 https://lists.source-

       Daniel Carl

vimb/3.6.0			    01 2020			       VIMB(1)


Want to link to this manual page? Use this URL:

home | help