diff --git a/runtime/syntax/diff.vim b/runtime/syntax/diff.vim
index a000514..ff69c58 100644
--- a/runtime/syntax/diff.vim
+++ b/runtime/syntax/diff.vim
@@ -2,7 +2,7 @@
 " Language:	Diff (context or unified)
 " Maintainer:	Bram Moolenaar <Bram@vim.org>
 "               Translations by Jakson Alves de Aquino.
-" Last Change:	2014 Nov 12
+" Last Change:	2015 Jan 07
 
 " Quit when a (custom) syntax file was already loaded
 if exists("b:current_syntax")
@@ -18,6 +18,9 @@
 syn match diffNoEOL	"^\\ No newline at end of file .*"
 syn match diffCommon	"^Common subdirectories: .*"
 
+" Disable the translations by setting diff_translations to zero.
+if !exists("diff_translations") || diff_translations
+
 " ca
 syn match diffOnly	"^Només a .*"
 syn match diffIdentical	"^Els fitxers .* i .* són idèntics$"
@@ -320,6 +323,8 @@
 syn match diffNoEOL	"^\\ 檔案末沒有 newline 字元"
 syn match diffCommon	"^.* 和 .* 有共同的副目錄$"
 
+endif
+
 
 syn match diffRemoved	"^-.*"
 syn match diffRemoved	"^<.*"
diff --git a/runtime/syntax/html.vim b/runtime/syntax/html.vim
index d59126d..ab1f9b3 100644
--- a/runtime/syntax/html.vim
+++ b/runtime/syntax/html.vim
@@ -2,7 +2,8 @@
 " Language:	HTML
 " Maintainer:	Claudio Fleiner <claudio@fleiner.com>
 " URL:		http://www.fleiner.com/vim/syntax/html.vim
-" Last Change:	2012 Oct 05
+" Last Change:	2015 Jan 07
+"		included patch from David Felix
 
 " Please check :help html.vim for some comments and a description of the options
 
@@ -168,7 +169,7 @@
   " JAVA SCRIPT
   syn include @htmlJavaScript syntax/javascript.vim
   unlet b:current_syntax
-  syn region  javaScript start=+<script\_[^>]*>+ keepend end=+</script>+me=s-1 contains=@htmlJavaScript,htmlCssStyleComment,htmlScriptTag,@htmlPreproc
+  syn region  javaScript start=+<script\_[^>]*>+ keepend end=+</script\_[^>]*>+me=s-1 contains=@htmlJavaScript,htmlCssStyleComment,htmlScriptTag,@htmlPreproc
   syn region  htmlScriptTag     contained start=+<script+ end=+>+ fold contains=htmlTagN,htmlString,htmlArg,htmlValue,htmlTagError,htmlEvent
   HtmlHiLink htmlScriptTag htmlTag
 
@@ -193,7 +194,7 @@
   " VB SCRIPT
   syn include @htmlVbScript syntax/vb.vim
   unlet b:current_syntax
-  syn region  javaScript start=+<script \_[^>]*language *=\_[^>]*vbscript\_[^>]*>+ keepend end=+</script>+me=s-1 contains=@htmlVbScript,htmlCssStyleComment,htmlScriptTag,@htmlPreproc
+  syn region  javaScript start=+<script \_[^>]*language *=\_[^>]*vbscript\_[^>]*>+ keepend end=+</script\_[^>]*>+me=s-1 contains=@htmlVbScript,htmlCssStyleComment,htmlScriptTag,@htmlPreproc
 endif
 
 syn cluster htmlJavaScript      add=@htmlPreproc
diff --git a/runtime/syntax/less.vim b/runtime/syntax/less.vim
new file mode 100644
index 0000000..5cc8c6d
--- /dev/null
+++ b/runtime/syntax/less.vim
@@ -0,0 +1,79 @@
+" Vim syntax file
+" Language:	less
+" Maintainer:	Alessandro Vioni <jenoma@gmail.com>
+" URL: https://github.com/genoma/vim-less
+" Last Change:	2014 November 24
+
+if exists("b:current_syntax")
+  finish
+endif
+
+runtime! syntax/css.vim
+runtime! after/syntax/css.vim
+
+syn case ignore
+
+syn cluster lessCssProperties contains=cssFontProp,cssFontDescriptorProp,cssColorProp,cssTextProp,cssBoxProp,cssGeneratedContentProp,cssPagingProp,cssUIProp,cssRenderProp,cssAuralProp,cssTableProp
+syn cluster lessCssAttributes contains=css.*Attr,lessEndOfLineComment,lessComment,cssValue.*,cssColor,cssURL,lessDefault,cssImportant,cssError,cssStringQ,cssStringQQ,cssFunction,cssUnicodeEscape,cssRenderProp
+
+syn region lessDefinition matchgroup=cssBraces start="{" end="}" contains=TOP
+
+syn match lessProperty "\%([{};]\s*\|^\)\@<=\%([[:alnum:]-]\|#{[^{}]*}\)\+\s*:" contains=css.*Prop skipwhite nextgroup=lessCssAttribute contained containedin=lessDefinition
+syn match lessProperty "^\s*\zs\s\%(\%([[:alnum:]-]\|#{[^{}]*}\)\+\s*:\|:[[:alnum:]-]\+\)"hs=s+1 contains=css.*Prop skipwhite nextgroup=lessCssAttribute
+syn match lessProperty "^\s*\zs\s\%(:\=[[:alnum:]-]\+\s*=\)"hs=s+1 contains=css.*Prop skipwhite nextgroup=lessCssAttribute
+syn match lessCssAttribute +\%("\%([^"]\|\\"\)*"\|'\%([^']\|\\'\)*'\|#{[^{}]*}\|[^{};]\)*+ contained contains=@lessCssAttributes,lessVariable,lessFunction,lessInterpolation
+syn match lessDefault "!default\>" contained
+
+" less variables and media queries
+syn match lessVariable "@[[:alnum:]_-]\+" nextgroup=lessCssAttribute skipwhite
+syn match lessMedia "@media" nextgroup=lessCssAttribute skipwhite
+
+" Less functions
+syn match lessFunction "\<\%(escape\|e\|unit\)\>(\@=" contained
+syn match lessFunction "\<\%(ceil\|floor\|percentage\|round\|sqrt\|abs\|sin\|asin\|cos\|acos\|tan\|atan\|pi\|pow\|min\|max\)\>(\@=" contained
+syn match lessFunction "\<\%(rgb\|rgba\|argb\|argb\|hsl\|hsla\|hsv\|hsva\)\>(\@=" contained
+syn match lessFunction "\<\%(hue\|saturation\|lightness\|red\|green\|blue\|alpha\|luma\)\>(\@=" contained
+syn match lessFunction "\<\%(saturate\|desaturate\|lighten\|darken\|fadein\|fadeout\|fade\|spin\|mix\|greyscale\|contrast\)\>(\@=" contained
+syn match lessFunction "\<\%(multiply\|screen\|overlay\|softlight\|hardlight\|difference\|exclusion\|average\|negation\)\>(\@=" contained
+
+" Less id class visualization
+syn match lessIdChar     "#[[:alnum:]_-]\@=" nextgroup=lessId,lessClassIdCall
+syn match lessId         "[[:alnum:]_-]\+" contained
+syn match lessClassIdCall  "[[:alnum:]_-]\+()" contained
+
+syn match lessClassChar  "\.[[:alnum:]_-]\@=" nextgroup=lessClass,lessClassCall
+syn match lessClass      "[[:alnum:]_-]\+" contained
+syn match lessClassCall  "[[:alnum:]_-]\+()" contained
+
+syn match lessAmpersand  "&" contains=lessIdChar,lessClassChar
+
+syn region lessInclude start="@import" end=";\|$" contains=lessComment,cssURL,cssUnicodeEscape,cssMediaType,cssStringQ,cssStringQQ
+
+syn keyword lessTodo        FIXME NOTE TODO OPTIMIZE XXX contained
+syn region  lessComment     start="^\z(\s*\)//"  end="^\%(\z1 \)\@!" contains=lessTodo,@Spell
+syn region  lessCssComment  start="^\z(\s*\)/\*" end="^\%(\z1 \)\@!" contains=lessTodo,@Spell
+syn match   lessEndOfLineComment "//.*" contains=lessComment,lessTodo,@Spell
+
+hi def link lessEndOfLineComment        lessComment
+hi def link lessCssComment              lessComment
+hi def link lessComment                 Comment
+hi def link lessDefault                 cssImportant
+hi def link lessVariable                Identifier
+hi def link lessFunction                PreProc
+hi def link lessTodo                    Todo
+hi def link lessInclude                 Include
+hi def link lessIdChar                  Special
+hi def link lessClassChar               Special
+hi def link lessAmpersand               Character
+hi def link lessId                      Identifier
+hi def link lessClass                   Type
+hi def link lessCssAttribute            PreProc
+hi def link lessClassCall               Type
+hi def link lessClassIdCall             Type
+hi def link lessTagName                 cssTagName
+hi def link lessDeprecated              cssDeprecated
+hi def link lessMedia                   cssMedia
+
+let b:current_syntax = "less"
+
+" vim:set sw=2:
diff --git a/runtime/syntax/netrw.vim b/runtime/syntax/netrw.vim
index 16e3c90..980fe5d 100644
--- a/runtime/syntax/netrw.vim
+++ b/runtime/syntax/netrw.vim
@@ -1,7 +1,7 @@
 " Language   : Netrw Remote-Directory Listing Syntax
-" Maintainer : Charles E. Campbell, Jr.
-" Last change: Mar 07, 2014
-" Version    : 18
+" Maintainer : Charles E. Campbell
+" Last change: Oct 06, 2014
+" Version    : 19
 " ---------------------------------------------------------------------
 
 " Syntax Clearing: {{{1
@@ -16,7 +16,7 @@
 syn cluster NetrwGroup		contains=netrwHide,netrwSortBy,netrwSortSeq,netrwQuickHelp,netrwVersion,netrwCopyTgt
 syn cluster NetrwTreeGroup	contains=netrwDir,netrwSymLink,netrwExe
 
-syn match  netrwPlain		"\(\S\+ \)*\S\+"					contains=@NoSpell
+syn match  netrwPlain		"\(\S\+ \)*\S\+"					contains=netrwLink,@NoSpell
 syn match  netrwSpecial		"\%(\S\+ \)*\S\+[*|=]\ze\%(\s\{2,}\|$\)"		contains=netrwClassify,@NoSpell
 syn match  netrwDir		"\.\{1,2}/"						contains=netrwClassify,@NoSpell
 "syn match  netrwDir		"\%(\S\+ \)*\S\+/"					contains=netrwClassify,@NoSpell
@@ -24,7 +24,11 @@
 syn match  netrwSizeDate	"\<\d\+\s\d\{1,2}/\d\{1,2}/\d\{4}\s"	skipwhite	contains=netrwDateSep,@NoSpell	nextgroup=netrwTime
 syn match  netrwSymLink		"\%(\S\+ \)*\S\+@\ze\%(\s\{2,}\|$\)"  			contains=netrwClassify,@NoSpell
 syn match  netrwExe		"\%(\S\+ \)*\S*[^~]\*\ze\%(\s\{2,}\|$\)" 		contains=netrwClassify,@NoSpell
+if has("gui_running") && (&enc == 'utf-8' || &enc == 'utf-16' || &enc == 'ucs-4')
 syn match  netrwTreeBar		"^\%([-+|│] \)\+"					contains=netrwTreeBarSpace	nextgroup=@netrwTreeGroup
+else
+syn match  netrwTreeBar		"^\%([-+|] \)\+"					contains=netrwTreeBarSpace	nextgroup=@netrwTreeGroup
+endif
 syn match  netrwTreeBarSpace	" "					contained
 
 syn match  netrwClassify	"[*=|@/]\ze\%(\s\{2,}\|$\)"		contained
@@ -44,10 +48,11 @@
 syn match  netrwComma		","				contained
 syn region netrwQuickHelp	matchgroup=Comment start="Quick Help:\s\+" end="$"	contains=netrwHelpCmd,netrwQHTopic,@NoSpell	keepend contained
 syn match  netrwHelpCmd		"\S\+\ze:"			contained skipwhite	contains=@NoSpell		nextgroup=netrwCmdSep
-syn match  netrwQHTopic		"-\a\+-"			contained skipwhite
+syn match  netrwQHTopic		"([a-zA-Z &]\+)"		contained skipwhite
 syn match  netrwCmdSep		":"				contained nextgroup=netrwCmdNote
 syn match  netrwCmdNote		".\{-}\ze  "			contained		contains=@NoSpell
 syn match  netrwVersion		"(netrw.*)"			contained		contains=@NoSpell
+syn match  netrwLink		"-->"				contained skipwhite
 
 " -----------------------------
 " Special filetype highlighting {{{1
@@ -95,6 +100,7 @@
  hi default link netrwComma	netrwComment
  hi default link netrwHide	netrwComment
  hi default link netrwMarkFile	TabLineSel
+ hi default link netrwLink	Special
 
  " special syntax highlighting (see :he g:netrw_special_syntax)
  hi default link netrwBak	NonText
diff --git a/runtime/syntax/r.vim b/runtime/syntax/r.vim
index 85a6eaa..9677823 100644
--- a/runtime/syntax/r.vim
+++ b/runtime/syntax/r.vim
@@ -3,12 +3,11 @@
 " Maintainer:	      Jakson Aquino <jalvesaq@gmail.com>
 " Former Maintainers: Vaidotas Zemlys <zemlys@gmail.com>
 " 		      Tom Payne <tom@tompayne.org>
-" Last Change:	      Wed Jul 09, 2014  10:29PM
+" Last Change:	      Wed Dec 31, 2014  12:36AM
 " Filenames:	      *.R *.r *.Rhistory *.Rt
-" 
-" NOTE: The highlighting of R functions is defined in the
-" r-plugin/functions.vim, which is part of vim-r-plugin2:
-" http://www.vim.org/scripts/script.php?script_id=2628
+"
+" NOTE: The highlighting of R functions is defined in
+" runtime files created by a filetype plugin, if installed.
 "
 " CONFIGURATION:
 "   syntax folding can be turned on by
@@ -37,9 +36,9 @@
 syn match rOKeyword contained "@\(param\|return\|name\|rdname\|examples\|include\|docType\)"
 syn match rOKeyword contained "@\(S3method\|TODO\|aliases\|alias\|assignee\|author\|callGraphDepth\|callGraph\)"
 syn match rOKeyword contained "@\(callGraphPrimitives\|concept\|exportClass\|exportMethod\|exportPattern\|export\|formals\)"
-syn match rOKeyword contained "@\(format\|importClassesFrom\|importFrom\|importMethodsFrom\|import\|keywords\)"
+syn match rOKeyword contained "@\(format\|importClassesFrom\|importFrom\|importMethodsFrom\|import\|keywords\|useDynLib\)"
 syn match rOKeyword contained "@\(method\|noRd\|note\|references\|seealso\|setClass\|slot\|source\|title\|usage\)"
-syn match rOKeyword contained "@\(family\|template\|templateVar\|description\|details\|inheritsParams\)"
+syn match rOKeyword contained "@\(family\|template\|templateVar\|description\|details\|inheritParams\)"
 syn match rOComment contains=@Spell,rOKeyword "#'.*"
 
 
@@ -79,12 +78,12 @@
 syn keyword rConstant T F LETTERS letters month.abb month.name pi
 syn keyword rConstant R.version.string
 
-syn keyword rNumber   NA_integer_ NA_real_ NA_complex_ NA_character_ 
+syn keyword rNumber   NA_integer_ NA_real_ NA_complex_ NA_character_
 
 " Constants
 syn keyword rConstant NULL
 syn keyword rBoolean  FALSE TRUE
-syn keyword rNumber   NA Inf NaN 
+syn keyword rNumber   NA Inf NaN
 
 " integer
 syn match rInteger "\<\d\+L"
@@ -93,7 +92,7 @@
 
 " number with no fractional part or exponent
 syn match rNumber "\<\d\+\>"
-" hexadecimal number 
+" hexadecimal number
 syn match rNumber "\<0x\([0-9]\|[a-f]\|[A-F]\)\+"
 
 " floating point number with integer and fractional parts and optional exponent
@@ -111,17 +110,19 @@
 syn match rComplex "\<\.\d\+\([Ee][-+]\=\d\+\)\=i"
 syn match rComplex "\<\d\+[Ee][-+]\=\d\+i"
 
+syn match rAssign    '='
 syn match rOperator    "&"
 syn match rOperator    '-'
 syn match rOperator    '\*'
 syn match rOperator    '+'
-syn match rOperator    '='
 if &filetype != "rmd" && &filetype != "rrst"
   syn match rOperator    "[|!<>^~/:]"
 else
   syn match rOperator    "[|!<>^~`/:]"
 endif
 syn match rOperator    "%\{2}\|%\S\{-}%"
+syn match rOperator '\([!><]\)\@<=='
+syn match rOperator '=='
 syn match rOpError  '\*\{3}'
 syn match rOpError  '//'
 syn match rOpError  '&&&'
@@ -129,8 +130,8 @@
 syn match rOpError  '<<'
 syn match rOpError  '>>'
 
-syn match rArrow "<\{1,2}-"
-syn match rArrow "->\{1,2}"
+syn match rAssign "<\{1,2}-"
+syn match rAssign "->\{1,2}"
 
 " Special
 syn match rDelimiter "[,;:]"
@@ -151,9 +152,14 @@
 syn match rCurlyError "[)\]]" contained
 syn match rParenError "[\]}]" contained
 
-" Source list of R functions. The list is produced by the Vim-R-plugin
-" http://www.vim.org/scripts/script.php?script_id=2628
-runtime r-plugin/functions.vim
+" Source list of R functions produced by a filetype plugin (if installed)
+if has("nvim")
+  " Nvim-R
+  runtime R/functions.vim
+else
+  " Vim-R-plugin
+  runtime r-plugin/functions.vim
+endif
 
 syn match rDollar display contained "\$"
 syn match rDollar display contained "@"
@@ -171,7 +177,7 @@
 endif
 
 " Type
-syn keyword rType array category character complex double function integer list logical matrix numeric vector data.frame 
+syn keyword rType array category character complex double function integer list logical matrix numeric vector data.frame
 
 " Name of object with spaces
 if &filetype != "rmd" && &filetype != "rrst"
@@ -179,13 +185,19 @@
 endif
 
 if &filetype == "rhelp"
-  syn match rhPreProc "^#ifdef.*" 
-  syn match rhPreProc "^#endif.*" 
+  syn match rhPreProc "^#ifdef.*"
+  syn match rhPreProc "^#endif.*"
   syn match rhSection "\\dontrun\>"
 endif
 
+if exists("r_syn_minlines")
+  exe "syn sync minlines=" . r_syn_minlines
+else
+  syn sync minlines=40
+endif
+
 " Define the default highlighting.
-hi def link rArrow       Statement	
+hi def link rAssign      Statement
 hi def link rBoolean     Boolean
 hi def link rBraceError  Error
 hi def link rComment     Comment
@@ -204,7 +216,7 @@
 hi def link rhPreProc    PreProc
 hi def link rhSection    PreCondit
 hi def link rInteger     Number
-hi def link rLstElmt	 Normal
+hi def link rLstElmt     Normal
 hi def link rNameWSpace  Normal
 hi def link rNumber      Number
 hi def link rOperator    Operator
