diff --git a/deploy/db_setup.py b/deploy/db_setup.py
index 04f424ad8..717d62eef 100644
--- a/deploy/db_setup.py
+++ b/deploy/db_setup.py
@@ -42,9 +42,10 @@ def try_mongodb_opts(host="localhost", database_name='INGInious'):
     database = try_mongodb_opts('db')
 
     database.users.insert_one({"username": username,
-                                       "realname": realname,
-                                       "email": email,
-                                       "password": UserManager.hash_password(password),
-                                       "bindings": {},
-                                       "language": "en"})
+                               "realname": realname,
+                               "email": email,
+                               "password": UserManager.hash_password(password),
+                               "bindings": {},
+                               "language": "en",
+                               "code_indentation": "4"})
     print('Superadmin user added!')
diff --git a/inginious/frontend/app.py b/inginious/frontend/app.py
index 7418f6f2f..433363125 100644
--- a/inginious/frontend/app.py
+++ b/inginious/frontend/app.py
@@ -176,6 +176,14 @@ def get_app(config):
     available_languages = {"en": "English"}
     available_languages.update(available_translations)
 
+    # available indentation types
+    available_indentation_types = {
+        "2": {"text": "2 spaces", "indent": 2, "indentWithTabs": False},
+        "3": {"text": "3 spaces", "indent": 3, "indentWithTabs": False},
+        "4": {"text": "4 spaces", "indent": 4, "indentWithTabs": False},
+        "tabs": {"text": "tabs", "indent": 4, "indentWithTabs": True},
+    }
+
     l10n_manager = L10nManager()
 
     l10n_manager.translations["en"] = gettext.NullTranslations()  # English does not need translation ;-)
@@ -242,6 +250,7 @@ def get_app(config):
     template_helper.add_to_template_globals("_", _)
     template_helper.add_to_template_globals("str", str)
     template_helper.add_to_template_globals("available_languages", available_languages)
+    template_helper.add_to_template_globals("available_indentation_types", available_indentation_types)
     template_helper.add_to_template_globals("get_homepath", get_homepath)
     template_helper.add_to_template_globals("pkg_version", __version__)
     template_helper.add_to_template_globals("allow_registration", config.get("allow_registration", True))
@@ -302,6 +311,7 @@ def flask_internalerror(e):
     flask_app.allow_registration = config.get("allow_registration", True)
     flask_app.allow_deletion = config.get("allow_deletion", True)
     flask_app.available_languages = available_languages
+    flask_app.available_indentation_types = available_indentation_types
     flask_app.welcome_page = config.get("welcome_page", None)
     flask_app.terms_page = config.get("terms_page", None)
     flask_app.privacy_page = config.get("privacy_page", None)
diff --git a/inginious/frontend/installer.py b/inginious/frontend/installer.py
index e08bad756..98a9a0074 100644
--- a/inginious/frontend/installer.py
+++ b/inginious/frontend/installer.py
@@ -568,6 +568,7 @@ def configure_authentication(self, database):
                                    "email": email,
                                    "password": UserManager.hash_password(password),
                                    "bindings": {},
+                                   "code_indentation": "4",
                                    "language": "en"})
 
         options["superadmins"].append(username)
diff --git a/inginious/frontend/pages/admin/admin.py b/inginious/frontend/pages/admin/admin.py
index 10a0bd025..b9537f5fa 100644
--- a/inginious/frontend/pages/admin/admin.py
+++ b/inginious/frontend/pages/admin/admin.py
@@ -64,7 +64,8 @@ def POST_AUTH(self, *args, **kwargs):
                 "email": email,
                 "password": password,
                 "bindings": {},
-                "language": "en"})
+                "language": "en",
+                "code_indentation": "4"})
         else:
             feedback = _("Unknown action.")
         if feedback:
diff --git a/inginious/frontend/pages/lti.py b/inginious/frontend/pages/lti.py
index 02d953ab6..332919dce 100644
--- a/inginious/frontend/pages/lti.py
+++ b/inginious/frontend/pages/lti.py
@@ -146,8 +146,7 @@ def GET(self):
 
         user_profile = self.database.users.find_one({"ltibindings." + data["task"][0] + "." + data["consumer_key"]: data["username"]})
         if user_profile:
-            self.user_manager.connect_user(user_profile["username"], user_profile["realname"], user_profile["email"],
-                                           user_profile["language"], user_profile.get("tos_accepted", False))
+            self.user_manager.connect_user(user_profile)
 
         if self.user_manager.session_logged_in():
             return redirect(self.app.get_homepath() + "/lti/task")
diff --git a/inginious/frontend/pages/preferences/profile.py b/inginious/frontend/pages/preferences/profile.py
index 316c53ae0..1f4cb1317 100644
--- a/inginious/frontend/pages/preferences/profile.py
+++ b/inginious/frontend/pages/preferences/profile.py
@@ -43,8 +43,9 @@ def save_profile(self, userdata, data):
                     msg = _("Incorrect email.")
                     return result, msg, error
                 else:
-                    self.user_manager.connect_user(result["username"], result["realname"], result["email"],
-                                                   result["language"], result.get("tos_accepted", False))
+                    self.user_manager.set_session_username(data["username"])
+
+        profile_data_to_be_updated = {}
 
         # Check if updating the password.
         if self.app.allow_registration and len(data["passwd"]) in range(1, 6):
@@ -68,38 +69,44 @@ def save_profile(self, userdata, data):
                 return result, msg, error
             else:
                 passwd_hash = UserManager.hash_password(data["passwd"])
-                result = self.database.users.find_one_and_update({"username": self.user_manager.session_username()},
-                                                                 {"$set": {"password": passwd_hash}},
-                                                                 return_document=ReturnDocument.AFTER)
+                profile_data_to_be_updated["password"] = passwd_hash
 
         # Check if updating language
-        if data["language"] != userdata["language"]:
+        if data["language"] != userdata.get("language", "en"):
             language = data["language"] if data["language"] in self.app.available_languages else "en"
-            result = self.database.users.find_one_and_update({"username": self.user_manager.session_username()},
-                                                             {"$set": {"language": language}},
-                                                             return_document=ReturnDocument.AFTER)
-            if not result:
+            profile_data_to_be_updated["language"] = language
+
+        # check if updating code indentation
+        if data["code_indentation"] != userdata.get("code_indentation", "4"):
+            code_indentation = data["code_indentation"] if data["code_indentation"] in self.app.available_indentation_types.keys() else "4"
+            profile_data_to_be_updated["code_indentation"] = code_indentation
+
+        # Checks if updating name
+        if data["realname"] != userdata.get("realname", ""):
+            if len(data["realname"]) > 0:
+                profile_data_to_be_updated["realname"] = data["realname"]
+            else:
                 error = True
-                msg = _("Incorrect username.")
+                msg = _("Name is too short.")
                 return result, msg, error
-            else:
-                self.user_manager.set_session_language(language)
 
-        # Checks if updating name
-        if len(data["realname"]) > 0:
-            result = self.database.users.find_one_and_update({"username": self.user_manager.session_username()},
-                                                             {"$set": {"realname": data["realname"]}},
-                                                             return_document=ReturnDocument.AFTER)
+        # updating profile in DB
+        if profile_data_to_be_updated:
+            self.database.users.find_one_and_update({"username": self.user_manager.session_username()},
+                                                    {"$set": profile_data_to_be_updated},
+                                                    return_document=ReturnDocument.AFTER)
             if not result:
                 error = True
                 msg = _("Incorrect username.")
                 return result, msg, error
             else:
-                self.user_manager.set_session_realname(data["realname"])
-        else:
-            error = True
-            msg = _("Name is too short.")
-            return result, msg, error
+                # updating session
+                if "language" in profile_data_to_be_updated:
+                    self.user_manager.set_session_language(profile_data_to_be_updated["language"])
+                if "code_indentation" in profile_data_to_be_updated:
+                    self.user_manager.set_session_code_indentation(profile_data_to_be_updated["code_indentation"])
+                if "realname" in profile_data_to_be_updated:
+                    self.user_manager.set_session_realname(profile_data_to_be_updated["realname"])
 
         msg = _("Profile updated.")
 
diff --git a/inginious/frontend/pages/register.py b/inginious/frontend/pages/register.py
index e1189764b..7e2f751af 100644
--- a/inginious/frontend/pages/register.py
+++ b/inginious/frontend/pages/register.py
@@ -100,6 +100,7 @@ def register_user(self, data):
                                                 "activate": activate_hash,
                                                 "bindings": {},
                                                 "language": self.user_manager._session.get("language", "en"),
+                                                "code_indentation": "4",
                                                 "tos_accepted": True
                                                 })
                 try:
diff --git a/inginious/frontend/static/js/codemirror/mode/cobol/index.html b/inginious/frontend/static/js/codemirror/mode/cobol/index.html
index 4352419a0..5db06fbff 100644
--- a/inginious/frontend/static/js/codemirror/mode/cobol/index.html
+++ b/inginious/frontend/static/js/codemirror/mode/cobol/index.html
@@ -29,7 +29,6 @@
 <script src="../../addon/selection/active-line.js"></script>
 <script src="../../addon/search/search.js"></script>
 <script src="../../addon/dialog/dialog.js"></script>
-<script src="../../addon/search/searchcursor.js"></script>
 <style>
         .CodeMirror {
           border: 1px solid #eee;
diff --git a/inginious/frontend/static/js/common.js b/inginious/frontend/static/js/common.js
index 34ae01ccd..a5907d810 100644
--- a/inginious/frontend/static/js/common.js
+++ b/inginious/frontend/static/js/common.js
@@ -77,11 +77,25 @@ function registerCodeEditor(textarea, lang, lines, firstline=1)
 
     var is_single = $(textarea).hasClass('single');
 
+     var keyMappings = {
+        'Ctrl-Enter': function() {
+                                 $('body,html').animate({
+                                   scrollTop: $('#task-submit').offset().top
+                                 }, 'fast');
+                               }
+     }
+
+    if (user_indentation_type["text"] == "tabs") {
+        keyMappings["Tab"] = function(cm) { cm.execCommand("insertTab"); cm.execCommand("indentLess"); cm.execCommand("insertTab"); };
+    } else {
+        keyMappings["Tab"] = function(cm) { cm.execCommand("insertSoftTab");};
+    }
+
 
 
     var editor = CodeMirror.fromTextArea(textarea, {
         lineNumbers:       true,
-        firstLineNumber: parseInt(firstline),
+        firstLineNumber:   parseInt(firstline),
         mode:              mode["mime"],
         foldGutter:        true,
         styleActiveLine:   true,
@@ -89,19 +103,15 @@ function registerCodeEditor(textarea, lang, lines, firstline=1)
         autoCloseBrackets: true,
         lineWrapping:      true,
         gutters:           ["CodeMirror-linenumbers", "CodeMirror-foldgutter"],
-        indentUnit:        4,
+        indentUnit:        user_indentation_type["indent"],
+        indentWithTabs:    user_indentation_type["indentWithTabs"],
+        tabSize:           user_indentation_type["indent"],
         viewportMargin:    Infinity,
         lint:              function()
                            {
                                return []
                            },
-        extraKeys:         {
-                               'Ctrl-Enter': function() {
-                                 $('body,html').animate({
-                                   scrollTop: $('#task-submit').offset().top
-                                 }, 'fast');
-                               },
-                           },
+        extraKeys:         keyMappings
     });
 
     if(is_single)
diff --git a/inginious/frontend/templates/layout.html b/inginious/frontend/templates/layout.html
index 4473afd72..0990520db 100644
--- a/inginious/frontend/templates/layout.html
+++ b/inginious/frontend/templates/layout.html
@@ -210,5 +210,9 @@
     <!-- Placed at the end of the document so the pages load faster -->
     <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
     {{ template_helper.call('javascript_footer') | safe }}
+    <script>
+        var available_indentation_types = {{available_indentation_types | tojson}}
+        var user_indentation_type = available_indentation_types["{{user_manager.session_code_indentation()}}"]
+    </script>
 </body>
 </html>
diff --git a/inginious/frontend/templates/preferences/profile.html b/inginious/frontend/templates/preferences/profile.html
index 6b95074e6..42b0ad5f5 100644
--- a/inginious/frontend/templates/preferences/profile.html
+++ b/inginious/frontend/templates/preferences/profile.html
@@ -70,6 +70,14 @@ <h2>{{ _("My profile") }}</h2>
                 {% endfor %}
             </select>
         </div>
+        <div class="col-sm-12">
+            <label class="control-label">{{ _("Code indentation :") }} </label>
+            <select name="code_indentation" class="form-control">
+                {% for code, indentation_data in available_indentation_types.items() %}
+                <option value="{{code}}" {% if code == user_manager.session_code_indentation() %} selected {% endif %}>{{ _(indentation_data["text"]) }}</option>
+                {% endfor %}
+            </select>
+        </div>
         {% if allow_registration %}
             <div class="col-sm-12">
                 <label class="control-label">{{ _("Old password :") }} </label>
diff --git a/inginious/frontend/user_manager.py b/inginious/frontend/user_manager.py
index ee0d711c4..4598ac043 100644
--- a/inginious/frontend/user_manager.py
+++ b/inginious/frontend/user_manager.py
@@ -73,7 +73,7 @@ def get_imlink(self):
         return ""
 
 
-UserInfo = namedtuple("UserInfo", ["realname", "email", "username", "bindings", "language", "activated"])
+UserInfo = namedtuple("UserInfo", ["realname", "email", "username", "bindings", "language", "code_indentation", "activated"])
 
 
 class UserManager:
@@ -183,6 +183,10 @@ def session_language(self):
         """ Returns the current session language """
         return self._session.get("language", "en")
 
+    def session_code_indentation(self):
+        """ Returns the current session code indentation """
+        return self._session.get("code_indentation", "4")
+
     def session_api_key(self):
         """ Returns the API key for the current user. Created on first demand. """
         return self.get_user_api_key(self.session_username())
@@ -192,6 +196,11 @@ def set_session_token(self, token):
         if self.session_logged_in():
             self._session["token"] = token
 
+    def set_session_username(self, username):
+        """ Sets the username of the current user in the session, if one is open."""
+        if self.session_logged_in():
+            self._session["username"] = username
+
     def set_session_realname(self, realname):
         """ Sets the real name of the current user in the session, if one is open."""
         if self.session_logged_in():
@@ -205,14 +214,20 @@ def set_session_tos_signed(self):
     def set_session_language(self, language):
         self._session["language"] = language
 
-    def _set_session(self, username, realname, email, language, tos_signed):
+    def set_session_code_indentation(self, code_indentation):
+        """ Sets the code indentation of the current user in the session, if one is open."""
+        if self.session_logged_in():
+            self._session["code_indentation"] = code_indentation
+
+    def _set_session(self, user):
         """ Init the session. Preserves potential LTI information. """
         self._session["loggedin"] = True
-        self._session["email"] = email
-        self._session["username"] = username
-        self._session["realname"] = realname
-        self._session["language"] = language
-        self._session["tos_signed"] = tos_signed
+        self._session["email"] = user["email"]
+        self._session["username"] = user["username"]
+        self._session["realname"] = user["realname"]
+        self._session["language"] = user.get("language", "en")
+        self._session["code_indentation"] = user.get("code_indentation", "4")
+        self._session["tos_signed"] = user.get("tos_signed", False)
         self._session["token"] = None
         if "lti" not in self._session:
             self._session["lti"] = None
@@ -223,6 +238,7 @@ def _destroy_session(self):
         self._session["email"] = None
         self._session["username"] = None
         self._session["realname"] = None
+        self._session["code_indentation"] = None
         self._session["token"] = None
         self._session["lti"] = None
         self._session["tos_signed"] = None
@@ -306,8 +322,7 @@ def auth_user(self, username, password, do_connect=True):
 
         if self.verify_hash(db_hash, password, method):
             if do_connect:
-                self.connect_user(username, user["realname"], user["email"], user["language"],
-                                  user.get("tos_accepted", False))
+                self.connect_user(user)
             return user
 
     def verify_hash(cls, db_hash, password, method="sha512"):
@@ -347,20 +362,27 @@ def is_user_activated(self, username):
             {"username": username, "activate": {"$exists": True, "$nin": [None]}})
         return user is None
 
-    def connect_user(self, username, realname, email, language, tos_accepted):
+    def connect_user(self, user):
         """ Opens a session for the user
 
-        :param username: Username
-        :param realname: User real name
-        :param email: User email
+        :param user : a dict representing the user, it contains the data of the user.
+            It must at least contain the following fields:
+            - realname
+            - email
+            - username
         """
 
-        self._database.users.update_one({"email": email},
-                                        {"$set": {"realname": realname, "username": username, "language": language}},
+        if not all(key in user for key in ["realname", "email", "username"]):
+            raise AuthInvalidInputException()
+
+        self._database.users.update_one({"email": user["email"]},
+                                        {"$set": {"realname": user["realname"], "username": user["username"],
+                                                  "language": user.get("language", "en")}},
                                         upsert=True)
+
         ip = flask.request.remote_addr
-        self._logger.info("User %s connected - %s - %s - %s", username, realname, email, ip)
-        self._set_session(username, realname, email, language, tos_accepted)
+        self._logger.info("User %s connected - %s - %s - %s", user["username"], user["realname"], user["email"], ip)
+        self._set_session(user)
         return True
 
     def disconnect_user(self):
@@ -389,7 +411,8 @@ def get_users_info(self, usernames, limit=0, skip=0) -> Dict[str, Optional[UserI
         infos = self._database.users.find(query).skip(skip).limit(limit)
 
         retval = {info["username"]: UserInfo(info["realname"], info["email"], info["username"], info["bindings"],
-                                             info["language"], "activate" not in info) for info in infos}
+                                             info["language"], info["code_indentation"], "activate" not in info)
+                  for info in infos}
         return retval
 
     def get_user_info(self, username) -> Optional[UserInfo]:
@@ -486,8 +509,7 @@ def bind_user(self, auth_id, user):
 
         if user_profile and not self.session_logged_in():
             # Sign in
-            self.connect_user(user_profile["username"], user_profile["realname"], user_profile["email"],
-                              user_profile["language"], user_profile.get("tos_accepted", False))
+            self.connect_user(user_profile)
         elif user_profile and self.session_username() == user_profile["username"]:
             # Logged in, refresh fields if found profile username matches session username
             self._database.users.find_one_and_update({"username": self.session_username()},
@@ -511,12 +533,17 @@ def bind_user(self, auth_id, user):
                 return False
             else:
                 # New user, create an account using email address
-                self._database.users.insert_one({"username": "",
-                                                 "realname": realname,
-                                                 "email": email,
-                                                 "bindings": {auth_id: [username, additional]},
-                                                 "language": self._session.get("language", "en")})
-                self.connect_user("", realname, email, self._session.get("language", "en"), False)
+                user_profile = {"username": "", "realname": realname, "email": email,
+                                "bindings": {auth_id: [username, additional]}, "language": self.session_language(),
+                                "code_indentation": self.session_code_indentation(), "tos_accepted": False}
+
+                self._database.users.insert_one({"username": user["username"],
+                                                 "realname": user["realname"],
+                                                 "email": user["email"],
+                                                 "bindings": user["bindings"],
+                                                 "language": user["language"],
+                                                 "code_indentation": user["code_indentation"]})
+                self.connect_user(user_profile)
 
         return True
 
@@ -576,8 +603,9 @@ def create_user(self, values):
                                          "realname": values["realname"],
                                          "email": values["email"],
                                          "password": self.hash_password(values["password"]),
-                                         "bindings": {},
-                                         "language": "en"})
+                                         "bindings": values["bindings"],
+                                         "language": values["language"],
+                                         "code_indentation": values["code_indentation"]})
         return None
 
     ##############################################