`layout': layout buffer text in columns and rows.

A layout is either a column or a row; a row is either an atom or a
number of columns; a column is either an atom or a number of rows.
We can start with either the columns or rows.  An atom can be given
in several forms: string literals, symbols i.e. variables, and
lists beginning with :eval which represent Lisp forms to be
evaluated (whose values must be strings or lists of strings).

A column is list beginning with :col while a row begins with either
:row The trivial column and row would be (:col) or (:row).  Here is
a simple layout: (:row "foo" "bar" "baz"), which is rendered as the

foobarbaz

Another simple layout would be (:col "foo" "bar" "baz"),
which would be rendered as:

foo
bar
baz

The layout function does the rendering and inserts the rendered
layout at point: (layout '(:col "foo" "bar" "baz"))

Things get a little more interesting when you nest columns and rows
with atoms of different sizes.

This layout is a row with five columns:

(layout '(:row
          (:col "a"   "bbb" "c")
          (:col " ")
          (:col "ddd" "e"   "f")
          (:col " ")
          (:col "g"   "h"   "iii")))

The result is:

a   ddd g
bbb e   h
c   f   iii

Note how the columns are aligned.

Here is a list of all the possible types of atoms, here shown in a
column, but they can all be used in rows as well:

(:col
 "a string"
 emacs-version
 (:eval (format "%g" (/ 9801 (* 2206 (sqrt 2))))))

which are, in order, a string, a variable, and a form to be
evaluated, and which renders as:

a string
28.2
3.14159

This example row has three columns and demonstrates how an atom
containing newlines renders as an implicit column.  It also shows
how to apply a distinct face (or any other property) to a column
(or, analogously, row):

(:row
 (:col "Emacs" emacs-version)
 (:col "  ")
 (:colprops (face font-lock-string-face) (:eval (mapconcat #'identity solar-n-hemi-seasons "\n"))))

This renders as:

Emacs  Vernal Equinox
28.2   Summer Solstice
       Autumnal Equinox
       Winter Solstice

with all the seasons in a distinct face.

This library also includes utility functions designed to work with
the way I use layouts.

I use layouts to build Emacs applications i.e. buffers that
implement user interfaces, like say Dired, or a game.  But you can
do whatever you want with them.