Best of both previous answers: you can invoke system default editor from within less, by pressing v.

pygmentize somefile.ex | less -R

or

function cless () {

    pygmentize -f terminal "$1" | less -R

}

Pygmentize comes as a part of the Pygments Python syntax highliter.

I think that you should use a text editor. I like vim myself. That will give you LOTS of power when viewing files and then when you want to edit them you will already know the basics.

Here are some of the advantages of using a text editor (specifically vim):

• syntax-highlighting


• powerful movement commands


• find


• jump to specific location in a file (called a mark)


• folding (useful when you just want to see function stubbs)

To open your file in readonly mode use this:

vim -R <file name>

Here is a basic navigation guide:

j - move down one line

k - move up one line

h - left one char

l -right one char



ctrl-f - forward one page

ctrl-b - back one page



/<something> - search for something

n - next of whatever you searched for

N - next (search backwards) of whatever you searched for



:q - quit

:q! - quit without saving

:w - save

Here is a link for more information:

http://www.viemu.com/a_vi_vim_graphical_cheat_sheet_tutorial.html

Just to recap, if you will use unix vim is pretty fundamental. I have heard that learning vim is like learning to type. It is the next most useful tool you can learn for programming.

(Just to avoid editor wars you could also look into emacs or another editor, however I personally prefer vim)

As others have said, you can use the power of vim. But importantly, you can do so without learning how to use vi/vim.

Vim comes with a less.vim script that works pretty well as a replacement for less, with full color syntax highlighting. It uses less keybindings (just hit 'q' to quit).

It had a few problems, so I improved it. Here's a screenshot from my blog post on it (archived 2013-04-09; original throws 503):

I was also searching for this and found another solution using Vim:
http://ubuntu-tutorials.com/2008/07/14/use-vim-as-a-syntax-highlighting-pager/

The post is rather old, so now on more recent distros vim 7.2 is shipped and the .bashrc will read:
alias vless='vim -u /usr/share/vim/vim72/macros/less.vim'

I'm glad to announce a new package, e2ansi, that provides
syntax highlighting support for pagers like more and less.

The package use the mother of all text editors, Emacs, to
perform the actual syntax highlighting. As an added bonus, all other
conversions normally performed by Emacs -- like uncompressing files --
is also performed.

Example

The following is the result of viewing a file using less and
e2ansi:

Configuration

The package provides a command-line tool e2ansi-cat that starts
Emacs in batch mode, opens files, syntax highlight them, and renders
the result using ANSI sequences.

You can integrate this into less by setting the following variables
to, for example (the location of your init file may vary):

export "LESSOPEN=||-/usr/local/emacs --batch -Q -l ~/.emacs -l bin/e2ansi-cat %s"

export "LESS=-r"

alias "more=less -X -E"

In the configuration above, less restores the original terminal
window content whereas more simply output new content after the
prompt.

Note: If you use an old version of less, it might not support the
|| or the - syntax, in which case you may need to use simply
LESSOPEN=|/usr/local/emacs ....

Using less in pipes

The "-" character in LESSOPEN indicates that the input filter should
also be used when piping text into less. In this case, Emacs can
only rely on text itself (and not a file name). Fortunately, Emacs
provides a system for this. In addition, the provided file file
e2ansi-magic.el sets up additional file types. For example:

Why use Emacs?

• Emacs has support for virtually all programming languages and
  structured text formats. In most cases, the syntax highlighting
  support is excellent.


• You can easily add support for more languages and formats, or modify
  existing packages to suit you needs.


• Emacs support color themes. When using e2ansi, the colors in the
  theme is preserved when viewing a file in less. You can pick a
  suitable color theme from a number of sources, or design your own.


• If you use Emacs as your editor of choice, you will get the same
  highlighting in the editor as you get when viewing a file using
  less (minus limitations in ANSI sequence format and the terminal
  window).


• 
  less will take advantage of Emacs features that perform automatic
  conversion, for example uncompressing files. In fact, you can teach
  Emacs to perform any kind of conversion like automatically convert a
  binary file to human readable form using an external tool.


• You can view files located on other machines by using Emacs' syntax
  for remote access like /USER@HOST:FILENAME.

Useful links

• 
  e2ansi is distributed on Melpa and can be installed using
  the standard Emacs package system


• 
  e2ansi is hosted on GitHub
  


• The e2ansi page on the Emacs Wiki
  


• The home of less.

Operating system notes

• On MS Windows, the console does not natively support ANSI sequences.
  Fortunately, the less application is capable of rendering them. I
  am not aware of any contemporary binary distribution of less for
  MS Windows and the provided build files is hard to use. Fortunately,
  it's easy to build less using CMake, see this text for
  details.




• OS X distributes an ancient version of less. Fortunately, it's
  easy to build a modern version directly from the source.

If you have GNU Source-highlight installed you can use the following command to highlight the syntax of a single file:

$ src-hilite-lesspipe.sh yourfile.xml | less -R

source-highlight has a .sh script located in /usr/share/source-highlight/*.sh. I've created a symbolic link to it with name hcat in /usr/bin.

It shows highlighted output in terminal (console) – hcat is highlighted cat.

How to:

[me@this]<bash><~> 43 

21:23 Fri Apr 19 > sudo apt-get install source-highlight



[me@this]<bash><~> 28 

21:03 Fri Apr 19 > ll /usr/share/source-highlight/*.sh

-rwxr-xr-x 1 root root 432 May  1  2012 /usr/share/source-highlight/src-hilite-lesspipe.sh*



[me@this]<bash><~> 29 

21:04 Fri Apr 19 > sudo su

root@this:/home/me# cd /usr/bin/

root@this:/usr/bin# ln -s /usr/share/source-highlight/src-hilite-lesspipe.sh hcat



[me@this]<bash><~> 36 

21:07 Fri Apr 19 > hcat test.xml

Using OS X 10.9 (Maverick) this would do the trick:

• brew install source-highlight (Assuming brew is installed - http://brew.sh)


• 
  

  sudo nano /etc/launchd.conf

  
  
  

  
  

  setenv LESSOPEN="| /usr/local/bin/src-hilite-lesspipe.sh %s"     
  
  setenv LESS=' -R '
  
  

  
  

  
  
  

  (Add to /etc/launchd.conf)

  
  



• reboot

In mac, you can just type view filename, does similar thing like less.

After installing GNU's source-highlight (package dev-util/source-highlight on sabayon/gentoo), I configured those envs in /etc/bash/bashrc.d/my-less-src-highlight:

#default:    export LESSOPEN="|lesspipe %s"

#don't like: export LESSOPEN="| /usr/bin/src-hilite-lesspipe.sh %s"

#default:    export LESS=" -R -M --shift 5"

export LESSCOLOR=always

export LESSCOLORIZER=/usr/bin/src-hilite-lesspipe.sh

I did not like to replace lesspipe because that has other features. Concatenation did not work.

If you want the same syntax highlighting you use in Vim, but for some reason you prefer to use less as your pager, you can use this script: https://github.com/rkitover/vimpager

The basic usage would be:

vimpager file.txt

or

vimcat file.ext | less -R

You can use -c to pass extra commands which aren't in your .vimrc (e.g. selecting a different colorscheme). The full command I use is:

vimcat -c 'set cmdheight=20' -c 'hi! clear Normal' -o - "$FILENAME" | less -REXS

Beware: If your Vim asks you to press Enter when it starts up, you won't see the prompt, but nothing will happen until you press Enter! The cmdheight trick above can help to mitigate that.

I found highlight which:

• Supports multiple colour schemes and 256-colours


• Works on STDIN (unlike source-highlight)


• Is much faster than pygmentize
  

Here is a script I call highlight-less-wrapper which includes .bashrc instructions on how to setup less to use it automatically.

#!/bin/bash



# Have highlight read from STDIN if '-' is given as filename



# Setup - Add to .bashrc:

# LESSOPEN='|-highlight-less-wrapper "%s"'

# export LESS=-FMRXis



# Usage:

# $ less file

# OR

# $ pipeline | less



warn () { printf "%s: %sn" "$(basename "$0")" "$*" 1>&2; }

die () { warn "$@"; exit 1; }



# Argument checking

case $# in

    0)

        # Allow `exec $0` for less setup

        echo "LESSOPEN='|-$(readlink -f "$0") "'"%s"''

        exit 255 ;;

    1)

        # Only one argument is expected.

        # less will invoke multiple times given multiple files.

        file=$1

        if [[ $file != - && ! -r $file ]]; then  # less passes '-' for STDIN

            die "Cannot open $file for reading"

        fi ;;

    *)

        die "Expected only one argument" ;;

esac



# Run highlight

# highlight will read from STDIN when given a null filename

run_highlight () {

    highlight --force -O truecolor --style aiseered "$1"

}



if [[ $file == - ]]; then  # Run on stdin

    run_highlight ""

else

    run_highlight "$file"

fi

I had the same question and I landed hear, read all answers and the following is what I finally did to have syntax highlighting everytime I use less or most:

sudo apt install source-highlight

Then I went and created an alias for my less and most (I use ZSH, but you can add aliases for your .bashrc file if you use bash):

vim ~/.zshrc

(For those who might get stuck in vim: press i to go to edit mode, when you are done press Esc then : then x and finally
Enter to save the changes)

And paste the following lines for debian-based distros (like Debian, Ubuntu, Mint, etc.):

alias most='AliasFuncLess() { unset -f AliasFuncLess; $(dpkg -L libsource-highlight-common | grep lesspipe) "$1" | less -R };AliasFuncLess'

alias most='AliasFuncMost() { unset -f AliasFuncMost; $(dpkg -L libsource-highlight-common | grep lesspipe) "$1" | most };AliasFuncMost'

or for RPM distros (Redhat, Fedora, Centos):

alias most='AliasFuncLess() { unset -f AliasFuncLess; $(rpm -ql source-highlight | grep lesspipe) "$1" | less -R };AliasFuncLess'

alias most='AliasFuncMost() { unset -f AliasFuncMost; $(rpm -ql source-highlight | grep lesspipe) "$1" | most };AliasFuncMost'

Remember to close the terminal and open it again to make sure alias is created.

Now you can enjoy the colors:

most yourFile.xml