diff --git a/index.html b/index.html
index 0617013..04d98b6 100644
--- a/index.html
+++ b/index.html
@@ -5,7 +5,9 @@
 		<meta http-equiv="X-UA-Compatible" content="IE=edge" />
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<title>Draw draw draw</title>
+		<script src="wss.js"></script>
 		<script src="draw.js" defer></script>
+		<link rel="stylesheet" href="style.css" />
 	</head>
 	<body>
 		<h1>Disegna <span id="theme"></span></h1>
@@ -29,7 +31,7 @@
 		<script>
 			const theme = document.querySelector("#theme");
 
-			const socket = new WebSocket(location.origin.replace(/^http/, "ws"));
+			const socket = new ReconnectingWebSocket(location.origin.replace(/^http/, "ws"));
 
 			socket.onmessage = (event) => {
 				let message;
diff --git a/public/style.css b/public/style.css
new file mode 100644
index 0000000..7b93560
--- /dev/null
+++ b/public/style.css
@@ -0,0 +1,3 @@
+#svgElement {
+	touch-action: none;
+}
diff --git a/public/wss.js b/public/wss.js
new file mode 100644
index 0000000..d29bc58
--- /dev/null
+++ b/public/wss.js
@@ -0,0 +1,382 @@
+// MIT License:
+//
+// Copyright (c) 2010-2012, Joe Walnes
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * This behaves like a WebSocket in every way, except if it fails to connect,
+ * or it gets disconnected, it will repeatedly poll until it successfully connects
+ * again.
+ *
+ * It is API compatible, so when you have:
+ *   ws = new WebSocket('ws://....');
+ * you can replace with:
+ *   ws = new ReconnectingWebSocket('ws://....');
+ *
+ * The event stream will typically look like:
+ *  onconnecting
+ *  onopen
+ *  onmessage
+ *  onmessage
+ *  onclose // lost connection
+ *  onconnecting
+ *  onopen  // sometime later...
+ *  onmessage
+ *  onmessage
+ *  etc...
+ *
+ * It is API compatible with the standard WebSocket API, apart from the following members:
+ *
+ * - `bufferedAmount`
+ * - `extensions`
+ * - `binaryType`
+ *
+ * Latest version: https://github.com/joewalnes/reconnecting-websocket/
+ * - Joe Walnes
+ *
+ * Syntax
+ * ======
+ * var socket = new ReconnectingWebSocket(url, protocols, options);
+ *
+ * Parameters
+ * ==========
+ * url - The url you are connecting to.
+ * protocols - Optional string or array of protocols.
+ * options - See below
+ *
+ * Options
+ * =======
+ * Options can either be passed upon instantiation or set after instantiation:
+ *
+ * var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });
+ *
+ * or
+ *
+ * var socket = new ReconnectingWebSocket(url);
+ * socket.debug = true;
+ * socket.reconnectInterval = 4000;
+ *
+ * debug
+ * - Whether this instance should log debug messages. Accepts true or false. Default: false.
+ *
+ * automaticOpen
+ * - Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close().
+ *
+ * reconnectInterval
+ * - The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.
+ *
+ * maxReconnectInterval
+ * - The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.
+ *
+ * reconnectDecay
+ * - The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.
+ *
+ * timeoutInterval
+ * - The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.
+ *
+ */
+(function (global, factory) {
+	if (typeof define === "function" && define.amd) {
+		define([], factory);
+	} else if (typeof module !== "undefined" && module.exports) {
+		module.exports = factory();
+	} else {
+		global.ReconnectingWebSocket = factory();
+	}
+})(this, function () {
+	if (!("WebSocket" in window)) {
+		return;
+	}
+
+	function ReconnectingWebSocket(url, protocols, options) {
+		// Default settings
+		var settings = {
+			/** Whether this instance should log debug messages. */
+			debug: false,
+
+			/** Whether or not the websocket should attempt to connect immediately upon instantiation. */
+			automaticOpen: true,
+
+			/** The number of milliseconds to delay before attempting to reconnect. */
+			reconnectInterval: 1000,
+			/** The maximum number of milliseconds to delay a reconnection attempt. */
+			maxReconnectInterval: 30000,
+			/** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
+			reconnectDecay: 1.5,
+
+			/** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
+			timeoutInterval: 2000,
+
+			/** The maximum number of reconnection attempts to make. Unlimited if null. */
+			maxReconnectAttempts: null,
+
+			/** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
+			binaryType: "blob",
+		};
+		if (!options) {
+			options = {};
+		}
+
+		// Overwrite and define settings with options if they exist.
+		for (var key in settings) {
+			if (typeof options[key] !== "undefined") {
+				this[key] = options[key];
+			} else {
+				this[key] = settings[key];
+			}
+		}
+
+		// These should be treated as read-only properties
+
+		/** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
+		this.url = url;
+
+		/** The number of attempted reconnects since starting, or the last successful connection. Read only. */
+		this.reconnectAttempts = 0;
+
+		/**
+		 * The current state of the connection.
+		 * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
+		 * Read only.
+		 */
+		this.readyState = WebSocket.CONNECTING;
+
+		/**
+		 * A string indicating the name of the sub-protocol the server selected; this will be one of
+		 * the strings specified in the protocols parameter when creating the WebSocket object.
+		 * Read only.
+		 */
+		this.protocol = null;
+
+		// Private state variables
+
+		var self = this;
+		var ws;
+		var forcedClose = false;
+		var timedOut = false;
+		var eventTarget = document.createElement("div");
+
+		// Wire up "on*" properties as event handlers
+
+		eventTarget.addEventListener("open", function (event) {
+			self.onopen(event);
+		});
+		eventTarget.addEventListener("close", function (event) {
+			self.onclose(event);
+		});
+		eventTarget.addEventListener("connecting", function (event) {
+			self.onconnecting(event);
+		});
+		eventTarget.addEventListener("message", function (event) {
+			self.onmessage(event);
+		});
+		eventTarget.addEventListener("error", function (event) {
+			self.onerror(event);
+		});
+
+		// Expose the API required by EventTarget
+
+		this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
+		this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
+		this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);
+
+		/**
+		 * This function generates an event that is compatible with standard
+		 * compliant browsers and IE9 - IE11
+		 *
+		 * This will prevent the error:
+		 * Object doesn't support this action
+		 *
+		 * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
+		 * @param s String The name that the event should use
+		 * @param args Object an optional object that the event will use
+		 */
+		function generateEvent(s, args) {
+			var evt = document.createEvent("CustomEvent");
+			evt.initCustomEvent(s, false, false, args);
+			return evt;
+		}
+
+		this.open = function (reconnectAttempt) {
+			ws = new WebSocket(self.url, protocols || []);
+			ws.binaryType = this.binaryType;
+
+			if (reconnectAttempt) {
+				if (
+					this.maxReconnectAttempts &&
+					this.reconnectAttempts > this.maxReconnectAttempts
+				) {
+					return;
+				}
+			} else {
+				eventTarget.dispatchEvent(generateEvent("connecting"));
+				this.reconnectAttempts = 0;
+			}
+
+			if (self.debug || ReconnectingWebSocket.debugAll) {
+				console.debug("ReconnectingWebSocket", "attempt-connect", self.url);
+			}
+
+			var localWs = ws;
+			var timeout = setTimeout(function () {
+				if (self.debug || ReconnectingWebSocket.debugAll) {
+					console.debug("ReconnectingWebSocket", "connection-timeout", self.url);
+				}
+				timedOut = true;
+				localWs.close();
+				timedOut = false;
+			}, self.timeoutInterval);
+
+			ws.onopen = function (event) {
+				clearTimeout(timeout);
+				if (self.debug || ReconnectingWebSocket.debugAll) {
+					console.debug("ReconnectingWebSocket", "onopen", self.url);
+				}
+				self.protocol = ws.protocol;
+				self.readyState = WebSocket.OPEN;
+				self.reconnectAttempts = 0;
+				var e = generateEvent("open");
+				e.isReconnect = reconnectAttempt;
+				reconnectAttempt = false;
+				eventTarget.dispatchEvent(e);
+			};
+
+			ws.onclose = function (event) {
+				clearTimeout(timeout);
+				ws = null;
+				if (forcedClose) {
+					self.readyState = WebSocket.CLOSED;
+					eventTarget.dispatchEvent(generateEvent("close"));
+				} else {
+					self.readyState = WebSocket.CONNECTING;
+					var e = generateEvent("connecting");
+					e.code = event.code;
+					e.reason = event.reason;
+					e.wasClean = event.wasClean;
+					eventTarget.dispatchEvent(e);
+					if (!reconnectAttempt && !timedOut) {
+						if (self.debug || ReconnectingWebSocket.debugAll) {
+							console.debug("ReconnectingWebSocket", "onclose", self.url);
+						}
+						eventTarget.dispatchEvent(generateEvent("close"));
+					}
+
+					var timeout =
+						self.reconnectInterval *
+						Math.pow(self.reconnectDecay, self.reconnectAttempts);
+					setTimeout(
+						function () {
+							self.reconnectAttempts++;
+							self.open(true);
+						},
+						timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout
+					);
+				}
+			};
+			ws.onmessage = function (event) {
+				if (self.debug || ReconnectingWebSocket.debugAll) {
+					console.debug("ReconnectingWebSocket", "onmessage", self.url, event.data);
+				}
+				var e = generateEvent("message");
+				e.data = event.data;
+				eventTarget.dispatchEvent(e);
+			};
+			ws.onerror = function (event) {
+				if (self.debug || ReconnectingWebSocket.debugAll) {
+					console.debug("ReconnectingWebSocket", "onerror", self.url, event);
+				}
+				eventTarget.dispatchEvent(generateEvent("error"));
+			};
+		};
+
+		// Whether or not to create a websocket upon instantiation
+		if (this.automaticOpen == true) {
+			this.open(false);
+		}
+
+		/**
+		 * Transmits data to the server over the WebSocket connection.
+		 *
+		 * @param data a text string, ArrayBuffer or Blob to send to the server.
+		 */
+		this.send = function (data) {
+			if (ws) {
+				if (self.debug || ReconnectingWebSocket.debugAll) {
+					console.debug("ReconnectingWebSocket", "send", self.url, data);
+				}
+				return ws.send(data);
+			} else {
+				throw "INVALID_STATE_ERR : Pausing to reconnect websocket";
+			}
+		};
+
+		/**
+		 * Closes the WebSocket connection or connection attempt, if any.
+		 * If the connection is already CLOSED, this method does nothing.
+		 */
+		this.close = function (code, reason) {
+			// Default CLOSE_NORMAL code
+			if (typeof code == "undefined") {
+				code = 1000;
+			}
+			forcedClose = true;
+			if (ws) {
+				ws.close(code, reason);
+			}
+		};
+
+		/**
+		 * Additional public API method to refresh the connection if still open (close, re-open).
+		 * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
+		 */
+		this.refresh = function () {
+			if (ws) {
+				ws.close();
+			}
+		};
+	}
+
+	/**
+	 * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+	 * this indicates that the connection is ready to send and receive data.
+	 */
+	ReconnectingWebSocket.prototype.onopen = function (event) {};
+	/** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
+	ReconnectingWebSocket.prototype.onclose = function (event) {};
+	/** An event listener to be called when a connection begins being attempted. */
+	ReconnectingWebSocket.prototype.onconnecting = function (event) {};
+	/** An event listener to be called when a message is received from the server. */
+	ReconnectingWebSocket.prototype.onmessage = function (event) {};
+	/** An event listener to be called when an error occurs. */
+	ReconnectingWebSocket.prototype.onerror = function (event) {};
+
+	/**
+	 * Whether all instances of ReconnectingWebSocket should log debug messages.
+	 * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
+	 */
+	ReconnectingWebSocket.debugAll = false;
+
+	ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
+	ReconnectingWebSocket.OPEN = WebSocket.OPEN;
+	ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
+	ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;
+
+	return ReconnectingWebSocket;
+});
