The API Stability is somewhere between experimental and stable.
You can use it out of the box for small to medium sites.
design goals and principles
- it is a GlintApp implementation
- runs in node.js and in the browser with browserify
- modular | collection of reusable, replacable modules | follows unix philosophy
- fast, no magic for SEO (like screen scraping of own content with headless browser)
- for WebSites as well as for WebApps
- Clean Code over Convention over Configuration
- mostly framework agnostic
- easy to learn
- inline editing
- minimal management backend
- minimal build tasks
- minimal configuration
- no dynamic require
- no magic
- only simple abstractions
- It should work with all of the newer browsers.
- Express is used on the server side
- It runs on Linux and Mac OS, Windows is not yet supported (any help appreciated)
- Tested with node 0.12.x and 4.x
Bring your own Database
glint-adapter for abstracting the data storage. glintcms-starter-intesso for example uses no database at all, but the file system
You can write your own adapter provider for the database storage of your choice with minimal effort.
Bring your own Template Engine
GlintCMS works with any template engine that supports node.js and runs in the browser as well.
Just keep in mind that not all of them perform as good. We made the best experience with doT.js.
Because GlintCMS is designed from the very beginning, to run efficient on the server as well as in the browser, it is a really good fit for many things.
- Web Application (Single Page Applications)
- Web Sites / Platforms (Heavy server side rendering)
+--------------+ +--------------+ +--------------+ | | | | | | | wrap | +----> | container | +----> | block | | | | | | | +--------------+ +--------------+ +--------------+ + + | | v v +--------------+ +--------------+ + + + + + + + + | | | | | widget | +----> | adapter | +----> + cache + | | | | +--------------+ +--------------+ + + + + + + + +
created with asciiflow
Blocks are the heart of everything that is editable in GlintCMS.
A block provider can be a plain text
glint-block-text, or an image or a rich text e.g.
block itself (
glint-block) is a unifying interface for the block providers.
It is the block providers responsibility to display its data and to turn it into something editable, when switching to edit mode.
They must basically implement the following sync functions:
load(content) edit() var content = save()
glint-adapter) is the unifying interface for the adapter providers like e.g.
The adapter provider is responsible for storing and retrieving the data/content.
It only solves access to single types, entities, documents or tables (the terms very with the providers technology, let's stick with the term
It does not combine instances of different types (joins), that's up to the
An adapter provider must implement these async functions:
load(.., cb) save(.., cb) delete(.., cb) find(.., cb)
Is optional and is not yet implemented.
glint-container) holds the different blocks and orchestrates nifty details, like
- what should be loaded (rendered) on the server and what in the browser.
- switching the blocks into the edit mode
editand back (
- passing the data between the
- a container has got one adapter and most likely has several
If you don't have any editable content on your page, you don't need a container.
glint-widget) can be useful for displaying content, that does not need to be editable in this place.
As an example, you could use it to display the three latest blog entries on the first page.
widget implementation needs to implement the functions:
data(cb) // async, optional, if you don't need to load data in an async way render(fn) // sync, returns the rendered content
widget itself exposes the
load function to integrate with the
wrap loading mechanism.
glint-wrap) wraps it all up.
- it can have several
- it also is involved in what should be loaded (rendered) on the server and what in the browser.
- Try out one of the starter projects (it should only take a couple of minutes to get going):
- Have a look at the API Documentation
- As well as the Extend Documentation
- Have a look at the code of the modules, shout out if you need help.
... for more detailed usage scenarios.