diff --git a/cypress/fixtures/doctype_with_tab_break.js b/cypress/fixtures/doctype_with_tab_break.js
index 74e5e6abba..bc346e8fb8 100644
--- a/cypress/fixtures/doctype_with_tab_break.js
+++ b/cypress/fixtures/doctype_with_tab_break.js
@@ -30,6 +30,11 @@ export default {
 			"link_doctype": "Contact",
 			"link_fieldname": "user"
 		},
+		{
+			"group": "Profile",
+			"link_doctype": "Chat Profile",
+			"link_fieldname": "user"
+		},
 	],
 	modified_by: 'Administrator',
 	module: 'Custom',
diff --git a/frappe/__init__.py b/frappe/__init__.py
index 4218aa113b..ad88901469 100644
--- a/frappe/__init__.py
+++ b/frappe/__init__.py
@@ -1798,7 +1798,7 @@ def get_version(doctype, name, limit=None, head=False, raise_err=True):
 			'limit': limit
 		}, as_list=1)
 
-		from frappe.utils import squashify, dictify, safe_json_loads
+		from frappe.chat.util import squashify, dictify, safe_json_loads
 
 		versions = []
 
@@ -1856,7 +1856,7 @@ def mock(type, size=1, locale='en'):
 			data = getattr(fake, type)()
 			results.append(data)
 
-	from frappe.utils import squashify
+	from frappe.chat.util import squashify
 	return squashify(results)
 
 def validate_and_sanitize_search_inputs(fn):
diff --git a/frappe/chat/__init__.py b/frappe/chat/__init__.py
new file mode 100644
index 0000000000..4c9b1c5db7
--- /dev/null
+++ b/frappe/chat/__init__.py
@@ -0,0 +1,23 @@
+
+import frappe
+from   frappe import _
+
+session = frappe.session
+
+def authenticate(user, raise_err = True):
+	if session.user == 'Guest':
+		if not frappe.db.exists('Chat Token', user):
+			if raise_err:
+				frappe.throw(_("Sorry, you're not authorized."))
+			else:
+				return False
+		else:
+			return True
+	else:
+		if user != session.user:
+			if raise_err:
+				frappe.throw(_("Sorry, you're not authorized."))
+			else:
+				return False
+		else:
+			return True
\ No newline at end of file
diff --git a/frappe/chat/doctype/__init__.py b/frappe/chat/doctype/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frappe/chat/doctype/chat_message/__init__.py b/frappe/chat/doctype/chat_message/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frappe/chat/doctype/chat_message/chat_message.js b/frappe/chat/doctype/chat_message/chat_message.js
new file mode 100644
index 0000000000..edaad011db
--- /dev/null
+++ b/frappe/chat/doctype/chat_message/chat_message.js
@@ -0,0 +1,10 @@
+// Copyright (c) 2017, Frappe Technologies and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on('Chat Message', {
+	onload: function(frm) {
+		if(frm.doc.type == 'File') {
+			frm.set_df_property('content', 'read_only', 1);
+		}
+	}
+});
diff --git a/frappe/chat/doctype/chat_message/chat_message.json b/frappe/chat/doctype/chat_message/chat_message.json
new file mode 100644
index 0000000000..9d2d70c5e0
--- /dev/null
+++ b/frappe/chat/doctype/chat_message/chat_message.json
@@ -0,0 +1,91 @@
+{
+ "beta": 1,
+ "creation": "2017-11-10 11:10:40.011099",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "room_type",
+  "type",
+  "user",
+  "room",
+  "content",
+  "mentions",
+  "urls"
+ ],
+ "fields": [
+  {
+   "fieldname": "room_type",
+   "fieldtype": "Select",
+   "in_list_view": 1,
+   "label": "Room Type",
+   "options": "Direct\nGroup\nVisitor",
+   "reqd": 1
+  },
+  {
+   "fieldname": "type",
+   "fieldtype": "Data",
+   "label": "Type",
+   "options": "Content\nFile"
+  },
+  {
+   "fieldname": "user",
+   "fieldtype": "Link",
+   "hidden": 1,
+   "label": "User",
+   "options": "User",
+   "read_only": 1
+  },
+  {
+   "fieldname": "room",
+   "fieldtype": "Link",
+   "label": "Room",
+   "options": "Chat Room",
+   "reqd": 1
+  },
+  {
+   "fieldname": "content",
+   "fieldtype": "Text",
+   "label": "Content",
+   "reqd": 1
+  },
+  {
+   "fieldname": "mentions",
+   "fieldtype": "Code",
+   "hidden": 1,
+   "label": "Mentions"
+  },
+  {
+   "fieldname": "urls",
+   "fieldtype": "Data",
+   "hidden": 1,
+   "label": "URLs"
+  }
+ ],
+ "modified": "2020-09-18 17:26:09.703215",
+ "modified_by": "Administrator",
+ "module": "Chat",
+ "name": "Chat Message",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "quick_entry": 1,
+ "search_fields": "content, user",
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "title_field": "content",
+ "track_changes": 1,
+ "track_seen": 1
+}
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_message/chat_message.py b/frappe/chat/doctype/chat_message/chat_message.py
new file mode 100644
index 0000000000..bc470a5e9c
--- /dev/null
+++ b/frappe/chat/doctype/chat_message/chat_message.py
@@ -0,0 +1,215 @@
+# imports - standard imports
+import json
+
+# imports - third-party imports
+import requests
+from bs4 import BeautifulSoup as Soup
+
+# imports - module imports
+from   frappe.model.document import Document
+from   frappe import _, _dict
+import frappe
+
+# imports - frappe module imports
+from frappe.chat 	  import authenticate
+from frappe.chat.util import (
+	get_if_empty,
+	check_url,
+	dictify,
+	get_emojis,
+	safe_json_loads,
+	get_user_doc,
+	squashify
+)
+
+session = frappe.session
+
+class ChatMessage(Document):
+	pass
+
+def get_message_urls(content):
+	soup     = Soup(content, 'html.parser')
+	anchors  = soup.find_all('a')
+	urls     = [ ]
+
+	for anchor in anchors:
+		text = anchor.text
+
+		if check_url(text):
+			urls.append(text)
+
+	return urls
+
+def get_message_mentions(content):
+	mentions = [ ]
+	tokens   = content.split(' ')
+
+	for token in tokens:
+		if token.startswith('@'):
+			what = token[1:]
+			if frappe.db.exists('User', what):
+				mentions.append(what)
+		else:
+			if frappe.db.exists('User', token):
+				mentions.append(token)
+
+	return mentions
+
+def get_message_meta(content):
+	'''
+		Assumes content to be HTML. Sanitizes the content
+		into a dict of metadata values.
+	'''
+	meta = _dict(
+		links 	 = [ ],
+		mentions = [ ]
+	)
+
+	meta.content  = content
+	meta.urls	  = get_message_urls(content)
+	meta.mentions = get_message_mentions(content)
+
+	return meta
+
+def sanitize_message_content(content):
+	emojis = get_emojis()
+
+	tokens = content.split(' ')
+	for token in tokens:
+		if token.startswith(':') and token.endswith(':'):
+			what = token[1:-1]
+
+			# Expensive, I know.
+			for emoji in emojis:
+				for alias in emoji.aliases:
+					if what == alias:
+						content = content.replace(token, emoji.emoji)
+
+	return content
+
+def get_new_chat_message_doc(user, room, content, type = "Content", link = True):
+	user = get_user_doc(user)
+	room = frappe.get_doc('Chat Room', room)
+
+	meta = get_message_meta(content)
+	mess = frappe.new_doc('Chat Message')
+	mess.room 	   = room.name
+	mess.room_type = room.type
+	mess.content   = sanitize_message_content(content)
+	mess.type      = type
+	mess.user	   = user.name
+
+	mess.mentions  = json.dumps(meta.mentions)
+	mess.urls      = ','.join(meta.urls)
+	mess.save(ignore_permissions = True)
+
+	if link:
+		room.update(dict(
+			last_message = mess.name
+		))
+		room.save(ignore_permissions = True)
+
+	return mess
+
+def get_new_chat_message(user, room, content, type = "Content"):
+	mess = get_new_chat_message_doc(user, room, content, type)
+
+	resp = dict(
+		name      = mess.name,
+		user      = mess.user,
+		room      = mess.room,
+		room_type = mess.room_type,
+		content   = json.loads(mess.content) if mess.type in ["File"] else mess.content,
+		urls      = mess.urls,
+		mentions  = json.loads(mess.mentions),
+		creation  = mess.creation,
+		seen      = json.loads(mess._seen) if mess._seen else [ ],
+	)
+
+	return resp
+
+@frappe.whitelist(allow_guest = True)
+def send(user, room, content, type = "Content"):
+	mess = get_new_chat_message(user, room, content, type)
+
+	frappe.publish_realtime('frappe.chat.message:create', mess, room = room,
+		after_commit = True)
+
+@frappe.whitelist(allow_guest = True)
+def seen(message, user = None):
+	authenticate(user)
+
+	has_message = frappe.db.exists('Chat Message', message)
+
+	if has_message:
+		mess = frappe.get_doc('Chat Message', message)
+		mess.add_seen(user)
+		mess.load_from_db()
+		room = mess.room
+		resp = dict(message = message, data = dict(seen = json.loads(mess._seen) if mess._seen else []))
+
+		frappe.publish_realtime('frappe.chat.message:update', resp, room = room, after_commit = True)
+
+def history(room, fields = None, limit = 10, start = None, end = None):
+	room = frappe.get_doc('Chat Room', room)
+	mess = frappe.get_all('Chat Message',
+		filters  = [
+			('Chat Message', 'room', 	  '=', room.name),
+			('Chat Message', 'room_type', '=', room.type)
+		],
+		fields   = fields if fields else [
+			'name', 'room_type', 'room', 'content', 'type', 'user', 'mentions', 'urls', 'creation', '_seen'
+		],
+		order_by = 'creation'
+	)
+
+	if not fields or 'seen' in fields:
+		for m in mess:
+			m['seen'] = json.loads(m._seen) if m._seen else [ ]
+			del m['_seen']
+	if not fields or 'content' in fields:
+		for m in mess:
+			m['content'] = json.loads(m.content) if m.type in ["File"] else m.content
+
+	frappe.enqueue('frappe.chat.doctype.chat_message.chat_message.mark_messages_as_seen',
+		message_names=[m.name for m in mess], user=frappe.session.user)
+
+	return mess
+
+def mark_messages_as_seen(message_names, user):
+	'''
+	Marks chat messages as seen, updates the _seen for each message
+	(should be run in background process)
+	'''
+	for name in message_names:
+		seen = frappe.db.get_value('Chat Message', name, '_seen') or '[]'
+		seen = json.loads(seen)
+		seen.append(user)
+		seen = json.dumps(seen)
+		frappe.db.set_value('Chat Message', name, '_seen', seen, update_modified=False)
+
+	frappe.db.commit()
+
+
+@frappe.whitelist()
+def get(name, rooms = None, fields = None):
+	rooms, fields = safe_json_loads(rooms, fields)
+
+	has_message = frappe.db.exists('Chat Message', name)
+
+	if has_message:
+		dmess = frappe.get_doc('Chat Message', name)
+		data  = dict(
+			name      = dmess.name,
+			user      = dmess.user,
+			room      = dmess.room,
+			room_type = dmess.room_type,
+			content   = json.loads(dmess.content) if dmess.type in ["File"] else dmess.content,
+			type      = dmess.type,
+			urls      = dmess.urls,
+			mentions  = dmess.mentions,
+			creation  = dmess.creation,
+			seen      = get_if_empty(dmess._seen, [ ])
+		)
+
+		return data
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_message/chat_message_list.js b/frappe/chat/doctype/chat_message/chat_message_list.js
new file mode 100644
index 0000000000..c5b717048b
--- /dev/null
+++ b/frappe/chat/doctype/chat_message/chat_message_list.js
@@ -0,0 +1,8 @@
+frappe.listview_settings['Chat Message'] = {
+	filters: [
+		['Chat Message', 'user',  '==', frappe.session.user, true]
+		// I need an or_filter here.
+		// ['Chat Room',    'owner', '==', frappe.session.user, true],
+		// ['Chat Room',    frappe.session.user, 'in', 'users', true]
+	]
+};
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_profile/__init__.py b/frappe/chat/doctype/chat_profile/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frappe/chat/doctype/chat_profile/chat_profile.js b/frappe/chat/doctype/chat_profile/chat_profile.js
new file mode 100644
index 0000000000..b27a98faf5
--- /dev/null
+++ b/frappe/chat/doctype/chat_profile/chat_profile.js
@@ -0,0 +1,10 @@
+/* eslint semi: "never" */
+frappe.ui.form.on('Chat Profile', {
+	refresh: function (form) {
+		if ( form.doc.name !== frappe.session.user ) {
+			form.disable_save()
+			form.set_read_only(true)
+			// There's one more that faris@frappe.io told me to add here. form.refresh_fields()?
+		}
+	}
+});
diff --git a/frappe/chat/doctype/chat_profile/chat_profile.json b/frappe/chat/doctype/chat_profile/chat_profile.json
new file mode 100644
index 0000000000..eb36f803fe
--- /dev/null
+++ b/frappe/chat/doctype/chat_profile/chat_profile.json
@@ -0,0 +1,98 @@
+{
+ "autoname": "field:user",
+ "beta": 1,
+ "creation": "2017-11-13 18:26:57.943027",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "user",
+  "status",
+  "chat_background",
+  "notifications",
+  "message_preview",
+  "notification_tones",
+  "conversation_tones",
+  "settings",
+  "enable_chat"
+ ],
+ "fields": [
+  {
+   "fieldname": "user",
+   "fieldtype": "Link",
+   "label": "User",
+   "options": "User",
+   "reqd": 1
+  },
+  {
+   "default": "Online",
+   "fieldname": "status",
+   "fieldtype": "Select",
+   "in_list_view": 1,
+   "label": "Status",
+   "options": "Online\nAway\nBusy\nOffline"
+  },
+  {
+   "fieldname": "chat_background",
+   "fieldtype": "Attach Image",
+   "label": "Chat Background"
+  },
+  {
+   "fieldname": "notifications",
+   "fieldtype": "Section Break",
+   "label": "Notifications"
+  },
+  {
+   "default": "1",
+   "fieldname": "message_preview",
+   "fieldtype": "Check",
+   "label": "Message Preview"
+  },
+  {
+   "default": "1",
+   "fieldname": "notification_tones",
+   "fieldtype": "Check",
+   "label": "Notification Tones"
+  },
+  {
+   "default": "1",
+   "fieldname": "conversation_tones",
+   "fieldtype": "Check",
+   "label": "Conversation Tones"
+  },
+  {
+   "fieldname": "settings",
+   "fieldtype": "Section Break",
+   "label": "Settings"
+  },
+  {
+   "default": "1",
+   "fieldname": "enable_chat",
+   "fieldtype": "Check",
+   "label": "Enable Chat"
+  }
+ ],
+ "in_create": 1,
+ "modified": "2019-11-07 13:21:36.414961",
+ "modified_by": "Administrator",
+ "module": "Chat",
+ "name": "Chat Profile",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "track_changes": 1
+}
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_profile/chat_profile.py b/frappe/chat/doctype/chat_profile/chat_profile.py
new file mode 100644
index 0000000000..da10a836c4
--- /dev/null
+++ b/frappe/chat/doctype/chat_profile/chat_profile.py
@@ -0,0 +1,98 @@
+# imports - module imports
+from   frappe.model.document import Document
+from   frappe import _
+import frappe
+
+# imports - frappe module imports
+from   frappe.core.doctype.version.version import get_diff
+from   frappe.chat.doctype.chat_room       import chat_room
+from   frappe.chat.util import (
+	safe_json_loads,
+	filter_dict,
+	dictify
+)
+
+session = frappe.session
+
+class ChatProfile(Document):
+	def on_update(self):
+		if not self.is_new():
+			b, a = self.get_doc_before_save(), self
+			diff = dictify(get_diff(a, b))
+			if diff:
+				user   = session.user
+
+				fields = [changed[0] for changed in diff.changed]
+
+				if 'status' in fields:
+					rooms  = chat_room.get(user, filters = ['Chat Room', 'type', '=', 'Direct'])
+					update = dict(user = user, data = dict(status = self.status))
+
+					for room in rooms:
+						frappe.publish_realtime('frappe.chat.profile:update', update, room = room.name, after_commit = True)
+
+				if 'enable_chat' in fields:
+					update = dict(user = user, data = dict(enable_chat = bool(self.enable_chat)))
+					frappe.publish_realtime('frappe.chat.profile:update', update, user = user, after_commit = True)
+
+def authenticate(user):
+	if user != session.user:
+		frappe.throw(_("Sorry, you're not authorized."))
+
+@frappe.whitelist()
+def get(user, fields = None):
+	duser   = frappe.get_doc('User', user)
+
+	if frappe.db.exists('Chat Profile', user):
+		dprof = frappe.get_doc('Chat Profile', user)
+
+		# If you're adding something here, make sure the client recieves it.
+		profile = dict(
+			# User
+			name       = duser.name,
+			email      = duser.email,
+			first_name = duser.first_name,
+			last_name  = duser.last_name,
+			username   = duser.username,
+			avatar     = duser.user_image,
+			bio        = duser.bio,
+			# Chat Profile
+			status             = dprof.status,
+			chat_background    = dprof.chat_background,
+			message_preview    = bool(dprof.message_preview),
+			notification_tones = bool(dprof.notification_tones),
+			conversation_tones = bool(dprof.conversation_tones),
+			enable_chat        = bool(dprof.enable_chat)
+		)
+		profile = filter_dict(profile, fields)
+
+		return dictify(profile)
+
+@frappe.whitelist()
+def create(user, exists_ok = False, fields = None):
+	authenticate(user)
+
+	exists_ok, fields = safe_json_loads(exists_ok, fields)
+
+	try:
+		dprof = frappe.new_doc('Chat Profile')
+		dprof.user = user
+		dprof.save(ignore_permissions = True)
+	except frappe.DuplicateEntryError:
+		frappe.clear_messages()
+		if not exists_ok:
+			frappe.throw(_('Chat Profile for User {0} exists.').format(user))
+
+	profile = get(user, fields = fields)
+
+	return profile
+
+@frappe.whitelist()
+def update(user, data):
+	authenticate(user)
+
+	data  = safe_json_loads(data)
+
+	dprof = frappe.get_doc('Chat Profile', user)
+	dprof.update(data)
+	dprof.save(ignore_permissions = True)
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_profile/chat_profile_list.js b/frappe/chat/doctype/chat_profile/chat_profile_list.js
new file mode 100644
index 0000000000..4d97b75e65
--- /dev/null
+++ b/frappe/chat/doctype/chat_profile/chat_profile_list.js
@@ -0,0 +1,11 @@
+frappe.listview_settings['Chat Profile'] = 
+{
+	get_indicator: function (doc)
+	{
+		const status = frappe.utils.squash(frappe.chat.profile.STATUSES.filter(
+			s => s.name === doc.status
+		));
+
+		return [__(status.name), status.color, `status,=,${status.name}`]
+	}
+};
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_room/__init__.py b/frappe/chat/doctype/chat_room/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frappe/chat/doctype/chat_room/chat_room.js b/frappe/chat/doctype/chat_room/chat_room.js
new file mode 100644
index 0000000000..00b9c8d8f7
--- /dev/null
+++ b/frappe/chat/doctype/chat_room/chat_room.js
@@ -0,0 +1,8 @@
+// Copyright (c) 2017, Frappe Technologies and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on('Chat Room', {
+	refresh: function (form) {
+
+	}
+});
diff --git a/frappe/chat/doctype/chat_room/chat_room.json b/frappe/chat/doctype/chat_room/chat_room.json
new file mode 100644
index 0000000000..1417306c45
--- /dev/null
+++ b/frappe/chat/doctype/chat_room/chat_room.json
@@ -0,0 +1,100 @@
+{
+ "autoname": "CR.#####",
+ "beta": 1,
+ "creation": "2017-11-08 15:27:21.156667",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "type",
+  "room_name",
+  "avatar",
+  "last_message",
+  "message_count",
+  "owner",
+  "user_list",
+  "users"
+ ],
+ "fields": [
+  {
+   "default": "Direct",
+   "fieldname": "type",
+   "fieldtype": "Select",
+   "in_list_view": 1,
+   "label": "Type",
+   "options": "Direct\nGroup\nVisitor",
+   "reqd": 1,
+   "set_only_once": 1
+  },
+  {
+   "depends_on": "eval:doc.type==\"Group\"",
+   "fieldname": "room_name",
+   "fieldtype": "Data",
+   "label": "Name"
+  },
+  {
+   "depends_on": "eval:doc.type==\"Group\"",
+   "fieldname": "avatar",
+   "fieldtype": "Attach Image",
+   "hidden": 1,
+   "label": "Avatar"
+  },
+  {
+   "fieldname": "last_message",
+   "fieldtype": "Data",
+   "hidden": 1,
+   "label": "Last Message"
+  },
+  {
+   "fieldname": "message_count",
+   "fieldtype": "Int",
+   "hidden": 1,
+   "label": "Message Count"
+  },
+  {
+   "fieldname": "owner",
+   "fieldtype": "Data",
+   "hidden": 1,
+   "label": "Owner",
+   "read_only": 1
+  },
+  {
+   "fieldname": "user_list",
+   "fieldtype": "Section Break",
+   "label": "Users"
+  },
+  {
+   "fieldname": "users",
+   "fieldtype": "Table",
+   "label": "Users",
+   "options": "Chat Room User"
+  }
+ ],
+ "image_field": "avatar",
+ "modified": "2019-11-07 13:20:24.625329",
+ "modified_by": "Administrator",
+ "module": "Chat",
+ "name": "Chat Room",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "set_user_permissions": 1,
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "search_fields": "room_name",
+ "show_name_in_global_search": 1,
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "title_field": "room_name",
+ "track_changes": 1
+}
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_room/chat_room.py b/frappe/chat/doctype/chat_room/chat_room.py
new file mode 100644
index 0000000000..bdbee44d7a
--- /dev/null
+++ b/frappe/chat/doctype/chat_room/chat_room.py
@@ -0,0 +1,227 @@
+# imports - module imports
+from frappe.model.document import Document
+from frappe import _
+import frappe
+
+# imports - frappe module imports
+from frappe.chat import authenticate
+from frappe.core.doctype.version.version import get_diff
+from frappe.chat.doctype.chat_message import chat_message
+from frappe.chat.util import (
+	safe_json_loads,
+	dictify,
+	listify,
+	squashify,
+	get_if_empty
+)
+
+session = frappe.session
+
+
+def is_direct(owner, other, bidirectional=False):
+	def get_room(owner, other):
+		room = frappe.get_all('Chat Room', filters=[
+			['Chat Room', 'type', 'in', ('Direct', 'Visitor')],
+			['Chat Room', 'owner', '=', owner],
+			['Chat Room User', 'user', '=', other]
+		], distinct=True)
+
+		return room
+
+	exists = len(get_room(owner, other)) == 1
+	if bidirectional:
+		exists = exists or len(get_room(other, owner)) == 1
+
+	return exists
+
+
+def get_chat_room_user_set(users, filter_=None):
+	seen, uset = set(), list()
+
+	for u in users:
+		if filter_(u) and u.user not in seen:
+			uset.append(u)
+			seen.add(u.user)
+
+	return uset
+
+
+class ChatRoom(Document):
+	def validate(self):
+		if self.is_new():
+			users = get_chat_room_user_set(self.users, filter_=lambda u: u.user != session.user)
+			self.update(dict(
+				users=users
+			))
+
+		if self.type == "Direct":
+			if len(self.users) != 1:
+				frappe.throw(_('{0} room must have atmost one user.').format(self.type))
+
+			other = squashify(self.users)
+
+			if self.is_new():
+				if is_direct(self.owner, other.user, bidirectional=True):
+					frappe.throw(_('Direct room with {0} already exists.').format(other.user))
+
+		if self.type == "Group" and not self.room_name:
+			frappe.throw(_('Group name cannot be empty.'))
+
+	def on_update(self):
+		if not self.is_new():
+			before = self.get_doc_before_save()
+			if not before: return
+
+			after = self
+			diff = dictify(get_diff(before, after))
+			if diff:
+				update = {}
+				for changed in diff.changed:
+					field, old, new = changed
+
+					if field == 'last_message':
+						new = chat_message.get(new)
+
+					update.update({field: new})
+
+				if diff.added or diff.removed:
+					update.update(dict(users=[u.user for u in self.users]))
+
+				update = dict(room=self.name, data=update)
+
+				frappe.publish_realtime('frappe.chat.room:update', update, room=self.name,
+						after_commit=True)
+
+
+@frappe.whitelist(allow_guest=True)
+def get(user=None, token=None, rooms=None, fields=None, filters=None):
+	# There is this horrible bug out here.
+	# Looks like if frappe.call sends optional arguments (not in right order),
+	# the argument turns to an empty string.
+	# I'm not even going to think searching for it.
+	# Hence, the hack was get_if_empty (previous assign_if_none)
+	# - Achilles Rasquinha achilles@frappe.io
+	data = user or token
+	authenticate(data)
+
+	rooms, fields, filters = safe_json_loads(rooms, fields, filters)
+
+	rooms = listify(get_if_empty(rooms, []))
+	fields = listify(get_if_empty(fields, []))
+
+	const = []  # constraints
+	if rooms:
+		const.append(['Chat Room', 'name', 'in', rooms])
+	if filters:
+		if isinstance(filters[0], list):
+			const = const + filters
+		else:
+			const.append(filters)
+
+	default = ['name', 'type', 'room_name', 'creation', 'owner', 'avatar']
+	handle = ['users', 'last_message']
+
+	param = [f for f in fields if f not in handle]
+
+	rooms = frappe.get_all('Chat Room',
+			or_filters=[
+				['Chat Room', 'owner', '=', frappe.session.user],
+				['Chat Room User', 'user', '=', frappe.session.user]
+			],
+			filters=const,
+			fields=param + ['name'] if param else default,
+			distinct=True
+		)
+
+	if not fields or 'users' in fields:
+		for i, r in enumerate(rooms):
+			droom = frappe.get_doc('Chat Room', r.name)
+			rooms[i]['users'] = []
+
+			for duser in droom.users:
+				rooms[i]['users'].append(duser.user)
+
+	if not fields or 'last_message' in fields:
+		for i, r in enumerate(rooms):
+			droom = frappe.get_doc('Chat Room', r.name)
+			if droom.last_message:
+				rooms[i]['last_message'] = chat_message.get(droom.last_message)
+			else:
+				rooms[i]['last_message'] = None
+
+	rooms = squashify(dictify(rooms))
+
+	return rooms
+
+
+@frappe.whitelist(allow_guest=True)
+def create(kind, token, users=None, name=None):
+	authenticate(token)
+
+	users = safe_json_loads(users)
+	create = True
+
+	if kind == 'Visitor':
+		room = squashify(frappe.db.sql("""
+			SELECT name
+			FROM   `tabChat Room`
+			WHERE  owner=%s
+			""", (frappe.session.user), as_dict=True))
+
+		if room:
+			room = frappe.get_doc('Chat Room', room.name)
+			create = False
+
+	if create:
+		room = frappe.new_doc('Chat Room')
+		room.type = kind
+		room.owner = frappe.session.user
+		room.room_name = name
+
+	dusers = []
+
+	if kind != 'Visitor':
+		if users:
+			users = listify(users)
+			for user in users:
+				duser = frappe.new_doc('Chat Room User')
+				duser.user = user
+				dusers.append(duser)
+
+			room.users = dusers
+	else:
+		dsettings = frappe.get_single('Website Settings')
+		room.room_name = dsettings.chat_room_name
+
+		users = [user for user in room.users] if hasattr(room, 'users') else []
+
+		for user in dsettings.chat_operators:
+			if user.user not in users:
+				# appending user to room.users will remove the user from chat_operators
+				# this is undesirable, create a new Chat Room User instead
+				chat_room_user = {"doctype": "Chat Room User", "user": user.user}
+				room.append('users', chat_room_user)
+
+	room.save(ignore_permissions=True)
+
+	room = get(token=token, rooms=room.name)
+	if room:
+		users = [room.owner] + [u for u in room.users]
+
+		for user in users:
+			frappe.publish_realtime('frappe.chat.room:create', room, user=user, after_commit=True)
+
+	return room
+
+
+@frappe.whitelist(allow_guest=True)
+def history(room, user, fields=None, limit=10, start=None, end=None):
+	if frappe.get_doc('Chat Room', room).type != 'Visitor':
+		authenticate(user)
+
+	fields = safe_json_loads(fields)
+
+	mess = chat_message.history(room, limit=limit, start=start, end=end)
+	mess = squashify(mess)
+
+	return dictify(mess)
diff --git a/frappe/chat/doctype/chat_room/chat_room_list.js b/frappe/chat/doctype/chat_room/chat_room_list.js
new file mode 100644
index 0000000000..70c708c7bd
--- /dev/null
+++ b/frappe/chat/doctype/chat_room/chat_room_list.js
@@ -0,0 +1,6 @@
+frappe.listview_settings['Chat Room'] = {
+	filters: [
+		['Chat Room', 'owner', '=', frappe.session.user, true],
+		['Chat Room User', 'user', '=', frappe.session.user, true]
+	]
+};
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_room_user/__init__.py b/frappe/chat/doctype/chat_room_user/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frappe/chat/doctype/chat_room_user/chat_room_user.json b/frappe/chat/doctype/chat_room_user/chat_room_user.json
new file mode 100644
index 0000000000..f7bdf6706b
--- /dev/null
+++ b/frappe/chat/doctype/chat_room_user/chat_room_user.json
@@ -0,0 +1,40 @@
+{
+ "beta": 1,
+ "creation": "2017-11-08 15:24:21.029314",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "user",
+  "is_admin"
+ ],
+ "fields": [
+  {
+   "fieldname": "user",
+   "fieldtype": "Link",
+   "in_list_view": 1,
+   "label": "User",
+   "options": "User",
+   "reqd": 1
+  },
+  {
+   "default": "0",
+   "fieldname": "is_admin",
+   "fieldtype": "Check",
+   "label": "Admin"
+  }
+ ],
+ "in_create": 1,
+ "istable": 1,
+ "modified": "2019-11-07 13:21:05.297337",
+ "modified_by": "Administrator",
+ "module": "Chat",
+ "name": "Chat Room User",
+ "owner": "Administrator",
+ "permissions": [],
+ "quick_entry": 1,
+ "read_only": 1,
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "track_changes": 1
+}
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_room_user/chat_room_user.py b/frappe/chat/doctype/chat_room_user/chat_room_user.py
new file mode 100644
index 0000000000..f6dbdc7659
--- /dev/null
+++ b/frappe/chat/doctype/chat_room_user/chat_room_user.py
@@ -0,0 +1,8 @@
+# imports - module imports
+from   frappe.model.document import Document
+import frappe
+
+session = frappe.session
+
+class ChatRoomUser(Document):
+	pass
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_token/__init__.py b/frappe/chat/doctype/chat_token/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frappe/chat/doctype/chat_token/chat_token.js b/frappe/chat/doctype/chat_token/chat_token.js
new file mode 100644
index 0000000000..78f03026ec
--- /dev/null
+++ b/frappe/chat/doctype/chat_token/chat_token.js
@@ -0,0 +1,8 @@
+// Copyright (c) 2018, Frappe Technologies and contributors
+// For license information, please see license.txt
+
+frappe.ui.form.on('Chat Token', {
+	refresh: function(frm) {
+
+	}
+});
diff --git a/frappe/chat/doctype/chat_token/chat_token.json b/frappe/chat/doctype/chat_token/chat_token.json
new file mode 100644
index 0000000000..b73505ac2c
--- /dev/null
+++ b/frappe/chat/doctype/chat_token/chat_token.json
@@ -0,0 +1,57 @@
+{
+ "autoname": "field:token",
+ "beta": 1,
+ "creation": "2018-03-26 18:20:13.825652",
+ "doctype": "DocType",
+ "editable_grid": 1,
+ "engine": "InnoDB",
+ "field_order": [
+  "token",
+  "ip_address",
+  "country"
+ ],
+ "fields": [
+  {
+   "fieldname": "token",
+   "fieldtype": "Data",
+   "in_list_view": 1,
+   "label": "Token",
+   "reqd": 1
+  },
+  {
+   "fieldname": "ip_address",
+   "fieldtype": "Data",
+   "label": "IP Address"
+  },
+  {
+   "fieldname": "country",
+   "fieldtype": "Data",
+   "label": "Country"
+  }
+ ],
+ "in_create": 1,
+ "modified": "2019-11-07 13:21:24.514558",
+ "modified_by": "Administrator",
+ "module": "Chat",
+ "name": "Chat Token",
+ "owner": "Administrator",
+ "permissions": [
+  {
+   "create": 1,
+   "delete": 1,
+   "email": 1,
+   "export": 1,
+   "print": 1,
+   "read": 1,
+   "report": 1,
+   "role": "System Manager",
+   "share": 1,
+   "write": 1
+  }
+ ],
+ "quick_entry": 1,
+ "read_only": 1,
+ "sort_field": "modified",
+ "sort_order": "DESC",
+ "track_changes": 1
+}
\ No newline at end of file
diff --git a/frappe/chat/doctype/chat_token/chat_token.py b/frappe/chat/doctype/chat_token/chat_token.py
new file mode 100644
index 0000000000..0be51b6081
--- /dev/null
+++ b/frappe/chat/doctype/chat_token/chat_token.py
@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2018, Frappe Technologies and contributors
+# License: MIT. See LICENSE
+
+import frappe
+from frappe.model.document import Document
+
+class ChatToken(Document):
+	pass
diff --git a/frappe/chat/util/__init__.py b/frappe/chat/util/__init__.py
new file mode 100644
index 0000000000..383df581cd
--- /dev/null
+++ b/frappe/chat/util/__init__.py
@@ -0,0 +1,13 @@
+# imports - module imports
+from frappe.chat.util.util import (
+	get_user_doc,
+	squashify,
+	safe_json_loads,
+	filter_dict,
+	get_if_empty,
+	listify,
+	dictify,
+	check_url,
+	create_test_user,
+	get_emojis
+)
\ No newline at end of file
diff --git a/frappe/chat/util/test_util.py b/frappe/chat/util/test_util.py
new file mode 100644
index 0000000000..e2d05a4024
--- /dev/null
+++ b/frappe/chat/util/test_util.py
@@ -0,0 +1,35 @@
+# imports - standard imports
+import unittest
+
+# imports - module imports
+from frappe.chat.util import (
+	get_user_doc,
+	safe_json_loads
+)
+import frappe
+
+class TestChatUtil(unittest.TestCase):
+	def test_safe_json_loads(self):
+		number = safe_json_loads("1")
+		self.assertEqual(type(number), int)
+
+		number = safe_json_loads("1.0")
+		self.assertEqual(type(number), float)
+
+		string = safe_json_loads("foobar")
+		self.assertEqual(type(string), str)
+
+		array  = safe_json_loads('[{ "foo": "bar" }]')
+		self.assertEqual(type(array), list)
+
+		objekt = safe_json_loads('{ "foo": "bar" }')
+		self.assertEqual(type(objekt), dict)
+
+		true, null = safe_json_loads("true", "null")
+		self.assertEqual(true, True)
+		self.assertEqual(null, None)
+
+	def test_get_user_doc(self):
+		# Needs more test cases.
+		user = get_user_doc()
+		self.assertEqual(user.name, frappe.session.user)
\ No newline at end of file
diff --git a/frappe/chat/util/util.py b/frappe/chat/util/util.py
new file mode 100644
index 0000000000..b7e7991c2b
--- /dev/null
+++ b/frappe/chat/util/util.py
@@ -0,0 +1,108 @@
+# imports - standard imports
+import json
+from collections.abc import MutableMapping, MutableSequence, Sequence
+
+# imports - third-party imports
+import requests
+from urllib.parse import urlparse
+
+# imports - module imports
+import frappe
+from frappe.exceptions import DuplicateEntryError
+from frappe.model.document import Document
+
+session = frappe.session
+
+
+def get_user_doc(user = None):
+	if isinstance(user, Document):
+		return user
+
+	user = user or session.user
+	user = frappe.get_doc('User', user)
+
+	return user
+
+def squashify(what):
+	if isinstance(what, Sequence) and len(what) == 1:
+		return what[0]
+
+	return what
+
+def safe_json_loads(*args):
+	results = []
+
+	for arg in args:
+		try:
+			arg = json.loads(arg)
+		except Exception:
+			pass
+
+		results.append(arg)
+
+	return squashify(results)
+
+def filter_dict(what, keys, ignore = False):
+	copy = dict()
+
+	if keys:
+		for k in keys:
+			if k not in what and not ignore:
+				raise KeyError('{key} not in dict.'.format(key = k))
+			else:
+				copy.update({
+					k: what[k]
+				})
+	else:
+		copy = what.copy()
+
+	return copy
+
+def get_if_empty(a, b):
+	if not a:
+		a = b
+	return a
+
+def listify(arg):
+	if not isinstance(arg, list):
+		arg = [arg]
+	return arg
+
+def dictify(arg):
+	if isinstance(arg, MutableSequence):
+		for i, a in enumerate(arg):
+			arg[i] = dictify(a)
+	elif isinstance(arg, MutableMapping):
+		arg = frappe._dict(arg)
+
+	return arg
+
+def check_url(what, raise_err = False):
+	if not urlparse(what).scheme:
+		if raise_err:
+			raise ValueError('{what} not a valid URL.')
+		else:
+			return False
+
+	return True
+
+def create_test_user(module):
+	try:
+		test_user = frappe.new_doc('User')
+		test_user.first_name = '{module}'.format(module = module)
+		test_user.email      = 'testuser.{module}@example.com'.format(module = module)
+		test_user.save()
+	except DuplicateEntryError:
+		frappe.log('Test User Chat Profile exists.')
+
+def get_emojis():
+	redis  = frappe.cache()
+	emojis = redis.hget('frappe_emojis', 'emojis')
+
+	if not emojis:
+		resp  = requests.get('http://git.io/frappe-emoji')
+		if resp.ok:
+			emojis = resp.json()
+			redis.hset('frappe_emojis', 'emojis', emojis)
+
+	return dictify(emojis)
diff --git a/frappe/chat/website/__init__.py b/frappe/chat/website/__init__.py
new file mode 100644
index 0000000000..12affd2782
--- /dev/null
+++ b/frappe/chat/website/__init__.py
@@ -0,0 +1,42 @@
+
+import frappe
+from   frappe.chat.util import filter_dict, safe_json_loads
+
+from   frappe.sessions  import get_geo_ip_country
+
+@frappe.whitelist(allow_guest = True)
+def settings(fields = None):
+    fields    = safe_json_loads(fields)
+
+    dsettings = frappe.get_single('Website Settings')
+    response  = dict(
+        socketio         = dict(
+            port         = frappe.conf.socketio_port
+        ),
+        enable           = bool(dsettings.chat_enable),
+        enable_from      = dsettings.chat_enable_from,
+        enable_to        = dsettings.chat_enable_to,
+        room_name        = dsettings.chat_room_name,
+        welcome_message  = dsettings.chat_welcome_message,
+        operators        = [
+            duser.user for duser in dsettings.chat_operators
+        ]
+    )
+
+    if fields:
+        response = filter_dict(response, fields)
+
+    return response
+
+@frappe.whitelist(allow_guest = True)
+def token():
+    dtoken             = frappe.new_doc('Chat Token')
+
+    dtoken.token       = frappe.generate_hash()
+    dtoken.ip_address  = frappe.local.request_ip
+    country            = get_geo_ip_country(dtoken.ip_address)
+    if country:
+        dtoken.country = country['iso_code']
+    dtoken.save(ignore_permissions = True)
+
+    return dtoken.token
\ No newline at end of file
diff --git a/frappe/core/doctype/role/role.json b/frappe/core/doctype/role/role.json
index ba82e023a9..0135cbf9e8 100644
--- a/frappe/core/doctype/role/role.json
+++ b/frappe/core/doctype/role/role.json
@@ -17,6 +17,7 @@
   "navigation_settings_section",
   "search_bar",
   "notifications",
+  "chat",
   "list_settings_section",
   "list_sidebar",
   "bulk_actions",
@@ -84,6 +85,12 @@
    "fieldtype": "Check",
    "label": "Search Bar"
   },
+  {
+   "default": "1",
+   "fieldname": "chat",
+   "fieldtype": "Check",
+   "label": "Chat"
+  },
   {
    "fieldname": "list_settings_section",
    "fieldtype": "Section Break",
@@ -148,11 +155,10 @@
  "idx": 1,
  "index_web_pages_for_search": 1,
  "links": [],
- "modified": "2021-10-08 14:06:55.729364",
+ "modified": "2021-01-27 10:35:37.638350",
  "modified_by": "Administrator",
  "module": "Core",
  "name": "Role",
- "naming_rule": "By fieldname",
  "owner": "Administrator",
  "permissions": [
   {
diff --git a/frappe/core/doctype/role/role.py b/frappe/core/doctype/role/role.py
index 98d2d72fc2..f4fa855ea1 100644
--- a/frappe/core/doctype/role/role.py
+++ b/frappe/core/doctype/role/role.py
@@ -5,7 +5,7 @@ import frappe
 
 from frappe.model.document import Document
 
-desk_properties = ("search_bar", "notifications", "list_sidebar",
+desk_properties = ("search_bar", "notifications", "chat", "list_sidebar",
 	"bulk_actions", "view_switcher", "form_sidebar", "timeline", "dashboard")
 
 class Role(Document):
@@ -82,4 +82,4 @@ def role_query(doctype, txt, searchfield, start, page_len, filters):
 		report_filters.extend(filters)
 
 	return frappe.get_all('Role', limit_start=start, limit_page_length=page_len,
-		filters=report_filters, as_list=1)
+		filters=report_filters, as_list=1)
\ No newline at end of file
diff --git a/frappe/core/doctype/system_settings/system_settings.json b/frappe/core/doctype/system_settings/system_settings.json
index bc517f9569..4b53983702 100644
--- a/frappe/core/doctype/system_settings/system_settings.json
+++ b/frappe/core/doctype/system_settings/system_settings.json
@@ -65,7 +65,9 @@
   "attach_view_link",
   "prepared_report_section",
   "enable_prepared_report_auto_deletion",
-  "prepared_report_expiry_period"
+  "prepared_report_expiry_period",
+  "chat",
+  "enable_chat"
  ],
  "fields": [
   {
@@ -379,6 +381,18 @@
    "fieldtype": "Check",
    "label": "Hide footer in auto email reports"
   },
+  {
+   "collapsible": 1,
+   "fieldname": "chat",
+   "fieldtype": "Section Break",
+   "label": "Chat"
+  },
+  {
+   "default": "1",
+   "fieldname": "enable_chat",
+   "fieldtype": "Check",
+   "label": "Enable Chat"
+  },
   {
    "fieldname": "column_break_21",
    "fieldtype": "Column Break"
@@ -460,7 +474,7 @@
  "icon": "fa fa-cog",
  "issingle": 1,
  "links": [],
- "modified": "2021-10-08 14:04:11.406725",
+ "modified": "2021-03-30 11:47:47.330437",
  "modified_by": "Administrator",
  "module": "Core",
  "name": "System Settings",
@@ -478,4 +492,4 @@
  "sort_field": "modified",
  "sort_order": "ASC",
  "track_changes": 1
-}
\ No newline at end of file
+}
diff --git a/frappe/core/doctype/user/user.json b/frappe/core/doctype/user/user.json
index a677736c16..c9e10368c5 100644
--- a/frappe/core/doctype/user/user.json
+++ b/frappe/core/doctype/user/user.json
@@ -617,6 +617,11 @@
    "link_doctype": "Contact",
    "link_fieldname": "user"
   },
+  {
+   "group": "Profile",
+   "link_doctype": "Chat Profile",
+   "link_fieldname": "user"
+  },
   {
    "group": "Profile",
    "link_doctype": "Blogger",
diff --git a/frappe/core/doctype/user/user.py b/frappe/core/doctype/user/user.py
index 86fd1cb4a6..b6f6f66ee4 100644
--- a/frappe/core/doctype/user/user.py
+++ b/frappe/core/doctype/user/user.py
@@ -421,6 +421,9 @@ class User(Document):
 					WHERE `%s` = %s""" %
 					(tab, field, '%s', field, '%s'), (new_name, old_name))
 
+		if frappe.db.exists("Chat Profile", old_name):
+			frappe.rename_doc("Chat Profile", old_name, new_name, force=True, show_alert=False)
+
 		if frappe.db.exists("Notification Settings", old_name):
 			frappe.rename_doc("Notification Settings", old_name, new_name, force=True, show_alert=False)
 
@@ -1054,4 +1057,4 @@ def get_enabled_users():
 		enabled_users = frappe.get_all("User", filters={"enabled": "1"}, pluck="name")
 		return enabled_users
 
-	return frappe.cache().get_value("enabled_users", _get_enabled_users)
+	return frappe.cache().get_value("enabled_users", _get_enabled_users)
\ No newline at end of file
diff --git a/frappe/core/doctype/user_permission/test_user_permission.py b/frappe/core/doctype/user_permission/test_user_permission.py
index cf905c2ce2..85db846982 100644
--- a/frappe/core/doctype/user_permission/test_user_permission.py
+++ b/frappe/core/doctype/user_permission/test_user_permission.py
@@ -73,7 +73,7 @@ class TestUserPermission(unittest.TestCase):
 	def test_for_applicable_on_update_from_apply_to_all(self):
 		''' Update User Permission from all to some applicable Doctypes'''
 		user = create_user('test_bulk_creation_update@example.com')
-		param = get_params(user,'User', user.name, applicable = ["Comment", "Contact"])
+		param = get_params(user,'User', user.name, applicable = ["Chat Room", "Chat Message"])
 
 		# Initially create User Permission document with apply_to_all checked
 		is_created = add_user_permissions(get_params(user, 'User', user.name))
@@ -84,8 +84,8 @@ class TestUserPermission(unittest.TestCase):
 		frappe.db.commit()
 
 		removed_apply_to_all = frappe.db.exists("User Permission", get_exists_param(user))
-		is_created_applicable_first = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Comment"))
-		is_created_applicable_second = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Contact"))
+		is_created_applicable_first = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Chat Room"))
+		is_created_applicable_second = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Chat Message"))
 
 		# Check that apply_to_all is removed
 		self.assertIsNone(removed_apply_to_all)
@@ -101,14 +101,14 @@ class TestUserPermission(unittest.TestCase):
 		param = get_params(user, 'User', user.name)
 
 		# create User permissions that with applicable
-		is_created = add_user_permissions(get_params(user, 'User', user.name, applicable = ["Comment", "Contact"]))
+		is_created = add_user_permissions(get_params(user, 'User', user.name, applicable = ["Chat Room", "Chat Message"]))
 
 		self.assertEqual(is_created, 1)
 
 		is_created = add_user_permissions(param)
 		is_created_apply_to_all = frappe.db.exists("User Permission", get_exists_param(user))
-		removed_applicable_first = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Comment"))
-		removed_applicable_second = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Contact"))
+		removed_applicable_first = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Chat Room"))
+		removed_applicable_second = frappe.db.exists("User Permission", get_exists_param(user, applicable = "Chat Message"))
 
 		# To check that a User permission with apply_to_all exists
 		self.assertIsNotNone(is_created_apply_to_all)
diff --git a/frappe/hooks.py b/frappe/hooks.py
index 8bca5c066c..2ae5a59066 100644
--- a/frappe/hooks.py
+++ b/frappe/hooks.py
@@ -76,6 +76,8 @@ before_tests = "frappe.utils.install.before_tests"
 
 email_append_to = ["Event", "ToDo", "Communication"]
 
+get_rooms = 'frappe.chat.doctype.chat_room.chat_room.get_rooms'
+
 calendars = ["Event"]
 
 leaderboards = "frappe.desk.leaderboard.get_leaderboards"
@@ -279,6 +281,11 @@ sounds = [
 	{"name": "error", "src": "/assets/frappe/sounds/error.mp3", "volume": 0.1},
 	{"name": "alert", "src": "/assets/frappe/sounds/alert.mp3", "volume": 0.2},
 	# {"name": "chime", "src": "/assets/frappe/sounds/chime.mp3"},
+
+	# frappe.chat sounds
+	{ "name": "chat-message", 	   "src": "/assets/frappe/sounds/chat-message.mp3",      "volume": 0.1 },
+	{ "name": "chat-notification", "src": "/assets/frappe/sounds/chat-notification.mp3", "volume": 0.1 }
+	# frappe.chat sounds
 ]
 
 bot_parsers = [
diff --git a/frappe/modules.txt b/frappe/modules.txt
index a707ca853e..1229116a2e 100644
--- a/frappe/modules.txt
+++ b/frappe/modules.txt
@@ -9,6 +9,7 @@ Integrations
 Printing
 Contacts
 Data Migration
+Chat
 Social
 Automation
-Event Streaming
\ No newline at end of file
+Event Streaming
diff --git a/frappe/public/js/chat.bundle.js b/frappe/public/js/chat.bundle.js
new file mode 100644
index 0000000000..5f9a91ebb7
--- /dev/null
+++ b/frappe/public/js/chat.bundle.js
@@ -0,0 +1 @@
+import "./frappe/chat";
diff --git a/frappe/public/js/desk.bundle.js b/frappe/public/js/desk.bundle.js
index 50947bd9bc..338ddda601 100644
--- a/frappe/public/js/desk.bundle.js
+++ b/frappe/public/js/desk.bundle.js
@@ -99,6 +99,7 @@ import "./frappe/query_string.js";
 
 // import "./frappe/ui/comment.js";
 
+import "./frappe/chat.js";
 import "./frappe/utils/energy_point_utils.js";
 import "./frappe/utils/dashboard_utils.js";
 import "./frappe/ui/chart.js";
diff --git a/frappe/public/js/frappe/chat.js b/frappe/public/js/frappe/chat.js
new file mode 100644
index 0000000000..fd440dcbbc
--- /dev/null
+++ b/frappe/public/js/frappe/chat.js
@@ -0,0 +1,2788 @@
+// Frappe Chat
+// Author - Achilles Rasquinha <achilles@frappe.io>
+
+import Fuse   from 'fuse.js'
+import hyper  from '../lib/hyper.min'
+
+import './socketio_client'
+
+import './ui/dialog'
+import './ui/capture'
+
+import './utils/user'
+
+/* eslint semi: "never" */
+// Fuck semicolons - https://mislav.net/2010/05/semicolons
+
+// frappe extensions
+
+/**
+ * @description The base class for all Frappe Errors.
+ *
+ * @example
+ * try
+ *      throw new frappe.Error("foobar")
+ * catch (e)
+ *      console.log(e.name)
+ * // returns "FrappeError"
+ *
+ * @see  https://stackoverflow.com/a/32749533
+ * @todo Requires "transform-builtin-extend" for Babel 6
+ */
+frappe.Error = Error
+// class extends Error {
+// 	constructor (message) {
+// 		super (message)
+
+// 		this.name = 'FrappeError'
+
+// 		if ( typeof Error.captureStackTrace === 'function' )
+// 			Error.captureStackTrace(this, this.constructor)
+// 		else
+// 			this.stack = (new Error(message)).stack
+// 	}
+// }
+
+/**
+ * @description TypeError
+ */
+frappe.TypeError  = TypeError
+// class extends frappe.Error {
+// 	constructor (message) {
+// 		super (message)
+
+// 		this.name = this.constructor.name
+// 	}
+// }
+
+/**
+ * @description ValueError
+ */
+frappe.ValueError = Error
+// class extends frappe.Error {
+// 	constructor (message) {
+// 		super (message)
+
+// 		this.name = this.constructor.name
+// 	}
+// }
+
+/**
+ * @description ImportError
+ */
+frappe.ImportError = Error
+// class extends frappe.Error {
+// 	constructor (message) {
+// 		super (message)
+
+// 		this.name  = this.constructor.name
+// 	}
+// }
+
+// frappe.datetime
+frappe.provide('frappe.datetime')
+
+/**
+ * @description Frappe's datetime object. (Inspired by Python's datetime object).
+ *
+ * @example
+ * const datetime = new frappe.datetime.datetime()
+ */
+frappe.datetime.datetime = class {
+	/**
+	 * @description Frappe's datetime Class's constructor.
+	 */
+	constructor (instance, format = null) {
+		if ( typeof moment === 'undefined' )
+			throw new frappe.ImportError(`Moment.js not installed.`)
+
+		this.moment = instance ? moment(instance, format) : moment()
+	}
+
+	/**
+	 * @description Returns a formatted string of the datetime object.
+	 */
+	format (format = null) {
+		const  formatted = this.moment.format(format)
+		return formatted
+	}
+}
+
+/**
+ * @description Frappe's daterange object.
+ *
+ * @example
+ * const range = new frappe.datetime.range(frappe.datetime.now(), frappe.datetime.now())
+ * range.contains(frappe.datetime.now())
+ */
+frappe.datetime.range   = class {
+	constructor (start, end) {
+		if ( typeof moment === undefined )
+			throw new frappe.ImportError(`Moment.js not installed.`)
+
+		this.start = start
+		this.end   = end
+	}
+
+	contains (datetime) {
+		const  contains = datetime.moment.isBetween(this.start.moment, this.end.moment)
+		return contains
+	}
+}
+
+/**
+ * @description Returns the current datetime.
+ *
+ * @example
+ * const datetime = new frappe.datetime.now()
+ */
+frappe.datetime.now   = () => new frappe.datetime.datetime()
+
+frappe.datetime.equal = (a, b, type) => {
+	a = a.moment
+	b = b.moment
+
+	const equal = a.isSame(b, type)
+
+	return equal
+}
+
+/**
+ * @description Compares two frappe.datetime.datetime objects.
+ *
+ * @param   {frappe.datetime.datetime} a - A frappe.datetime.datetime/moment object.
+ * @param   {frappe.datetime.datetime} b - A frappe.datetime.datetime/moment object.
+ *
+ * @returns {number} 0 (if a and b are equal), 1 (if a is before b), -1 (if a is after b).
+ *
+ * @example
+ * frappe.datetime.compare(frappe.datetime.now(), frappe.datetime.now())
+ * // returns 0
+ * const then = frappe.datetime.now()
+ *
+ * frappe.datetime.compare(then, frappe.datetime.now())
+ * // returns 1
+ */
+frappe.datetime.compare = (a, b) => {
+	a = a.moment
+	b = b.moment
+
+	if ( a.isBefore(b) )
+		return  1
+	else
+	if ( b.isBefore(a) )
+		return -1
+	else
+		return  0
+}
+
+// frappe.quick_edit
+frappe.quick_edit      = (doctype, docname, fn) => {
+	return new Promise(resolve => {
+		frappe.model.with_doctype(doctype, () => {
+			frappe.db.get_doc(doctype, docname).then(doc  => {
+				const meta     = frappe.get_meta(doctype)
+				const fields   = meta.fields
+				const required = fields.filter(f => f.reqd || f.bold && !f.read_only)
+
+				required.map(f => {
+					if(f.fieldname == 'content' && doc.type == 'File') {
+						f['read_only'] = 1;
+					}
+				})
+
+				const dialog   = new frappe.ui.Dialog({
+					title: __('Edit') + `${doctype} (${docname})`,
+					fields: required,
+					action: {
+						primary: {
+							   label: __("Save"),
+							onsubmit: (values) => {
+								frappe.call('frappe.client.save',
+									{ doc: { doctype: doctype, docname: docname, ...doc, ...values } })
+									  .then(r => {
+										if ( fn )
+											fn(r.message)
+
+										resolve(r.message)
+									  })
+
+								dialog.hide()
+							}
+						},
+						secondary: {
+							label: __("Discard")
+						}
+					}
+				})
+				dialog.set_values(doc)
+
+				const $element = $(dialog.body)
+				$element.append(`
+					<div class="qe-fp" style="padding-top: '15px'; padding-bottom: '15px'; padding-left: '7px'">
+						<button class="btn btn-default btn-sm">
+							${__("Edit in Full Page")}
+						</button>
+					</div>
+				`)
+				$element.find('.qe-fp').click(() => {
+					dialog.hide()
+					frappe.set_route('Form', doctype, docname)
+				})
+
+				dialog.show()
+			})
+		})
+	})
+}
+
+// frappe._
+// frappe's utility namespace.
+frappe.provide('frappe._')
+
+// String Utilities
+
+/**
+ * @description Python-inspired format extension for string objects.
+ *
+ * @param  {string} string - A string with placeholders.
+ * @param  {object} object - An object with placeholder, value pairs.
+ *
+ * @return {string}        - The formatted string.
+ *
+ * @example
+ * frappe._.format('{foo} {bar}', { bar: 'foo', foo: 'bar' })
+ * // returns "bar foo"
+ */
+frappe._.format = (string, object) => {
+	for (const key in object)
+		string  = string.replace(`{${key}}`, object[key])
+
+	return string
+}
+
+/**
+ * @description Fuzzy Search a given query within a dataset.
+ *
+ * @param  {string} query   - A query string.
+ * @param  {array}  dataset - A dataset to search within, can contain singletons or objects.
+ * @param  {object} options - Options as per fuze.js
+ *
+ * @return {array}          - The fuzzy matched index/object within the dataset.
+ *
+ * @example
+ * frappe._.fuzzy_search("foobar", ["foobar", "bartender"])
+ * // returns [0, 1]
+ *
+ * @see http://fusejs.io
+ */
+frappe._.fuzzy_search = (query, dataset, options) => {
+	const DEFAULT     = {
+				shouldSort: true,
+				 threshold: 0.6,
+				  location: 0,
+				  distance: 100,
+		minMatchCharLength: 1,
+		  maxPatternLength: 32
+	}
+	options       = { ...DEFAULT, ...options }
+
+	const fuse    = new Fuse(dataset, options)
+	const result  = fuse.search(query)
+
+	return result
+}
+
+/**
+ * @description Pluralizes a given word.
+ *
+ * @param  {string} word  - The word to be pluralized.
+ * @param  {number} count - The count.
+ *
+ * @return {string}       - The pluralized string.
+ *
+ * @example
+ * frappe._.pluralize('member',  1)
+ * // returns "member"
+ * frappe._.pluralize('members', 0)
+ * // returns "members"
+ *
+ * @todo Handle more edge cases.
+ */
+frappe._.pluralize = (word, count = 0, suffix = 's') => `${word}${count === 1 ? '' : suffix}`
+
+/**
+ * @description Captializes a given string.
+ *
+ * @param   {word}  - The word to be capitalized.
+ *
+ * @return {string} - The capitalized word.
+ *
+ * @example
+ * frappe._.capitalize('foobar')
+ * // returns "Foobar"
+ */
+frappe._.capitalize = word => `${word.charAt(0).toUpperCase()}${word.slice(1)}`
+
+// Array Utilities
+
+/**
+ * @description Returns the first element of an array.
+ *
+ * @param   {array} array - The array.
+ *
+ * @returns - The first element of an array, undefined elsewise.
+ *
+ * @example
+ * frappe._.head([1, 2, 3])
+ * // returns 1
+ * frappe._.head([])
+ * // returns undefined
+ */
+frappe._.head = arr => frappe._.is_empty(arr) ? undefined : arr[0]
+
+/**
+ * @description Returns a copy of the given array (shallow).
+ *
+ * @param   {array} array - The array to be copied.
+ *
+ * @returns {array}       - The copied array.
+ *
+ * @example
+ * frappe._.copy_array(["foobar", "barfoo"])
+ * // returns ["foobar", "barfoo"]
+ *
+ * @todo Add optional deep copy.
+ */
+frappe._.copy_array = array => {
+	if ( Array.isArray(array) )
+		return array.slice()
+	else
+		throw frappe.TypeError(`Expected Array, recieved ${typeof array} instead.`)
+}
+
+/**
+ * @description Check whether an array|string|object|jQuery is empty.
+ *
+ * @param   {any}     value - The value to be checked on.
+ *
+ * @returns {boolean}       - Returns if the object is empty.
+ *
+ * @example
+ * frappe._.is_empty([])      // returns true
+ * frappe._.is_empty(["foo"]) // returns false
+ *
+ * frappe._.is_empty("")      // returns true
+ * frappe._.is_empty("foo")   // returns false
+ *
+ * frappe._.is_empty({ })            // returns true
+ * frappe._.is_empty({ foo: "bar" }) // returns false
+ *
+ * frappe._.is_empty($('.papito'))   // returns false
+ *
+ * @todo Handle other cases.
+ */
+frappe._.is_empty = value => {
+	let empty = false
+
+	if ( value === undefined || value === null )
+		empty = true
+	else
+	if ( Array.isArray(value) || typeof value === 'string' || value instanceof $ )
+		empty = value.length === 0
+	else
+	if ( typeof value === 'object' )
+		empty = Object.keys(value).length === 0
+
+	return empty
+}
+
+/**
+ * @description Converts a singleton to an array, if required.
+ *
+ * @param {object} item - An object
+ *
+ * @example
+ * frappe._.as_array("foo")
+ * // returns ["foo"]
+ *
+ * frappe._.as_array(["foo"])
+ * // returns ["foo"]
+ *
+ * @see https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList-T...-
+ */
+frappe._.as_array = item => Array.isArray(item) ? item : [item]
+
+/**
+ * @description Return a singleton if array contains a single element.
+ *
+ * @param   {array}        list - An array to squash.
+ *
+ * @returns {array|object}      - Returns an array if there's more than 1 object else the first object itself.
+ *
+ * @example
+ * frappe._.squash(["foo"])
+ * // returns "foo"
+ *
+ * frappe._.squash(["foo", "bar"])
+ * // returns ["foo", "bar"]
+ */
+frappe._.squash = list => Array.isArray(list) && list.length === 1 ? list[0] : list
+
+/**
+ * @description Returns true, if the current device is a mobile device.
+ *
+ * @example
+ * frappe._.is_mobile()
+ * // returns true|false
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent
+ */
+frappe._.is_mobile = () => {
+	const regex    = new RegExp("Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini", "i")
+	const agent    = navigator.userAgent
+	const mobile   = regex.test(agent)
+
+	return mobile
+}
+
+/**
+ * @description Removes falsey values from an array.
+ *
+ * @example
+ * frappe._.compact([1, 2, false, NaN, ''])
+ * // returns [1, 2]
+ */
+frappe._.compact   = array => array.filter(Boolean)
+
+// extend utils to base.
+frappe.utils       = { ...frappe.utils, ...frappe._ }
+
+// frappe extensions
+
+// frappe.user extensions
+/**
+ * @description Returns the first name of a User.
+ *
+ * @param {string} user - User
+ *
+ * @returns The first name of the user.
+ *
+ * @example
+ * frappe.user.first_name("Rahul Malhotra")
+ * // returns "Rahul"
+ */
+frappe.provide('frappe.user')
+frappe.user.first_name = user => frappe._.head(frappe.user.full_name(user).split(" "))
+
+frappe.provide('frappe.ui.keycode')
+frappe.ui.keycode = { RETURN: 13 }
+
+/**
+ * @description Frappe's Store Class
+ */
+ // frappe.stores  - A registry for frappe stores.
+frappe.provide('frappe.stores')
+frappe.stores = [ ]
+frappe.Store  = class
+{
+	/**
+	 * @description Frappe's Store Class's constructor.
+	 *
+	 * @param {string} name - Name of the logger.
+	 */
+	constructor (name) {
+		if ( typeof name !== 'string' )
+			throw new frappe.TypeError(`Expected string for name, got ${typeof name} instead.`)
+		this.name = name
+	}
+
+	/**
+	 * @description Get instance of frappe.Store (return registered one if declared).
+	 *
+	 * @param {string} name - Name of the store.
+	 */
+	static get (name) {
+		if ( !(name in frappe.stores) )
+			frappe.stores[name] = new frappe.Store(name)
+		return frappe.stores[name]
+	}
+
+	set (key, value) { localStorage.setItem(`${this.name}:${key}`, value) }
+	get (key, value) { return localStorage.getItem(`${this.name}:${key}`) }
+}
+
+// frappe.loggers - A registry for frappe loggers.
+frappe.provide('frappe.loggers')
+/**
+ * @description Frappe's Logger Class
+ *
+ * @example
+ * frappe.log       = frappe.Logger.get('foobar')
+ * frappe.log.level = frappe.Logger.DEBUG
+ *
+ * frappe.log.info('foobar')
+ * // prints '[timestamp] foobar: foobar'
+ */
+frappe.Logger = class {
+	/**
+	 * @description Frappe's Logger Class's constructor.
+	 *
+	 * @param {string} name - Name of the logger.
+	 */
+	constructor (name, level) {
+		if ( typeof name !== 'string' )
+			throw new frappe.TypeError(`Expected string for name, got ${typeof name} instead.`)
+
+		this.name   = name
+		this.level  = level
+
+		if ( !this.level ) {
+			if ( frappe.boot.developer_mode )
+				this.level = frappe.Logger.ERROR
+			else
+				this.level = frappe.Logger.NOTSET
+		}
+		this.format = frappe.Logger.FORMAT
+	}
+
+	/**
+	 * @description Get instance of frappe.Logger (return registered one if declared).
+	 *
+	 * @param {string} name - Name of the logger.
+	 */
+	static get (name, level) {
+		if ( !(name in frappe.loggers) )
+			frappe.loggers[name] = new frappe.Logger(name, level)
+		return frappe.loggers[name]
+	}
+
+	debug (message) { this.log(message, frappe.Logger.DEBUG) }
+	info  (message) { this.log(message, frappe.Logger.INFO)  }
+	warn  (message) { this.log(message, frappe.Logger.WARN)  }
+	error (message) { this.log(message, frappe.Logger.ERROR) }
+
+	log (message, level) {
+		const timestamp   = frappe.datetime.now()
+
+		if ( level.value <= this.level.value ) {
+			const format  = frappe._.format(this.format, {
+				time: timestamp.format('HH:mm:ss'),
+				name: this.name
+			})
+			console.log(`%c ${format}:`, `color: ${level.color}`, message)
+		}
+	}
+}
+
+frappe.Logger.DEBUG  = { value: 10, color: '#616161', name: 'DEBUG'  }
+frappe.Logger.INFO   = { value: 20, color: '#2196F3', name: 'INFO'   }
+frappe.Logger.WARN   = { value: 30, color: '#FFC107', name: 'WARN'   }
+frappe.Logger.ERROR  = { value: 40, color: '#F44336', name: 'ERROR'  }
+frappe.Logger.NOTSET = { value:  0,                   name: 'NOTSET' }
+
+frappe.Logger.FORMAT = '{time} {name}'
+
+// frappe.chat
+frappe.provide('frappe.chat')
+
+frappe.log = frappe.Logger.get('frappe.chat', frappe.Logger.NOTSET)
+
+// frappe.chat.profile
+frappe.provide('frappe.chat.profile')
+
+/**
+ * @description Create a Chat Profile.
+ *
+ * @param   {string|array} fields - (Optional) fields to be retrieved after creating a Chat Profile.
+ * @param   {function}     fn     - (Optional) callback with the returned Chat Profile.
+ *
+ * @returns {Promise}
+ *
+ * @example
+ * frappe.chat.profile.create(console.log)
+ *
+ * frappe.chat.profile.create("status").then(console.log) // { status: "Online" }
+ */
+frappe.chat.profile.create = (fields, fn) => {
+	if ( typeof fields === "function" ) {
+		fn     = fields
+		fields = null
+	} else
+	if ( typeof fields === "string" )
+		fields = frappe._.as_array(fields)
+
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.doctype.chat_profile.chat_profile.create",
+			{ user: frappe.session.user, exists_ok: true, fields: fields },
+				response => {
+					if ( fn )
+						fn(response.message)
+
+					resolve(response.message)
+				})
+	})
+}
+
+/**
+ * @description Updates a Chat Profile.
+ *
+ * @param   {string} user   - (Optional) Chat Profile User, defaults to session user.
+ * @param   {object} update - (Required) Updates to be dispatched.
+ *
+ * @example
+ * frappe.chat.profile.update(frappe.session.user, { "status": "Offline" })
+ */
+frappe.chat.profile.update = (user, update, fn) => {
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.doctype.chat_profile.chat_profile.update",
+			{ user: user || frappe.session.user, data: update },
+				response => {
+					if ( fn )
+						fn(response.message)
+
+					resolve(response.message)
+				})
+	})
+}
+
+// frappe.chat.profile.on
+frappe.provide('frappe.chat.profile.on')
+
+/**
+ * @description Triggers on a Chat Profile update of a user (Only if there's a one-on-one conversation).
+ *
+ * @param   {function} fn - (Optional) callback with the User and the Chat Profile update.
+ *
+ * @returns {Promise}
+ *
+ * @example
+ * frappe.chat.profile.on.update(function (user, update)
+ * {
+ *      // do stuff
+ * })
+ */
+frappe.chat.profile.on.update = function (fn) {
+	frappe.realtime.on("frappe.chat.profile:update", r => fn(r.user, r.data))
+}
+frappe.chat.profile.STATUSES
+=
+[
+	{
+		name: "Online",
+	   color: "green"
+	},
+	{
+		 name: "Away",
+		color: "yellow"
+	},
+	{
+		 name: "Busy",
+		color: "red"
+	},
+	{
+		 name: "Offline",
+		color: "gray"
+	}
+]
+
+// frappe.chat.room
+frappe.provide('frappe.chat.room')
+
+/**
+ * @description Creates a Chat Room.
+ *
+ * @param   {string}       kind  - (Required) "Direct", "Group" or "Visitor".
+ * @param   {string}       owner - (Optional) Chat Room owner (defaults to current user).
+ * @param   {string|array} users - (Required for "Direct" and "Visitor", Optional for "Group") User(s) within Chat Room.
+ * @param   {string}       name  - Chat Room name.
+ * @param   {function}     fn    - callback with created Chat Room.
+ *
+ * @returns {Promise}
+ *
+ * @example
+ * frappe.chat.room.create("Direct", frappe.session.user, "foo@bar.com", function (room) {
+ *      // do stuff
+ * })
+ * frappe.chat.room.create("Group",  frappe.session.user, ["santa@gmail.com", "banta@gmail.com"], "Santa and Banta", function (room) {
+ *      // do stuff
+ * })
+ */
+frappe.chat.room.create = function (kind, owner, users, name, fn) {
+	if ( typeof name === "function" ) {
+		fn   = name
+		name = null
+	}
+
+	users    = frappe._.as_array(users)
+
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.doctype.chat_room.chat_room.create",
+			{ kind: kind, token: owner || frappe.session.user, users: users, name: name },
+			r => {
+				let room = r.message
+				room     = { ...room, creation: new frappe.datetime.datetime(room.creation) }
+
+				if ( fn )
+					fn(room)
+
+				resolve(room)
+			})
+	})
+}
+
+/**
+ * @description Returns Chat Room(s).
+ *
+ * @param   {string|array} names   - (Optional) Chat Room(s) to retrieve.
+ * @param   {string|array} fields  - (Optional) fields to be retrieved for each Chat Room.
+ * @param   {function}     fn      - (Optional) callback with the returned Chat Room(s).
+ *
+ * @returns {Promise}
+ *
+ * @example
+ * frappe.chat.room.get(function (rooms) {
+ *      // do stuff
+ * })
+ * frappe.chat.room.get().then(function (rooms) {
+ *      // do stuff
+ * })
+ *
+ * frappe.chat.room.get(null, ["room_name", "avatar"], function (rooms) {
+ *      // do stuff
+ * })
+ *
+ * frappe.chat.room.get("CR00001", "room_name", function (room) {
+ *      // do stuff
+ * })
+ *
+ * frappe.chat.room.get(["CR00001", "CR00002"], ["room_name", "last_message"], function (rooms) {
+ *
+ * })
+ */
+frappe.chat.room.get = function (names, fields, fn) {
+	if ( typeof names === "function" ) {
+		fn     = names
+		names  = null
+		fields = null
+	}
+	else
+	if ( typeof names === "string" ) {
+		names  = frappe._.as_array(names)
+
+		if ( typeof fields === "function" ) {
+			fn     = fields
+			fields = null
+		}
+		else
+		if ( typeof fields === "string" )
+			fields = frappe._.as_array(fields)
+	}
+
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.doctype.chat_room.chat_room.get",
+			{ user: frappe.session.user, rooms: names, fields: fields },
+				response => {
+					let rooms = response.message
+					if ( rooms ) { // frappe.api BOGZ! (emtpy arrays are falsified, not good design).
+						rooms = frappe._.as_array(rooms)
+						rooms = rooms.map(room => {
+							return { ...room, creation: new frappe.datetime.datetime(room.creation),
+								last_message: room.last_message ? {
+									...room.last_message,
+									creation: new frappe.datetime.datetime(room.last_message.creation)
+								} : null
+							}
+						})
+						rooms = frappe._.squash(rooms)
+					}
+					else
+						rooms = [ ]
+
+					if ( fn )
+						fn(rooms)
+
+					resolve(rooms)
+				})
+	})
+}
+
+/**
+ * @description Subscribe current user to said Chat Room(s).
+ *
+ * @param {string|array} rooms - Chat Room(s).
+ *
+ * @example
+ * frappe.chat.room.subscribe("CR00001")
+ */
+frappe.chat.room.subscribe = function (rooms) {
+	frappe.realtime.publish("frappe.chat.room:subscribe", rooms)
+}
+
+/**
+ * @description Get Chat Room history.
+ *
+ * @param   {string} name - Chat Room name
+ *
+ * @returns {Promise}     - Chat Message(s)
+ *
+ * @example
+ * frappe.chat.room.history(function (messages)
+ * {
+ *      // do stuff.
+ * })
+ */
+frappe.chat.room.history = function (name, fn) {
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.doctype.chat_room.chat_room.history",
+			{ room: name, user: frappe.session.user },
+				r => {
+					let messages = r.message ? frappe._.as_array(r.message) : [ ] // frappe.api BOGZ! (emtpy arrays are falsified, not good design).
+					messages     = messages.map(m => {
+						return { ...m,
+							creation: new frappe.datetime.datetime(m.creation)
+						}
+					})
+
+					if ( fn )
+						fn(messages)
+
+					resolve(messages)
+				})
+	})
+}
+
+/**
+ * @description Searches Rooms based on a query.
+ *
+ * @param   {string} query - The query string.
+ * @param   {array}  rooms - A list of Chat Rooms.
+ *
+ * @returns {array}        - A fuzzy searched list of rooms.
+ */
+frappe.chat.room.search = function (query, rooms) {
+	const dataset = rooms.map(r => {
+		if ( r.room_name )
+			return r.room_name
+		else
+			if ( r.owner === frappe.session.user )
+				return frappe.user.full_name(frappe._.squash(r.users))
+			else
+				return frappe.user.full_name(r.owner)
+	})
+	const results = frappe._.fuzzy_search(query, dataset)
+	rooms         = results.map(i => rooms[i])
+
+	return rooms
+}
+
+/**
+ * @description Sort Chat Room(s) based on Last Message Timestamp or Creation Date.
+ *
+ * @param {array}   - A list of Chat Room(s)
+ * @param {compare} - (Optional) a comparision function.
+ */
+frappe.chat.room.sort = function (rooms, compare = null) {
+	compare = compare || function (a, b) {
+		if ( a.last_message && b.last_message )
+			return frappe.datetime.compare(a.last_message.creation, b.last_message.creation)
+		else
+		if ( a.last_message )
+			return frappe.datetime.compare(a.last_message.creation, b.creation)
+		else
+		if ( b.last_message )
+			return frappe.datetime.compare(a.creation, b.last_message.creation)
+		else
+			return frappe.datetime.compare(a.creation, b.creation)
+	}
+	rooms.sort(compare)
+
+	return rooms
+}
+
+// frappe.chat.room.on
+frappe.provide('frappe.chat.room.on')
+
+/**
+ * @description Triggers on Chat Room updated.
+ *
+ * @param {function} fn - callback with the Chat Room and Update.
+ */
+frappe.chat.room.on.update = function (fn) {
+	frappe.realtime.on("frappe.chat.room:update", r => {
+		if ( r.data.last_message )
+			// creation to frappe.datetime.datetime (easier to manipulate).
+			r.data = { ...r.data, last_message: { ...r.data.last_message, creation: new frappe.datetime.datetime(r.data.last_message.creation) } }
+
+		fn(r.room, r.data)
+	})
+}
+
+/**
+ * @description Triggers on Chat Room created.
+ *
+ * @param {function} fn - callback with the created Chat Room.
+ */
+frappe.chat.room.on.create = function (fn) {
+	frappe.realtime.on("frappe.chat.room:create", r =>
+		fn({ ...r, creation: new frappe.datetime.datetime(r.creation) })
+	)
+}
+
+/**
+ * @description Triggers when a User is typing in a Chat Room.
+ *
+ * @param {function} fn - callback with the typing User within the Chat Room.
+ */
+frappe.chat.room.on.typing = function (fn) {
+	frappe.realtime.on("frappe.chat.room:typing", r => fn(r.room, r.user))
+}
+
+// frappe.chat.message
+frappe.provide('frappe.chat.message')
+
+frappe.chat.message.typing = function (room, user) {
+	frappe.realtime.publish("frappe.chat.message:typing", { user: user || frappe.session.user, room: room })
+}
+
+frappe.chat.message.send   = function (room, message, type = "Content") {
+	frappe.call("frappe.chat.doctype.chat_message.chat_message.send",
+		{ user: frappe.session.user, room: room, content: message, type: type })
+}
+
+frappe.chat.message.update = function (message, update, fn) {
+	return new Promise(resolve => {
+		frappe.call('frappe.chat.doctype.chat_message.chat_message.update',
+			{ user: frappe.session.user, message: message, update: update },
+			r =>  {
+				if ( fn )
+					fn(response.message)
+
+				resolve(response.message)
+			})
+	})
+}
+
+frappe.chat.message.sort   = (messages) => {
+	if ( !frappe._.is_empty(messages) )
+		messages.sort((a, b) => frappe.datetime.compare(b.creation, a.creation))
+
+	return messages
+}
+
+/**
+ * @description Add user to seen (defaults to session.user)
+ */
+frappe.chat.message.seen   = (mess, user) => {
+	frappe.call('frappe.chat.doctype.chat_message.chat_message.seen',
+		{ message: mess, user: user || frappe.session.user })
+}
+
+frappe.provide('frappe.chat.message.on')
+frappe.chat.message.on.create = function (fn) {
+	frappe.realtime.on("frappe.chat.message:create", r =>
+		fn({ ...r, creation: new frappe.datetime.datetime(r.creation) })
+	)
+}
+
+frappe.chat.message.on.update = function (fn) {
+	frappe.realtime.on("frappe.chat.message:update", r => fn(r.message, r.data))
+}
+
+frappe.chat.pretty_datetime   = function (date) {
+	const today    = moment()
+	const instance = date.moment
+
+	if ( today.isSame(instance, "d") )
+		return instance.format("hh:mm A")
+	else
+	if ( today.isSame(instance, "week") )
+		return instance.format("dddd")
+	else
+		return instance.format("DD/MM/YYYY")
+}
+
+// frappe.chat.sound
+frappe.provide('frappe.chat.sound')
+
+/**
+ * @description Plays a given registered sound.
+ *
+ * @param {value} - The name of the registered sound.
+ *
+ * @example
+ * frappe.chat.sound.play("message")
+ */
+frappe.chat.sound.play  = function (name, volume = 0.1) {
+	// frappe._.play_sound(`chat-${name}`)
+	const $audio = $(`<audio class="chat-audio"/>`)
+	$audio.attr('volume', volume)
+
+	if  ( frappe._.is_empty($audio) )
+		$(document).append($audio)
+
+	if  ( !$audio.paused ) {
+		frappe.log.info('Stopping sound playing.')
+		$audio[0].pause()
+		$audio.attr('currentTime', 0)
+	}
+
+	frappe.log.info('Playing sound.')
+	$audio.attr('src', `${frappe.chat.sound.PATH}/chat-${name}.mp3`)
+	$audio[0].play()
+}
+frappe.chat.sound.PATH  = '/assets/frappe/sounds'
+
+// frappe.chat.emoji
+frappe.chat.emojis = [ ]
+frappe.chat.emoji  = function (fn) {
+	return new Promise(resolve => {
+		if ( !frappe._.is_empty(frappe.chat.emojis) ) {
+			if ( fn )
+				fn(frappe.chat.emojis)
+
+			resolve(frappe.chat.emojis)
+		}
+		else
+			$.get('https://cdn.rawgit.com/frappe/emoji/master/emoji', (data) => {
+				frappe.chat.emojis = JSON.parse(data)
+
+				if ( fn )
+					fn(frappe.chat.emojis)
+
+				resolve(frappe.chat.emojis)
+			})
+	})
+}
+
+// Website Settings
+frappe.provide('frappe.chat.website.settings')
+frappe.chat.website.settings = (fields, fn) =>
+{
+	if ( typeof fields === "function" ) {
+		fn     = fields
+		fields = null
+	} else
+	if ( typeof fields === "string" )
+		fields = frappe._.as_array(fields)
+
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.website.settings",
+			{ fields: fields })
+			.then(response => {
+				var message = response.message
+
+				if ( message.enable_from )
+					message   = { ...message, enable_from: new frappe.datetime.datetime(message.enable_from, 'HH:mm:ss') }
+				if ( message.enable_to )
+					message   = { ...message, enable_to:   new frappe.datetime.datetime(message.enable_to,   'HH:mm:ss') }
+
+				if ( fn )
+					fn(message)
+
+				resolve(message)
+			})
+	})
+}
+
+frappe.chat.website.token    = (fn) =>
+{
+	return new Promise(resolve => {
+		frappe.call("frappe.chat.website.token")
+			.then(response => {
+				if ( fn )
+					fn(response.message)
+
+				resolve(response.message)
+			})
+	})
+}
+
+const { h, Component } = hyper
+
+// frappe.components
+// frappe's component namespace.
+frappe.provide('frappe.components')
+
+frappe.provide('frappe.chat.component')
+
+/**
+ * @description Button Component
+ *
+ * @prop {string}  type  - (Optional) "default", "primary", "info", "success", "warning", "danger" (defaults to "default")
+ * @prop {boolean} block - (Optional) Render a button block (defaults to false).
+ */
+frappe.components.Button
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+		const size      = frappe.components.Button.SIZE[props.size]
+
+		return (
+			h("button", { ...props, class: `btn ${size && size.class} btn-${props.type} ${props.block ? "btn-block" : ""} ${props.class ? props.class : ""}` },
+				props.children
+			)
+		)
+	}
+}
+frappe.components.Button.SIZE
+=
+{
+	small: {
+		class: "btn-sm"
+	},
+	large: {
+		class: "btn-lg"
+	}
+}
+frappe.components.Button.defaultProps
+=
+{
+	 type: "default",
+	block: false
+}
+
+/**
+ * @description FAB Component
+ *
+ * @extends frappe.components.Button
+ */
+frappe.components.FAB
+=
+class extends frappe.components.Button {
+	render ( ) {
+		const { props } = this
+		const size      = frappe.components.FAB.SIZE[props.size]
+
+		return (
+			h(frappe.components.Button, { ...props, class: `${props.class} ${size && size.class}`},
+				h("i", { class: props.icon })
+			)
+		)
+	}
+}
+frappe.components.FAB.defaultProps
+=
+{
+	icon: "octicon octicon-plus"
+}
+frappe.components.FAB.SIZE
+=
+{
+	small:
+	{
+		class: "frappe-fab-sm"
+	},
+	large:
+	{
+		class: "frappe-fab-lg"
+	}
+}
+
+/**
+ * @description Octicon Component
+ *
+ * @prop color - (Required) color for the indicator
+ */
+frappe.components.Indicator
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+
+		return props.color ? h("span", { ...props, class: `indicator ${props.color}` }) : null
+	}
+}
+
+/**
+ * @description FontAwesome Component
+ */
+frappe.components.FontAwesome
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+
+		return props.type ? h("i", { ...props, class: `fa ${props.fixed ? "fa-fw" : ""} fa-${props.type} ${props.class}` }) : null
+	}
+}
+frappe.components.FontAwesome.defaultProps
+=
+{
+	fixed: false
+}
+
+/**
+ * @description Octicon Component
+ *
+ * @extends frappe.Component
+ */
+frappe.components.Octicon
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+
+		return props.type ? h("i", { ...props, class: `octicon octicon-${props.type}` }) : null
+	}
+}
+
+/**
+ * @description Avatar Component
+ *
+ * @prop {string} title - (Optional) title for the avatar.
+ * @prop {string} abbr  - (Optional) abbreviation for the avatar, defaults to the first letter of the title.
+ * @prop {string} size  - (Optional) size of the avatar to be displayed.
+ * @prop {image}  image - (Optional) image for the avatar, defaults to the first letter of the title.
+ */
+frappe.components.Avatar
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+		const abbr      = props.abbr || props.title.substr(0, 1)
+		const size      = frappe.components.Avatar.SIZE[props.size] || frappe.components.Avatar.SIZE.medium
+
+		return (
+			h("span", { class: `avatar ${size.class} ${props.class ? props.class : ""}` },
+				props.image ?
+					h("img", { class: "media-object", src: props.image })
+					:
+					h("div", { class: "standard-image" }, abbr)
+			)
+		)
+	}
+}
+frappe.components.Avatar.SIZE
+=
+{
+	small:
+	{
+		class: "avatar-small"
+	},
+	large:
+	{
+		class: "avatar-large"
+	},
+	medium:
+	{
+		class: "avatar-medium"
+	}
+}
+
+/**
+ * @description Frappe Chat Object.
+ *
+ * @example
+ * const chat = new frappe.Chat(options) // appends to "body"
+ * chat.render()
+ * const chat = new frappe.Chat(".selector", options)
+ * chat.render()
+ *
+ * const chat = new frappe.Chat()
+ * chat.set_wrapper('.selector')
+ *     .set_options(options)
+ *     .render()
+ */
+frappe.Chat
+=
+class {
+	/**
+	 * @description Frappe Chat Object.
+	 *
+	 * @param {string} selector - A query selector, HTML Element or jQuery object.
+	 * @param {object} options  - Optional configurations.
+	 */
+	constructor (selector, options) {
+		if ( !(typeof selector === "string" || selector instanceof $ || selector instanceof HTMLElement) ) {
+			options  = selector
+			selector = null
+		}
+
+		this.options = frappe.Chat.OPTIONS
+
+		this.set_wrapper(selector ? selector : "body")
+		this.set_options(options)
+
+	}
+
+	/**
+	 * Set the container on which the chat widget is mounted on.
+	 * @param   {string|HTMLElement} selector - A query selector, HTML Element or jQuery object.
+	 *
+	 * @returns {frappe.Chat}                 - The instance.
+	 *
+	 * @example
+	 * const chat = new frappe.Chat()
+	 * chat.set_wrapper(".selector")
+	 */
+	set_wrapper (selector) {
+		this.$wrapper = $(selector)
+
+		return this
+	}
+
+	/**
+	 * Set the configurations for the chat interface.
+	 * @param   {object}      options - Optional Configurations.
+	 *
+	 * @returns {frappe.Chat}         - The instance.
+	 *
+	 * @example
+	 * const chat = new frappe.Chat()
+	 * chat.set_options({ layout: frappe.Chat.Layout.PAGE })
+	 */
+	set_options (options) {
+		this.options = { ...this.options, ...options }
+
+		return this
+	}
+
+	/**
+	 * @description Destory the chat widget.
+	 *
+	 * @returns {frappe.Chat} - The instance.
+	 *
+	 * @example
+	 * const chat = new frappe.Chat()
+	 * chat.render()
+	 *     .destroy()
+	 */
+	destroy ( ) {
+		const $wrapper = this.$wrapper
+		$wrapper.remove(".frappe-chat")
+
+		return this
+	}
+
+	/**
+	 * @description Render the chat widget component onto destined wrapper.
+	 *
+	 * @returns {frappe.Chat} - The instance.
+	 *
+	 * @example
+	 * const chat = new frappe.Chat()
+	 * chat.render()
+	 */
+	render (props = { }) {
+		this.destroy()
+
+		const $wrapper   = this.$wrapper
+		const options    = this.options
+
+		const component  = h(frappe.Chat.Widget, {
+			layout: options.layout,
+			target: options.target,
+			...props
+		})
+
+		hyper.render(component, $wrapper[0])
+
+		return this
+	}
+}
+frappe.Chat.Layout
+=
+{
+	PAGE: "page", POPPER: "popper"
+}
+frappe.Chat.OPTIONS
+=
+{
+	layout: frappe.Chat.Layout.POPPER
+}
+
+/**
+ * @description The base Component for Frappe Chat
+ */
+frappe.Chat.Widget
+=
+class extends Component {
+	constructor (props) {
+		super (props)
+
+		this.setup(props)
+		this.make()
+	}
+
+	setup (props) {
+		// room actions
+		this.room           = { }
+		this.room.add       = rooms => {
+			rooms           = frappe._.as_array(rooms)
+			const names     = rooms.map(r => r.name)
+
+			frappe.log.info(`Subscribing ${frappe.session.user} to Chat Rooms ${names.join(", ")}.`)
+			frappe.chat.room.subscribe(names)
+
+			const state     = [ ]
+
+			for (const room of rooms)
+				  if ( ["Group", "Visitor"].includes(room.type) || room.owner === frappe.session.user || room.last_message || room.users.includes(frappe.session.user)) {
+					frappe.log.info(`Adding ${room.name} to component.`)
+					state.push(room)
+				}
+
+			this.set_state({ rooms: [ ...this.state.rooms, ...state ] })
+		}
+		this.room.update    = (room, update) => {
+			const { state } = this
+			var   exists    = false
+			const rooms     = state.rooms.map(r => {
+				if ( r.name === room ) {
+					exists  = true
+					if ( update.typing ) {
+						if ( !frappe._.is_empty(r.typing) ) {
+							const usr = update.typing
+							if ( !r.typing.includes(usr) ) {
+								update.typing = frappe._.copy_array(r.typing)
+								update.typing.push(usr)
+							}
+						}
+						else
+							update.typing = frappe._.as_array(update.typing)
+					}
+
+					return { ...r, ...update }
+				}
+
+				return r
+			})
+
+			if ( frappe.session.user !== 'Guest' ) {
+				if ( !exists )
+					frappe.chat.room.get(room, (room) => this.room.add(room))
+				else
+					this.set_state({ rooms })
+			}
+
+			if ( state.room.name === room ) {
+				if ( update.typing ) {
+					if ( !frappe._.is_empty(state.room.typing) ) {
+						const usr = update.typing
+						if ( !state.room.typing.includes(usr) ) {
+							update.typing = frappe._.copy_array(state.room.typing)
+							update.typing.push(usr)
+						}
+					} else
+						update.typing = frappe._.as_array(update.typing)
+				}
+
+				const room  = { ...state.room, ...update }
+
+				this.set_state({ room })
+			}
+		}
+		this.room.select    = (name) => {
+			frappe.chat.room.history(name, (messages) => {
+				const  { state } = this
+				const room       = state.rooms.find(r => r.name === name)
+
+				this.set_state({
+					room: { ...state.room, ...room, messages: messages }
+				})
+			})
+		}
+
+		this.state = { ...frappe.Chat.Widget.defaultState, ...props }
+	}
+
+	make ( ) {
+		if ( frappe.session.user !== 'Guest' ) {
+			frappe.chat.profile.create([
+				"status", "message_preview", "notification_tones", "conversation_tones"
+			]).then(profile => {
+				this.set_state({ profile })
+
+				frappe.chat.room.get(rooms => {
+					rooms = frappe._.as_array(rooms)
+					frappe.log.info(`User ${frappe.session.user} is subscribed to ${rooms.length} ${frappe._.pluralize('room', rooms.length)}.`)
+
+					if ( !frappe._.is_empty(rooms) )
+						this.room.add(rooms)
+				})
+
+				this.bind()
+			})
+		} else {
+			this.bind()
+		}
+	}
+
+	bind ( ) {
+		frappe.chat.profile.on.update((user, update) => {
+			frappe.log.warn(`TRIGGER: Chat Profile update ${JSON.stringify(update)} of User ${user}.`)
+
+			if ( 'status' in update ) {
+				if ( user === frappe.session.user ) {
+					this.set_state({
+						profile: { ...this.state.profile, status: update.status }
+					})
+				} else {
+					const status = frappe.chat.profile.STATUSES.find(s => s.name === update.status)
+					const color  = status.color
+
+					const alert  = `<span class="indicator ${color}"/> ${frappe.user.full_name(user)} is currently <b>${update.status}</b>`
+					frappe.show_alert(alert, 3)
+				}
+			}
+		})
+
+		frappe.chat.room.on.create((room) => {
+			frappe.log.warn(`TRIGGER: Chat Room ${room.name} created.`)
+			this.room.add(room)
+		})
+
+		frappe.chat.room.on.update((room, update) => {
+			frappe.log.warn(`TRIGGER: Chat Room ${room} update ${JSON.stringify(update)} recieved.`)
+			this.room.update(room, update)
+		})
+
+		frappe.chat.room.on.typing((room, user) => {
+			if ( user !== frappe.session.user ) {
+				frappe.log.warn(`User ${user} typing in Chat Room ${room}.`)
+				this.room.update(room, { typing: user })
+
+				setTimeout(() => this.room.update(room, { typing: null }), 5000)
+			}
+		})
+
+		frappe.chat.message.on.create((r) => {
+			const { state } = this
+
+			// play sound.
+			if ( state.room.name )
+				state.profile.conversation_tones && frappe.chat.sound.play('message')
+			else
+				state.profile.notification_tones && frappe.chat.sound.play('notification')
+
+			if ( r.user !== frappe.session.user && state.profile.message_preview && !state.toggle ) {
+				const $element = $('body').find('.frappe-chat-alert')
+				$element.remove()
+
+				const  alert   = // TODO: ellipses content
+				`
+				<span data-action="show-message" class="cursor-pointer">
+					<span class="indicator yellow"/>
+						<span class="avatar avatar-small">
+							<span class="avatar-frame" style="background-image: url(${frappe.user.image(r.user)})"></span>
+						</span>
+						<b>${frappe.user.first_name(r.user)}</b>: ${r.content}
+				</span>
+				`
+				frappe.show_alert(alert, 15, {
+					"show-message": function (r) {
+						this.room.select(r.room)
+						this.base.firstChild._component.toggle()
+					}.bind(this, r)
+				})
+				frappe.notify(`${frappe.user.first_name(r.user)}`, {
+					body: r.content,
+					icon: frappe.user.image(r.user),
+					tag: r.user
+				})
+			}
+
+			if ( r.room === state.room.name ) {
+				const mess  = frappe._.copy_array(state.room.messages)
+				mess.push(r)
+
+				this.set_state({ room: { ...state.room, messages: mess } })
+			}
+		})
+
+		frappe.chat.message.on.update((message, update) => {
+			frappe.log.warn(`TRIGGER: Chat Message ${message} update ${JSON.stringify(update)} recieved.`)
+		})
+	}
+
+	render ( ) {
+		const { props, state } = this
+		const me               = this
+
+		const ActionBar        = h(frappe.Chat.Widget.ActionBar, {
+			placeholder: __("Search or Create a New Chat"),
+				  class: "level",
+				 layout: props.layout,
+				actions:
+			frappe._.compact([
+				{
+					  label: __("New"),
+					onclick: function ( ) {
+						const dialog = new frappe.ui.Dialog({
+							  title: __("New Chat"),
+							 fields: [
+								 {
+										 label: __("Chat Type"),
+									 fieldname: "type",
+									 fieldtype: "Select",
+									   options: ["Group", "Direct Chat"],
+									   default: "Group",
+									  onchange: () =>  {
+											const type     = dialog.get_value("type")
+											const is_group = type === "Group"
+
+											dialog.set_df_property("group_name", "reqd",  is_group)
+											dialog.set_df_property("user",       "reqd", !is_group)
+									  }
+								 },
+								 {
+										 label: __("Group Name"),
+									 fieldname: "group_name",
+									 fieldtype: "Data",
+										  reqd: true,
+									depends_on: "eval:doc.type == 'Group'"
+								 },
+								 {
+										 label: __("Users"),
+									 fieldname: "users",
+									 fieldtype: "MultiSelect",
+									   options: frappe.user.get_emails(),
+									depends_on: "eval:doc.type == 'Group'"
+								 },
+								 {
+										 label: __("User"),
+									 fieldname: "user",
+									 fieldtype: "Link",
+									   options: "User",
+									depends_on: "eval:doc.type == 'Direct Chat'"
+								 }
+							 ],
+							action: {
+								primary: {
+									   label: __('Create'),
+									onsubmit: (values) => {
+										if ( values.type === "Group" ) {
+											if ( !frappe._.is_empty(values.users) ) {
+												const name  = values.group_name
+												const users = dialog.fields_dict.users.get_values()
+
+												frappe.chat.room.create("Group",  null, users, name)
+											}
+										} else {
+											const user      = values.user
+
+											frappe.chat.room.create("Direct", null, user)
+										}
+										dialog.hide()
+									}
+								}
+							}
+						})
+						dialog.show()
+					}
+				},
+				frappe._.is_mobile() && {
+					   icon: "octicon octicon-x",
+					   class: "frappe-chat-close",
+					onclick: () => this.set_state({ toggle: false })
+				}
+			], Boolean),
+			change: query => { me.set_state({ query }) },
+			  span: span  => { me.set_state({ span  }) },
+		})
+
+		var   contacts   = [ ]
+		if ( 'user_info' in frappe.boot ) {
+			const emails = frappe.user.get_emails()
+			for (const email of emails) {
+				var exists = false
+
+				for (const room of state.rooms) {
+					if ( room.type === 'Direct' ) {
+						if ( room.owner === email || frappe._.squash(room.users) === email )
+							exists = true
+					}
+				}
+
+				if ( !exists )
+					contacts.push({ owner: frappe.session.user, users: [email] })
+			}
+		}
+		const rooms      = state.query ? frappe.chat.room.search(state.query, state.rooms.concat(contacts)) : frappe.chat.room.sort(state.rooms)
+
+		const layout     = state.span  ? frappe.Chat.Layout.PAGE : frappe.Chat.Layout.POPPER
+
+		const RoomList   = frappe._.is_empty(rooms) && !state.query ?
+			h("div", { class: "vcenter" },
+				h("div", { class: "text-center text-extra-muted" },
+					h("p","",__("You don't have any messages yet."))
+				)
+			)
+			:
+			h(frappe.Chat.Widget.RoomList, { rooms: rooms, click: room =>  {
+				if ( room.name )
+					this.room.select(room.name)
+				else
+					frappe.chat.room.create("Direct", room.owner, frappe._.squash(room.users), ({ name }) => this.room.select(name))
+			}})
+		const Room       = h(frappe.Chat.Widget.Room, { ...state.room, layout: layout, destroy: () => {
+			this.set_state({
+				room: { name: null, messages: [ ] }
+			})
+		}})
+
+		const component  = layout === frappe.Chat.Layout.POPPER ?
+			h(frappe.Chat.Widget.Popper, { heading: ActionBar, page: state.room.name && Room, target: props.target,
+				toggle: (t) => this.set_state({ toggle: t }) },
+				RoomList
+			)
+			:
+			h("div", { class: "frappe-chat-popper" },
+				h("div", { class: "frappe-chat-popper-collapse" },
+					h("div", { class: "panel panel-default panel-span", style: { width: "25%" } },
+						h("div", { class: "panel-heading" },
+							ActionBar
+						),
+						RoomList
+					),
+					Room
+				)
+			)
+
+		return (
+			h("div", { class: "frappe-chat" },
+				component
+			)
+		)
+	}
+}
+frappe.Chat.Widget.defaultState =  {
+	  query: "",
+	profile: { },
+	  rooms: [ ],
+	   room: { name: null, messages: [ ], typing: [ ] },
+	 toggle: false,
+	   span: false
+}
+frappe.Chat.Widget.defaultProps = {
+	layout: frappe.Chat.Layout.POPPER
+}
+
+/**
+ * @description Chat Widget Popper HOC.
+ */
+frappe.Chat.Widget.Popper
+=
+class extends Component {
+	constructor (props) {
+		super (props)
+
+		this.setup(props);
+	}
+
+	setup (props) {
+		this.toggle = this.toggle.bind(this)
+
+		this.state  = frappe.Chat.Widget.Popper.defaultState
+
+		if ( props.target )
+			$(props.target).click(() => this.toggle())
+
+		frappe.chat.widget = this
+	}
+
+	toggle  (active) {
+		let toggle
+		if ( arguments.length === 1 )
+			toggle = active
+		else
+			toggle = this.state.active ? false : true
+
+		this.set_state({ active: toggle })
+
+		this.props.toggle(toggle)
+	}
+
+	on_mounted ( ) {
+		$(document.body).on('click', '.page-container, .frappe-chat-close', ({ currentTarget }) => {
+			this.toggle(false)
+		})
+	}
+
+	render  ( )  {
+		const { props, state } = this
+
+		return !state.destroy ?
+		(
+			h("div", { class: "frappe-chat-popper", style: !props.target ? { "margin-bottom": "80px" } : null },
+				!props.target ?
+					h(frappe.components.FAB, {
+						  class: "frappe-fab",
+						   icon: state.active ? "fa fa-fw fa-times" : "font-heavy octicon octicon-comment",
+						   size: frappe._.is_mobile() ? null : "large",
+						   type: "primary",
+						onclick: () => this.toggle(),
+					}) : null,
+				state.active ?
+					h("div", { class: "frappe-chat-popper-collapse" },
+						props.page ? props.page : (
+							h("div", { class: `panel panel-default ${frappe._.is_mobile() ? "panel-span" : ""}` },
+								h("div", { class: "panel-heading" },
+									props.heading
+								),
+								props.children
+							)
+						)
+				) : null
+			)
+		) : null
+	}
+}
+frappe.Chat.Widget.Popper.defaultState
+=
+{
+	 active: false,
+	destroy: false
+}
+
+/**
+ * @description frappe.Chat.Widget ActionBar Component
+ */
+frappe.Chat.Widget.ActionBar
+=
+class extends Component {
+	constructor (props) {
+		super (props)
+
+		this.change = this.change.bind(this)
+		this.submit = this.submit.bind(this)
+
+		this.state  = frappe.Chat.Widget.ActionBar.defaultState
+	}
+
+	change (e) {
+		const { props, state } = this
+
+		this.set_state({
+			[e.target.name]: e.target.value
+		})
+
+		props.change(state.query)
+	}
+
+	submit (e) {
+		const { props, state } = this
+
+		e.preventDefault()
+
+		props.submit(state.query)
+	}
+
+	render ( ) {
+		const me               = this
+		const { props, state } = this
+		const { actions }      = props
+
+		return (
+			h("div", { class: `frappe-chat-action-bar ${props.class ? props.class : ""}` },
+				h("form", { oninput: this.change, onsubmit: this.submit },
+					h("input", { autocomplete: "off", class: "form-control input-sm", name: "query", value: state.query, placeholder: props.placeholder || "Search" }),
+				),
+				!frappe._.is_empty(actions) ?
+					actions.map(action => h(frappe.Chat.Widget.ActionBar.Action, { ...action })) : null,
+				!frappe._.is_mobile() ?
+					h(frappe.Chat.Widget.ActionBar.Action, {
+						icon: `octicon octicon-screen-${state.span ? "normal" : "full"}`,
+						onclick: () => {
+							const span = !state.span
+							me.set_state({ span })
+							props.span(span)
+						}
+					})
+					:
+					null
+			)
+		)
+	}
+}
+frappe.Chat.Widget.ActionBar.defaultState
+=
+{
+	query: null,
+	 span: false
+}
+
+/**
+ * @description frappe.Chat.Widget ActionBar's Action Component.
+ */
+frappe.Chat.Widget.ActionBar.Action
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+
+		return (
+			h(frappe.components.Button, { size: "small", class: "btn-action", ...props },
+				props.icon ? h("i", { class: props.icon }) : null,
+				`${props.icon ? " " : ""}${props.label ? props.label : ""}`
+			)
+		)
+	}
+}
+
+/**
+ * @description frappe.Chat.Widget RoomList Component
+ */
+frappe.Chat.Widget.RoomList
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+		const rooms     = props.rooms
+
+		return !frappe._.is_empty(rooms) ? (
+			h("ul", { class: "frappe-chat-room-list nav nav-pills nav-stacked" },
+				rooms.map(room => h(frappe.Chat.Widget.RoomList.Item, { ...room, click: props.click }))
+			)
+		) : null
+	}
+}
+
+/**
+ * @description frappe.Chat.Widget RoomList's Item Component
+ */
+frappe.Chat.Widget.RoomList.Item
+=
+class extends Component {
+	render ( ) {
+		const { props }    = this
+		const item         = { }
+
+		if ( props.type === "Group" ) {
+			item.title     = props.room_name
+			item.image     = props.avatar
+
+			if ( !frappe._.is_empty(props.typing) ) {
+				props.typing  = frappe._.as_array(props.typing) // HACK: (BUG) why does typing return a string?
+				const names   = props.typing.map(user => frappe.user.first_name(user))
+				item.subtitle = `${names.join(", ")} typing...`
+			} else
+			if ( props.last_message ) {
+				const message = props.last_message
+				const content = message.content
+
+				if ( message.type === "File" ) {
+					item.subtitle = `📁 ${content.name}`
+				} else {
+					item.subtitle = props.last_message.content
+				}
+			}
+		} else {
+			const user     = props.owner === frappe.session.user ? frappe._.squash(props.users) : props.owner
+
+			item.title     = frappe.user.full_name(user)
+			item.image     = frappe.user.image(user)
+			item.abbr      = frappe.user.abbr(user)
+
+			if ( !frappe._.is_empty(props.typing) )
+				item.subtitle = 'typing...'
+			else
+			if ( props.last_message ) {
+				const message = props.last_message
+				const content = message.content
+
+				if ( message.type === "File" ) {
+					item.subtitle = `📁 ${content.name}`
+				} else {
+					item.subtitle = props.last_message.content
+				}
+			}
+		}
+
+		let is_unread = false
+		if ( props.last_message ) {
+			item.timestamp = frappe.chat.pretty_datetime(props.last_message.creation)
+			is_unread = !props.last_message.seen.includes(frappe.session.user)
+		}
+
+		return (
+			h("li", null,
+				h("a", { class: props.active ? "active": "", onclick: () => {
+					if (props.last_message) {
+						frappe.chat.message.seen(props.last_message.name);
+					}
+					props.click(props)
+				} },
+					h("div", { class: "row" },
+						h("div", { class: "col-xs-9" },
+							h(frappe.Chat.Widget.MediaProfile, { ...item })
+						),
+						h("div", { class: "col-xs-3 text-right" },
+							[
+								h("div", { class: "text-muted", style: { "font-size": "9px" } }, item.timestamp),
+								is_unread ? h("span", { class: "indicator red" }) : null
+							]
+						),
+					)
+				)
+			)
+		)
+	}
+}
+
+/**
+ * @description frappe.Chat.Widget's MediProfile Component.
+ */
+frappe.Chat.Widget.MediaProfile
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+		const position  = frappe.Chat.Widget.MediaProfile.POSITION[props.position || "left"]
+		const avatar    = (
+			h("div", { class: `${position.class} media-middle` },
+				h(frappe.components.Avatar, { ...props,
+					title: props.title,
+					image: props.image,
+					 size: props.size,
+					 abbr: props.abbr
+				})
+			)
+		)
+
+		return (
+			h("div", { class: "media", style: position.class === "media-right" ? { "text-align": "right" } : null },
+				position.class === "media-left"  ? avatar : null,
+				h("div", { class: "media-body" },
+					h("div", { class: "media-heading ellipsis small", style: `max-width: ${props.width_title || "100%"} display: inline-block` }, props.title),
+					props.content  ? h("div","",h("small","",props.content))  : null,
+					props.subtitle ? h("div",{ class: "media-subtitle small" },h("small", { class: "text-muted" }, props.subtitle)) : null
+				),
+				position.class === "media-right" ? avatar : null
+			)
+		)
+	}
+}
+frappe.Chat.Widget.MediaProfile.POSITION
+=
+{
+	left: { class: "media-left" }, right: { class: "media-right" }
+}
+
+/**
+ * @description frappe.Chat.Widget Room Component
+ */
+frappe.Chat.Widget.Room
+=
+class extends Component {
+	render ( ) {
+		const { props, state } = this
+		const hints            =
+		[
+			{
+				 match: /@(\w*)$/,
+				search: function (keyword, callback) {
+					if ( props.type === 'Group' ) {
+						const query = keyword.slice(1)
+						const users = [].concat(frappe._.as_array(props.owner), props.users)
+						const grep  = users.filter(user => user !== frappe.session.user && user.indexOf(query) === 0)
+
+						callback(grep)
+					}
+				},
+				component: function (item) {
+					return (
+						h(frappe.Chat.Widget.MediaProfile, {
+							title: frappe.user.full_name(item),
+							image: frappe.user.image(item),
+							 size: "small"
+						})
+					)
+				}
+			},
+			{
+				match: /:([a-z]*)$/,
+			   search: function (keyword, callback) {
+					frappe.chat.emoji(function (emojis) {
+						const query = keyword.slice(1)
+						const items = [ ]
+						for (const emoji of emojis)
+							for (const alias of emoji.aliases)
+								if ( alias.indexOf(query) === 0 )
+									items.push({ name: alias, value: emoji.emoji })
+
+						callback(items)
+					})
+			   },
+				 content: (item) => item.value,
+			   component: function (item) {
+					return (
+						h(frappe.Chat.Widget.MediaProfile, {
+							title: item.name,
+							 abbr: item.value,
+							 size: "small"
+						})
+					)
+			   }
+		   }
+		]
+
+		const actions = frappe._.compact([
+			!frappe._.is_mobile() && {
+				 icon: "camera",
+				label: "Camera",
+				onclick: ( ) => {
+					const capture = new frappe.ui.Capture({
+						animate: false,
+						  error: true
+					})
+					capture.show()
+
+					capture.submit(data_url => {
+						// data_url
+					})
+				}
+			},
+			{
+				 icon: "file",
+				label: "File",
+				onclick: ( ) => {
+					new frappe.ui.FileUploader({
+						doctype: "Chat Room",
+						docname: props.name,
+						on_success(file_doc) {
+							const { file_url, filename } = file_doc
+							frappe.chat.message.send(props.name, { path: file_url, name: filename }, "File")
+						}
+					})
+				}
+			}
+		])
+
+		if ( frappe.session.user !== 'Guest' ) {
+			if (props.messages) {
+				props.messages = frappe._.as_array(props.messages)
+				for (const message of props.messages)
+					if ( !message.seen.includes(frappe.session.user) )
+						frappe.chat.message.seen(message.name)
+					else
+						break
+			}
+		}
+
+		return (
+			h("div", { class: `panel panel-default
+				${props.name ? "panel-bg" : ""}
+				${props.layout === frappe.Chat.Layout.PAGE || frappe._.is_mobile() ? "panel-span" : ""}`,
+				style: props.layout === frappe.Chat.Layout.PAGE && { width: "75%", left: "25%", "box-shadow": "none" } },
+				props.name && h(frappe.Chat.Widget.Room.Header, { ...props, on_back: props.destroy }),
+				props.name ?
+					!frappe._.is_empty(props.messages) ?
+						h(frappe.chat.component.ChatList, {
+							messages: props.messages
+						})
+						:
+						h("div", { class: "panel-body", style: { "height": "100%" } },
+							h("div", { class: "vcenter" },
+								h("div", { class: "text-center text-extra-muted" },
+									h(frappe.components.Octicon, { type: "comment-discussion", style: "font-size: 48px" }),
+									h("p","",__("Start a conversation."))
+								)
+							)
+						)
+					:
+					h("div", { class: "panel-body", style: { "height": "100%" } },
+						h("div", { class: "vcenter" },
+							h("div", { class: "text-center text-extra-muted" },
+								h(frappe.components.Octicon, { type: "comment-discussion", style: "font-size: 125px" }),
+								h("p","",__("Select a chat to start messaging."))
+							)
+						)
+					),
+				props.name ?
+					h("div", { class: "chat-room-footer" },
+						h(frappe.chat.component.ChatForm, { actions: actions,
+							onchange: () => {
+								frappe.chat.message.typing(props.name)
+							},
+							onsubmit: (message) => {
+								frappe.chat.message.send(props.name, message)
+							},
+							hint: hints
+						})
+					)
+					:
+					null
+			)
+		)
+	}
+}
+
+frappe.Chat.Widget.Room.Header
+=
+class extends Component {
+	render ( ) {
+		const { props }     = this
+
+		const item          = { }
+
+		if ( ["Group", "Visitor"].includes(props.type) ) {
+			item.route      = `chat-room/${props.name}`
+
+			item.title      = props.room_name
+			item.image      = props.avatar
+
+			if ( !frappe._.is_empty(props.typing) ) {
+				props.typing  = frappe._.as_array(props.typing) // HACK: (BUG) why does typing return as a string?
+				const users   = props.typing.map(user => frappe.user.first_name(user))
+				item.subtitle = `${users.join(", ")} typing...`
+			} else
+				item.subtitle = props.type === "Group" ?
+					`${props.users.length} ${frappe._.pluralize('member', props.users.length)}`
+					: ""
+		}
+		else {
+			const user      = props.owner === frappe.session.user ? frappe._.squash(props.users) : props.owner
+
+			item.route      = `user/${user}`
+
+			item.title      = frappe.user.full_name(user)
+			item.image      = frappe.user.image(user)
+
+			if ( !frappe._.is_empty(props.typing) )
+				item.subtitle = 'typing...'
+		}
+
+		const popper        = props.layout === frappe.Chat.Layout.POPPER || frappe._.is_mobile()
+
+		return (
+			h("div", { class: "panel-heading", style: { "height": "50px" } }, // sorry. :(
+				h("div", { class: "level" },
+					popper && frappe.session.user !== "Guest" ?
+						h(frappe.components.Button,{class:"btn-back",onclick:props.on_back},
+							h(frappe.components.Octicon, { type: "chevron-left" })
+						) : null,
+					h("div","",
+						h("div", { class: "panel-title" },
+							h("div", { class: "cursor-pointer", onclick: () => {
+								frappe.session.user !== "Guest" ?
+									frappe.set_route(item.route) : null;
+							}},
+								h(frappe.Chat.Widget.MediaProfile, { ...item })
+							)
+						)
+					),
+					h("div", { class: popper ? "col-xs-2"  : "col-xs-3" },
+						h("div", { class: "text-right" },
+							frappe._.is_mobile() && h(frappe.components.Button, { class: "frappe-chat-close", onclick: props.toggle },
+								h(frappe.components.Octicon, { type: "x" })
+							)
+						)
+					)
+				)
+			)
+		)
+	}
+}
+
+/**
+ * @description ChatList Component
+ *
+ * @prop {array} messages - ChatMessage(s)
+ */
+frappe.chat.component.ChatList
+=
+class extends Component {
+	on_mounted ( ) {
+		this.$element  = $('.frappe-chat').find('.chat-list')
+		this.$element.scrollTop(this.$element[0].scrollHeight)
+	}
+
+	on_updated ( ) {
+		this.$element.scrollTop(this.$element[0].scrollHeight)
+	}
+
+	render ( ) {
+		var messages = [ ]
+		for (var i   = 0 ; i < this.props.messages.length ; ++i) {
+			var   message   = this.props.messages[i]
+			const me        = message.user === frappe.session.user
+
+			if ( i === 0 || !frappe.datetime.equal(message.creation, this.props.messages[i - 1].creation, 'day') )
+				messages.push({ type: "Notification", content: message.creation.format('MMMM DD') })
+
+			messages.push(message)
+		}
+
+		return (
+			h("div",{class:"chat-list list-group"},
+				!frappe._.is_empty(messages) ?
+					messages.map(m => h(frappe.chat.component.ChatList.Item, {...m})) : null
+			)
+		)
+	}
+}
+
+/**
+ * @description ChatList.Item Component
+ *
+ * @prop {string} name       - ChatMessage name
+ * @prop {string} user       - ChatMessage user
+ * @prop {string} room       - ChatMessage room
+ * @prop {string} room_type  - ChatMessage room_type ("Direct", "Group" or "Visitor")
+ * @prop {string} content    - ChatMessage content
+ * @prop {frappe.datetime.datetime} creation - ChatMessage creation
+ *
+ * @prop {boolean} groupable - Whether the ChatMessage is groupable.
+ */
+frappe.chat.component.ChatList.Item
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+
+		const me        = props.user === frappe.session.user
+		const content   = props.content
+
+		return (
+			h("div",{class: "chat-list-item list-group-item"},
+				props.type === "Notification" ?
+					h("div",{class:"chat-list-notification"},
+						h("div",{class:"chat-list-notification-content"},
+							content
+						)
+					)
+					:
+					h("div",{class:`${me ? "text-right" : ""}`},
+						props.room_type === "Group" && !me ?
+							h(frappe.components.Avatar, {
+								title: frappe.user.full_name(props.user),
+								image: frappe.user.image(props.user)
+							}) : null,
+						h(frappe.chat.component.ChatBubble, props)
+					)
+			)
+		)
+	}
+}
+
+/**
+ * @description ChatBubble Component
+ *
+ * @prop {string} name       - ChatMessage name
+ * @prop {string} user       - ChatMessage user
+ * @prop {string} room       - ChatMessage room
+ * @prop {string} room_type  - ChatMessage room_type ("Direct", "Group" or "Visitor")
+ * @prop {string} content    - ChatMessage content
+ * @prop {frappe.datetime.datetime} creation - ChatMessage creation
+ *
+ * @prop {boolean} groupable - Whether the ChatMessage is groupable.
+ */
+frappe.chat.component.ChatBubble
+=
+class extends Component {
+	constructor (props) {
+		super (props)
+
+		this.onclick = this.onclick.bind(this)
+	}
+
+	onclick ( ) {
+		const { props } = this
+		if ( props.user === frappe.session.user ) {
+			frappe.quick_edit("Chat Message", props.name, (values) => {
+
+			})
+		}
+	}
+
+	render  ( ) {
+		const { props } = this
+		const creation 	= props.creation.format('hh:mm A')
+
+		const me        = props.user === frappe.session.user
+		const read      = !frappe._.is_empty(props.seen) && !props.seen.includes(frappe.session.user)
+
+		const content   = props.content
+
+		return (
+			h("div",{class:`chat-bubble ${props.groupable ? "chat-groupable" : ""} chat-bubble-${me ? "r" : "l"}`,
+				onclick: this.onclick},
+				props.room_type === "Group" && !me ?
+					h("div",{class:"chat-bubble-author"},
+					h("a", { onclick: () => { frappe.set_route('Form', 'User', props.user) } },
+						frappe.user.full_name(props.user)
+					)
+					) : null,
+				h("div",{class:"chat-bubble-content"},
+						h("small","",
+							props.type === "File" ?
+								h("a", { class: "no-decoration", href: content.path, target: "_blank" },
+									h(frappe.components.FontAwesome, { type: "file", fixed: true }), ` ${content.name}`
+								)
+								:
+								content
+						)
+				),
+				h("div",{class:"chat-bubble-meta"},
+					h("span",{class:"chat-bubble-creation"},creation),
+					me && read ?
+						h("span",{class:"chat-bubble-check"},
+							h(frappe.components.Octicon,{type:"check"})
+						) : null
+				)
+			)
+		)
+	}
+}
+
+/**
+ * @description ChatForm Component
+ */
+frappe.chat.component.ChatForm
+=
+class extends Component {
+	constructor (props) {
+		super (props)
+
+		this.onchange   = this.onchange.bind(this)
+		this.onsubmit   = this.onsubmit.bind(this)
+
+		this.hint        = this.hint.bind(this)
+
+		this.state       = frappe.chat.component.ChatForm.defaultState
+	}
+
+	onchange (e) {
+		const { props, state } = this
+		const value            = e.target.value
+
+		this.set_state({
+			[e.target.name]: value
+		})
+
+		props.onchange(state)
+
+		this.hint(value)
+	}
+
+	hint (value) {
+		const { props, state } = this
+
+		if ( props.hint ) {
+			const tokens =  value.split(" ")
+			const sliced = tokens.slice(0, tokens.length - 1)
+
+			const token  = tokens[tokens.length - 1]
+
+			if ( token ) {
+				props.hint   = frappe._.as_array(props.hint)
+				const hint   = props.hint.find(hint => hint.match.test(token))
+
+				if ( hint ) {
+					hint.search(token, items => {
+						const hints = items.map(item => {
+							// You should stop writing one-liners! >_>
+							const replace = token.replace(hint.match, hint.content ? hint.content(item) : item)
+							const content = `${sliced.join(" ")} ${replace}`.trim()
+							item          = { component: hint.component(item), content: content }
+
+							return item
+						}).slice(0, hint.max || 5)
+
+						this.set_state({ hints })
+					})
+				}
+				else
+					this.set_state({ hints: [ ] })
+			} else
+				this.set_state({ hints: [ ] })
+		}
+	}
+
+	onsubmit (e) {
+		e.preventDefault()
+
+		if ( this.state.content ) {
+			this.props.onsubmit(this.state.content)
+
+			this.set_state({ content: null })
+		}
+	}
+
+	render ( ) {
+		const { props, state } = this
+
+		return (
+			h("div",{class:"chat-form"},
+				state.hints.length ?
+					h("ul", { class: "hint-list list-group" },
+						state.hints.map((item) => {
+							return (
+								h("li", { class: "hint-list-item list-group-item" },
+									h("a", { href: "javascript:void(0)", onclick: () => {
+										this.set_state({ content: item.content, hints: [ ] })
+									}},
+										item.component
+									)
+								)
+							)
+						})
+					) : null,
+				h("form", { oninput: this.onchange, onsubmit: this.onsubmit },
+					h("div",{class:"input-group input-group-lg"},
+						!frappe._.is_empty(props.actions) ?
+							h("div",{class:"input-group-btn dropup"},
+								h(frappe.components.Button,{ class: (frappe.session.user === "Guest" ? "disabled" : "dropdown-toggle"), "data-toggle": "dropdown"},
+									h(frappe.components.FontAwesome, { class: "text-muted", type: "paperclip", fixed: true })
+								),
+								h("div",{ class:"dropdown-menu dropdown-menu-left", onclick: e => e.stopPropagation() },
+									!frappe._.is_empty(props.actions) && props.actions.map((action) => {
+										return (
+											h("li", null,
+												h("a",{onclick:action.onclick},
+													h(frappe.components.FontAwesome,{type:action.icon,fixed:true}), ` ${action.label}`,
+												)
+											)
+										)
+									})
+								)
+							) : null,
+						h("textarea", {
+									class: "form-control",
+									 name: "content",
+									value: state.content,
+							  placeholder: "Type a message",
+								autofocus: true,
+							   onkeypress: (e) => {
+									if ( e.which === frappe.ui.keycode.RETURN && !e.shiftKey )
+										this.onsubmit(e)
+							   }
+						}),
+						h("div",{class:"input-group-btn"},
+							h(frappe.components.Button, { onclick: this.onsubmit },
+								h(frappe.components.FontAwesome, { class: !frappe._.is_empty(state.content) ? "text-primary" : "text-muted", type: "send", fixed: true })
+							),
+						)
+					)
+				)
+			)
+		)
+	}
+}
+frappe.chat.component.ChatForm.defaultState
+=
+{
+	content: null,
+	  hints: [ ],
+}
+
+/**
+ * @description EmojiPicker Component
+ *
+ * @todo Under Development
+ */
+frappe.chat.component.EmojiPicker
+=
+class extends Component  {
+	render ( ) {
+		const { props } = this
+
+		return (
+			h("div", { class: `frappe-chat-emoji dropup ${props.class}` },
+				h(frappe.components.Button, { type: "primary", class: "dropdown-toggle", "data-toggle": "dropdown" },
+					h(frappe.components.FontAwesome, { type: "smile-o", fixed: true })
+				),
+				h("div", { class: "dropdown-menu dropdown-menu-right", onclick: e => e.stopPropagation() },
+					h("div", { class: "panel panel-default" },
+						h(frappe.chat.component.EmojiPicker.List)
+					)
+				)
+			)
+		)
+	}
+}
+frappe.chat.component.EmojiPicker.List
+=
+class extends Component {
+	render ( ) {
+		const { props } = this
+
+		return (
+			h("div", { class: "list-group" },
+
+			)
+		)
+	}
+}
+
+/**
+ * @description Python equivalent to sys.platform
+ */
+frappe.provide('frappe._')
+frappe._.platform   = () => {
+	const string    = navigator.appVersion
+
+	if ( string.includes("Win") ) 	return "Windows"
+	if ( string.includes("Mac") ) 	return "Darwin"
+	if ( string.includes("X11") ) 	return "UNIX"
+	if ( string.includes("Linux") ) return "Linux"
+
+	return undefined
+}
+
+/**
+ * @description Frappe's Asset Helper
+ */
+frappe.provide('frappe.assets')
+frappe.assets.image = (image, app = 'frappe') => {
+	const  path     = `/assets/${app}/images/${image}`
+	return path
+}
+
+/**
+ * @description Notify using Web Push Notifications
+ */
+frappe.provide('frappe.boot')
+frappe.provide('frappe.browser')
+frappe.browser.Notification = 'Notification' in window
+
+frappe.notify     = (string, options) => {
+	frappe.log    = frappe.Logger.get('frappe.notify')
+
+	const OPTIONS = {
+		icon: frappe.assets.image('favicon.png', 'frappe'),
+		lang: frappe.boot.lang || "en"
+	}
+	options       = Object.assign({ }, OPTIONS, options)
+
+	if ( !frappe.browser.Notification )
+		frappe.log.error('ERROR: This browser does not support desktop notifications.')
+
+	Notification.requestPermission(status => {
+		if ( status === "granted" ) {
+			const notification = new Notification(string, options)
+		}
+	})
+}
+
+frappe.chat.render = (render = true, force = false) =>
+{
+	frappe.log.info(`${render ? "Enable" : "Disable"} Chat for User.`)
+
+	const desk = 'desk' in frappe
+	if ( desk ) {
+		// With the assumption, that there's only one navbar.
+		const $placeholder = $('.navbar .frappe-chat-dropdown')
+
+		if ( render ) {
+			$placeholder.removeClass('hidden')
+		} else {
+			$placeholder.addClass('hidden')
+		}
+	}
+
+	// Avoid re-renders. Once is enough.
+	if ( !frappe.chatter || force ) {
+		frappe.chatter = new frappe.Chat({
+			target: desk ? '.frappe-chat-toggle' : null
+		})
+
+		if ( render ) {
+			if ( frappe.session.user === 'Guest' && !desk ) {
+				frappe.store = frappe.Store.get('frappe.chat')
+				var token	 = frappe.store.get('guest_token')
+
+				frappe.log.info(`Local Guest Token - ${token}`)
+
+				const setup_room = (token) =>
+				{
+					return new Promise(resolve => {
+						frappe.chat.room.create("Visitor", token).then(room => {
+							frappe.log.info(`Visitor Room Created: ${room.name}`)
+							frappe.chat.room.subscribe(room.name)
+
+							var reference = room
+
+							frappe.chat.room.history(room.name).then(messages => {
+								const  room = { ...reference, messages: messages }
+								return room
+							}).then(room => {
+								resolve(room)
+							})
+						})
+					})
+				}
+
+				if ( !token ) {
+					frappe.chat.website.token().then(token => {
+						frappe.log.info(`Generated Guest Token - ${token}`)
+						frappe.store.set('guest_token', token)
+
+						setup_room(token).then(room => {
+							frappe.chatter.render({ room })
+						})
+					})
+				} else {
+					setup_room(token).then(room => {
+						frappe.chatter.render({ room })
+					})
+				}
+			} else {
+				frappe.chatter.render()
+			}
+		}
+	}
+}
+
+frappe.chat.setup  = () => {
+	frappe.log     = frappe.Logger.get('frappe.chat')
+
+	frappe.log.info('Setting up frappe.chat')
+	frappe.log.warn('TODO: frappe.chat.<object> requires a storage.')
+
+	if ( frappe.session.user !== 'Guest' ) {
+		// Create/Get Chat Profile for session User, retrieve enable_chat
+		frappe.log.info('Creating a Chat Profile.')
+
+		frappe.chat.profile.create('enable_chat').then(({ enable_chat }) => {
+			frappe.log.info(`Chat Profile created for User ${frappe.session.user}.`)
+
+			if ( 'desk' in frappe && frappe.sys_defaults ) { // same as desk?
+				const should_render = Boolean(parseInt(frappe.sys_defaults.enable_chat)) && enable_chat
+				frappe.chat.render(should_render)
+			}
+		})
+
+		// Triggered when a User updates his/her Chat Profile.
+		// Don't worry, enable_chat is broadcasted to this user only. No overhead. :)
+		frappe.chat.profile.on.update((user, profile) => {
+			if ( user === frappe.session.user && 'enable_chat' in profile ) {
+				frappe.log.warn(`Chat Profile update (Enable Chat - ${Boolean(profile.enable_chat)})`)
+				const should_render = Boolean(parseInt(frappe.sys_defaults.enable_chat)) && profile.enable_chat
+				frappe.chat.render(should_render)
+			}
+		})
+	} else {
+		// Website Settings
+		frappe.log.info('Retrieving Chat Website Settings.')
+		frappe.chat.website.settings(["socketio", "enable", "enable_from", "enable_to"])
+			.then(settings => {
+				frappe.log.info(`Chat Website Setting - ${JSON.stringify(settings)}`)
+				frappe.log.info(`Chat Website Setting - ${settings.enable ? "Enable" : "Disable"}`)
+
+				var should_render = settings.enable
+				if ( settings.enable_from && settings.enable_to ) {
+					frappe.log.info(`Enabling Chat Schedule - ${settings.enable_from.format()} : ${settings.enable_to.format()}`)
+
+					const range   = new frappe.datetime.range(settings.enable_from, settings.enable_to)
+					should_render = range.contains(frappe.datetime.now())
+				}
+
+				if ( should_render ) {
+					frappe.log.info("Initializing Socket.IO")
+					frappe.socketio.init(settings.socketio.port)
+				}
+
+				frappe.chat.render(should_render)
+		})
+	}
+}
+
+// TODO: Re-enable after re-designing chat
+// $(document).on('ready toolbar_setup', () =>
+// {
+// 	frappe.chat.setup()
+// })
diff --git a/frappe/public/less/chat.bundle.less b/frappe/public/less/chat.bundle.less
new file mode 100644
index 0000000000..1d4820435c
--- /dev/null
+++ b/frappe/public/less/chat.bundle.less
@@ -0,0 +1,461 @@
+// Author - Achilles Rasquinha <achilles@frappe.io>
+// http://codeguide.co - @mdo (Author of Bootstrap)
+
+@import "../css/font-awesome.css";
+@import "../css/octicons/octicons.css";
+
+// Typography
+@font-weight-bold:								700;
+@font-weight-heavy:								900;
+
+@chat-toggle-height:							40px;
+
+@fab-box-shadow:                                0 5px 15px rgba(0, 0, 0, .25);
+@fab-size:                                      48px;
+@fab-size-lg:                                   56px;
+@fab-margin:                                    20px;
+
+@chat-popper-margin:							@fab-margin;
+@chat-popper-panel-width:						350px;
+@chat-popper-panel-height:						500px;
+// z-index greater than FAB, lesser than modal.
+@chat-popper-z-index:							1035;
+
+// BS modal's box-shadow
+@chat-popper-panel-box-shadow:					@fab-box-shadow;
+
+// https://github.com/twbs/bootstrap/blob/v3.3.7/less/variables.less#L278
+// Keep z-index of the ChatPopper higher than others, lower than modal background.
+
+@chat-room-list-content-max-width:				180px;
+
+@chat-form-font-size:							12px;
+@chat-form-menu-border-radius:					4px;
+@chat-form-list-group-height:					150px; // Hints
+
+// Typography
+.font-bold  { font-weight: @font-weight-bold;  }
+.font-heavy { font-weight: @font-weight-heavy; }
+
+// Utilities
+.cursor-pointer { cursor: pointer; }
+
+// Hacks and Fixes
+// suggested by rushabh@frappe.io. Thanks, Rushabh!
+// .avatar { padding: 2px; }
+
+.frappe-fab
+{
+         position: fixed;
+           bottom: 0;
+            right: 0;
+    border-radius: 50%;
+       box-shadow: @fab-box-shadow;
+           margin: @fab-margin;
+            width: @fab-size;
+           height: @fab-size;
+
+    &.frappe-fab-lg
+    {
+            width: @fab-size-lg;
+           height: @fab-size-lg;
+    }
+}
+
+.navbar
+{
+    .frappe-chat-toggle
+    {
+            height: @chat-toggle-height;
+        text-align: center;
+    }
+
+    .octicon { margin-top: 3px; } // Hack, somewhat.
+}
+
+.frappe-chat
+{
+    & > .frappe-chat-popper
+    {
+         position: fixed;
+           bottom: 0px;
+            right: 0px;
+           margin: @chat-popper-margin;
+          z-index: @chat-popper-z-index;
+
+        & > .frappe-chat-popper-collapse
+        {
+            & > .panel
+            {
+                       position: relative;
+                        display: flex;
+                 flex-direction: column;
+                          width: @chat-popper-panel-width;
+                         height: @chat-popper-panel-height;
+                     box-shadow: @chat-popper-panel-box-shadow;
+
+                .vcenter
+                {
+                     position: absolute;
+                          top: 50%;
+                         left: 50%;
+                    transform: translate(-50%, -50%);
+                }
+
+                .panel-heading
+                {
+                    .panel-title
+                    {
+                        .media-heading
+                        {
+                            font-size: 12px;
+                               margin: 0px;
+                              padding: 0px;
+                        }
+
+                        .media-left {
+                            padding-right: 10px;
+                        }
+
+                        .media-subtitle
+                        {
+                            font-size: 12px;
+                        }
+                    }
+
+                    .frappe-chat-action-bar
+                    {
+                        form
+                        {
+                            width: 100%;
+                        }
+
+                        .btn-action
+                        {
+                            margin-left: 5px !important;
+                        }
+                    }
+                }
+
+                .frappe-chat-room-list
+                {
+                        height: 100%;
+                    overflow-y: auto;
+                       padding: 0 1px 0 1px;
+
+                    & > li > a
+                    {
+                        border-radius: 0px !important;
+                    }
+
+                    .media
+                    {
+                        .media-heading, .media-subtitle
+                        {
+                            max-width: @chat-room-list-content-max-width;
+                        }
+                    }
+                }
+            }
+
+            & > .panel.panel-bg
+            {
+                background-size: 350px 500px;
+                background-image: url(/assets/frappe/images/chat/wallpaper-default.jpg);
+            }
+
+            & > .panel.panel-span
+            {
+                     position: fixed;
+                        width: 100%;
+                       height: 100%;
+                          top: 0px;
+                         left: 0px;
+                       bottom: 0px;
+                        right: 0px;
+                     overflow: auto;
+                border-radius: 0px;
+
+                .panel-heading
+                {
+                    border-radius: 0px;
+                }
+            }
+        }
+    }
+
+    .panel
+    {
+        margin-bottom: 0px !important;
+
+        .chat-form
+        {
+            .form-control
+            {
+                font-size: @chat-form-font-size;
+            }
+
+            .dropdown-menu
+            {
+                border-radius: @chat-form-menu-border-radius;
+            }
+
+            // Hints
+            .hint-list.list-group
+            {
+                    margin: 0px;
+                max-height: @chat-form-list-group-height;
+                overflow-y: auto;
+
+                .hint-list-item.list-group-item:first-child, .hint-list-item.list-group-item:last-child
+                {
+                    border-radius: 0px !important;
+
+                    a { text-decoration: none }
+                }
+            }
+        }
+    }
+}
+
+@chat-color-grey:                        #8D99A6;
+
+@chat-base-font-size:                    12px;
+@chat-base-font-size-lg:                 14px;
+
+@chat-base-spacing:                      5px;
+
+// ChatForm
+@chat-form-border:                       1px solid #D1D8DD;
+
+// ChatList
+@chat-list-bg-color:                     #FAFBFC;
+
+// ChatList.Item
+@chat-list-item-padding:                 @chat-base-spacing @chat-base-spacing * 2;
+
+// ChatBubble
+@chat-bubble-padding:					@chat-base-spacing @chat-base-spacing * 2;
+@chat-bubble-min-width:                  25%;
+@chat-bubble-max-width:                  75%;
+
+@chat-bubble-box-shadow:                 0px 0.1px 0.5px 0px rgba(0,0,0,0.5);
+
+@chat-bubble-border-size:                1px;
+@chat-bubble-border-radius:				@chat-base-spacing;
+
+@chat-bubble-l-color:			 	  #EBEFF2;
+@chat-bubble-r-color:				  #EBF7CF;
+
+@chat-bubble-l-groupable-margin-left:    40px;
+
+@chat-bubble-author-font-size:           @chat-base-font-size;
+
+@chat-bubble-content-margin-bottom:      @chat-base-spacing;
+
+@chat-bubble-meta-font-size:             @chat-base-spacing * 2;
+
+@chat-bubble-check-font-size:            @chat-base-font-size;
+
+.frappe-chat-popper-collapse
+{
+    & > .panel
+    {
+        & > .panel-heading
+        {
+            padding: @chat-base-spacing @chat-base-spacing * 2;
+
+            .btn-back
+            {
+                margin-right: @chat-base-spacing;
+            }
+
+            .avatar
+            {
+                width: 32px; height: 32px;
+            }
+        }
+    }
+
+}
+
+
+.chat-room-footer
+{
+    .chat-form
+    {
+        border-top: @chat-form-border;
+
+        .input-group-btn
+        {
+            .btn
+            {
+                   background: white;
+                border-radius: 0px;
+            }
+        }
+
+        .form-control
+        {
+              line-height: 27px; // HACK: Makes input and placeholder centered within textarea. Also takes care of the input-btn
+                   border: none;
+               box-shadow: none;
+                   resize: none;
+             padding-left: 0px;
+            padding-right: 0px;
+                 overflow: hidden;
+        }
+
+        .fa
+        {
+             font-size: @chat-base-font-size-lg;
+            transition: color 0.5s; // Change, with grace. :)
+        }
+    }
+}
+
+
+.chat-list
+{
+        height: 100%;
+    // background: @chat-list-bg-color;
+    overflow-y: scroll;
+
+    .chat-list-item
+    {
+        .avatar
+        {
+            vertical-align: top;
+
+            .standard-image
+            {
+                background-color: white;
+            }
+        }
+
+        .cursor-pointer;
+
+            border: none !important;
+           padding: @chat-list-item-padding;
+        background: transparent;
+
+        .chat-bubble
+        {
+            max-width: @chat-bubble-max-width;
+            display: inline-block;
+            padding: @chat-bubble-padding;
+            border-radius: @chat-bubble-border-radius;
+
+            -webkit-box-shadow: @chat-bubble-box-shadow;
+            -moz-box-shadow: @chat-bubble-box-shadow;
+            box-shadow: @chat-bubble-box-shadow;
+
+            @media (max-width : 768px) {
+                min-width: @chat-bubble-min-width;
+            }
+
+            &.chat-bubble-l
+            {
+                &.chat-groupable
+                {
+                     margin-left: @chat-bubble-l-groupable-margin-left;
+                }
+
+                // background-color: @chat-bubble-l-color;
+                background-color: white;
+
+                .chat-bubble-meta
+                {
+                    & > .chat-bubble-creation, & > .chat-bubble-check i
+                    {
+                        color: darken(@chat-bubble-l-color, 50%) !important;
+                    }
+                }
+            }
+
+            &.chat-bubble-r
+            {
+                      text-align: right;
+                background-color: @chat-bubble-r-color;
+
+                .chat-bubble-meta
+                {
+                    & > .chat-bubble-creation, & > .chat-bubble-check i
+                    {
+                        color: darken(@chat-bubble-r-color, 50%) !important;
+                    }
+                }
+            }
+
+            .chat-bubble-author
+            {
+                font-size: @chat-bubble-author-font-size;
+
+                a
+                {
+                    .font-bold;
+
+                    text-decoration: none !important;
+                }
+            }
+
+            .chat-bubble-content
+            {
+                margin-bottom: @chat-bubble-content-margin-bottom;
+                    word-wrap: break-word;
+            }
+
+            .chat-bubble-meta
+            {
+                    font-size: @chat-bubble-meta-font-size;
+
+                & > .chat-bubble-check
+                {
+                    margin-left: @chat-base-spacing;
+
+                    i
+                    {
+                        font-size: @chat-bubble-check-font-size;
+                    }
+                }
+            }
+        }
+    }
+}
+
+.chat-list-notification
+{
+    text-align: center;
+}
+
+.chat-list-notification-content
+{
+    color: white;
+    background-color: #8D99A6;
+    display: inline-block;
+    /* padding: 5px; */
+    border-radius: 20px;
+    opacity: 0.5;
+    font-size: 10px;
+    padding: 5px;
+    // background-color: white;
+}
+
+// v12 fixes for visitor chat
+.panel-default > .panel-heading {
+    background-color: #f7fafc;
+    border-color: #ced5db;
+    display: flex;
+}
+
+textarea.form-control {
+    resize: none;
+    height: 3.2em;
+}
+
+@media (max-width: 767px) {
+    .nav-stacked > li + li {
+      margin-top: 0px;
+      margin-left: 2px;
+    }
+}
diff --git a/frappe/public/sounds/chat-message.mp3 b/frappe/public/sounds/chat-message.mp3
new file mode 100644
index 0000000000..1ef09b9f68
Binary files /dev/null and b/frappe/public/sounds/chat-message.mp3 differ
diff --git a/frappe/public/sounds/chat-notification.mp3 b/frappe/public/sounds/chat-notification.mp3
new file mode 100644
index 0000000000..8c55d16946
Binary files /dev/null and b/frappe/public/sounds/chat-notification.mp3 differ
diff --git a/frappe/templates/base.html b/frappe/templates/base.html
index bc1f802cf7..3bbb9f46bd 100644
--- a/frappe/templates/base.html
+++ b/frappe/templates/base.html
@@ -57,6 +57,7 @@
 		window.dev_server = {{ dev_server }};
 		window.socketio_port = {{ (frappe.socketio_port or 'null') }};
 		window.show_language_picker = {{ show_language_picker or 'false' }};
+		window.is_chat_enabled = {{ chat_enable }};
 	</script>
 </head>
 <body frappe-session-status="{{ 'logged-in' if frappe.session.user != 'Guest' else 'logged-out'}}" data-path="{{ path | e }}" {%- if template and template.endswith('.md') %} frappe-content-type="markdown" {%- endif %} class="{{ body_class or ''}}">
diff --git a/frappe/utils/__init__.py b/frappe/utils/__init__.py
index 5873bb2efc..1b4cdc7922 100644
--- a/frappe/utils/__init__.py
+++ b/frappe/utils/__init__.py
@@ -17,7 +17,6 @@ from typing import Generator, Iterable
 from urllib.parse import quote, urlparse
 from werkzeug.test import Client
 from redis.exceptions import ConnectionError
-from collections.abc import MutableMapping, MutableSequence, Sequence
 
 import frappe
 # utility functions like cint, int, flt, etc.
@@ -862,31 +861,3 @@ def groupby_metric(iterable: typing.Dict[str, list], key: str):
 
 def get_table_name(table_name: str) -> str:
 	return f"tab{table_name}" if not table_name.startswith("__") else table_name
-
-def squashify(what):
-	if isinstance(what, Sequence) and len(what) == 1:
-		return what[0]
-
-	return what
-
-def safe_json_loads(*args):
-	results = []
-
-	for arg in args:
-		try:
-			arg = json.loads(arg)
-		except Exception:
-			pass
-
-		results.append(arg)
-
-	return squashify(results)
-
-def dictify(arg):
-	if isinstance(arg, MutableSequence):
-		for i, a in enumerate(arg):
-			arg[i] = dictify(a)
-	elif isinstance(arg, MutableMapping):
-		arg = frappe._dict(arg)
-
-	return arg
diff --git a/frappe/website/doctype/website_settings/website_settings.json b/frappe/website/doctype/website_settings/website_settings.json
index 48f097e525..e7ae2a01e1 100644
--- a/frappe/website/doctype/website_settings/website_settings.json
+++ b/frappe/website/doctype/website_settings/website_settings.json
@@ -63,7 +63,14 @@
   "subdomain",
   "head_html",
   "robots_txt",
-  "route_redirects"
+  "route_redirects",
+  "section_break_39",
+  "chat_enable",
+  "chat_enable_from",
+  "chat_enable_to",
+  "chat_room_name",
+  "chat_welcome_message",
+  "chat_operators"
  ],
  "fields": [
   {
@@ -259,6 +266,51 @@
    "fieldtype": "Code",
    "label": "Robots.txt"
   },
+  {
+   "collapsible": 1,
+   "fieldname": "section_break_39",
+   "fieldtype": "Section Break",
+   "label": "Chat"
+  },
+  {
+   "default": "0",
+   "fieldname": "chat_enable",
+   "fieldtype": "Check",
+   "label": "Enable Chat"
+  },
+  {
+   "depends_on": "chat_enable",
+   "fieldname": "chat_enable_from",
+   "fieldtype": "Time",
+   "label": "From"
+  },
+  {
+   "depends_on": "chat_enable",
+   "fieldname": "chat_enable_to",
+   "fieldtype": "Time",
+   "label": "To"
+  },
+  {
+   "default": "Support",
+   "depends_on": "chat_enable",
+   "fieldname": "chat_room_name",
+   "fieldtype": "Data",
+   "label": "Chat Room Name"
+  },
+  {
+   "default": "Hi, how may I help you?",
+   "depends_on": "chat_enable",
+   "fieldname": "chat_welcome_message",
+   "fieldtype": "Data",
+   "label": "Welcome Message"
+  },
+  {
+   "depends_on": "chat_enable",
+   "fieldname": "chat_operators",
+   "fieldtype": "Table",
+   "label": "Chat Operators",
+   "options": "Chat Room User"
+  },
   {
    "fieldname": "route_redirects",
    "fieldtype": "Table",
@@ -418,4 +470,4 @@
  "sort_field": "modified",
  "sort_order": "ASC",
  "track_changes": 1
-}
+}
\ No newline at end of file
diff --git a/frappe/website/doctype/website_settings/website_settings.py b/frappe/website/doctype/website_settings/website_settings.py
index 7a744eaf53..dfe0574e80 100644
--- a/frappe/website/doctype/website_settings/website_settings.py
+++ b/frappe/website/doctype/website_settings/website_settings.py
@@ -120,7 +120,8 @@ def get_website_settings(context=None):
 		"facebook_share", "google_plus_one", "twitter_share", "linked_in_share",
 		"disable_signup", "hide_footer_signup", "head_html", "title_prefix",
 		"navbar_template", "footer_template", "navbar_search", "enable_view_tracking",
-		"footer_logo", "call_to_action", "call_to_action_url", "show_language_picker"]:
+		"footer_logo", "call_to_action", "call_to_action_url", "show_language_picker",
+		"chat_enable"]:
 		if hasattr(settings, k):
 			context[k] = settings.get(k)
 
diff --git a/frappe/website/js/website.js b/frappe/website/js/website.js
index f6ea3f02ec..5d25b975b4 100644
--- a/frappe/website/js/website.js
+++ b/frappe/website/js/website.js
@@ -633,11 +633,17 @@ $(document).on("page-change", function() {
 
 frappe.ready(function() {
 	frappe.show_language_picker();
-
-	frappe.require([
-		"/assets/frappe/node_modules/moment/min/moment-with-locales.min.js",
-		"/assets/frappe/node_modules/moment-timezone/builds/moment-timezone-with-data.min.js",
-		"/assets/frappe/js/lib/socket.io.min.js"
-	]);
+	if (window.is_chat_enabled) {
+		frappe.require([
+			"/assets/frappe/node_modules/moment/min/moment-with-locales.min.js",
+			"/assets/frappe/node_modules/moment-timezone/builds/moment-timezone-with-data.min.js",
+			"chat.bundle.css",
+			"/assets/frappe/js/lib/socket.io.min.js"
+		], () => {
+			frappe.require('chat.bundle.js', () => {
+				frappe.chat.setup();
+			});
+		});
+	}
 	frappe.socketio.init(window.socketio_port);
 });