Using pandoc and lynx without creating temporary files:

pandoc file.md | lynx -stdin

On debian systems you can install with:

apt-get install pandoc

I wrote a lightweight terminal markdown viewer in python, for CLI or as lib:

• https://github.com/axiros/terminal_markdown_viewer

It supports e.g. tables, admonitions and tons of color themes.

Usage:
mdv [-t THEME] [-T C_THEME] [-x] [-l] [-L] [-c COLS] [-f FROM] [-m] [-M DIR] [-H] [-A] [MDFILE]

Options:
MDFILE : Path to markdown file
-t THEME : Key within the color ansi_table.json. 'random' accepted.
-T C_THEME: Theme for code highlight. If not set: Use THEME.
-l : Light background (not yet supported)
-L : Display links
-x : Do not try guess code lexer (guessing is a bit slow)
-f FROM : Display FROM given substring of the file.
-m : Monitor file for changes and redisplay FROM given substring
-M DIR : Monitor directory for markdown file changes
-c COLS : Fix columns to this (default: your terminal width)
-A : Strip all ansi (no colors then)
-H : Print html version

Note: credits to @Joe's answer in Stack Overflow.

You can use Grip, which renders the Markdown exactly as GitHub would (it uses the GitHub markdown API).

Install it with pip:

pip install grip

To render a file example.md:

grip -b example.md

How this looks like:

Is a GUI program, but I find useful for this task ReText, that is an editor for Markdown and reStructuredText with a preview mode:

However, if you need see the file of ReText from a terminal, one option could be convert the marddown to html with pandoc and see the html copy in lynx:

pandoc file.mkd > file.html ; lynx file.html

Edit

There are a few more free markdown editors with preview available for *nix systems. Some in official repositories, others not, and each with their own strengths and weaknesses, but as suitable viewers I would like to highlight these:

• Typora: It is still in beta phase, but it’s free meanwhile (it’s not clear how will be licensed the stable version). Although it is not FOSS, is perfect as markdown viewer because it work by default nearly as a WYSIWYG editor ("live preview mode") with a Outline panel (table of contents) that is very convenient for large files. The "source code mode" have syntax highlight, including bigger fonts for headings and italics for emphasis. And not only export to HTML, ODT and PDF. Also can import-export to several formats via pandoc integration.




• Ghostwriter: HTML preview only (non editable) but also have a nice outline panel and syntax highlight. Without import options, but export to several formats with pandoc and others processors (MultiMarkdown, Discount, or cmark) and have a live spellcheck via hunspell/myspell.




• MdCharm: Similar to Retext, but support markdown (markdown extra) and MultiMarkdown. Show also an outline (ToC) panel.

For R Markdown users, I should mention also editR. Is not a program, but a R package to edit/html preview of R Markdown in a browser. R Commander and RStudio also allow a easy preview in HTML, PDF or Word.

For those who prefer w3m (vi style bindings):

pandoc file.md | w3m -T text/html

I put it in a script, mdview.sh, and put that in my path:

#!/bin/sh
pandoc "$1" | w3m -T text/html

Use the mdless gem / command. It displays a Markdown file nicely in the terminal.

gem install mdless

Then run

mdless README.d

Links:

• mdless on Github


• Project home page

There's also Discount, David Parsons' C implementation of John Gruber's Markdown text to html language. Discount consists of several command-line tools including markdown, mkd2html, makepage, mktags and theme.

http://www.pell.portland.or.us/~orc/Code/discount/

In addition, there's an implementation of markdown in C, using a PEG grammar.

https://github.com/jgm/peg-markdown

On Mac OS X you also may have a look at qlmarkdown, a QuickLook generator for Markdown files.

I know you said you preferred a non-GUI application, but I am currently working on a GUI application called DownMarker which does this. You can find the source in a mercurial repository here. You can find a stand-alone executable to run with mono or .NET here.

Caveat: It is far from finished and only occasionally tested on linux/mono. Last test I did was on Mono 2.6. If you want to build it yourself will need a recent version of mercurial to clone the repository, and MonoDevelop to compile the application.

2 more tools:

- Showdown is JavaScript port or Markdown: https://github.com/coreyti/showdown . You can use it only from browser

- txt2tags can read Markdown format but it adds a lot of new options and featues: http://txt2tags.org/online.php

A couple comments asked about or mentioned the possibility of using a browser add-on. I like this approach because I can edit markdown files in any Linux text editor (from nano to vim to Kate) and view the files in Firefox (my browser of choice).

I simply installed this Firefox add-on and it worked out of the box on Kubuntu 12.04 and Firefox 33.0. No tweaks required.

Markdown Viewer :: Add-ons for Firefox
https://addons.mozilla.org/en-us/firefox/addon/markdown-viewer/

(I also like ReText, but I would prefer to see something like ReText implemented as a plugin for Kate. ReText lacks too many features to compete with mature editors like Kate.)

Assuming you want to see what the html looks like: Use a web browser (with an addon) as a viewer.

For example, for Google Chrome there's TextDown which also lets you edit files straight in the browser and see a live preview.

After adding it, you also need to go to chrome://chrome/extensions/ and check "allow access to file URLs" so you can open local files. A warning though: if you save (shift-ctrl-s) TextDown does not save to the file you opened but to your downloads folder.

I suggest taking a look at Atom. It is an excellent text editor with in-built markdown preview. I don't usually use the markdown preview mode as it has a serious bug - line breaks (unless they come in pairs which indicates a <p> tag's contents) are preserved in the preview. But the syntax highlight mode is so good (since Markdown is optimized to be human readable and Atom's colorization is excellent) that I usually end up reading markdown files in source view mode.

An IMHO heavily underestimated command line markdown viewer is the markdown-cli.

Installation

npm install markdown-cli --global

Usage

markdown-cli <file>

Features

Probably not noticed much, because it misses any documentation...

But as far as I could figure out by some example markdown files, some things that convinced me:

• handles ill formatted files much better (similarly to atom, github, etc.; eg. when blank lines are missing before lists)


• more stable with formatting in headers or lists (bold text in lists breaks sublists in some other viewers)


• proper table formatting


• syntax highlightning


• resolves footnote links to show the link instead of the footnote number (not everyone might want this)

Screenshot

Drawbacks

I have realized the following issues

• code blocks are flattened (all leading spaces disappear)


• two blank lines appear before lists

Here is a commandline script which opens up a markdown file in your browser after converting it into html: http://minhajuddin.com/2012/03/16/markdown-viewer-script-for-your-markdown-documents/

You could have a look at mad which is very easy to use:

mad file.md

Readonly Vim with Markdown highlighting & folding

With Vim Markdown highlighting and folding up and running, the most straightforward solution is to evoke vim in the read only mode with either vim -R, or (at least on Ubuntu) more elegantly:

$ view filename.md

Add the following at the very bottom of your .vimrc file, and view will behave just like less with the added benefit of your favourite syntax highlighting (not only for markdown!) and folding:

" less behaviour for view
" https://unix.stackexchange.com/a/314184/39845

" http://vim.wikia.com/wiki/Using_vim_as_a_syntax-highlighting_pager
function! LessBehaviour()
 if (!&modifiable || &ro)
 set nonumber
 set nospell
 set laststatus=0 " Status line
 set cmdheight=1
 set guioptions=aiMr " No menu bar, nor tool bar
 noremap u <C-u>
 noremap d <C-d>
 noremap q :q<CR>
 endif
endfunction

" https://vi.stackexchange.com/a/9101/3168
augroup ReadOnly
 au!
 au VimEnter * :call LessBehaviour() 
augroup END

There exists also a more rigorous less.sh script. On my system, it comes packaged with vim. To find it, use:

$ find /usr/share/vim -name less.sh

However, contrary to the script listed above, folding will not work with this less.sh.

Currently using mdp in Arch Linux and Termux on android, a markdown presentation tool.

Usage

$ mdp file.md

Slick alias

md() 
 fileName=$1:-"README.md"
 mdp "$fileName"

An easy solution for most situations: copy/paste the markdown into a viewer in the "cloud." Here are two choices:

1. Dillinger.io


2. 
   Dingus

Nothing to install! Cross platform! Cross browser! Always available!

Disadvantages: could be hassle for large files, standard cloud application security issues.

This is an alias that encapsulates a function:

alias mdless='_mdless() less ; fi ; fi ;; _mdless '

Explanation

• 
  alias mdless='...' : creates an alias for mdless
  


• 
  _mdless() ...; : creates a temporary function to be called afterwards


• 
  _mdless : at the end, call it (the function above)

Inside the function:

• 
  if [ -n "$1" ] ; then : if the first argument is not null then...


• 
  if [ -f "$1" ] ; then : also, if the file exists and is regular then...


• 
  cat arg1 arg2 | groff ... : cat sends this two arguments concatenated to groff; the arguments being:
  
  
  • arg1: <(echo ".TH $1 7date --iso-8601Dr.Beco Markdown") : something that starts the file and groff will understand as the header and footer notes. This substitutes the empty header from -s key on pandoc.
  
  
  • arg2: <(pandoc -t man $1) : the file itself, filtered by pandoc, outputing the man style of file $1
  
  


• 
  | groff -K utf8 -t -T utf8 -man 2>/dev/null : piping the resulting concatenated file to groff:
  
  
  • 
    -K utf8 so groff understands the input file code
  
  
  • 
    -t so it displays correctly tables in the file
  
  
  • 
    -T utf8 so it output in the correct format
  
  
  • 
    -man so it uses the MACRO package to outputs the file in man format
  
  
  • 
    2>/dev/null to ignore errors (after all, its a raw file being transformed in man by hand, we don't care the errors as long as we can see the file in a not-so-much-ugly format).
  
  


• 
  | less : finally, shows the file paginating it with less (I've tried to avoid this pipe by using groffer instead of groff, but groffer is not as robust as less and some files hangs it or do not show at all. So, let it go through one more pipe, what the heck!

Add it to your ~/.bash_aliases (or alike)

Moeditor

Just stumbled today on this nice, simple and effective markdown editor:

https://moeditor.js.org/