diff --git a/admin.go b/admin.go
index 7785a5f..07974b6 100644
--- a/admin.go
+++ b/admin.go
@@ -1,186 +1,187 @@
 package writefreely
 
 import (
 	"fmt"
 	"github.com/gogits/gogs/pkg/tool"
 	"github.com/gorilla/mux"
 	"github.com/writeas/impart"
 	"github.com/writeas/web-core/auth"
 	"github.com/writeas/writefreely/config"
 	"net/http"
 	"runtime"
 	"strconv"
 	"time"
 )
 
 var (
 	appStartTime = time.Now()
 	sysStatus    systemStatus
 )
 
 type systemStatus struct {
 	Uptime       string
 	NumGoroutine int
 
 	// General statistics.
 	MemAllocated string // bytes allocated and still in use
 	MemTotal     string // bytes allocated (even if freed)
 	MemSys       string // bytes obtained from system (sum of XxxSys below)
 	Lookups      uint64 // number of pointer lookups
 	MemMallocs   uint64 // number of mallocs
 	MemFrees     uint64 // number of frees
 
 	// Main allocation heap statistics.
 	HeapAlloc    string // bytes allocated and still in use
 	HeapSys      string // bytes obtained from system
 	HeapIdle     string // bytes in idle spans
 	HeapInuse    string // bytes in non-idle span
 	HeapReleased string // bytes released to the OS
 	HeapObjects  uint64 // total number of allocated objects
 
 	// Low-level fixed-size structure allocator statistics.
 	//	Inuse is bytes used now.
 	//	Sys is bytes obtained from system.
 	StackInuse  string // bootstrap stacks
 	StackSys    string
 	MSpanInuse  string // mspan structures
 	MSpanSys    string
 	MCacheInuse string // mcache structures
 	MCacheSys   string
 	BuckHashSys string // profiling bucket hash table
 	GCSys       string // GC metadata
 	OtherSys    string // other system allocations
 
 	// Garbage collector statistics.
 	NextGC       string // next run in HeapAlloc time (bytes)
 	LastGC       string // last run in absolute time (ns)
 	PauseTotalNs string
 	PauseNs      string // circular buffer of recent GC pause times, most recent at [(NumGC+255)%256]
 	NumGC        uint32
 }
 
 func handleViewAdminDash(app *app, u *User, w http.ResponseWriter, r *http.Request) error {
 	updateAppStats()
 	p := struct {
 		*UserPage
 		SysStatus systemStatus
 		Config    config.AppCfg
 
 		Message, ConfigMessage string
 
 		AboutPage, PrivacyPage string
 	}{
 		UserPage:  NewUserPage(app, r, u, "Admin", nil),
 		SysStatus: sysStatus,
 		Config:    app.cfg.App,
 
 		Message:       r.FormValue("m"),
 		ConfigMessage: r.FormValue("cm"),
 	}
 
 	var err error
 	p.AboutPage, err = getAboutPage(app)
 	if err != nil {
 		return err
 	}
 
 	p.PrivacyPage, _, err = getPrivacyPage(app)
 	if err != nil {
 		return err
 	}
 
 	showUserPage(w, "admin", p)
 	return nil
 }
 
 func handleAdminUpdateSite(app *app, u *User, w http.ResponseWriter, r *http.Request) error {
 	vars := mux.Vars(r)
 	id := vars["page"]
 
 	// Validate
 	if id != "about" && id != "privacy" {
 		return impart.HTTPError{http.StatusNotFound, "No such page."}
 	}
 
 	// Update page
 	m := ""
 	err := app.db.UpdateDynamicContent(id, r.FormValue("content"))
 	if err != nil {
 		m = "?m=" + err.Error()
 	}
 	return impart.HTTPError{http.StatusFound, "/admin" + m + "#page-" + id}
 }
 
 func handleAdminUpdateConfig(app *app, u *User, w http.ResponseWriter, r *http.Request) error {
 	app.cfg.App.SiteName = r.FormValue("site_name")
+	app.cfg.App.SiteDesc = r.FormValue("site_desc")
 	app.cfg.App.OpenRegistration = r.FormValue("open_registration") == "on"
 	mul, err := strconv.Atoi(r.FormValue("min_username_len"))
 	if err == nil {
 		app.cfg.App.MinUsernameLen = mul
 	}
 	mb, err := strconv.Atoi(r.FormValue("max_blogs"))
 	if err == nil {
 		app.cfg.App.MaxBlogs = mb
 	}
 	app.cfg.App.Federation = r.FormValue("federation") == "on"
 	app.cfg.App.PublicStats = r.FormValue("public_stats") == "on"
 	app.cfg.App.Private = r.FormValue("private") == "on"
 
 	m := "?cm=Configuration+saved."
 	err = config.Save(app.cfg)
 	if err != nil {
 		m = "?cm=" + err.Error()
 	}
 	return impart.HTTPError{http.StatusFound, "/admin" + m + "#config"}
 }
 
 func updateAppStats() {
 	sysStatus.Uptime = tool.TimeSincePro(appStartTime)
 
 	m := new(runtime.MemStats)
 	runtime.ReadMemStats(m)
 	sysStatus.NumGoroutine = runtime.NumGoroutine()
 
 	sysStatus.MemAllocated = tool.FileSize(int64(m.Alloc))
 	sysStatus.MemTotal = tool.FileSize(int64(m.TotalAlloc))
 	sysStatus.MemSys = tool.FileSize(int64(m.Sys))
 	sysStatus.Lookups = m.Lookups
 	sysStatus.MemMallocs = m.Mallocs
 	sysStatus.MemFrees = m.Frees
 
 	sysStatus.HeapAlloc = tool.FileSize(int64(m.HeapAlloc))
 	sysStatus.HeapSys = tool.FileSize(int64(m.HeapSys))
 	sysStatus.HeapIdle = tool.FileSize(int64(m.HeapIdle))
 	sysStatus.HeapInuse = tool.FileSize(int64(m.HeapInuse))
 	sysStatus.HeapReleased = tool.FileSize(int64(m.HeapReleased))
 	sysStatus.HeapObjects = m.HeapObjects
 
 	sysStatus.StackInuse = tool.FileSize(int64(m.StackInuse))
 	sysStatus.StackSys = tool.FileSize(int64(m.StackSys))
 	sysStatus.MSpanInuse = tool.FileSize(int64(m.MSpanInuse))
 	sysStatus.MSpanSys = tool.FileSize(int64(m.MSpanSys))
 	sysStatus.MCacheInuse = tool.FileSize(int64(m.MCacheInuse))
 	sysStatus.MCacheSys = tool.FileSize(int64(m.MCacheSys))
 	sysStatus.BuckHashSys = tool.FileSize(int64(m.BuckHashSys))
 	sysStatus.GCSys = tool.FileSize(int64(m.GCSys))
 	sysStatus.OtherSys = tool.FileSize(int64(m.OtherSys))
 
 	sysStatus.NextGC = tool.FileSize(int64(m.NextGC))
 	sysStatus.LastGC = fmt.Sprintf("%.1fs", float64(time.Now().UnixNano()-int64(m.LastGC))/1000/1000/1000)
 	sysStatus.PauseTotalNs = fmt.Sprintf("%.1fs", float64(m.PauseTotalNs)/1000/1000/1000)
 	sysStatus.PauseNs = fmt.Sprintf("%.3fs", float64(m.PauseNs[(m.NumGC+255)%256])/1000/1000/1000)
 	sysStatus.NumGC = m.NumGC
 }
 
 func adminResetPassword(app *app, u *User, newPass string) error {
 	hashedPass, err := auth.HashPass([]byte(newPass))
 	if err != nil {
 		return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not create password hash: %v", err)}
 	}
 
 	err = app.db.ChangePassphrase(u.ID, true, "", hashedPass)
 	if err != nil {
 		return impart.HTTPError{http.StatusInternalServerError, fmt.Sprintf("Could not update passphrase: %v", err)}
 	}
 	return nil
 }
diff --git a/config/config.go b/config/config.go
index 50a904b..438dc15 100644
--- a/config/config.go
+++ b/config/config.go
@@ -1,111 +1,112 @@
 package config
 
 import (
 	"gopkg.in/ini.v1"
 )
 
 const (
 	FileName = "config.ini"
 )
 
 type (
 	ServerCfg struct {
 		HiddenHost string `ini:"hidden_host"`
 		Port       int    `ini:"port"`
 		Bind       string `ini:"bind"`
 
 		TLSCertPath string `ini:"tls_cert_path"`
 		TLSKeyPath  string `ini:"tls_key_path"`
 
 		Dev bool `ini:"-"`
 	}
 
 	DatabaseCfg struct {
 		Type     string `ini:"type"`
 		User     string `ini:"username"`
 		Password string `ini:"password"`
 		Database string `ini:"database"`
 		Host     string `ini:"host"`
 		Port     int    `ini:"port"`
 	}
 
 	AppCfg struct {
 		SiteName string `ini:"site_name"`
+		SiteDesc string `ini:"site_description"`
 		Host     string `ini:"host"`
 
 		// Site appearance
 		Theme      string `ini:"theme"`
 		JSDisabled bool   `ini:"disable_js"`
 		WebFonts   bool   `ini:"webfonts"`
 
 		// Users
 		SingleUser       bool `ini:"single_user"`
 		OpenRegistration bool `ini:"open_registration"`
 		MinUsernameLen   int  `ini:"min_username_len"`
 		MaxBlogs         int  `ini:"max_blogs"`
 
 		// Federation
 		Federation  bool `ini:"federation"`
 		PublicStats bool `ini:"public_stats"`
 		Private     bool `ini:"private"`
 	}
 
 	Config struct {
 		Server   ServerCfg   `ini:"server"`
 		Database DatabaseCfg `ini:"database"`
 		App      AppCfg      `ini:"app"`
 	}
 )
 
 func New() *Config {
 	return &Config{
 		Server: ServerCfg{
 			Port: 8080,
 			Bind: "localhost", /* IPV6 support when not using localhost? */
 		},
 		Database: DatabaseCfg{
 			Type: "mysql",
 			Host: "localhost",
 			Port: 3306,
 		},
 		App: AppCfg{
 			Host:           "http://localhost:8080",
 			Theme:          "write",
 			WebFonts:       true,
 			SingleUser:     true,
 			MinUsernameLen: 3,
 			MaxBlogs:       1,
 			Federation:     true,
 			PublicStats:    true,
 		},
 	}
 }
 
 func (cfg *Config) IsSecureStandalone() bool {
 	return cfg.Server.Port == 443 && cfg.Server.TLSCertPath != "" && cfg.Server.TLSKeyPath != ""
 }
 
 func Load() (*Config, error) {
 	cfg, err := ini.Load(FileName)
 	if err != nil {
 		return nil, err
 	}
 
 	// Parse INI file
 	uc := &Config{}
 	err = cfg.MapTo(uc)
 	if err != nil {
 		return nil, err
 	}
 	return uc, nil
 }
 
 func Save(uc *Config) error {
 	cfg := ini.Empty()
 	err := ini.ReflectFrom(cfg, uc)
 	if err != nil {
 		return err
 	}
 
 	return cfg.SaveTo(FileName)
 }
diff --git a/nodeinfo.go b/nodeinfo.go
index eab15cc..d247168 100644
--- a/nodeinfo.go
+++ b/nodeinfo.go
@@ -1,99 +1,102 @@
 package writefreely
 
 import (
 	"github.com/writeas/go-nodeinfo"
 	"github.com/writeas/web-core/log"
 	"github.com/writeas/writefreely/config"
 	"strings"
 )
 
 type nodeInfoResolver struct {
 	cfg *config.Config
 	db  *datastore
 }
 
 func nodeInfoConfig(db *datastore, cfg *config.Config) *nodeinfo.Config {
 	name := cfg.App.SiteName
-	desc := "Minimal, federated blogging platform."
+	desc := cfg.App.SiteDesc
+	if desc == "" {
+		desc = "Minimal, federated blogging platform."
+	}
 	if cfg.App.SingleUser {
 		// Fetch blog information, instead
 		coll, err := db.GetCollectionByID(1)
 		if err == nil {
 			desc = coll.Description
 		}
 	}
 	return &nodeinfo.Config{
 		BaseURL: cfg.App.Host,
 		InfoURL: "/api/nodeinfo",
 
 		Metadata: nodeinfo.Metadata{
 			NodeName:        name,
 			NodeDescription: desc,
 			Private:         cfg.App.Private,
 			Software: nodeinfo.SoftwareMeta{
 				HomePage: softwareURL,
 				GitHub:   "https://github.com/writeas/writefreely",
 				Follow:   "https://writing.exchange/@write_as",
 			},
 		},
 		Protocols: []nodeinfo.NodeProtocol{
 			nodeinfo.ProtocolActivityPub,
 		},
 		Services: nodeinfo.Services{
 			Inbound: []nodeinfo.NodeService{},
 			Outbound: []nodeinfo.NodeService{
 				nodeinfo.ServiceRSS,
 			},
 		},
 		Software: nodeinfo.SoftwareInfo{
 			Name:    strings.ToLower(serverSoftware),
 			Version: softwareVer,
 		},
 	}
 }
 
 func (r nodeInfoResolver) IsOpenRegistration() (bool, error) {
 	return r.cfg.App.OpenRegistration, nil
 }
 
 func (r nodeInfoResolver) Usage() (nodeinfo.Usage, error) {
 	var collCount, postCount int64
 	var activeHalfYear, activeMonth int
 	var err error
 	collCount, err = r.db.GetTotalCollections()
 	if err != nil {
 		collCount = 0
 	}
 	postCount, err = r.db.GetTotalPosts()
 	if err != nil {
 		log.Error("Unable to fetch post counts: %v", err)
 	}
 
 	if r.cfg.App.PublicStats {
 		// Display bi-yearly / monthly stats
 		err = r.db.QueryRow(`SELECT COUNT(*) FROM (
 SELECT DISTINCT collection_id
 FROM posts
 INNER JOIN collections c
 ON collection_id = c.id
 WHERE collection_id IS NOT NULL
 	AND updated > DATE_SUB(NOW(), INTERVAL 6 MONTH)) co`).Scan(&activeHalfYear)
 
 		err = r.db.QueryRow(`SELECT COUNT(*) FROM (
 SELECT DISTINCT collection_id
 FROM posts
 INNER JOIN FROM collections c
 ON collection_id = c.id
 WHERE collection_id IS NOT NULL
 	AND updated > DATE_SUB(NOW(), INTERVAL 1 MONTH)) co`).Scan(&activeMonth)
 	}
 
 	return nodeinfo.Usage{
 		Users: nodeinfo.UsageUsers{
 			Total:          int(collCount),
 			ActiveHalfYear: activeHalfYear,
 			ActiveMonth:    activeMonth,
 		},
 		LocalPosts: int(postCount),
 	}, nil
 }
diff --git a/templates/user/admin.tmpl b/templates/user/admin.tmpl
index 41b51ee..9d19494 100644
--- a/templates/user/admin.tmpl
+++ b/templates/user/admin.tmpl
@@ -1,193 +1,197 @@
 {{define "admin"}}
 {{template "header" .}}
 
 <style type="text/css">
 h2 {font-weight: normal;}
 ul.pagenav {list-style: none;}
 form {
 	margin: 0 0 2em;
 }
 form dt {
 	line-height: inherit;
 }
 .ui.divider:not(.vertical):not(.horizontal) {
 	border-top: 1px solid rgba(34,36,38,.15);
 	border-bottom: 1px solid rgba(255,255,255,.1);
 }
 .ui.divider {
 	margin: 1rem 0;
 	line-height: 1;
 	height: 0;
 	font-weight: 700;
 	text-transform: uppercase;
 	letter-spacing: .05em;
 	color: rgba(0,0,0,.85);
 	-webkit-user-select: none;
 	-moz-user-select: none;
 	-ms-user-select: none;
 	user-select: none;
 	-webkit-tap-highlight-color: transparent;
 	font-size: 1rem;
 }
 </style>
 
 <script>
 function savePage(el) {
 	var $btn = el.querySelector('input[type=submit]');
 	$btn.value = 'Saving...';
 	$btn.disabled = true;
 }
 </script>
 
 <div class="content-container snug">
 	<h1>Admin Dashboard</h1>
 
 	{{if .Message}}<p>{{.Message}}</p>{{end}}
 
 	<ul class="pagenav">
 		{{if not .SingleUser}}
 		<li><a href="#page-about">Edit About page</a></li>
 		<li><a href="#page-privacy">Edit Privacy page</a></li>
 		{{end}}
 		<li><a href="#reset-pass">Reset user password</a></li>
 		<li><a href="#config">Configuration</a></li>
 		<li><a href="#monitor">Application monitor</a></li>
 	</ul>
 
 	<hr />
 
 	{{if not .SingleUser}}
 	<h2>Site</h2>
 
 	<h3 id="page-about">About page</h3>
 	<p>Describe what your instance is <a href="/about" target="page">about</a>. <em>Accepts Markdown</em>.</p>
 	<form method="post" action="/admin/update/about" onsubmit="savePage(this)">
 		<textarea id="about-editor" class="section codable norm edit-page" name="content">{{.AboutPage}}</textarea>
 		<input type="submit" value="Save" />
 	</form>
 
 	<h3 id="page-privacy">Privacy page</h3>
 	<p>Outline your <a href="/privacy" target="page">privacy policy</a>. <em>Accepts Markdown</em>.</p>
 	<form method="post" action="/admin/update/privacy" onsubmit="savePage(this)">
 		<textarea id="privacy-editor" class="section codable norm edit-page" name="content">{{.PrivacyPage}}</textarea>
 		<input type="submit" value="Save" />
 	</form>
 
 	<hr />
 	{{end}}
 
 	<h2>Users</h2>
 
 	<h3><a name="reset-pass"></a>reset password</h3>
 	<pre><code>writefreely --reset-pass &lt;username&gt;</code></pre>
 
 	<hr />
 
 	<h2><a name="config"></a>App Configuration</h2>
 
 	{{if .ConfigMessage}}<p class="success" style="text-align: center">{{.ConfigMessage}}</p>{{end}}
 
 	<form action="/admin/update/config" method="post">
 	<div class="ui attached table segment">
 		<dl class="dl-horizontal admin-dl-horizontal">
 			<dt>Site Name</dt>
 			<dd><input type="text" name="site_name" id="site_name" class="inline" value="{{.Config.SiteName}}" style="width: 14em;" /></dd>
+			{{if not .SingleUser}}
+			<dt>Site Description</dt>
+			<dd><input type="text" name="site_desc" id="site_desc" class="inline" value="{{.Config.SiteDesc}}" style="width: 14em;" /></dd>
+			{{end}}
 			<dt>Host</dt>
 			<dd>{{.Config.Host}}</dd>
 			<dt>User Mode</dt>
 			<dd>{{if .Config.SingleUser}}Single user{{else}}Multiple users{{end}}</dd>
 			<dt><label for="open_registration">Open Registrations</label></dt>
 			<dd><input type="checkbox" name="open_registration" id="open_registration" {{if .Config.OpenRegistration}}checked="checked"{{end}} /></dd>
 			<dt><label for="min_username_len">Minimum Username Length</label></dt>
 			<dd><input type="number" name="min_username_len" id="min_username_len" class="inline" min="1" max="100" value="{{.Config.MinUsernameLen}}" /></dd>
 			<dt><label for="max_blogs">Maximum Blogs per User</label></dt>
 			<dd><input type="number" name="max_blogs" id="max_blogs" class="inline" min="1" value="{{.Config.MaxBlogs}}" /></dd>
 			<dt><label for="federation">Federation</label></dt>
 			<dd><input type="checkbox" name="federation" id="federation" {{if .Config.Federation}}checked="checked"{{end}} /></dd>
 			<dt><label for="public_stats">Public Stats</label></dt>
 			<dd><input type="checkbox" name="public_stats" id="public_stats" {{if .Config.PublicStats}}checked="checked"{{end}} /></dd>
 			<dt><label for="private">Private Instance</label></dt>
 			<dd><input type="checkbox" name="private" id="private" {{if .Config.Private}}checked="checked"{{end}} /></dd>
 		</dl>
 		<input type="submit" value="Save Configuration" />
 	</div>
 	</form>
 
 	<hr />
 
 	<h2><a name="monitor"></a>Application</h2>
 
 	<div class="ui attached table segment">
 		<dl class="dl-horizontal admin-dl-horizontal">
 			<dt>Server Uptime</dt>
 			<dd>{{.SysStatus.Uptime}}</dd>
 			<dt>Current Goroutines</dt>
 			<dd>{{.SysStatus.NumGoroutine}}</dd>
 			<div class="ui divider"></div>
 			<dt>Current memory usage</dt>
 			<dd>{{.SysStatus.MemAllocated}}</dd>
 			<dt>Total mem allocated</dt>
 			<dd>{{.SysStatus.MemTotal}}</dd>
 			<dt>Memory obtained</dt>
 			<dd>{{.SysStatus.MemSys}}</dd>
 			<dt>Pointer lookup times</dt>
 			<dd>{{.SysStatus.Lookups}}</dd>
 			<dt>Memory allocate times</dt>
 			<dd>{{.SysStatus.MemMallocs}}</dd>
 			<dt>Memory free times</dt>
 			<dd>{{.SysStatus.MemFrees}}</dd>
 			<div class="ui divider"></div>
 			<dt>Current heap usage</dt>
 			<dd>{{.SysStatus.HeapAlloc}}</dd>
 			<dt>Heap memory obtained</dt>
 			<dd>{{.SysStatus.HeapSys}}</dd>
 			<dt>Heap memory idle</dt>
 			<dd>{{.SysStatus.HeapIdle}}</dd>
 			<dt>Heap memory in use</dt>
 			<dd>{{.SysStatus.HeapInuse}}</dd>
 			<dt>Heap memory released</dt>
 			<dd>{{.SysStatus.HeapReleased}}</dd>
 			<dt>Heap objects</dt>
 			<dd>{{.SysStatus.HeapObjects}}</dd>
 			<div class="ui divider"></div>
 			<dt>Bootstrap stack usage</dt>
 			<dd>{{.SysStatus.StackInuse}}</dd>
 			<dt>Stack memory obtained</dt>
 			<dd>{{.SysStatus.StackSys}}</dd>
 			<dt>MSpan structures in use</dt>
 			<dd>{{.SysStatus.MSpanInuse}}</dd>
 			<dt>MSpan structures obtained</dt>
 			<dd>{{.SysStatus.HeapSys}}</dd>
 			<dt>MCache structures in use</dt>
 			<dd>{{.SysStatus.MCacheInuse}}</dd>
 			<dt>MCache structures obtained</dt>
 			<dd>{{.SysStatus.MCacheSys}}</dd>
 			<dt>Profiling bucket hash table obtained</dt>
 			<dd>{{.SysStatus.BuckHashSys}}</dd>
 			<dt>GC metadata obtained</dt>
 			<dd>{{.SysStatus.GCSys}}</dd>
 			<dt>Other system allocation obtained</dt>
 			<dd>{{.SysStatus.OtherSys}}</dd>
 			<div class="ui divider"></div>
 			<dt>Next GC recycle</dt>
 			<dd>{{.SysStatus.NextGC}}</dd>
 			<dt>Since last GC</dt>
 			<dd>{{.SysStatus.LastGC}}</dd>
 			<dt>Total GC pause</dt>
 			<dd>{{.SysStatus.PauseTotalNs}}</dd>
 			<dt>Last GC pause</dt>
 			<dd>{{.SysStatus.PauseNs}}</dd>
 			<dt>GC times</dt>
 			<dd>{{.SysStatus.NumGC}}</dd>
 		</dl>
 	</div>
 </div>
 
 <script>
 history.replaceState(null, "", "/admin"+window.location.hash);
 </script>
 
 {{template "footer" .}}
 
 {{template "body-end" .}}
 {{end}}