• direct file editing in the filesystem
• command-line interface for metadata listing, content addition, mass tag editing and more
• include other pages or links to them filtered by tags on a page
• parameterised include with placeholders and conditionals
• any file type is supported for inclusion. there are several default content types with special rendering: itml, plain, preformatted, url and csv. media is included using the html <object> tag: png, jpg, svg, gif. other types are by default hyperlinked when included
• itml is an indent based markup language with extendable custom dynamic expression support. for the syntax see itml
• csv file inclusion rendered as one or multiple grouped tables based on a csv column
• separate instances with the same codebase but different data sets possible. for example for multiple different sites on the same sph-cms version
• bonus: inclusion of automatically extracted guile scheme code documentation for guile modules

• read-only html/http interface
• html5 output using <section> and <object> tags to embed content
• browse by tags
• browse with pagination, optional content inlining while browsing, optionally sorted by title or modification time
• atom feed for recently modified files with custom tag queries
• view markup source for a page
• thumbnails of customisable size for images

• content tagging
• tag filter queries with and/or/not, ##### fully supporting

as a sph-web-app project, other projects can derive from it, import it, use and extend its routes and other features

• pages are text and any other type of files
• metadata is stored in an automatically managed database, sph-dg
• derivative configuration files

have overview pages with hyperlinks to sub-pages filtered by tags to create mind map like websites, or pages that include content matching certain tags

browse a list of content ordered by modification time like a super minimal weblog

extend it with new url paths that call scheme procedures for custom responses

lists all tags split into two groups based on how many elements they are used for

• lists all content with all selected tags
• supports a nestable expression syntax with and/or/not, for example "/essays/(not topic-a)"
• when filtering content, two rows are displayed: one for adding non-ubiquitous tags to the query, and one for removing tags/expressions from the current query

like /browse/link but without rendering the browse navigation, only a list of matching content

like browse/link but directly includes text content if it is below a certain file size. by default sorted by modification time

every content element has a database-unique base32 id

direct access to content files

• install the dependencies
• get the source code "git clone git://sph.mn/sph-cms"
• unpack the archive and change to the unpacked/source directory

• "./exe/sph-cms start" starts the application ("C-c" exits) with an scgi interface. if there are no errors, that likely means that the install of the sph-cms code is working
• then to access it via http, an http server that supports scgi like nginx has to be configured like in the sph-web-app documentation
• here are the example configurations for nginx from the web-app documentation nginx configuration example

• for files: mount the "data/files/" directory with sshfs or use rsync or git to synchronise the directory. because files are registered in the database, content can only be edited, not deleted or added this way
• for metadata: load-balance two started instances of the same installation. pack the database with tar (the database is a sparse file), stop one instance, replace the database, start. repeat for the other instance. since the database stores little data, this usually takes only a few seconds

• versioning of edits (can be implemented with (sph filesystem versioning))
• access control (can be implemented with sph-lib-dg (sph storage permission))
• user accounts (can be implemented with sph-lib-dg (sph storage user))
• search (an extension could search through the content files)
• use of record data structures for content elements (classes)
• create one default configuration file stored with the project and a script to start nginx using that local configuration file so that no separate web server configuration is required
• display links to pages that link to the currently visited content
• check for broken links in the markup
• management of remote instances with the sph-cms command
• permalinks, content urls that do not change when content is moved between databases
• template and style extensions