diff --git a/cms_form/README.rst b/cms_form/README.rst
new file mode 100644
index 00000000..6b1f2f90
--- /dev/null
+++ b/cms_form/README.rst
@@ -0,0 +1,222 @@
+.. image:: https://img.shields.io/badge/licence-lgpl--3-blue.svg
+   :target: http://www.gnu.org/licenses/LGPL-3.0-standalone.html
+   :alt: License: LGPL-3
+
+CMS Form
+========
+
+Basic website contents form framework. Allows to define front-end forms for every models in a simple way.
+
+If you are tired of re-defining every time an edit form or a search form for your odoo website,
+this is the module you are looking for.
+
+Features
+========
+
+* automatic form generation (create, write, search)
+* automatic route generation (create, write, search)
+* automatic machinery based on fields' type:
+    * widget rendering
+    * field value load (from existing instance or from request)
+    * field value extraction (from request)
+    * field value write (to existing instance)
+
+* highly customizable
+* works with every odoo model
+* works also without any model
+* add handy attributes to models inheriting from ``website.published.mixin``:
+    * ``cms_add_url``: lead to create form view. By default ``/cms/form/create/my.model``
+    * ``cms_edit_url``: lead to edit form view. By default ``/cms/form/edit/my.model/model_id``
+    * ``cms_search_url``: lead to search form view. By default ``/cms/form/search/my.model``
+
+Usage
+=====
+
+Create / Edit form
+------------------
+
+Just inherit from ``cms.form`` to add a form for your model. Quick example for partner:
+
+.. code-block:: python
+
+    class PartnerForm(models.AbstractModel):
+
+        _name = 'cms.form.res.partner'
+        _inherit = 'cms.form'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id')
+        _form_required_fields = ('name', 'country_id')
+
+
+In this case you'll have form with the following characteristics:
+
+* works with ``res.partner`` model
+* have only ``name`` and ``country_id`` fields
+* both fields are required (is not possible to submit the form w/out one of those values)
+
+Here's the result:
+
+|preview_create|
+|preview_edit|
+
+The form will be automatically available on these routes:
+
+* ``/cms/form/create/res.partner`` to create new partners
+* ``/cms/form/edit/res.partner/1`` edit existing partners (partner id=1 in this case)
+
+NOTE: default generic routes work if the form's name is ``cms.form.`` + model name, like ``cms.form.res.partner``.
+If you want you can easily define your own controller and give your form a different name,
+and have more elegant routes like ```/partner/edit/partner-slug-1``.
+Take a look at `cms_form_example <../cms_form_example>`_.
+
+By default, the form is rendered as an horizontal twitter bootstrap form, but you can provide your own templates of course.
+By default, fields are ordered by their order in the model's schema. You can tweak it using ``_form_fields_order``.
+
+
+Form with extra control fields
+------------------------------
+
+Imagine you want to notify the partner after its creation but only if you really need it.
+
+The form above can be extended with extra fields that are not part of the ``_form_model`` schema:
+
+.. code-block:: python
+
+    class PartnerForm(models.AbstractModel):
+
+        _name = 'cms.form.res.partner'
+        _inherit = 'cms.form'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id', 'email')
+        _form_required_fields = ('name', 'country_id', 'email')
+
+        notify_partner = fields.Boolean()
+
+        def form_after_create_or_update(self, values, extra_values):
+            if extra_values.get('notify_partner'):
+                # do what you want here...
+
+``notify_partner`` will be included into the form but it will be discarded on create and write.
+Nevertheless you can use it as a control flag before and after the record has been created or updated
+using the hook ``form_after_create_or_update``, as you see in this example.
+
+
+Search form
+-----------
+
+Just inherit from ``cms.form.search`` to add a form for your model. Quick example for partner:
+
+.. code-block:: python
+
+    class PartnerSearchForm(models.AbstractModel):
+        """Partner model search form."""
+
+        _name = 'cms.form.search.res.partner'
+        _inherit = 'cms.form.search'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id', )
+        _form_fields_order = ('country_id', 'name', )
+
+
+|preview_search|
+
+The form will be automatically available at: ``/cms/form/search/res.partner``.
+
+NOTE: default generic routes work if the form's name is ```cms.form.search`` + model name, like ``cms.form.search.res.partner``.
+If you want you can easily define your own controller and give your form a different name,
+and have more elegant routes like ``/partners``.
+Take a look at `cms_form_example <../cms_form_example>`_.
+
+
+Master / slave fields
+---------------------
+
+A typical use case nowadays: you want to show/hide fields based on other fields' values.
+For the simplest cases you don't have to write a single line of JS. You can do it like this:
+
+.. code-block:: python
+
+    class PartnerForm(models.AbstractModel):
+
+        _name = 'cms.form.res.partner'
+        _inherit = 'cms.form'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'type', 'foo')
+
+        def _form_master_slave_info(self):
+            info = self._super._form_master_slave_info()
+            info.update({
+                # master field
+                'type':{
+                    # actions
+                    'hide': {
+                        # slave field: action values
+                        'foo': ('contact', ),
+                    },
+                    'show': {
+                        'foo': ('address', 'invoice', ),
+                    }
+                },
+            })
+            return info
+
+Here we declared that:
+
+* when `type` field is equal to `contact` -> hide `foo` field
+* when `type` field is equal to `address` or `invoice` -> show `foo` field
+
+
+Known issues / Roadmap
+======================
+
+* add more tests, especially per each widget and type of field
+* provide better widgets for image and file fields in general
+* o2m fields: to be tested at all
+* move widgets to abstract models too
+* search form: generate default search domain in a clever way
+* add easy way to switch from horizontal to vertical form
+* provide more examples
+* x2x fields: allow sub-items creation
+* handle api onchanges
+* support python expressions into master/slave rules
+
+
+Bug Tracker
+===========
+
+Bugs are tracked on `GitHub Issues
+<https://github.com/OCA/website-cms/issues>`_. In case of trouble, please
+check there if your issue has already been reported. If you spotted it first,
+help us smashing it by providing a detailed and welcomed feedback.
+
+Credits
+=======
+
+Sponsor
+-------
+
+* `Fluxdock.io <https://fluxdock.io>`_.
+
+Contributors
+------------
+
+* Simone Orsi <simone.orsi@camptocamp.com>
+
+Maintainer
+----------
+
+.. image:: https://odoo-community.org/logo.png
+   :alt: Odoo Community Association
+   :target: https://odoo-community.org
+
+This module is maintained by the OCA.
+
+OCA, or the Odoo Community Association, is a nonprofit organization whose
+mission is to support the collaborative development of Odoo features and
+promote its widespread use.
+
+To contribute to this module, please visit https://odoo-community.org.
+
+.. |preview_create| image:: ./images/cms_form_example_create_partner.png
+.. |preview_edit| image:: ./images/cms_form_example_edit_partner.png
+.. |preview_search| image:: ./images/cms_form_example_search.png
diff --git a/cms_form/__init__.py b/cms_form/__init__.py
new file mode 100644
index 00000000..f7209b17
--- /dev/null
+++ b/cms_form/__init__.py
@@ -0,0 +1,2 @@
+from . import models
+from . import controllers
diff --git a/cms_form/__openerp__.py b/cms_form/__openerp__.py
new file mode 100644
index 00000000..33efef52
--- /dev/null
+++ b/cms_form/__openerp__.py
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+{
+    'name': 'CMS Form',
+    'summary': """
+        Basic content type form""",
+    'version': '9.0.1.0.0',
+    'license': 'LGPL-3',
+    'author': 'Camptocamp SA, Odoo Community Association (OCA)',
+    'depends': [
+        'website',
+        'cms_status_message',
+    ],
+    'data': [
+        'security/cms_form.xml',
+        'templates/assets.xml',
+        'templates/form.xml',
+        'templates/widgets.xml',
+    ],
+    'demo': [
+    ],
+}
diff --git a/cms_form/controllers/__init__.py b/cms_form/controllers/__init__.py
new file mode 100644
index 00000000..12a7e529
--- /dev/null
+++ b/cms_form/controllers/__init__.py
@@ -0,0 +1 @@
+from . import main
diff --git a/cms_form/controllers/main.py b/cms_form/controllers/main.py
new file mode 100644
index 00000000..354a5312
--- /dev/null
+++ b/cms_form/controllers/main.py
@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+import werkzeug
+
+from openerp import http, _
+from openerp.http import request
+
+
+class FormControllerMixin(object):
+
+    # default template
+    template = 'cms_form.form_wrapper'
+
+    def get_template(self, form, **kw):
+        """Retrieve rendering template.
+
+        Defaults to `template` attribute.
+        Can be overridden straight in the form
+        using the attribute `form_wrapper_template`.
+        """
+        template = self.template
+
+        if getattr(form, 'form_wrapper_template', None):
+            template = form.form_wrapper_template
+
+        if not template:
+            raise NotImplementedError("You must provide a template!")
+        return template
+
+    def get_render_values(self, main_object, **kw):
+        """Retrieve rendering values.
+
+        You can override this to inject more values.
+        """
+        parent = None
+        if getattr(main_object, 'parent_id', None):
+            # get the parent if any
+            parent = main_object.parent_id
+
+        kw.update({
+            'main_object': main_object,
+            'parent': parent,
+            'controller': self,
+        })
+        return kw
+
+    def _can_create(self, model, raise_exception=True):
+        """Check that current user can create instances of given model."""
+        return request.env[model].check_access_rights(
+            'create', raise_exception=raise_exception)
+
+    def _can_edit(self, main_object, raise_exception=True):
+        """Check that current user can edit given main object."""
+        try:
+            main_object.check_access_rights('write')
+            main_object.check_access_rule('write')
+            can = True
+        except Exception:
+            if raise_exception:
+                raise
+            can = False
+        return can
+
+    def form_model_key(self, model):
+        """Return a valid form model."""
+        return 'cms.form.' + model
+
+    def get_form(self, model, main_object=None, **kw):
+        """Retrieve form for given model or object and initialize it."""
+        form_model_key = self.form_model_key(model)
+        if form_model_key in request.env:
+            form = request.env[form_model_key].form_init(
+                request, main_object=main_object)
+        else:
+            # TODO: enable form by default?
+            # How? with a flag on ir.model.model?
+            # And which fields to include automatically?
+            raise NotImplementedError(
+                _('%s model has no CMS form registered.') % model
+            )
+        return form
+
+    def check_permission(self, model, main_object):
+        """Check permission on current model and main object."""
+        if main_object:
+            self._can_edit(main_object)
+        else:
+            self._can_create(model)
+
+    def make_response(self, model, model_id=None, page=0, **kw):
+        """Prepare and return form response.
+
+        :param model: an odoo model's name
+        :param model_id: an odoo record's id
+        :param page: current page if any (mostly for search forms)
+        :param kw: extra parameters
+
+        How it works:
+        * retrieve current main object if any
+        * check permission on model and/or main object
+        * retrieve the form
+        * make the form process current request
+        * if the form is successful and has `form_redirect` attribute
+          it redirects to it.
+        * otherwise it just renders the form
+        """
+        main_object = None
+        if model_id:
+            main_object = request.env[model].browse(model_id)
+        self.check_permission(model, main_object)
+        form = self.get_form(model, main_object=main_object)
+        # pass only specific extra args, to not pollute form render values
+        form.form_process(extra_args={'page': page})
+        # search forms do not need these attrs
+        if getattr(form, 'form_success', None) \
+                and getattr(form, 'form_redirect', None):
+            # anything went fine, redirect to next url
+            return werkzeug.utils.redirect(form.form_next_url())
+        # render form wrapper
+        values = self.get_render_values(main_object, **kw)
+        values['form'] = form
+        return request.render(
+            self.get_template(form, **kw),
+            values,
+        )
+
+
+class CMSFormController(http.Controller, FormControllerMixin):
+    """CMS form controller."""
+
+    @http.route([
+        '/cms/form/create/<string:model>',
+        '/cms/form/edit/<string:model>/<int:model_id>',
+    ], type='http', auth='user', website=True)
+    def cms_form(self, model, model_id=None, **kw):
+        """Handle a `form` route.
+        """
+        return self.make_response(model, model_id=model_id, **kw)
+
+
+class SearchFormControllerMixin(FormControllerMixin):
+
+    template = 'cms_form.search_form_wrapper'
+
+    def form_model_key(self, model):
+        return 'cms.form.search.' + model
+
+    def check_permission(self, model, main_object):
+        pass
+
+
+class CMSSearchFormController(http.Controller, SearchFormControllerMixin):
+    """CMS form controller."""
+
+    @http.route([
+        '/cms/form/search/<string:model>',
+        '/cms/form/search/<string:model>/page/<int:page>',
+    ], type='http', auth='public', website=True)
+    def cms_form(self, model, **kw):
+        """Handle a search `form` route.
+        """
+        return self.make_response(model, **kw)
diff --git a/cms_form/i18n/de.po b/cms_form/i18n/de.po
new file mode 100644
index 00000000..fd0e3dd7
--- /dev/null
+++ b/cms_form/i18n/de.po
@@ -0,0 +1,150 @@
+# Translation of Odoo Server.
+# This file contains the translation of the following modules:
+# 	* cms_form
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Odoo Server 9.0c\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-03-30 10:43+0000\n"
+"PO-Revision-Date: 2017-03-30 12:45+0200\n"
+"Last-Translator: <>\n"
+"Language-Team: \n"
+"Language: de\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: \n"
+"X-Generator: Poedit 1.8.9\n"
+
+#. module: cms_form
+#: code:addons/cms_form/controllers/main.py:79
+#: code:addons/odoo/external-src/website-cms/cms_form/controllers/main.py:79
+#, python-format
+msgid "%s model has no CMS form registered."
+msgstr ""
+
+#. module: cms_form
+#: model:ir.model,name:cms_form.model_cms_form
+#: model:ir.model,name:cms_form.model_cms_form_mixin
+#: model:ir.model,name:cms_form.model_cms_form_search
+msgid "CMS Form mixin"
+msgstr "CMS Form mixin"
+
+#. module: cms_form
+#: model:ir.model.fields,field_description:cms_form.field_website_published_mixin_cms_edit_url
+msgid "CMS edit URL"
+msgstr "CMS edit URL"
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.base_form_buttons
+msgid "Cancel"
+msgstr "Abbrechen"
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_form.py:36
+#: code:addons/cms_form/models/cms_form.py:41
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_form.py:36
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_form.py:41
+#, python-format
+msgid "Create %s"
+msgstr "%s anlegen"
+
+#. module: cms_form
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_display_name
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_mixin_display_name
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_search_display_name
+msgid "Display Name"
+msgstr "Angezeigter Name"
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_form.py:34
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_form.py:34
+#, python-format
+msgid "Edit \"%s\""
+msgstr "\"%s\" Bearbeiten"
+
+#. module: cms_form
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_id
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_mixin_id
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_search_id
+msgid "ID"
+msgstr "ID"
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_form.py:58
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_form.py:58
+#, python-format
+msgid "Item created."
+msgstr "Objekt wurde erstellt."
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_form.py:63
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_form.py:63
+#, python-format
+msgid "Item updated."
+msgstr "Objekt wurde aktualisiert."
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.field_widget_image
+msgid "Keep current image"
+msgstr "Aktuelles Bild beibehalten"
+
+#. module: cms_form
+#: model:ir.model.fields,field_description:cms_form.field_cms_form___last_update
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_mixin___last_update
+#: model:ir.model.fields,field_description:cms_form.field_cms_form_search___last_update
+msgid "Last Modified on"
+msgstr "Zuletzt geändert am"
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.form_horizontal_field_wrapper
+msgid "Name"
+msgstr "Bezeichnung"
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.field_widget_image
+msgid "Replace current image"
+msgstr "Aktuelles Bild ersetzen"
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.base_form
+msgid "Required fields"
+msgstr "Pflichtfelder"
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_search_form.py:43
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_search_form.py:43
+#: model:ir.ui.view,arch_db:cms_form.search_form_buttons
+#, python-format
+msgid "Search"
+msgstr "Suche"
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_search_form.py:48
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_search_form.py:48
+#, python-format
+msgid "Search %s"
+msgstr "%s suchen"
+
+#. module: cms_form
+#: code:addons/cms_form/models/cms_form.py:67
+#: code:addons/odoo/external-src/website-cms/cms_form/models/cms_form.py:67
+#, python-format
+msgid "Some required fields are empty."
+msgstr "Bitte füllen Sie alle Pflichtfelder aus."
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.base_form_buttons
+msgid "Submit"
+msgstr "Absenden"
+
+#. module: cms_form
+#: model:ir.ui.view,arch_db:cms_form.field_widget_date
+msgid "YYYY-MM-DD"
+msgstr "JJJJ-MM-TT"
+
+#. module: cms_form
+#: model:ir.model,name:cms_form.model_website_published_mixin
+msgid "website.published.mixin"
+msgstr "website.published.mixin"
diff --git a/cms_form/images/cms_form_example_create_partner.png b/cms_form/images/cms_form_example_create_partner.png
new file mode 100644
index 00000000..6c5f33c0
Binary files /dev/null and b/cms_form/images/cms_form_example_create_partner.png differ
diff --git a/cms_form/images/cms_form_example_edit_partner.png b/cms_form/images/cms_form_example_edit_partner.png
new file mode 100644
index 00000000..73be6518
Binary files /dev/null and b/cms_form/images/cms_form_example_edit_partner.png differ
diff --git a/cms_form/images/cms_form_example_search.png b/cms_form/images/cms_form_example_search.png
new file mode 100644
index 00000000..45b4164a
Binary files /dev/null and b/cms_form/images/cms_form_example_search.png differ
diff --git a/cms_form/models/__init__.py b/cms_form/models/__init__.py
new file mode 100644
index 00000000..eee28441
--- /dev/null
+++ b/cms_form/models/__init__.py
@@ -0,0 +1,6 @@
+from . import cms_form_mixin
+from . import cms_form
+from . import cms_search_form
+from . import test_models
+from . import website_mixin
+from . import widgets
diff --git a/cms_form/models/cms_form.py b/cms_form/models/cms_form.py
new file mode 100644
index 00000000..77e18c78
--- /dev/null
+++ b/cms_form/models/cms_form.py
@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+import werkzeug
+from psycopg2 import IntegrityError
+
+from openerp import models, exceptions, _
+
+
+class CMSForm(models.AbstractModel):
+    _name = 'cms.form'
+    _inherit = 'cms.form.mixin'
+
+    _form_validators = {}
+
+    # internal flag for successful form
+    __form_success = False
+
+    @property
+    def form_success(self):
+        return self.__form_success
+
+    @form_success.setter
+    def form_success(self, value):
+        self.__form_success = value
+
+    @property
+    def form_title(self):
+        if self.main_object:
+            rec_field = self.main_object[self.form_model._rec_name]
+            if hasattr(rec_field, 'id'):
+                rec_field = rec_field.name
+            title = _('Edit "%s"') % rec_field
+        else:
+            title = _('Create %s')
+            if self._form_model:
+                model = self.env['ir.model'].search(
+                    [('model', '=', self._form_model)])
+                name = model and model.name or ''
+                title = _('Create %s') % name
+        return title
+
+    # internal flag for turning on redirection
+    __form_redirect = False
+
+    @property
+    def form_redirect(self):
+        return self.__form_redirect
+
+    @form_redirect.setter
+    def form_redirect(self, value):
+        self.__form_redirect = value
+
+    @property
+    def form_msg_success_created(self):
+        # TODO: include form model name if any
+        msg = _('Item created.')
+        return msg
+
+    @property
+    def form_msg_success_updated(self):
+        return _('Item updated.')
+
+    @property
+    def form_msg_error_missing(self):
+        return _('Some required fields are empty.')
+
+    def form_next_url(self, main_object=None):
+        """URL to redirect to after successful form submission."""
+        if self.request.args.get('redirect'):
+            # redirect overridden
+            return self.request.args.get('redirect')
+        main_object = main_object or self.main_object
+        if main_object and 'website_url' in main_object:
+            return main_object.website_url
+        return '/'
+
+    def form_cancel_url(self, main_object=None):
+        """URL to redirect to after click on "cancel" button."""
+        if self.request.args.get('redirect'):
+            # redirect overridden
+            return self.request.args.get('redirect')
+        main_object = main_object or self.main_object
+        if main_object and 'website_url' in main_object:
+            return main_object.website_url
+        return self.request.referrer or '/'
+
+    def form_check_empty_field(self, fname, field, value, **req_values):
+        """Return True if passed field value is really empty."""
+        if isinstance(value, werkzeug.datastructures.FileStorage):
+            has_value = bool(value.filename)
+            if not has_value and req_values.get(fname + '_keepcheck') == 'yes':
+                # no value, but we want to preserve existing one
+                return False
+            # file field w/ no content
+            # TODO: this is not working sometime...
+            # return not bool(value.content_length)
+            return not has_value
+        return value in (False, '')
+
+    def form_validate(self, request_values=None):
+        """Validate submitted values."""
+        errors = {}
+        errors_message = {}
+        request_values = request_values or self.form_get_request_values()
+
+        missing = False
+        for fname, field in self.form_fields().iteritems():
+            value = request_values.get(fname)
+            error = False
+            if field['required'] \
+                    and self.form_check_empty_field(
+                        fname, field, value, **request_values):
+                errors[fname] = 'missing'
+                missing = True
+            validator = self.form_get_validator(fname, field)
+            if validator:
+                error, error_msg = validator(value, **request_values)
+            if error:
+                errors[fname] = error
+                errors_message[fname] = error_msg
+
+        # error message for empty required fields
+        if missing and self.o_request.website:
+            msg = self.form_msg_error_missing
+            self.o_request.website.add_status_message(msg, type_='danger')
+        return errors, errors_message
+
+    def form_get_validator(self, fname, field):
+        """Retrieve field validator."""
+        # 1nd lookup for a default type validator
+        validator = self._form_validators.get(field['type'], None)
+        # 2nd lookup for a specific type validator
+        validator = getattr(
+            self, '_form_validate_' + field['type'], validator)
+        # 3rd lookup and override by named validator if any
+        validator = getattr(
+            self, '_form_validate_' + fname, validator)
+        return validator
+
+    def form_before_create_or_update(self, values, extra_values):
+        """Pre create/update hook."""
+        pass
+
+    def form_after_create_or_update(self, values, extra_values):
+        """Post create/update hook."""
+        pass
+
+    def _form_purge_non_model_fields(self, values):
+        """Purge fields that are not in `form_model` schema and return them."""
+        extra_values = {}
+        _model_fields = self.form_model.fields_get(
+            self._form_model_fields,
+            attributes=self._form_fields_attributes).keys()
+        submitted_keys = values.keys()
+        for fname in submitted_keys:
+            if fname not in _model_fields:
+                extra_values[fname] = values.pop(fname)
+        return extra_values
+
+    def _form_write(self, values):
+        """Just write on the main object."""
+        self.main_object.write(values)
+
+    def _form_create(self, values):
+        """Just create the main object."""
+        self.main_object = self.form_model.create(values)
+
+    def form_create_or_update(self):
+        """Prepare values and create or update main_object."""
+        write_values = self.form_extract_values()
+        extra_values = self._form_purge_non_model_fields(write_values)
+        # pre hook
+        self.form_before_create_or_update(write_values, extra_values)
+        if self.main_object:
+            self._form_write(write_values)
+            msg = self.form_msg_success_updated
+        else:
+            self._form_create(write_values)
+            msg = self.form_msg_success_created
+        if msg and self.o_request.website:
+            self.o_request.website.add_status_message(msg)
+        # post hook
+        self.form_after_create_or_update(write_values, extra_values)
+        return self.main_object
+
+    def form_process_POST(self, render_values):
+        """Process POST requests."""
+        errors, errors_message = self.form_validate()
+        if not errors:
+            try:
+                self.form_create_or_update()
+                self.form_success = True
+                self.form_redirect = True
+                return render_values
+            except exceptions.ValidationError as err:
+                # sounds like there's no way to validate fields
+                # before calling write or create,
+                # hence we are forced to do it here.
+                errors['_validation'] = True
+                # err message can be something like
+                # u'Error while validating constraint\n
+                #    \nEnd Date cannot be set before Start Date.\nNone'
+                errors_message['_validation'] = '<br />'.join([
+                    x for x in err.name.replace('None', '').split('\n')
+                    if x.strip()
+                ])
+            except IntegrityError as err:
+                errors['_integrity'] = True
+                errors_message['_integrity'] = '<br />'.join([
+                    x for x in err.message.replace('None', '').split('\n')
+                    if x.strip()
+                ])
+
+        # TODO: how to handle validation error on create?
+        # If you use @api.constrains to validate fields' value
+        # the check happens only AFTER the record has been created.
+        # So, on the 1st submit the record is created
+        # and the user is not aware of it since it gets redirected to the form
+        # with errors highlighted. He corrects the error and submit again.
+        # If no errors, he gets redirected to the new record, ANOTHER record.
+        # In the end: we get 2 duplicated objects :(
+        # To avoid this beforehand we need validation on JS side +
+        # pre-validation (where possible) before create or write.
+
+        self.form_success = False
+        # handle ORM validation error
+        orm_error = errors.get('_validation') or errors.get('_integrity')
+        if orm_error:
+            msg = errors_message.get('_validation') \
+                or errors_message.get('_integrity')
+            if msg and self.o_request.website:
+                self.o_request.website.add_status_message(
+                    msg, type_='danger', title=None)
+        render_values.update({
+            'errors': errors,
+            'errors_message': errors_message,
+        })
+        return render_values
diff --git a/cms_form/models/cms_form_mixin.py b/cms_form/models/cms_form_mixin.py
new file mode 100644
index 00000000..0c062905
--- /dev/null
+++ b/cms_form/models/cms_form_mixin.py
@@ -0,0 +1,475 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+import inspect
+import json
+from collections import OrderedDict
+
+from openerp import models, tools
+
+from ..utils import data_merge
+
+
+IGNORED_FORM_FIELDS = [
+    'display_name',
+    '__last_update',
+    # TODO: retrieve from inherited schema
+    'message_ids',
+    'message_follower_ids',
+    'message_follower',
+    'message_last_post',
+    'message_unread',
+    'message_unread_counter',
+    'message_needaction_counter',
+    'website_message_ids',
+    'website_published',
+] + models.MAGIC_COLUMNS
+
+
+class CMSFormMixin(models.AbstractModel):
+    """Base abstract CMS form."""
+    _name = 'cms.form.mixin'
+    _description = 'CMS Form mixin'
+
+    # template to render the form
+    form_template = 'cms_form.base_form'
+    form_fields_template = 'cms_form.base_form_fields'
+    form_buttons_template = 'cms_form.base_form_buttons'
+    form_action = ''
+    form_method = 'POST'
+    _form_mode = ''
+    # extra css klasses for the whole form wrapper
+    _form_wrapper_extra_css_klass = ''
+    # extra css klasses for just the form element
+    _form_extra_css_klass = ''
+    # model tied to this form
+    _form_model = ''
+    # model's fields to load
+    _form_model_fields = []
+    # force fields order
+    _form_fields_order = []
+    # quickly force required fields
+    _form_required_fields = ()
+    # mark some fields as "sub".
+    # For usability reasons you might want to move some fields
+    # inside the widget of another field.
+    # If you mark a field as "sub" this field
+    # won't be included into fields' list as usual
+    # but you can still find it in `form_fields` value.
+    _form_sub_fields = {
+        # 'mainfield': {
+        #     # loaded for a specific value
+        #     'mainfield_value': ('subfield1', 'subfield2'),
+        #     # loaded for all values
+        #     '_all': ('subfield3', ),
+        # }
+    }
+    # fields' attributes to load
+    _form_fields_attributes = [
+        'type', 'string', 'domain',
+        'required', 'readonly', 'relation',
+        'store', 'help', 'selection',
+    ]
+    # include only these fields
+    _form_fields_whitelist = ()
+    # exclude these fields
+    _form_fields_blacklist = ()
+    # extract values mode
+    # This param can be used to alter value format
+    # when extracting values from request.
+    # eg: in write mode you can get on a m2m [(6, 0, [1,2,3])]
+    # while in read mode you can get just the ids [1,2,3]
+    _form_extract_value_mode = 'write'
+    # ignore this fields default
+    __form_fields_ignore = IGNORED_FORM_FIELDS
+    # current edit object if any
+    __form_main_object = None
+
+    @property
+    def main_object(self):
+        """Current main object."""
+        return self.__form_main_object
+
+    @main_object.setter
+    def main_object(self, value):
+        """Current main object setter."""
+        self.__form_main_object = value
+
+    def form_init(self, request, main_object=None, **kw):
+        """Initalize a form instance.
+
+        @param request: an odoo-wrapped werkeug request
+        @param main_object: current model instance if any
+        @param kw: pass any override for `_form_` attributes
+            ie: `fields_attributes` -> `_form_fields_attributes`
+        """
+        form = self.new()
+        form.o_request = request  # odoo wrapped request
+        form.request = request.httprequest  # werkzeug request, the "real" one
+        form.main_object = main_object
+        # override `_form_` parameters
+        for k, v in kw.iteritems():
+            if not inspect.ismethod(getattr(form, '_form_' + k)):
+                setattr(form, '_form_' + k, v)
+        return form
+
+    @property
+    def form_title(self):
+        return ''
+
+    @property
+    def form_description(self):
+        return ''
+
+    @property
+    def form_mode(self):
+        if self._form_mode:
+            # forced mode
+            return self._form_mode
+        if self.main_object:
+            return 'edit'
+        return 'create'
+
+    @property
+    def form_model(self):
+        return self.env[self._form_model]
+
+    def form_fields(self):
+        _fields = self._form_fields()
+        # update fields attributes
+        self.form_update_fields_attributes(_fields)
+        return _fields
+
+    @tools.cache('self')
+    def _form_fields(self):
+        """Retrieve form fields ready to be used.
+
+        Fields lookup:
+        * model's fields
+        * form's fields
+
+        Blacklisted fields are skipped.
+        Whitelisted fields are loaded only.
+        """
+        _all_fields = OrderedDict()
+        # load model fields
+        _model_fields = {}
+        if self._form_model:
+            _model_fields = self.form_model.fields_get(
+                self._form_model_fields,
+                attributes=self._form_fields_attributes)
+            # inject defaults
+            defaults = self.form_model.default_get(self._form_model_fields)
+            for k, v in defaults.iteritems():
+                _model_fields[k]['_default'] = v
+        # load form fields
+        _form_fields = self.fields_get(attributes=self._form_fields_attributes)
+        # inject defaults
+        for k, v in self.default_get(_form_fields.keys()).iteritems():
+            _form_fields[k]['_default'] = v
+        _all_fields.update(_model_fields)
+        # form fields override model fields
+        _all_fields.update(_form_fields)
+        # exclude blacklisted
+        for fname in self._form_fields_blacklist:
+            # make it fail if passing wrong field name
+            _all_fields.pop(fname)
+        # include whitelisted
+        _all_whitelisted = {}
+        for fname in self._form_fields_whitelist:
+            _all_whitelisted[fname] = _all_fields[fname]
+        _all_fields = _all_whitelisted or _all_fields
+        # remove unwanted fields
+        self._form_remove_uwanted(_all_fields)
+        # remove non-stored fields to exclude computed
+        _all_fields = {k: v for k, v in _all_fields.iteritems() if v['store']}
+        # update fields order
+        if self._form_fields_order:
+            _sorted_all_fields = OrderedDict()
+            for fname in self._form_fields_order:
+                _sorted_all_fields[fname] = _all_fields[fname]
+            _all_fields = _sorted_all_fields
+        # compute subfields and remove them from all fields if any
+        self._form_prepare_subfields(_all_fields)
+        return _all_fields
+
+    def _form_prepare_subfields(self, _all_fields):
+        """Add subfields to related main fields."""
+        # TODO: test this
+        for mainfield, subfields in self._form_sub_fields.iteritems():
+            if mainfield in _all_fields:
+                _subfields = {}
+                for val, subs in subfields.iteritems():
+                    _subfields[val] = {}
+                    for sub in subs:
+                        if sub in _all_fields:
+                            _subfields[val][sub] = _all_fields[sub]
+                            _all_fields[sub]['is_subfield'] = True
+                _all_fields[mainfield]['subfields'] = _subfields
+
+    def _form_remove_uwanted(self, _all_fields):
+        """Remove fields from form fields."""
+        for fname in self.__form_fields_ignore:
+            _all_fields.pop(fname, None)
+
+    def form_update_fields_attributes(self, _fields):
+        """Manipulate fields attributes."""
+        for fname, field in _fields.iteritems():
+            if fname in self._form_required_fields:
+                _fields[fname]['required'] = True
+            _fields[fname]['widget'] = self.form_get_widget(fname, field)
+
+    @property
+    def form_widgets(self):
+        """Return a mapping between field name and widget model."""
+        return {}
+
+    def form_get_widget_model(self, fname, field):
+        """Retrieve widget model name."""
+        widget_model = 'cms.form.widget.char'
+        for key in (field['type'], fname):
+            model_key = 'cms.form.widget.' + key
+            if model_key in self.env:
+                widget_model = model_key
+        return self.form_widgets.get(fname, widget_model)
+
+    def form_get_widget(self, fname, field):
+        """Retrieve and initialize widget."""
+        return self.env[self.form_get_widget_model(fname, field)].widget_init(
+            self, fname, field,
+        )
+
+    @property
+    def form_file_fields(self):
+        """File fields."""
+        return {
+            k: v for k, v in self.form_fields().iteritems()
+            if v['type'] == 'binary'
+        }
+
+    def form_get_request_values(self):
+        """Retrieve fields values from current request."""
+        # on POST requests values are in `form` attr
+        # on GET requests values are in `args` attr
+        _values = self.request.form
+        if not _values:
+            # make sure to give precedence to form attribute
+            # since you might get some extra params (like ?redirect)
+            # and this will make the form machinery miss all the fields
+            _values = self.request.args
+        # normal fields
+        values = {
+            k: v for k, v in _values.iteritems()
+            if k not in ('csrf_token', )
+        }
+        # file fields
+        values.update(
+            {k: v for k, v in self.request.files.iteritems()}
+        )
+        return values
+
+    def form_load_defaults(self, main_object=None, request_values=None):
+        """Load default values.
+
+        Values lookup order:
+
+        1. `main_object` fields' values (if an existing main_object is passed)
+        2. request parameters (only parameters matching form fields names)
+        """
+        main_object = main_object or self.main_object
+        request_values = request_values or self.form_get_request_values()
+        defaults = request_values.copy()
+        form_fields = self.form_fields()
+        for fname, field in form_fields.iteritems():
+            value = field['widget'].w_load(**request_values)
+            # override via specific form loader when needed
+            loader = self.form_get_loader(
+                fname, field,
+                main_object=main_object, value=value, **request_values)
+            if loader:
+                value = loader(fname, field, value, **request_values)
+            defaults[fname] = value
+        return defaults
+
+    def form_get_loader(self, fname, field,
+                        main_object=None, value=None, **req_values):
+        """Retrieve form value loader.
+
+        :param fname: field name
+        :param field: field description as `fields_get`
+        :param main_object: current main object if any
+        :param value: current field value if any
+        :param req_values: custom request valuess
+        """
+        # lookup for a specific type loader method
+        loader = getattr(
+            self, '_form_load_' + field['type'], None)
+        # 3rd lookup and override by named loader if any
+        loader = getattr(
+            self, '_form_load_' + fname, loader)
+        return loader
+
+    def form_extract_values(self, **request_values):
+        """Extract values from request form."""
+        request_values = request_values or self.form_get_request_values()
+        values = {}
+        for fname, field in self.form_fields().iteritems():
+            value = field['widget'].w_extract(**request_values)
+            # override via specific form extractor when needed
+            extractor = self.form_get_extractor(
+                fname, field, value=value, **request_values)
+            if extractor:
+                value = extractor(self, fname, value, **request_values)
+            if value is None:
+                # we assume we do not want to override the field value.
+                # a typical example is an image field.
+                # If you have an existing image
+                # you cannot set the default value on the file input
+                # for standard HTML security restrictions.
+                # If you want to flush a value on a field just return "False".
+                continue
+            values[fname] = value
+        return values
+
+    def form_get_extractor(self, fname, field, value=None, **req_values):
+        """Retrieve form value extractor.
+
+        :param fname: field name
+        :param field: field description as `fields_get`
+        :param value: current field value if any
+        :param req_values: custom request valuess
+        """
+        # lookup for a specific type handler
+        extractor = getattr(
+            self, '_form_extract_' + field['type'], None)
+        # 3rd lookup and override by named handler if any
+        extractor = getattr(
+            self, '_form_extract_' + fname, extractor)
+        return extractor
+
+    __form_render_values = {}
+
+    @property
+    def form_render_values(self):
+        """Values used to render the form."""
+        if not self.__form_render_values:
+            # default render values
+            self.__form_render_values = {
+                'main_object': self.main_object,
+                'form': self,
+                'form_data': {},
+                'errors': {},
+                'errors_messages': {},
+            }
+        return self.__form_render_values
+
+    @form_render_values.setter
+    def form_render_values(self, value):
+        self.__form_render_values = value
+
+    def form_render(self, **kw):
+        """Renders form template declared in `form_template`.
+
+        To render the form simply do:
+
+            <t t-raw="form.form_render()" />
+        """
+        values = self.form_render_values.copy()
+        values.update(kw)
+        return self.env.ref(self.form_template).render(values)
+
+    def form_process(self, **kw):
+        """Process current request.
+
+        :param kw: inject custom / extra rendering values.
+
+        Lookup correct request handler by request method
+        and call it with rendering values.
+        The handler can perform any action (like creating objects)
+        and then return final rendering form values
+        and store them into `form_render_values`.
+        """
+        render_values = self.form_render_values
+        render_values.update(kw)
+        render_values['form_data'] = self.form_load_defaults()
+        handler = getattr(self, 'form_process_' + self.request.method.upper())
+        render_values.update(handler(render_values))
+        self.form_render_values = render_values
+
+    def form_process_GET(self, render_values):
+        """Process GET requests."""
+        return render_values
+
+    def form_process_POST(self, render_values):
+        """Process POST requests."""
+        raise NotImplementedError()
+
+    @property
+    def form_wrapper_css_klass(self):
+        """Return form wrapper css klass.
+
+        By default the form markup is wrapped
+        into a `cms_form_wrapper` element.
+        You can use this set of klasses to customize form styles.
+
+        Included by default:
+        * `cms_form_wrapper` marker
+        * form model name normalized (res.partner -> res_partner)
+        * `_form_wrapper_extra_css_klass` extra klasses from form attribute
+        * `mode_` + form mode (ie: 'mode_write')
+        """
+        parts = [
+            'cms_form_wrapper',
+            self._name.replace('.', '_').lower(),
+            self._form_model.replace('.', '_').lower(),
+            self._form_wrapper_extra_css_klass,
+            'mode_' + self.form_mode,
+        ]
+        return ' '.join([x.strip() for x in parts if x.strip()])
+
+    @property
+    def form_css_klass(self):
+        """Return `<form />` element css klasses.
+
+        By default you can provide extra klasses via `_form_extra_css_klass`.
+        """
+        return self._form_extra_css_klass
+
+    def form_json_info(self):
+        info = {}
+        info.update({
+            'master_slave': self._form_master_slave_info()
+        })
+        return json.dumps(info)
+
+    def _form_master_slave_info(self):
+        """Return info about master/slave fields JSON compatible.
+
+        # TODO: support pyeval expressions in JS
+
+        Eg: {
+            'field_master1': {
+                'hide': {
+                    # field to hide: values
+                    # TODO: support pyeval expressions
+                    'field_slave1': (master_value1, ),
+                },
+                'show': {
+                    # field to show: pyeval expr
+                    'field_slave1': (master_value2, ),
+                },
+            }
+        }
+        """
+        return {}
+
+    def _form_info_merge(self, info, tomerge):
+        """Merge info dictionaries.
+
+        Practical example:
+        when inheriting forms you can add extra rules for the same master field
+        so if you don't want to override info completely
+        you can use this method to merge them properly.
+        """
+        return data_merge(info, tomerge)
diff --git a/cms_form/models/cms_search_form.py b/cms_form/models/cms_search_form.py
new file mode 100644
index 00000000..19f699b5
--- /dev/null
+++ b/cms_form/models/cms_search_form.py
@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+from openerp import models, _
+
+
+class CMSFormSearch(models.AbstractModel):
+    _name = 'cms.form.search'
+    _inherit = 'cms.form.mixin'
+
+    form_buttons_template = 'cms_form.search_form_buttons'
+    form_search_results_template = 'cms_form.search_results'
+    form_action = ''
+    form_method = 'GET'
+    # you might want to just list items based on a predefined query
+    # if this flag is false the search form won't be rendered
+    form_show_search_form = True
+    _form_mode = 'search'
+    _form_extract_value_mode = 'read'
+    # show results if no query has been submitted?
+    _form_show_results_no_submit = 1
+    _form_results_per_page = 10
+    # sort by this param, defaults to model's `_order`
+    _form_results_orderby = ''
+
+    def form_update_fields_attributes(self, _fields):
+        """No field should be mandatory."""
+        super(CMSFormSearch, self).form_update_fields_attributes(_fields)
+        for fname, field in _fields.iteritems():
+            field['required'] = False
+
+    __form_search_results = {}
+
+    @property
+    def form_search_results(self):
+        """Return search results."""
+        return self.__form_search_results
+
+    @form_search_results.setter
+    def form_search_results(self, value):
+        self.__form_search_results = value
+
+    @property
+    def form_title(self):
+        title = _('Search')
+        if self._form_model:
+            model = self.env['ir.model'].search(
+                [('model', '=', self._form_model)])
+            name = model and model.name or ''
+            title = _('Search %s') % name
+        return title
+
+    def form_process_GET(self, render_values):
+        self.form_search(render_values)
+        return render_values
+
+    def form_search(self, render_values):
+        """Produce search results."""
+        search_values = self.form_extract_values()
+        if not search_values and not self._form_show_results_no_submit:
+            return self.form_search_results
+        domain = self.form_search_domain(search_values)
+        count = self.form_model.search_count(domain)
+        page = render_values.get('extra_args', {}).get('page', 0)
+        url = render_values.get('extra_args', {}).get('pager_url', '')
+        if self._form_model:
+            url = getattr(self.form_model, 'cms_search_url', url)
+        pager = self._form_results_pager(count=count, page=page, url=url)
+        order = self._form_results_orderby or None
+        results = self.form_model.search(
+            domain,
+            limit=self._form_results_per_page,
+            offset=pager['offset'],
+            order=order
+        )
+        self.form_search_results = {
+            'results': results,
+            'count': count,
+            'pager': pager,
+        }
+        return self.form_search_results
+
+    def pager(self, **kw):
+        return self.env['website'].pager(**kw)
+
+    def _form_results_pager(self, count=None, page=0, url='', url_args=None):
+        """Prepare pager for current search."""
+        url_args = url_args or self.request.args.to_dict()
+        count = count
+        return self.pager(
+            url=url,
+            total=count,
+            page=page,
+            step=self._form_results_per_page,
+            scope=self._form_results_per_page,
+            url_args=url_args
+        )
+
+    def form_search_domain(self, search_values):
+        """Build search domain."""
+        domain = []
+        for fname, field in self.form_fields().iteritems():
+            value = search_values.get(fname)
+            if value is None:
+                continue
+            if field['type'] in ('many2one', ) and value < 1:
+                # we need an existing ID here ( > 0)
+                continue
+            # TODO: find the way to properly handle this.
+            # It would be nice to guess leafs in a clever way.
+            operator = '='
+            if field['type'] in ('char', 'text'):
+                operator = 'ilike'
+                value = '%{}%'.format(value)
+            elif field['type'] in ('integer', 'float', 'many2one'):
+                operator = '='
+            elif field['type'] in ('one2many', 'many2many'):
+                if not value:
+                    continue
+                operator = 'in'
+            elif field['type'] in ('many2one', ) and not value:
+                # we need an existing ID here ( > 0)
+                continue
+            elif field['type'] in ('boolean', ):
+                value = value == 'on' and True
+            leaf = (fname, operator, value)
+            domain.append(leaf)
+        return domain
diff --git a/cms_form/models/test_models.py b/cms_form/models/test_models.py
new file mode 100644
index 00000000..65470c47
--- /dev/null
+++ b/cms_form/models/test_models.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+from openerp import fields, models, tools
+import os
+
+testing = tools.config.get('test_enable') or os.environ.get('ODOO_TEST_ENABLE')
+
+if testing:
+    class TestPartnerForm(models.AbstractModel):
+        """A test model form."""
+
+        _name = 'cms.form.res.partner'
+        _inherit = 'cms.form'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id')
+        _form_required_fields = ('name', 'country_id')
+
+        custom = fields.Char()
+
+        def _form_load_custom(
+                self, main_object, fname, value, **req_values):
+            return req_values.get('custom', 'oh yeah!')
+
+    class TestSearchPartnerForm(models.AbstractModel):
+        """A test model search form."""
+
+        _name = 'cms.form.search.res.partner'
+        _inherit = 'cms.form.search'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id')
+
+        def form_search_domain(self, search_values):
+            """Force domain to include only test-created records."""
+            domain = super(
+                TestSearchPartnerForm, self
+            ).form_search_domain(search_values)
+            # we use this attr in tests to limit search results
+            # to test records' scope
+            include_only_ids = getattr(self, 'test_record_ids', [])
+            if include_only_ids:
+                domain.append(('id', 'in', include_only_ids))
+            return domain
+
+    class TestFieldsForm(models.AbstractModel):
+        """A test model form."""
+
+        _name = 'cms.form.test_fields'
+        _inherit = 'cms.form'
+
+        a_char = fields.Char()
+        a_number = fields.Integer()
+        a_float = fields.Float()
+        # fake relation fields
+        a_many2one = fields.Char()
+        a_one2many = fields.Char()
+        a_many2many = fields.Char()
+
+        def _form_fields(self):
+            _fields = super(TestFieldsForm, self)._form_fields()
+            # fake fields' types
+            _fields['a_many2one']['type'] = 'many2one'
+            _fields['a_many2one']['relation'] = 'res.partner'
+            _fields['a_many2many']['type'] = 'many2many'
+            _fields['a_many2many']['relation'] = 'res.partner'
+            _fields['a_one2many']['type'] = 'one2many'
+            _fields['a_one2many']['relation'] = 'res.partner'
+            return _fields
+
+        def _form_validate_a_float(self, value, **request_values):
+            """Specific validator for `a_float` field."""
+            value = float(value or '0')
+            return not value > 5, 'Must be greater than 5!'
+
+        def _form_validate_char(self, value, **request_values):
+            """Specific validator for all `char` fields."""
+            return not len(value) > 8, 'Text lenght must be greater than 8!'
diff --git a/cms_form/models/website_mixin.py b/cms_form/models/website_mixin.py
new file mode 100644
index 00000000..b1a6d5e7
--- /dev/null
+++ b/cms_form/models/website_mixin.py
@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+from openerp import api, fields, models
+
+
+class WebsitePublishedMixin(models.AbstractModel):
+    _inherit = "website.published.mixin"
+
+    @property
+    def cms_add_url(self):
+        return '/cms/form/create/{}'.format(self._name)
+
+    @property
+    def cms_search_url(self):
+        return '/cms/form/search/{}'.format(self._name)
+
+    cms_edit_url = fields.Char(
+        string='CMS edit URL',
+        compute='_compute_cms_edit_url',
+        readonly=True,
+    )
+
+    @api.multi
+    def _compute_cms_edit_url(self):
+        for item in self:
+            item.cms_edit_url = \
+                '/cms/form/edit/{}/{}'.format(item._name, item.id)
diff --git a/cms_form/models/widgets.py b/cms_form/models/widgets.py
new file mode 100644
index 00000000..5363b764
--- /dev/null
+++ b/cms_form/models/widgets.py
@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+import json
+import werkzeug
+import base64
+
+from openerp.tools.mimetypes import guess_mimetype
+from openerp import models
+
+from .. import utils
+
+
+class Widget(models.AbstractModel):
+    _name = 'cms.form.widget.mixin'
+
+    # use `w_` prefix as a namespace for all widget properties
+    _w_template = ''
+    _w_css_klass = ''
+
+    def widget_init(self, form, fname, field,
+                    data=None, subfields=None, template='', css_klass=''):
+        widget = self.new()
+        widget.w_form = form
+        widget.w_record = form.main_object
+        widget.w_form_values = form.form_render_values
+        widget.w_fname = fname
+        widget.w_field = field
+        widget.w_field_value = widget.w_form_values.get(
+            'form_data', {}).get(fname)
+        widget.w_data = data or {}
+        widget.w_subfields = subfields or field.get('subfields', {})
+        widget._w_template = template or self._w_template
+        widget._w_css_klass = css_klass or self._w_css_klass
+        return widget
+
+    def render(self):
+        return self.env.ref(self.w_template).render({'widget': self})
+
+    @property
+    def w_template(self):
+        return self._w_template
+
+    @property
+    def w_css_klass(self):
+        return self._w_css_klass
+
+    def w_load(self, **req_values):
+        """Load value for current field in current request."""
+        value = self.w_field.get('_default')
+        # we could have form-only fields (like `custom` in test form below)
+        if self.w_record and self.w_fname in self.w_record:
+            value = self.w_record[self.w_fname] or value
+        # maybe a POST request with new values: override item value
+        value = req_values.get(self.w_fname, value)
+        return value
+
+    def w_extract(self, **req_values):
+        """Extract value from form submit."""
+        return req_values.get(self.w_fname)
+
+    def w_ids_from_input(self, value):
+        """Convert list of ids from form input."""
+        return [int(rec_id) for rec_id in value.split(',') if rec_id.isdigit()]
+
+    def w_subfields_by_value(self, value='_all'):
+        return self.w_subfields.get(value, {})
+
+
+class CharWidget(models.AbstractModel):
+    _name = 'cms.form.widget.char'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_char'
+
+
+class IntegerWidget(models.AbstractModel):
+    _name = 'cms.form.widget.integer'
+    _inherit = 'cms.form.widget.char'
+
+    def w_extract(self, **req_values):
+        value = super(IntegerWidget, self).w_extract(**req_values)
+        return utils.safe_to_integer(value)
+
+
+class FloatWidget(models.AbstractModel):
+    _name = 'cms.form.widget.float'
+    _inherit = 'cms.form.widget.char'
+
+    def w_extract(self, **req_values):
+        value = super(FloatWidget, self).w_extract(**req_values)
+        return utils.safe_to_float(value)
+
+
+class M2OWidget(models.AbstractModel):
+    _name = 'cms.form.widget.many2one'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_m2o'
+
+    def widget_init(self, form, fname, field, **kw):
+        widget = super(M2OWidget, self).widget_init(form, fname, field, **kw)
+        widget.w_comodel = self.env[widget.w_field['relation']]
+        widget.w_domain = widget.w_field.get('domain', [])
+        return widget
+
+    @property
+    def w_option_items(self):
+        return self.w_comodel.search(self.w_domain)
+
+    def w_load(self, **req_values):
+        value = super(M2OWidget, self).w_load(**req_values)
+        return self.m2o_to_form(value)
+
+    def m2o_to_form(self, value):
+        # important: return False if no value
+        # otherwise you will compare an empty recordset with an id
+        # in a select input in form widget template.
+        if isinstance(value, basestring) and value.isdigit():
+            # number as string
+            return int(value) > 0 and int(value)
+        elif isinstance(value, models.BaseModel):
+            return value and value.id or None
+        elif isinstance(value, int):
+            return value
+        return None
+
+    def w_extract(self, **req_values):
+        value = super(M2OWidget, self).w_extract(**req_values)
+        return self.form_to_m2o(value, **req_values)
+
+    def form_to_m2o(self, value, **req_values):
+        val = utils.safe_to_integer(value)
+        # we don't want m2o value do be < 1
+        return val > 0 and val or None
+
+
+class SelectionWidget(models.AbstractModel):
+    _name = 'cms.form.widget.selection'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_selection'
+
+    @property
+    def w_option_items(self):
+        return [
+            {'value': x[0], 'label': x[1]}
+            for x in self.w_field['selection']
+        ]
+
+
+class RadioSelectionWidget(SelectionWidget):
+    _name = 'cms.form.widget.radio'
+    _inherit = 'cms.form.widget.selection'
+    _w_template = 'cms_form.field_widget_radio_selection'
+    # you can define help message per each options
+    # opt value: help msg (can be html too)
+    w_options_help = {}
+
+    def widget_init(self, form, fname, field, **kw):
+        widget = super(
+            RadioSelectionWidget, self).widget_init(form, fname, field, **kw)
+        widget.w_options_help = kw.get('options_help') or {}
+        return widget
+
+
+class X2MWidget(models.AbstractModel):
+    _name = 'cms.form.widget.x2m.mixin'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_x2m'
+    w_diplay_field = 'display_name'
+
+    def widget_init(self, form, fname, field, **kw):
+        widget = super(X2MWidget, self).widget_init(form, fname, field, **kw)
+        widget.w_comodel = self.env[widget.w_field['relation']]
+        widget.w_domain = widget.w_field.get('domain', [])
+        return widget
+
+    def w_load(self, **req_values):
+        value = super(X2MWidget, self).w_load(**req_values)
+        return self.x2many_to_form(value, **req_values)
+
+    def x2many_to_form(self, value, **req_values):
+        if not value:
+            return json.dumps([])
+        # FIXME: this check can compare pears and apples
+        # because the value might come from the request
+        # and we compare objects to strings or list of strings
+        if self.w_record and value == self.w_record[self.w_fname]:
+            # value from record
+            value = [
+                {'id': x.id, 'name': x[self.w_diplay_field]}
+                for x in value or []
+            ]
+        elif (isinstance(value, basestring) and
+                value == req_values.get(self.w_fname)):
+            # value from request
+            # FIXME: the field could come from the form not the model!
+            value = self.w_form.form_model[self.w_fname].browse(
+                self.w_ids_from_input(value)).read(['name'])
+        value = json.dumps(value)
+        return value
+
+    def w_extract(self, **req_values):
+        value = super(X2MWidget, self).w_extract(**req_values)
+        return self.form_to_x2many(value, **req_values)
+
+    def form_to_x2many(self, value, **req_values):
+        _value = False
+        if self.w_form._form_extract_value_mode == 'write':
+            if value:
+                _value = [(6, False, self.w_ids_from_input(value))]
+            else:
+                # wipe them
+                _value = [(5, )]
+        else:
+            _value = value and self.w_ids_from_input(value) or []
+        return _value
+
+
+# TODO: handle advanced editing via table view and subform for such fields
+class O2ManyWidget(models.AbstractModel):
+    _name = 'cms.form.widget.one2many'
+    _inherit = 'cms.form.widget.x2m.mixin'
+
+
+class M2MWidget(models.AbstractModel):
+    _name = 'cms.form.widget.many2many'
+    _inherit = 'cms.form.widget.x2m.mixin'
+
+
+# TODO: add datetime widget
+class DateWidget(models.AbstractModel):
+    _name = 'cms.form.widget.date'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_date'
+
+    def w_extract(self, **req_values):
+        value = super(DateWidget, self).w_extract(**req_values)
+        return self.form_to_date(value, **req_values)
+
+    def form_to_date(self, value, **req_values):
+        return utils.safe_to_date(value)
+
+
+class TextWidget(models.AbstractModel):
+    _name = 'cms.form.widget.text'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_text'
+    w_maxlength = None
+
+    def widget_init(self, form, fname, field, **kw):
+        widget = super(TextWidget, self).widget_init(
+            form, fname, field, **kw
+        )
+        widget.w_maxlength = kw.get('maxlength')
+        return widget
+
+
+class BinaryWidget(models.AbstractModel):
+    _name = 'cms.form.widget.binary.mixin'
+    _inherit = 'cms.form.widget.mixin'
+
+    def w_load(self, **req_values):
+        value = super(BinaryWidget, self).w_load(**req_values)
+        return self.binary_to_form(value, **req_values)
+
+    def binary_to_form(self, value, **req_values):
+        _value = {
+            # 'value': '',
+            # 'raw_value': '',
+            # 'mimetype': '',
+        }
+        if value:
+            if isinstance(value, werkzeug.datastructures.FileStorage):
+                # value from request, we cannot set a value for input field
+                value = ''
+                mimetype = ''
+            else:
+                mimetype = guess_mimetype(value.decode('base64'))
+            _value = {
+                'value': value,
+                'raw_value': value,
+                'mimetype': mimetype,
+            }
+            if mimetype.startswith('image/'):
+                _value['value'] = 'data:{};base64,{}'.format(mimetype, value)
+        return _value
+
+    def w_extract(self, **req_values):
+        value = super(BinaryWidget, self).w_extract(**req_values)
+        return self.form_to_binary(value, **req_values)
+
+    def form_to_binary(self, value, **req_values):
+        _value = False
+        if req_values.get(self.w_fname + '_keepcheck') == 'yes':
+            # prevent discarding image
+            req_values.pop(self.w_fname, None)
+            req_values.pop(self.w_fname + '_keepcheck')
+            return None
+        if value:
+            if hasattr(value, 'read'):
+                file_content = value.read()
+                _value = base64.encodestring(file_content)
+            else:
+                _value = value.split(',')[-1]
+        return _value
+
+
+class ImageWidget(models.AbstractModel):
+    _name = 'cms.form.widget.image'
+    _inherit = 'cms.form.widget.binary.mixin'
+    _w_template = 'cms_form.field_widget_image'
+
+
+class BooleanWidget(models.AbstractModel):
+    _name = 'cms.form.widget.boolean'
+    _inherit = 'cms.form.widget.mixin'
+    _w_template = 'cms_form.field_widget_boolean'
+
+    w_true_values = utils.TRUE_VALUES
+
+    def widget_init(self, form, fname, field, **kw):
+        widget = super(BooleanWidget, self).widget_init(
+            form, fname, field, **kw)
+        widget.w_true_values = kw.get('true_values', self.w_true_values)
+        widget.w_field_value = widget.w_field_value in self.w_true_values
+        return widget
+
+    def w_extract(self, **req_values):
+        value = super(BooleanWidget, self).w_extract(**req_values)
+        return utils.string_to_bool(value, true_values=self.w_true_values)
diff --git a/cms_form/security/cms_form.xml b/cms_form/security/cms_form.xml
new file mode 100644
index 00000000..b1edc6f0
--- /dev/null
+++ b/cms_form/security/cms_form.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright 2017 Simone Orsi
+License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+-->
+
+<odoo>
+<data>
+
+    <record model="ir.model.access" id="cms_form_access_name"> <!-- TODO acl id -->
+        <field name="name">cms.form access name</field> <!-- TODO acl name -->
+        <field name="model_id" ref="model_cms_form"/>
+        <!-- TODO review and adapt -->
+        <field name="group_id" ref="base.group_user"/>
+        <field name="perm_read" eval="1"/>
+        <field name="perm_create" eval="0"/>
+        <field name="perm_write" eval="0"/>
+        <field name="perm_unlink" eval="0"/>
+    </record>
+
+</data>
+</odoo>
diff --git a/cms_form/static/description/icon.png b/cms_form/static/description/icon.png
new file mode 100644
index 00000000..3a0328b5
Binary files /dev/null and b/cms_form/static/description/icon.png differ
diff --git a/cms_form/static/src/js/date_widget.js b/cms_form/static/src/js/date_widget.js
new file mode 100644
index 00000000..4b87e153
--- /dev/null
+++ b/cms_form/static/src/js/date_widget.js
@@ -0,0 +1,27 @@
+odoo.define('cms_form.date_widget', function (require) {
+    'use strict';
+
+    $(document).ready(function () {
+        $("input.js_datepicker").each(function(){
+            var $input = $(this);
+            $input.datepicker({
+                useSeconds: false,
+                icons : {
+                    time: 'fa fa-clock-o',
+                    date: 'fa fa-calendar',
+                    up: 'fa fa-chevron-up',
+                    down: 'fa fa-chevron-down'
+                },
+                dateFormat : $input.data('format')
+            }).datepicker("setDate", new Date());
+            $input
+                .closest('.input-group')
+                .find('.js_datepicker_trigger').click(function(){
+                    $input.datepicker('show');
+                })
+        })
+
+
+    });
+
+});
diff --git a/cms_form/static/src/js/master_slave.js b/cms_form/static/src/js/master_slave.js
new file mode 100644
index 00000000..17575aed
--- /dev/null
+++ b/cms_form/static/src/js/master_slave.js
@@ -0,0 +1,89 @@
+odoo.define('cms_form.master_slave', function (require) {
+    'use strict';
+    /*
+    Handle master / slave fields automatically.
+    TODO: explain behavior.
+    */
+
+    // TODO: this does not work ATM :(
+    // var pyeval = require('web.pyeval');
+    var animation = require("web_editor.snippets.animation");
+    var $ = require("$");
+
+    return animation.registry.CMSFormMasterSlave = animation.Class.extend({
+      selector: ".cms_form_wrapper form",
+      start: function (editable_mode) {
+        this.data = this.$el.data('form');
+        this.setup_handlers();
+        this.load_master_slave();
+      },
+      setup_handlers: function(){
+        this.handlers = {
+          'hide': $.proxy(this.handle_hide, this),
+          'show': $.proxy(this.handle_show, this),
+          'readonly': $.proxy(this.handle_readonly, this),
+          'no_readonly': $.proxy(this.handle_no_readonly, this),
+          'required': $.proxy(this.handle_required, this),
+          'no_required': $.proxy(this.handle_no_required, this)
+        };
+      },
+      load_master_slave: function(){
+        var self = this;
+        $.each(this.data.master_slave, function(master, slaves){
+          var $master_input = $('[name="' + master +'"]');
+          $.each(slaves, function(action, mapping){
+            var handler = self.handlers[action];
+            if (handler) {
+              $master_input.on('change', function(){
+                handler($(this), mapping) }
+              ).filter(':selected,:checked,[type=text]').trigger('change'); // trigger change only for specific inputs
+            }
+          })
+        })
+      },
+      // TODO: merge these functions as they are pretty much equals
+      handle_hide: function($input, mapping){
+        $.each(mapping, function(slave_fname, values){
+          if ($.inArray($input.val(), values) >= 0) {
+            $('[name="' + slave_fname +'"]').closest('.form-group').hide();
+          }
+        });
+      },
+      handle_show: function($input, mapping){
+        $.each(mapping, function(slave_fname, values){
+          if ($.inArray($input.val(), values) >= 0) {
+            $('[name="' + slave_fname +'"]').closest('.form-group').show();
+          }
+        });
+      },
+      handle_readonly: function($input, mapping){
+        $.each(mapping, function(slave_fname, values){
+          if ($.inArray($input.val(), values) >= 0) {
+            $('[name="' + slave_fname +'"]').attr('disabled', 'disabled');
+          }
+        });
+      },
+      handle_no_readonly: function($input, mapping){
+        $.each(mapping, function(slave_fname, values){
+          if ($.inArray($input.val(), values) >= 0) {
+            $('[name="' + slave_fname +'"]').attr('disabled', null);
+          }
+        });
+      },
+      handle_required: function($input, mapping){
+        $.each(mapping, function(slave_fname, values){
+          if ($.inArray($input.val(), values) >= 0) {
+            $('[name="' + slave_fname +'"]').attr('required', 'required');
+          }
+        });
+      },
+      handle_no_required: function($input, mapping){
+        $.each(mapping, function(slave_fname, values){
+          if ($.inArray($input.val(), values) >= 0) {
+            $('[name="' + slave_fname +'"]').attr('required', null);
+          }
+        });
+      }
+    });
+
+});
diff --git a/cms_form/static/src/js/select2widgets.js b/cms_form/static/src/js/select2widgets.js
new file mode 100644
index 00000000..a8562893
--- /dev/null
+++ b/cms_form/static/src/js/select2widgets.js
@@ -0,0 +1,86 @@
+odoo.define('cms_form.select2widgets', function (require) {
+    'use strict';
+
+    var Model = require('web.Model');
+    var ajax = require('web.ajax');
+    var core = require('web.core');
+    var base = require('web_editor.base');
+
+    var _t = core._t;
+
+
+    if(!$('.js_select2_m2m_widget').length) {
+        return $.Deferred().reject("DOM doesn't contain '.js_select2_m2m_widget'");
+    }
+
+    $(document).ready(function () {
+
+        $('input.js_select2_m2m_widget').each(function(){
+            var $input = $(this);
+            var lastsearch = [];
+            $input.select2({
+                multiple: true,
+                tags: true,
+                tokenSeparators: [",", " ", "_"],
+                formatResult: function(term) {
+                    if (term.isNew) {
+                        return '<span class="label label-primary">New</span> ' + _.escape(term.text);
+                    } else {
+                        return _.escape(term.text);
+                    }
+                },
+                query: function(options) {
+                    var domain = [];
+                    if (options.term){
+                        domain.push([
+                          $input.data('search_field') || 'name', 'ilike', '%' + options.term + '%'
+                        ])
+                    }
+                    // TODO: use data.CompundDomain to build domain
+                    // ATM it's just in backend assets
+                    // and requires both data.js and pyeval.js
+                    domain = _.union(domain, $input.data('domain'));
+                    ajax.jsonRpc("/web/dataset/call_kw", 'call', {
+                        model: $input.data('model'),
+                        method: 'search_read',
+                        args: [domain],
+                        kwargs: {
+                            fields: $input.data('fields'),
+                            context: base.get_context()
+                        }
+                    }).then(function(data) {
+                        var display_name = $input.data('display_name');
+                        data.sort(function(a, b) {
+                            return a[display_name].localeCompare(b[display_name]);
+                        });
+                        var res = {
+                            results: []
+                        };
+                        _.each(data, function(x) {
+                            res.results.push({
+                                id: x.id,
+                                text: x[display_name],
+                                isNew: false
+                            });
+                        });
+                        options.callback(res);
+                    });
+                },
+                // Default tags from the input value
+                initSelection: function(element, callback) {
+                    var data = [];
+                    _.each(element.data('init-value'), function(x) {
+                        data.push({
+                            id: x.id,
+                            text: x.name,
+                            isNew: false
+                        });
+                    });
+                    element.val('');
+                    callback(data);
+                },
+            });
+        });
+
+    });
+});
diff --git a/cms_form/static/src/js/textarea_widget.js b/cms_form/static/src/js/textarea_widget.js
new file mode 100644
index 00000000..97e160b9
--- /dev/null
+++ b/cms_form/static/src/js/textarea_widget.js
@@ -0,0 +1,23 @@
+odoo.define('cms_form.textarea_widget', function (require) {
+    'use strict';
+
+    var ajax = require('web.ajax');
+
+    $(document).ready(function () {
+        $('textarea[maxlength]').bind('input propertychange', function(){
+            var $self = $(this),
+                maxlength = parseInt($self.attr('maxlength')),
+                length = $self.val().length,
+                left = maxlength - length,
+                $counter = $self.siblings('.text-counter');
+            if ($self.data('counter')) {
+                $counter = $($self.data('counter'));
+            }
+            if (left < 0) {
+                left = 0;
+            }
+            $counter.val(left);
+        }).trigger('input');
+    });
+
+});
diff --git a/cms_form/static/src/less/cms_form.less b/cms_form/static/src/less/cms_form.less
new file mode 100644
index 00000000..03227bc4
--- /dev/null
+++ b/cms_form/static/src/less/cms_form.less
@@ -0,0 +1,15 @@
+.cms_form_wrapper{
+    form{
+        .field-required{
+            .control-label::after{
+                content: '*';
+                font-weight: bold;
+            }
+        }
+        .text-counter{
+            width: auto;
+            float: right;
+            margin-top: 0.2em;
+        }
+    }
+}
diff --git a/cms_form/templates/assets.xml b/cms_form/templates/assets.xml
new file mode 100644
index 00000000..5121bb20
--- /dev/null
+++ b/cms_form/templates/assets.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright 2017 Simone Orsi
+License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+-->
+<odoo>
+
+	<template id="assets_frontend" name="CMS Form frontend assets" inherit_id="website.assets_frontend">
+
+		<xpath expr="." position="inside">
+			<link rel="stylesheet" type="text/css" href="/cms_form/static/src/less/cms_form.less" />
+			<script type="text/javascript" src="/cms_form/static/src/js/select2widgets.js"></script>
+			<script type="text/javascript" src="/cms_form/static/src/js/date_widget.js"></script>
+			<script type="text/javascript" src="/cms_form/static/src/js/textarea_widget.js"></script>
+			<script type="text/javascript" src="/cms_form/static/src/js/master_slave.js"></script>
+		</xpath>
+
+	</template>
+
+</odoo>
diff --git a/cms_form/templates/form.xml b/cms_form/templates/form.xml
new file mode 100644
index 00000000..4ab8efb6
--- /dev/null
+++ b/cms_form/templates/form.xml
@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright 2017 Simone Orsi
+License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+-->
+<odoo>
+
+<template id="form_wrapper" name="CMS form wrapper">
+
+  <t t-call="website.layout">
+    <t t-set="title" t-value="form.form_title" />
+    <div id="wrap" t-att-class="form.form_wrapper_css_klass">
+        <div class="container">
+          <t t-if="form.form_title">
+            <h2><span class="form_title" t-esc="form.form_title" /></h2>
+          </t>
+          <t t-if="form.form_description">
+            <p class="form_description" t-esc="form.form_description" />
+          </t>
+          <t t-raw="form.form_render()" />
+        </div>
+    </div>
+  </t>
+
+</template>
+
+<!-- TODO: add non-horizontal form template -->
+
+<template id="form_horizontal_field_wrapper" name="CMS form field wrapper horiz form">
+    <div t-attf-class="form-group form-field field-#{fname} #{field['required'] and 'field-required' or ''} #{errors.get(fname) and 'has-error' or ''}">
+      <label class="col-md-3 col-sm-4 control-label"
+             t-att-for="fname" t-esc="field['string']">Name</label>
+      <div class="col-md-9 col-sm-8">
+        <t t-raw="widget.render()"/>
+        <t t-if="field.get('help')">
+            <t t-call="cms_form.base_form_field_help_block" />
+        </t>
+      </div>
+    </div>
+</template>
+
+
+<template id="base_form_field_help_block" name="CMS form field help block">
+    <div class="help-block">
+      <!-- use `raw` to allow injecting html stuff here -->
+      <t t-raw="field['help']" />
+    </div>
+</template>
+
+<template id="base_form_fields" name="CMS form fields">
+    <t t-foreach="form_fields.iterkeys()" t-as="fname">
+      <t t-if="not form_fields[fname].get('is_subfield')">
+        <t t-call="cms_form.form_horizontal_field_wrapper">
+          <t t-set="field" t-value="form_fields[fname]" />
+          <t t-set="widget" t-value="field['widget']" />
+        </t>
+      </t>
+    </t>
+</template>
+
+
+<template id="base_form" name="CMS form template">
+
+  <form t-att-action="form.form_action" t-att-method="form.form_method"
+        t-att-data-form="form.form_json_info()"
+        t-attf-class="form-horizontal #{form.form_css_klass}"
+        enctype="multipart/form-data">
+
+    <t t-if="form.form_method == 'POST'">
+        <input type="hidden" name="csrf_token" t-att-value="form.o_request.csrf_token()"/>
+    </t>
+
+    <t t-set="form_fields" t-value="form.form_fields()" />
+
+    <t t-call="#{ form.form_fields_template }" />
+
+    <div class="col-sm-9 col-sm-offset-3 above-controls">
+        <!-- you can style required fields like this:
+            `form .form-group.field-required label.control-label::after{ content: '*'}`
+            You'll get the symbol here, with proper legend
+        -->
+        <t t-if="form.form_mode != 'search'">
+            <div class="form-group field-required">
+                <p class="field-required-legend"><label class="control-label"></label> Required fields</p>
+            </div>
+        </t>
+    </div>
+    <t t-call="#{ form.form_buttons_template }" />
+
+  </form>
+
+</template>
+
+<template id="base_form_buttons" name="CMS base form buttons">
+
+  <div class="form-group form-controls">
+    <div class="col-sm-9 col-sm-offset-3">
+      <a class="btn btn-default" t-att-href="form.form_cancel_url()">Cancel</a>
+      <button type="submit" class="btn btn-primary">Submit</button>
+    </div>
+  </div>
+
+</template>
+
+<template id="search_form_wrapper" name="CMS search form wrapper"
+          inherit_id="cms_form.form_wrapper" primary="True">
+
+  <xpath expr="//t[@t-raw]" position="replace">
+    <t t-if="form.form_show_search_form">
+      <t t-raw="form.form_render()" />
+    </t>
+    <t t-call="#{ form.form_search_results_template }" />
+  </xpath>
+
+</template>
+
+
+<template id="search_form_buttons" name="CMS search form buttons"
+          inherit_id="cms_form.base_form_buttons" primary="True">
+
+  <xpath expr="//div[contains(@class, 'form-controls')]" position="replace">
+    <div class="form-group form-controls">
+       <div class="col-sm-9 col-sm-offset-3">
+         <button type="submit" class="btn btn-primary">Search</button>
+       </div>
+     </div>
+  </xpath>
+
+</template>
+
+
+<template id="search_results" name="CMS form search results">
+  <t t-foreach="form.form_search_results['results']" t-as="item">
+    <div t-attf-id="list_item_#{item.id}" class="list_item" t-attf-data-item='{"id": #{item.id}}'>
+      <h3 class="item-name">
+        <t t-if="'website_url' in item">
+          <a t-att-href="item.website_url" t-field="item.display_name" />
+        </t>
+        <t t-if="'website_url' not in item">
+          <span t-field="item.display_name" />
+        </t>
+      </h3>
+      <t t-if="'website_description' in item">
+        <p class="item-description" t-field="item.website_description"></p>
+      </t>
+    </div>
+  </t>
+  <div class="text-center mb32">
+    <t t-call="website.pager">
+    <t t-set="pager" t-value="form.form_search_results['pager']" />
+    </t>
+  </div>
+</template>
+
+
+</odoo>
diff --git a/cms_form/templates/widgets.xml b/cms_form/templates/widgets.xml
new file mode 100644
index 00000000..26740740
--- /dev/null
+++ b/cms_form/templates/widgets.xml
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright 2017 Simone Orsi
+License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+-->
+<odoo>
+
+
+<template id="field_widget_char" name="CMS form text field widget">
+
+  <input type="text"
+         t-attf-class="form-control #{widget.w_css_klass}"
+         t-att-name="widget.w_fname"
+         t-att-value="widget.w_field_value"
+         t-att-required="widget.w_field['required'] and '1' or None"
+         t-att-data-params="widget.w_data"
+         t-att-placeholder="widget.w_field['string'] + '...'"
+         />
+
+</template>
+
+
+<template id="field_widget_m2o" name="CMS form m2o field widget">
+
+  <select t-attf-class="form-control #{widget.w_css_klass}"
+          t-att-name="widget.w_fname"
+          t-att-required="widget.w_field['required'] and '1' or None"
+          t-att-data-params="widget.w_data">
+    <option value=""><t t-esc="widget.w_field['string'] + '...'" /></option>
+    <t t-foreach="widget.w_option_items" t-as="opt_item">
+      <option t-att-value="opt_item.id"
+             t-att-selected="opt_item.id == widget.w_field_value">
+        <t t-esc="opt_item.name"/>
+      </option>
+    </t>
+  </select>
+
+</template>
+
+
+<template id="field_widget_selection" name="CMS form selection field widget"
+    inherit_id="cms_form.field_widget_m2o" primary="True">
+
+    <xpath expr="//t[@t-foreach]/option" position="replace">
+      <option t-att-value="opt_item['value']"
+             t-att-selected="opt_item['value'] == widget.w_field_value">
+        <t t-esc="opt_item['label']"/>
+      </option>
+    </xpath>
+
+</template>
+
+
+<template id="field_widget_radio_selection" name="CMS form selection field radio widget">
+
+  <div t-attf-class="radio-select #{widget.w_css_klass}">
+    <t t-foreach="widget.w_option_items" t-as="opt_item">
+      <div class="radio option-item">
+        <label t-attf-for="#{widget.w_fname}_#{opt_item_index}">
+          <input type="radio"
+                 t-att-name="widget.w_fname"
+                 t-attf-id="#{widget.w_fname}_#{opt_item_index}"
+                 t-att-value="opt_item['value']"
+                 t-att-checked="opt_item['value'] == widget.w_field_value" />
+          <span t-esc="opt_item['label']" />
+        </label>
+        <t t-if="opt_item.get('help')">
+            <div class="help-block" t-raw="opt_item.get('help')" />
+        </t>
+        <t t-if="widget.w_options_help.get(opt_item['value'])">
+            <div class="help-block" t-raw="widget.w_options_help.get(opt_item['value'])" />
+        </t>
+      </div>
+    </t>
+  </div>
+
+</template>
+
+
+<template id="field_widget_x2m" name="CMS form x2m field widget">
+
+  <!-- NOTE: `t-att-value` is really important here
+  since without it `initSelection` function for select2 does not work-->
+  <input type="text" t-att-id="fname" t-att-name="widget.w_fname"
+         t-attf-class="form-control js_select2_m2m_widget #{widget.w_css_klass}"
+         t-attf-data-init-value="#{widget.w_field_value}" t-att-value="widget.w_field_value or widget.w_fname"
+         t-att-data-model="widget.w_field['relation']"
+         data-display_name="name" data-fields='["name"]'
+         t-att-placeholder="widget.w_field['string'] + '...'"
+         t-att-data-domain="widget.w_field.get('domain') or []"
+        />
+
+</template>
+
+
+<template id="field_widget_date" name="CMS form date field widget">
+
+  <div class="input-group">
+    <!-- TODO: show date in user locale and convert value server side -->
+    <input t-att-name="widget.w_fname" t-att-id="fname"
+           t-attf-class="form-control js_datepicker #{widget.w_css_klass}"
+           type="text" data-format="yy-mm-dd" placeholder="YYYY-MM-DD"
+           t-att-value="widget.w_field_value"/>
+    <span class="input-group-addon js_datepicker_trigger">
+      <span class="fa fa-calendar"></span>
+    </span>
+  </div>
+
+</template>
+
+
+<template id="field_widget_text" name="CMS form text field widget">
+
+    <textarea t-att-name="widget.w_fname" t-att-id="fname"
+              t-attf-class="form-control #{widget.w_css_klass}"
+              t-esc="widget.w_field_value"
+              t-att-maxlength="widget.w_maxlength" />
+    <t t-if="widget.w_maxlength">
+        <input type="text" size="3" readonly="1" t-ignore="1"
+               t-attf-name="#{widget.w_fname}_counter"
+               class="form-control text-counter" />
+    </t>
+
+</template>
+
+
+<template id="field_widget_boolean" name="CMS form boolean field widget">
+
+    <input type="checkbox"
+           t-att-name="widget.w_fname" t-att-id="fname"
+           t-att-checked="widget.w_field_value or None"
+           t-attf-class="form-control #{widget.w_css_klass}"
+           />
+
+</template>
+
+
+<template id="field_widget_image" name="CMS form image field widget">
+  <div class="image-widget-wrapper">
+    <input
+        type="file" capture="camera" accept="image/*"
+        t-att-id="widget.w_fname"
+        t-att-name="widget.w_fname"
+        class="form-control"
+        />
+    <t t-if="widget.w_field_value">
+      <t t-set="prefix" t-value="fname"/>
+      <img class="img img-responsive" t-att-src="widget.w_field_value.get('value')" />
+      <div t-attf-id="#{prefix}_keepbox" class="keepbox text-center">
+        <div class="form-group">
+          <label class="checkbox inline" t-attf-for="#{prefix}_keepcheck_yes">
+            <input type="radio" t-attf-id="#{prefix}_keepcheck_yes" t-attf-name="#{prefix}_keepcheck" checked="1" value="yes"/>
+            Keep current image
+          </label>
+          <label class="checkbox inline" t-attf-for="#{prefix}_keepcheck_no">
+            <input type="radio" t-attf-id="#{prefix}_keepcheck_no" t-attf-name="#{prefix}_keepcheck" value="no"/>
+            Replace current image
+          </label>
+        </div>
+      </div>
+    </t>
+  </div>
+</template>
+
+
+
+</odoo>
diff --git a/cms_form/tests/__init__.py b/cms_form/tests/__init__.py
new file mode 100644
index 00000000..beacc5fd
--- /dev/null
+++ b/cms_form/tests/__init__.py
@@ -0,0 +1,6 @@
+from . import test_controllers
+from . import test_form_base
+from . import test_form_cms
+from . import test_form_render
+from . import test_form_search
+from . import test_loaders
diff --git a/cms_form/tests/common.py b/cms_form/tests/common.py
new file mode 100644
index 00000000..5239e811
--- /dev/null
+++ b/cms_form/tests/common.py
@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+
+from cStringIO import StringIO
+from lxml import html
+from werkzeug.wrappers import Request
+import mock
+import urllib
+
+from openerp import http
+from openerp.tests.common import TransactionCase, HttpCase
+
+
+def fake_request(form_data=None, query_string=None,
+                 method='GET', content_type=None):
+    data = urllib.urlencode(form_data or {})
+    query_string = query_string or ''
+    content_type = content_type or 'application/x-www-form-urlencoded'
+    # werkzeug request
+    w_req = Request.from_values(
+        query_string=query_string,
+        content_length=len(data),
+        input_stream=StringIO(data),
+        content_type=content_type,
+        method=method)
+    w_req.session = mock.MagicMock()
+    # odoo request
+    o_req = http.HttpRequest(w_req)
+    o_req.website = mock.MagicMock()
+    o_req.csrf_token = mock.MagicMock()
+    o_req.httprequest = w_req
+    o_req.__testing__ = True
+    return o_req
+
+
+class FormTestMixin(object):
+
+    at_install = False
+    post_install = True
+
+    def get_form(self, form_model, req=None, **kw):
+        request = req or fake_request()
+        return self.env[form_model].form_init(request, **kw)
+
+
+class FormRenderMixin(FormTestMixin):
+
+    def to_xml_node(self, html_):
+        return html.fragments_fromstring(html_)
+
+    def find_input_name(self, node, name):
+        return node.xpath(
+            '(//input|//select|//textarea)[@name="{}"]'.format(name))
+
+    def assert_match_attrs(self, value, expected):
+        for k, v in expected.iteritems():
+            self.assertEqual(value[k].strip(), v.strip())
+
+    def assert_match_inputs(self, node, expected):
+        for name in expected:
+            self.assertEqual(len(self.find_input_name(node, name)), 1)
+
+
+class FormTestCase(TransactionCase, FormTestMixin):
+    """Base class for transaction cases."""
+
+
+class FormRenderTestCase(TransactionCase, FormRenderMixin):
+    """Base class for http cases."""
+
+
+class FormHttpTestCase(HttpCase, FormRenderMixin):
+
+    def html_get(self, url):
+        return html.document_fromstring(self.url_open(url, timeout=30).read())
diff --git a/cms_form/tests/test_controllers.py b/cms_form/tests/test_controllers.py
new file mode 100644
index 00000000..46147d48
--- /dev/null
+++ b/cms_form/tests/test_controllers.py
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+
+from contextlib import contextmanager
+import mock
+
+from .common import fake_request, FormHttpTestCase
+from ..controllers import main
+
+
+IMPORT = 'openerp.addons.cms_form.controllers.main'
+
+
+class TestControllers(FormHttpTestCase):
+
+    def setUp(self):
+        super(TestControllers, self).setUp()
+        self.form_controller = main.CMSFormController()
+        self.form_search_controller = main.CMSSearchFormController()
+        self.authenticate('admin', 'admin')
+
+    @contextmanager
+    def mock_assets(self):
+        """Mocks some stuff like request."""
+        with mock.patch('%s.request' % IMPORT) as request:
+            faked = fake_request()
+            request.session = self.session
+            request.env = self.env
+            request.httprequest = faked.httprequest
+            yield {
+                'request': request,
+            }
+
+    def test_get_form(self):
+        with self.mock_assets():
+            # we do not have a specific form for res.groups
+            # and cms form is not enabled on partner model
+            with self.assertRaises(NotImplementedError):
+                form = self.form_controller.get_form('res.groups')
+
+            # but we have one for res.partner
+            form = self.form_controller.get_form('res.partner')
+            self.assertTrue(
+                isinstance(form, self.env['cms.form.res.partner'].__class__)
+            )
+            self.assertEqual(form._form_model, 'res.partner')
+            self.assertEqual(form.form_mode, 'create')
+            self.assertTrue(form)
+
+            # we have a specific form here
+            form = self.form_search_controller.get_form('res.partner')
+            self.assertTrue(
+                isinstance(form,
+                           self.env['cms.form.search.res.partner'].__class__)
+            )
+            self.assertEqual(form._form_model, 'res.partner')
+            self.assertEqual(form.form_mode, 'search')
+
+    def _check_route(self, url, model, mode):
+        """Check default markup for form and form wrapper."""
+        # with self.mock_assets():
+        dom = self.html_get(url)
+        # test wrapper klass
+        wrapper_node = dom.find_class('cms_form_wrapper')[0]
+        expected_attrs = {
+            'class':
+                'cms_form_wrapper {form_model} {model} mode_{mode}'.format(
+                    form_model='cms_form_res_partner',
+                    model=model.replace('.', '_'),
+                    mode=mode
+                )
+        }
+        self.assert_match_attrs(wrapper_node.attrib, expected_attrs)
+        # test form is there and has correct klass
+        form_node = dom.xpath('//form')[0]
+        expected_attrs = {
+            'enctype': 'multipart/form-data',
+            'method': 'POST',
+            'class': 'form-horizontal'
+        }
+        self.assert_match_attrs(form_node.attrib, expected_attrs)
+
+    def test_default_routes(self):
+        self._check_route(
+            '/cms/form/create/res.partner',
+            'res.partner',
+            'create')
+        partner = self.env.ref('base.res_partner_1')
+        self._check_route(
+            '/cms/form/edit/res.partner/{}'.format(partner.id),
+            'res.partner',
+            'edit')
diff --git a/cms_form/tests/test_extractors.py b/cms_form/tests/test_extractors.py
new file mode 100644
index 00000000..37bb3653
--- /dev/null
+++ b/cms_form/tests/test_extractors.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+# TODO
diff --git a/cms_form/tests/test_form_base.py b/cms_form/tests/test_form_base.py
new file mode 100644
index 00000000..d2ee0d91
--- /dev/null
+++ b/cms_form/tests/test_form_base.py
@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+
+from werkzeug.wrappers import Request
+
+from openerp import http
+
+from .common import fake_request, FormTestCase
+
+
+class TestFormBase(FormTestCase):
+
+    def test_form_init(self):
+        form = self.get_form('cms.form.mixin')
+        self.assertTrue(isinstance(form.request, Request))
+        self.assertTrue(isinstance(form.o_request, http.HttpRequest))
+
+    def test_form_init_overrides(self):
+        overrides = dict(
+            model='res.partner',
+            mode='foo',
+            fields_whitelist=('name', ),
+            fields_blacklist=('country_id', ),
+            fields_attributes=('string', 'type', ),
+            wrapper_extra_css_klass='foo',
+            extra_css_klass='baz',
+        )
+        form = self.get_form('cms.form.mixin', **overrides)
+        for k, v in overrides.iteritems():
+            self.assertEqual(getattr(form, '_form_' + k), v)
+
+    def test_fields_load(self):
+        form = self.get_form('cms.form.res.partner')
+        fields = form.form_fields()
+        self.assertEqual(len(fields), 3)
+        self.assertTrue('name' in fields.keys())
+        self.assertTrue('country_id' in fields.keys())
+        self.assertTrue('custom' in fields.keys())
+
+        # whitelist
+        form = self.get_form(
+            'cms.form.res.partner',
+            fields_whitelist=('name', ))
+        fields = form.form_fields()
+        self.assertEqual(len(fields), 1)
+        self.assertTrue('name' in fields.keys())
+        self.assertTrue('country_id' not in fields.keys())
+        self.assertTrue('custom' not in fields.keys())
+
+        # blacklist
+        form = self.get_form(
+            'cms.form.res.partner',
+            fields_blacklist=('country_id', ))
+        fields = form.form_fields()
+        self.assertEqual(len(fields), 2)
+        self.assertTrue('name' in fields.keys())
+        self.assertTrue('country_id' not in fields.keys())
+        self.assertTrue('custom' in fields.keys())
+
+    def test_fields_order(self):
+        form = self.get_form(
+            'cms.form.res.partner',
+            fields_order=['name', 'custom', 'country_id', ])
+        fields = form.form_fields()
+        self.assertEqual(fields.keys()[0], 'name')
+        self.assertEqual(fields.keys()[1], 'custom')
+        self.assertEqual(fields.keys()[2], 'country_id')
+
+        # change order
+        form = self.get_form(
+            'cms.form.res.partner',
+            fields_order=['country_id', 'name', 'custom'])
+        fields = form.form_fields()
+        self.assertEqual(fields.keys()[0], 'country_id')
+        self.assertEqual(fields.keys()[1], 'name')
+        self.assertEqual(fields.keys()[2], 'custom')
+
+    def test_fields_attributes(self):
+        form = self.get_form('cms.form.res.partner')
+        fields = form.form_fields()
+        # this one is required in partner model
+        self.assertTrue(fields['name']['required'])
+        # this one is forced to required in our custom form
+        self.assertTrue(fields['country_id']['required'])
+
+    def test_get_loader(self):
+        form = self.get_form('cms.form.test_fields')
+        expected = {}.fromkeys((
+            'a_char',
+            'a_number',
+            'a_float',
+            'a_many2one',
+            'a_one2many',
+            'a_many2many',
+        ), None)
+        fields = form.form_fields()
+        for fname, loader in expected.iteritems():
+            self.assertEqual(
+                loader, form.form_get_loader(fname, fields[fname])
+            )
+
+        def custom_loader(*pa, **ka):
+            return pa, ka
+
+        # by type
+        form._form_load_char = custom_loader
+        form._form_load_integer = custom_loader
+        form._form_load_float = custom_loader
+        # by name
+        form._form_load_a_many2many = custom_loader
+
+        for fname in ('a_char', 'a_number', 'a_float', 'a_many2many'):
+            self.assertEqual(
+                custom_loader,
+                form.form_get_loader(fname, fields[fname])
+            )
+
+    def test_get_extractor(self):
+        form = self.get_form('cms.form.test_fields')
+        expected = {}.fromkeys((
+            'a_char',
+            'a_number',
+            'a_float',
+            'a_many2one',
+            'a_one2many',
+            'a_many2many',
+        ), None)
+        fields = form.form_fields()
+        for fname, loader in expected.iteritems():
+            self.assertEqual(
+                loader, form.form_get_extractor(fname, fields[fname])
+            )
+
+        def custom_extractor(*pa, **ka):
+            return pa, ka
+
+        # by type
+        form._form_extract_char = custom_extractor
+        form._form_extract_integer = custom_extractor
+        form._form_extract_float = custom_extractor
+        # by name
+        form._form_extract_a_many2many = custom_extractor
+
+        for fname in ('a_char', 'a_number', 'a_float', 'a_many2many'):
+            self.assertEqual(
+                custom_extractor,
+                form.form_get_extractor(fname, fields[fname])
+            )
+
+    def test_load_defaults(self):
+        # create mode, no main_object
+        main_object = None
+        form = self.get_form('cms.form.res.partner', main_object=main_object)
+        defaults = form.form_load_defaults()
+        expected = {
+            'name': None,
+            'country_id': None,
+            'custom': 'oh yeah!'
+        }
+        for k, v in expected.iteritems():
+            self.assertEqual(defaults[k], v)
+
+        # write mode, have main_object
+        main_object = self.env['res.partner'].new({})
+        main_object.name = 'John Wayne'
+        main_object.country_id = 5
+        form = self.get_form('cms.form.res.partner', main_object=main_object)
+        defaults = form.form_load_defaults()
+        expected = {
+            'name': 'John Wayne',
+            'country_id': 5,
+            'custom': 'oh yeah!'
+        }
+        for k, v in expected.iteritems():
+            self.assertEqual(defaults[k], v)
+
+        # values from request
+        data = {
+            'name': 'Paul Newman',
+            'country_id': 7,
+            'custom': 'yay!'
+        }
+        request = fake_request(form_data=data)
+        form = self.get_form(
+            'cms.form.res.partner', req=request, main_object=main_object)
+        defaults = form.form_load_defaults()
+        for k, v in data.iteritems():
+            self.assertEqual(defaults[k], v)
+
+    def test_extract_from_request(self):
+        form = self.get_form('cms.form.test_fields')
+        # values from request
+        data = {
+            'a_char': 'Jack White',
+            'a_number': '10',
+            'a_float': '5',
+            'a_many2one': '123',
+            'a_many2many': '1,2,3',
+            'a_one2many': '4,5,6',
+        }
+        request = fake_request(form_data=data)
+        # write mode
+        form = self.get_form('cms.form.test_fields', req=request)
+        values = form.form_extract_values()
+        expected = {
+            'a_char': 'Jack White',
+            'a_number': 10,
+            'a_float': 5.0,
+            'a_many2one': 123,
+            'a_many2many': [(6, False, [1, 2, 3]), ],
+            'a_one2many': [(6, False, [4, 5, 6]), ],
+        }
+        for k, v in values.iteritems():
+            self.assertEqual(expected[k], v)
+        # read mode
+        form = self.get_form(
+            'cms.form.test_fields', req=request, extract_value_mode='read')
+        values = form.form_extract_values()
+        expected.update({
+            'a_many2many': [1, 2, 3],
+            'a_one2many': [4, 5, 6],
+        })
+        for k, v in values.iteritems():
+            self.assertEqual(expected[k], v)
diff --git a/cms_form/tests/test_form_cms.py b/cms_form/tests/test_form_cms.py
new file mode 100644
index 00000000..80f2b483
--- /dev/null
+++ b/cms_form/tests/test_form_cms.py
@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+import mock
+
+from .common import fake_request, FormTestCase
+
+
+class TestCMSForm(FormTestCase):
+
+    def test_validate(self):
+        form = self.get_form('cms.form.test_fields')
+        # values from request
+        data = {
+            'a_char': 'Foo',
+            'a_number': '10',
+            'a_float': '5',
+            'a_many2one': '',
+            'a_many2many': '',
+        }
+        request = fake_request(form_data=data)
+        required = (
+            'a_many2one', 'a_many2many'
+        )
+        form = self.get_form(
+            'cms.form.test_fields', req=request, required_fields=required)
+        errors, errors_message = form.form_validate()
+        self.assertTrue('a_char' in errors)
+        self.assertTrue('a_float' in errors)
+        self.assertTrue('a_many2one' in errors)
+        self.assertTrue('a_many2many' in errors)
+
+    def test_create_or_update(self):
+        # create
+        data = {
+            'name': 'Edward Norton',
+        }
+        request = fake_request(form_data=data, method='POST')
+        form = self.get_form(
+            'cms.form.res.partner',
+            req=request,
+            required_fields=('name', ))
+        main_object = form.form_create_or_update()
+        self.assertEqual(main_object._name, 'res.partner')
+        self.assertEqual(main_object.name, data['name'])
+        # update
+        data = {
+            'name': 'Edward Flip',
+            'country_id': 1,
+            'custom': 'foo',
+        }
+        request = fake_request(form_data=data, method='POST')
+        form = self.get_form(
+            'cms.form.res.partner',
+            req=request,
+            required_fields=('name', ))
+        main_object = form.form_create_or_update()
+        self.assertEqual(main_object.name, data['name'])
+        self.assertEqual(main_object.country_id.id, data['country_id'])
+
+    def test_create_or_update_with_errors(self):
+        request = fake_request(form_data={}, method='POST')
+        form = self.get_form(
+            'cms.form.res.partner',
+            req=request)
+        values = form.form_process_POST({})
+        self.assertTrue('_integrity' in values['errors'])
+
+    def test_purge_non_model_fields(self):
+        data = {
+            'name': 'Johnny Glamour',
+            'custom': 'Remove me from write and create, tnx!'
+        }
+        request = fake_request(form_data=data, method='POST')
+        form = self.get_form(
+            'cms.form.res.partner',
+            req=request)
+        to_patch = \
+            'openerp.addons.cms_form.models.cms_form.CMSForm._form_create'
+        with mock.patch(to_patch) as patched:
+            form.form_create_or_update()
+            patched.assert_called_with({'name': 'Johnny Glamour'})
+
+        main_object = self.env['res.partner'].create({'name': 'Update Me'})
+        request = fake_request(form_data=data, method='POST')
+        form = self.get_form(
+            'cms.form.res.partner',
+            main_object=main_object,
+            req=request)
+        to_patch = \
+            'openerp.addons.cms_form.models.cms_form.CMSForm._form_write'
+        with mock.patch(to_patch) as patched:
+            form.form_create_or_update()
+            patched.assert_called_with({'name': 'Johnny Glamour'})
diff --git a/cms_form/tests/test_form_render.py b/cms_form/tests/test_form_render.py
new file mode 100644
index 00000000..28f8bca8
--- /dev/null
+++ b/cms_form/tests/test_form_render.py
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+from .common import FormRenderTestCase
+
+
+class TestRender(FormRenderTestCase):
+
+    def test_render_form_attrs(self):
+        form = self.get_form('cms.form.test_fields')
+        html = form.form_render()
+        node = self.to_xml_node(html)[0]
+        self.assertEqual(node.tag, 'form')
+        expected_attrs = {
+            'enctype': 'multipart/form-data',
+            'method': 'POST',
+            'class': 'form-horizontal'
+        }
+        self.assert_match_attrs(node.attrib, expected_attrs)
+
+    def test_render_form_fields(self):
+        form = self.get_form('cms.form.test_fields')
+        html = form.form_render()
+        node = self.to_xml_node(html)[0]
+        expected_fields = (
+            'csrf_token',
+            'a_char',
+            'a_float',
+            'a_number',
+            'a_many2one',
+            'a_many2many',
+            'a_one2many',
+        )
+        self.assertEqual(
+            len(node[0].xpath('//input|//select')), len(expected_fields)
+        )
+        self.assert_match_inputs(node, expected_fields)
+
+    def test_field_attrs(self):
+        # TODO: test all fields rendering
+        pass
diff --git a/cms_form/tests/test_form_search.py b/cms_form/tests/test_form_search.py
new file mode 100644
index 00000000..d2648eb7
--- /dev/null
+++ b/cms_form/tests/test_form_search.py
@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+from .common import fake_request, FormTestCase
+
+
+class TestCMSSearchForm(FormTestCase):
+
+    def setUp(self):
+        super(TestCMSSearchForm, self).setUp()
+        self.partner_model = self.env['res.partner']
+
+        self.expected_partners = []
+        self.expected_partners_ids = []
+        self._expected_partners = (
+            ('Salmo', self.env.ref('base.it').id, ),
+            ('Marracash', self.env.ref('base.it').id, ),
+            ('Notorious BIG', self.env.ref('base.us').id, ),
+            ('Dr. Dre', self.env.ref('base.us').id, ),
+            ('NTM', self.env.ref('base.fr').id, ),
+        )
+
+        for name, country_id in self._expected_partners:
+            self.expected_partners_ids.append(self.partner_model.create({
+                'name': name,
+                'country_id': country_id,
+            }).id)
+        self.expected_partners = \
+            self.partner_model.browse(self.expected_partners_ids)
+
+    def assert_results(self, form, count, expected):
+        self.assertTrue('results' in form.form_search_results)
+        self.assertTrue('count' in form.form_search_results)
+        self.assertTrue('pager' in form.form_search_results)
+        self.assertEqual(len(form.form_search_results['results']), count)
+        self.assertEqual(form.form_search_results['count'], count)
+        self.assertEqual(
+            sorted(form.form_search_results['results'].mapped('id')),
+            sorted(expected.mapped('id')),
+        )
+
+    def get_search_form(self, data):
+        request = fake_request(form_data=data)
+        form = self.get_form(
+            'cms.form.search.res.partner', req=request)
+        # restrict search results to these ids
+        form.test_record_ids = self.expected_partners_ids
+        form.form_process()
+        return form
+
+    def test_search(self):
+        data = {'name': 'Salmo', }
+        form = self.get_search_form(data)
+        self.assert_results(form, 1, self.expected_partners[:1])
+
+        data = {'name': 'Marracash', }
+        form = self.get_search_form(data)
+        self.assert_results(form, 1, self.expected_partners[1:2])
+
+        data = {'country_id': self.env.ref('base.it').id, }
+        form = self.get_search_form(data)
+        self.assert_results(form, 2, self.expected_partners[:2])
+
+        data = {'country_id': self.env.ref('base.fr').id, }
+        form = self.get_search_form(data)
+        self.assert_results(form, 1, self.expected_partners[4:])
diff --git a/cms_form/tests/test_loaders.py b/cms_form/tests/test_loaders.py
new file mode 100644
index 00000000..37bb3653
--- /dev/null
+++ b/cms_form/tests/test_loaders.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+# TODO
diff --git a/cms_form/tests/test_widgets.py b/cms_form/tests/test_widgets.py
new file mode 100644
index 00000000..37bb3653
--- /dev/null
+++ b/cms_form/tests/test_widgets.py
@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+# TODO
diff --git a/cms_form/utils.py b/cms_form/utils.py
new file mode 100644
index 00000000..1a348700
--- /dev/null
+++ b/cms_form/utils.py
@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
+
+
+def safe_to_integer(value, **kw):
+    """Convert to integer safely."""
+    try:
+        return int(value)
+    except (ValueError, TypeError):
+        return 0
+
+
+def safe_to_float(value, **kw):
+    try:
+        return float(value)
+    except (ValueError, TypeError):
+        return 0.0
+
+
+def safe_to_date(value, **kw):
+    if not value:
+        # make sure we do not return empty string which breaks the ORM
+        return False
+    return value
+
+
+TRUE_VALUES = ('on', 'yes', 'ok', 'true', True, 1, '1', )
+
+
+def string_to_bool(value, true_values=TRUE_VALUES):
+    return value in true_values
+
+
+# DEFAULT_LOADERS = {
+#     'many2one': m2o_to_form,
+#     'one2many': x2many_to_form,
+#     'many2many': x2many_to_form,
+#     'binary': binary_to_form,
+#     # TODO: use a specific field type for images
+#     'image': binary_to_form,
+# }
+# DEFAULT_EXTRACTORS = {
+#     'integer': form_to_integer,
+#     'float': form_to_float,
+#     'many2one': form_to_m2o,
+#     'one2many': form_to_x2many,
+#     'many2many': form_to_x2many,
+#     # TODO: use a specific field type for images
+#     'image': form_to_binary,
+#     'binary': form_to_binary,
+#     'date': form_to_date,
+#     'datetime': form_to_date,
+#     'boolean': form_to_bool,
+# }
+#
+
+def data_merge(a, b):
+    """Merges b into a and return merged result
+
+    NOTE: tuples and arbitrary objects are not handled
+    as it is totally ambiguous what should happen.
+
+    Thanks to http://stackoverflow.com/a/15836901/647924
+    """
+    key = None
+    # ## debug output
+    # sys.stderr.write("DEBUG: %s to %s\n" %(b,a))
+    try:
+        if a is None or isinstance(a, (str, unicode, int, long, float)):
+            # border case for first run or if a is a primitive
+            a = b
+        elif isinstance(a, list):
+            # lists can be only appended
+            if isinstance(b, list):
+                # merge lists
+                a.extend(b)
+            else:
+                # append to list
+                a.append(b)
+        elif isinstance(a, dict):
+            # dicts must be merged
+            if isinstance(b, dict):
+                for key in b:
+                    if key in a:
+                        a[key] = data_merge(a[key], b[key])
+                    else:
+                        a[key] = b[key]
+            else:
+                raise Exception(
+                    'Cannot merge non-dict "%s" into dict "%s"' % (b, a))
+        else:
+            raise Exception('NOT IMPLEMENTED "%s" into "%s"' % (b, a))
+    except TypeError, e:
+        raise Exception(
+            'TypeError "%s" in key "%s" '
+            'when merging "%s" into "%s"' % (e, key, b, a))
+    return a
diff --git a/cms_form_example/README.rst b/cms_form_example/README.rst
new file mode 100644
index 00000000..5f6bfd6b
--- /dev/null
+++ b/cms_form_example/README.rst
@@ -0,0 +1,52 @@
+.. image:: https://img.shields.io/badge/licence-AGPL--3-blue.svg
+   :target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
+   :alt: License: AGPL-3
+
+========
+CMS Form
+========
+
+Basic content type form example.
+
+
+Usage
+=====
+
+TODO
+
+
+Bug Tracker
+===========
+
+Bugs are tracked on `GitHub Issues
+<https://github.com/OCA/website-cms/issues>`_. In case of trouble, please
+check there if your issue has already been reported. If you spotted it first,
+help us smashing it by providing a detailed and welcomed feedback.
+
+Credits
+=======
+
+Images
+------
+
+* Odoo Community Association: `Icon <https://github.com/OCA/maintainer-tools/blob/master/template/module/static/description/icon.svg>`_.
+
+Contributors
+------------
+
+* Simone Orsi <simone.orsi@camptocamp.com>
+
+Maintainer
+----------
+
+.. image:: https://odoo-community.org/logo.png
+   :alt: Odoo Community Association
+   :target: https://odoo-community.org
+
+This module is maintained by the OCA.
+
+OCA, or the Odoo Community Association, is a nonprofit organization whose
+mission is to support the collaborative development of Odoo features and
+promote its widespread use.
+
+To contribute to this module, please visit https://odoo-community.org.
diff --git a/cms_form_example/__init__.py b/cms_form_example/__init__.py
new file mode 100644
index 00000000..f7209b17
--- /dev/null
+++ b/cms_form_example/__init__.py
@@ -0,0 +1,2 @@
+from . import models
+from . import controllers
diff --git a/cms_form_example/__openerp__.py b/cms_form_example/__openerp__.py
new file mode 100644
index 00000000..bdf5ab57
--- /dev/null
+++ b/cms_form_example/__openerp__.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+{
+    'name': 'CMS Form example',
+    'summary': """
+        Basic content type form example""",
+    'version': '9.0.1.0.0',
+    'license': 'AGPL-3',
+    'author': 'Simone Orsi,Odoo Community Association (OCA)',
+    'depends': [
+        'website_partner',
+        'cms_form',
+    ],
+    'data': [
+        'templates/assets.xml',
+    ],
+}
diff --git a/cms_form_example/controllers/__init__.py b/cms_form_example/controllers/__init__.py
new file mode 100644
index 00000000..12a7e529
--- /dev/null
+++ b/cms_form_example/controllers/__init__.py
@@ -0,0 +1 @@
+from . import main
diff --git a/cms_form_example/controllers/main.py b/cms_form_example/controllers/main.py
new file mode 100644
index 00000000..7fc02703
--- /dev/null
+++ b/cms_form_example/controllers/main.py
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from openerp import http
+from openerp.addons.cms_form.controllers.main import SearchFormControllerMixin
+from openerp.addons.cms_form.controllers.main import FormControllerMixin
+
+
+class PartnerFormController(http.Controller, FormControllerMixin):
+    """Partner form controller."""
+
+    @http.route([
+        '/partner/add',
+        '/partner/<model("res.partner"):main_object>/edit',
+    ], type='http', auth='user', website=True)
+    def cms_form(self, main_object=None, **kw):
+        """Handle a `form` route.
+        """
+        model = 'res.partner'
+        return self.make_response(
+            model, model_id=main_object and main_object.id, **kw)
+
+
+class PartnerListing(http.Controller, SearchFormControllerMixin):
+    """Partner search form controller."""
+
+    @http.route([
+        '/partners',
+        '/partners/page/<int:page>',
+    ], type='http', auth="public", website=True)
+    def market(self, **kw):
+        model = 'res.partner'
+        return self.make_response(model, **kw)
diff --git a/cms_form_example/models/__init__.py b/cms_form_example/models/__init__.py
new file mode 100644
index 00000000..4da81fa3
--- /dev/null
+++ b/cms_form_example/models/__init__.py
@@ -0,0 +1 @@
+from . import partner
diff --git a/cms_form_example/models/partner.py b/cms_form_example/models/partner.py
new file mode 100644
index 00000000..701ae656
--- /dev/null
+++ b/cms_form_example/models/partner.py
@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright 2017 Simone Orsi
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from openerp import models
+from openerp import fields
+from openerp import tools
+
+testing = tools.config.get('test_enable')
+
+
+if not testing:
+    # prevent these forms to be registered when running tests
+
+    class ExamplePartnerForm(models.AbstractModel):
+        """A test model form."""
+
+        _name = 'cms.form.res.partner'
+        _inherit = 'cms.form'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id')
+        _form_required_fields = ('name', )
+        _form_fields_order = ('name', 'country_id')
+
+        custom = fields.Char()
+
+        def _form_load_custom(
+                self, form, main_object, fname, value, **req_values):
+            """Load a custom default for the field 'custom'."""
+            return req_values.get('custom', 'oh yeah!')
+
+    class PartnerSearchForm(models.AbstractModel):
+        """Partner model search form."""
+
+        _name = 'cms.form.search.res.partner'
+        _inherit = 'cms.form.search'
+        _form_model = 'res.partner'
+        _form_model_fields = ('name', 'country_id', )
diff --git a/cms_form_example/static/description/icon.png b/cms_form_example/static/description/icon.png
new file mode 100644
index 00000000..3a0328b5
Binary files /dev/null and b/cms_form_example/static/description/icon.png differ
diff --git a/cms_form_example/static/src/js/cms_form_example.tour.js b/cms_form_example/static/src/js/cms_form_example.tour.js
new file mode 100644
index 00000000..4b18cedd
--- /dev/null
+++ b/cms_form_example/static/src/js/cms_form_example.tour.js
@@ -0,0 +1,38 @@
+/* Copyright 2017 OCA/oscar@vauxoo.com
+ * License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). */
+odoo.define("cms_form_example.tour", function (require) {
+    "use strict";
+
+    var Tour = require("web.Tour");
+    var core = require('web.core');
+    var _t = core._t;
+
+    Tour.register({
+        id: "test_create_partner",
+        name: "Try to create a partner",
+        path: "/partner/add",
+        // mode: "test",
+        steps: [
+            {
+                title: "Fill form with the data to create the 'Demo Partner'",
+                element: "button.btn-primary:contains(Submit)",
+                onload: function () {
+                    $('input[name="name"]').val('Demo Partner');
+                    $('input[name="custom"]').val('Demo custom message here!');
+                    $('select[name="country_id"] option').each(function(){
+                        if (this.text === 'Italy') {
+                            $('select[name="country_id"]').val(this.value);
+                        }
+                    });
+                },
+            },
+            {
+                title: _t("Partner created"),
+                waitFor: "alert alert-info alert-dismissible:contains(Item created.)",
+                content:   _t("This is the new partner. Let's edit it."),
+                popover:   { next: _t("Continue") },
+            }
+        ]
+    });
+
+});
diff --git a/cms_form_example/templates/assets.xml b/cms_form_example/templates/assets.xml
new file mode 100644
index 00000000..60f93997
--- /dev/null
+++ b/cms_form_example/templates/assets.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<odoo>
+
+	<template id="assets_frontend" name="CMS Form frontend assets" inherit_id="website.assets_frontend">
+
+		<xpath expr="." position="inside">
+			<script type="text/javascript" src="/cms_form_example/static/src/js/cms_form_example.tour.js"></script>
+		</xpath>
+
+	</template>
+
+</odoo>