---
myst:
html_meta:
"description": ""
"property=og:description": ""
"property=og:title": ""
"keywords": ""
---
(intro-what-is-plone-label)=
# What is Plone?
Plone is an open source Content Management System (CMS) built in Python. A CMS lets non-technical people create and maintain information for a public website or an intranet using only a web browser.
- Open Source Enterprise `CMS`
- Written in `Python`
- `Plone` 5.2 supports `Python` 3 and 2
- `Plone` 6 supports `Python` 3
- {doc}`plone6docs:plone.restapi/docs/source/index`
- `Volto`: `React` based frontend and editor
- Based on the web framework {term}`Zope`
- Database: `Zope Object Database` {term}`ZODB` or `ORM` & `SQL`/`Postgres`/`Oracle`
- Runs on Linux, macOS, BSD, Solaris, NixOS and Windows
Plone has a multitude of powerful features, is easily accessible to editors but also fun for programmers.
- Workflow-driven, collaborative management of content
- Industrial Strength Security and Access-Control
- Limitless Extensibility
The modular and open component architecture of Plone allows you to change or extend Plone in every respect!
```{seealso}
- [What Is Plone?](https://5.docs.plone.org/intro/index.html)
- [Conceptual Overview](https://5.docs.plone.org/working-with-content/introduction/conceptual-overview.html)
```
## Core concepts
Here are the technical concepts that Plone uses.
They make Plone special and distinguish it from most other systems.
### Traversal
- Plone uses [Traversal](https://5.docs.plone.org/develop/plone/serving/traversing.html) (portal/folder/document) instead of URL dispatch.
- Python objects exists in a object tree that looks like a huge nested dictionary:
```python
{'site': {'folder': {'page': page_object}}}
```
- Objects can be accessed like walking through a file-system:
```python
root['site']['folder']['page']
```
```python
>>> from plone import api
>>> portal = api.portal.get()
>>> portal.keys()
['folder1', 'document1']
>>> portal['folder1']
```
### Object publishing
Objects can be called and return a representation of itself - usually HTML.
```python
>>> obj = portal['folder1']['a-newsitem']
>>> obj
>>> obj()
'\n\n\n
-
```
````
### CMF
- `CMF` was an add-on for Zope to build Content Management Systems (like Plone).
- It provides libraries for building content management applications together with the Zope Application Server.
### Plone (the backend)
This is the backend of the CMS.
This is what we are extending and using during this training.
### Rest API
{doc}`plone6docs:plone.restapi/docs/source/index`
is a hypermedia API to access Plone content using REST (Representational State Transfer).
It is used to connect the Volto frontend with Plone.
(volto-basics-label)=
### Volto Frontend
[Volto](https://github.com/plone/volto) is the default frontend for Plone 6 written in ReactJS.
It uses the Rest API to communicate with the backend and offers a modern editing experience.
Here are some basics that you need to understand if you are new to Volto:
- All data is stored in Plone backend.
The Volto frontend comes in to display and edit the content.
- Volto is built in [ReactJS](https://www.reactjs.dev), a modern Javascript Framework.
- Volto uses {doc}`plone6docs:plone.restapi/docs/source/index` to communicate with the Plone backend.
- Volto is installed separately from the Plone backend.
See chapter {ref}`instructions-install-frontend-label` for instructions.
- Volto runs in a different process than the Plone backend.
By default Volto runs on port 3000. If you start Volto with `yarn start` you can see the frontend on .
The Plone backend runs by default on
- You create a new Plone instance in an already set up Zope environment via the backend.
This is by now not possible in Volto.
- Volto takes advantage of [Semantic UI React components](https://react.semantic-ui.com/) to compose most of the views.
For example the component [Image](https://react.semantic-ui.com/elements/image/) is used to render images.
- The Volto default theme is based on Semantic UI theme and is called [Pastanaga](https://www.youtube.com/watch?v=wW9mTl1Tavc&t=133s).
- Same as Plone Classic, Volto is highly extendable with add-ons for further features.
- Existing Volto components are customizable with a technology similar to `z3c.jbot` called {ref}`volto-overrides-componentshadowing-label`.
- Volto provides server side rendering (SSR), important for SEO-purposes.
- Volto aims to provide 100% of the features of the current Plone backend.
Not all features of Plone are implemented in Volto yet.
- Volto provides additional functionality that Plone does not have.
- For example Volto features the Pastanaga Editor, allowing you to visually compose a page using blocks.
This feature is enabled for content types that have the behavior `volto.blocks` enabled.
- Using the `Volto` editor, the content you add in blocks and the arrangement of blocks is stored as JSON in the schema fields `blocks` and `blocks_layout` provided by the dexterity behavior `volto.blocks`.
Additionally you can edit all fields of the content type schema in a sidebar.
- If you do not use the behavior `volto.blocks`, the fields from a content-type schema are edited and stored exactly like previously in Plone Classic.
### Classic Frontend
A stable alternative to the `React` frontend Volto is the classic frontend of Plone that uses server-side rendered HTML.
Plone ships with a default theme called Barceloneta.
Since Plone 6 it uses [Bootstrap 5](https://getbootstrap.com/).
The Plone Classic frontend uses the template-engine [Chameleon](https://chameleon.readthedocs.io/en/latest/) to create html.
```{note} Choosing the right frontend
Here are some pointers that may help you decide:
- The new Plone 6 frontend is recommended for new projects.
- Existing projects that are updated to Plone 6 can decide which frontend to use.
If a lot of customizations were done and you don't want to reimplement a lot of custom templates and features in Volto, it is a good idea to use Plone Classic.
- For a selection of awesome Volto add-ons see
- There are a growing ecosystem of add-ons for the React frontend.
Be aware that a Plone Classic add-on may not have value for your project, if it has a theming component or anything that concerns the UI.
That could be for example a backend add-on that implements the logic and storage of bookmarks.
The UI needs to be implemented in React, be it an open source add-on or your custom add-on.
Both, frontend and backend, communicate via REST API.
- Most existing add-ons for Plone will have to be adapted to Volto if they touch the UI (e.g. templates for content types, control panels or viewlets).
- Ask the community for advice if you are not certain what to choose.
```