diff --git a/src/sphoords.js b/src/sphoords.js
new file mode 100644
index 000000000..f0a96d619
--- /dev/null
+++ b/src/sphoords.js
@@ -0,0 +1,361 @@
+/*
+* Sphoords v0.1
+* http://jeremyheleine.me
+*
+* Copyright (c) 2015 Jérémy Heleine
+*
+* 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.
+*/
+
+/**
+ * Sphoords class allowing to retrieve the current orientation of a device supporting the Orientation API.
+ * @class
+ **/
+
+var Sphoords = function() {
+	/**
+	 * Detects the used browser engine.
+	 * @private
+	 * @return {void}
+	 **/
+
+	var detectBrowserEngine = function() {
+		// User-Agent
+		var ua = navigator.userAgent;
+
+		// Gecko
+		if (/Gecko\/[0-9.]+/.test(ua))
+			return 'Gecko';
+
+		// Blink
+		if (/Chrome\/[0-9.]+/.test(ua))
+			return 'Blink';
+
+		// WebKit
+		if (/AppleWebKit\/[0-9.]+/.test(ua))
+			return 'WebKit';
+
+		// Trident
+		if (/Trident\/[0-9.]+/.test(ua))
+			return 'Trident';
+
+		// Presto
+		if (/Opera\/[0-9.]+/.test(ua))
+			return 'Presto';
+
+		// No engine detected, Gecko by default
+		return 'Gecko';
+	};
+
+	/**
+	 * Returns the principal angle in degrees.
+	 * @private
+	 * @param {number} angle - The initial angle
+	 * @return {number} The principal angle
+	 **/
+
+	var getPrincipalAngle = function(angle) {
+		return angle - Math.floor(angle / 360.0) * 360.0;
+	};
+
+	/**
+	 * Attaches the DeviceOrientation event to the window and starts the record, only if Device Orientation is supported.
+	 * @public
+	 * @return {boolean} `true` if event is attached, `false` otherwise
+	 **/
+
+	this.start = function() {
+		if (Sphoords.isDeviceOrientationSupported) {
+			window.addEventListener('deviceorientation', onDeviceOrientation, false);
+
+			recording = true;
+			return true;
+		}
+
+		else {
+			console.log('Device Orientation API not supported');
+			return false;
+		}
+	};
+
+	/**
+	 * Stops the record by removing the event handler.
+	 * @public
+	 * @return {void}
+	 **/
+
+	this.stop = function() {
+		// Is there something to remove?
+		if (recording) {
+			window.removeEventListener('deviceorientation', onDeviceOrientation, false);
+
+			recording = false;
+		}
+	};
+
+	/**
+	 * Toggles the recording state.
+	 * @public
+	 * @return {void}
+	 **/
+
+	this.toggle = function() {
+		if (recording)
+			this.stop();
+
+		else
+			this.start();
+	};
+
+	/**
+	 * Determines whether Device Orientation Event is attached.
+	 * @public
+	 * @return {boolean} `true` if event is attached, `false` otherwise
+	 **/
+
+	this.isEventAttached = function() {
+		return recording;
+	};
+
+	/**
+	 * Records the current orientation
+	 * @private
+	 * @param {Event} evt - The event
+	 * @return {void}
+	 **/
+
+	var onDeviceOrientation = function(evt) {
+		// Current screen orientation
+		orientation = Sphoords.getScreenOrientation();
+
+		// Coordinates depend on the orientation
+		var theta = 0, phi = 0;
+
+		switch (orientation) {
+			// Portrait mode
+			case 'portrait-primary':
+				theta = evt.alpha + evt.gamma;
+				phi = evt.beta - 90;
+
+				break;
+
+			// Landscape mode
+			case 'landscape-primary':
+				// If "-90" is not present for theta, origin won't be the same than for portrait mode
+				theta = evt.alpha + evt.beta - 90;
+				phi = -evt.gamma - 90;
+
+				// The user looks to the top while phi "looks" to the bottom
+				if (Math.abs(evt.beta) > 90) {
+					// Here browser engines have different behaviors
+					// Hope we have a really respected standard soon
+
+					switch (engine) {
+						case 'Blink':
+							phi += 180;
+							break;
+
+						case 'Gecko':
+						default:
+							phi = -phi;
+							break;
+					}
+				}
+
+				break;
+
+			// Landscape mode (inversed)
+			case 'landscape-secondary':
+				// Still the same reason for "+90"
+				theta = evt.alpha - evt.beta + 90;
+				phi = evt.gamma - 90;
+
+				// The user looks to the top while phi "looks" to the bottom
+				if (Math.abs(evt.beta) > 90) {
+					// Here again, some different behaviors…
+
+					switch (engine) {
+						case 'Blink':
+							phi += 180;
+							break;
+
+						case 'Gecko':
+						default:
+							phi = -phi;
+							break;
+					}
+				}
+
+				break;
+
+			// Portrait mode (inversed)
+			case 'portrait-secondary':
+				theta = evt.alpha - evt.gamma;
+				phi = 180 - (evt.beta - 90);
+				phi = 270 - evt.beta;
+
+				break;
+		}
+
+		// First, we want phi to be between -π and π
+		phi = getPrincipalAngle(phi);
+
+		if (phi >= 180)
+			phi -= 360;
+
+		// We store the right values
+		long_deg = getPrincipalAngle(theta);
+		lat_deg = Math.max(-90, Math.min(90, phi));
+
+		long = long_deg * DEG_TO_RAD;
+		lat = lat_deg * DEG_TO_RAD;
+
+		// We execute the wanted functions
+		executeListeners();
+	};
+
+	/**
+	 * Returns the current coordinates.
+	 * @public
+	 * @return {object} Longitude/latitude couple
+	 **/
+
+	this.getCoordinates = function() {
+		return {
+				longitude: long,
+				latitude: lat
+			};
+	};
+
+	/**
+	 * Returns the current coordinates in degrees.
+	 * @return {object} Longitude/latitude couple
+	 **/
+
+	this.getCoordinatesInDegrees = function() {
+		return {
+				longitude: long_deg,
+				latitude: lat_deg
+			};
+	};
+
+	/**
+	 * Returns the current screen orientation.
+	 * @return {string|null} The screen orientation (portrait-primary, portrait-secondary, landscape-primary, landscape-secondary) or `null` if not supported
+	 **/
+
+	this.getScreenOrientation = function() {
+		return orientation;
+	};
+
+	/**
+	 * Adds a function to execute when device orientation changes.
+	 * @public
+	 * @param {function} f - The handler function
+	 * @return {void}
+	 **/
+
+	this.addListener = function(f) {
+		listeners.push(f);
+	};
+
+	/**
+	 * Executes all the wanted functions for the main event.
+	 * @private
+	 * @return {void}
+	 **/
+
+	var executeListeners = function() {
+		if (!!listeners.length) {
+			for (var i = 0, l = listeners.length; i < l; ++i) {
+				listeners[i]({
+					longitude: long,
+					latitude: lat
+				});
+			}
+		}
+	};
+
+	// Current state
+	var recording = false;
+
+	// Coordinates in degrees
+	var long_deg = 0, lat_deg = 0;
+
+	// Coordinates in radians
+	var long = 0, lat = 0;
+
+	// What a useful constant!
+	var DEG_TO_RAD = Math.PI / 180;
+
+	// Screen orientation
+	var orientation = Sphoords.getScreenOrientation();
+
+	// Browser engine
+	var engine = detectBrowserEngine();
+
+	// Listeners
+	var listeners = [];
+};
+
+/**
+ * Retrieves the current screen orientation.
+ * @static
+ * @return {string|null} Current screen orientation, `null` if not supported
+ **/
+
+Sphoords.getScreenOrientation = function() {
+	var screen_orientation = null;
+
+	if (!!screen.orientation)
+		screen_orientation = screen.orientation;
+
+	else if (!!screen.mozOrientation)
+		screen_orientation = screen.mozOrientation;
+
+	else if (!!screen.msOrientation)
+		screen_orientation = screen.msOrientation;
+
+	// Are the specs respected?
+	return (screen_orientation !== null && (typeof screen_orientation == 'object')) ? screen_orientation.type : screen_orientation;
+};
+
+/**
+ * A boolean to know if device orientation is supported (`true` if it is, `false` otherwise).
+ * @static
+ **/
+
+Sphoords.isDeviceOrientationSupported = false;
+
+// Just testing if window.DeviceOrientationEvent is defined is not enough
+// In fact, it can return false positives with some desktop browsers which run in computers that don't have the dedicated hardware
+(function() {
+	// We attach the right event
+	// If it is fired, the API is really supported so we can indicate true :)
+	if (!!window.DeviceOrientationEvent && Sphoords.getScreenOrientation() !== null) {
+		function testDeviceOrientation(evt) {
+			if (evt !== null && evt.alpha !== null) {
+				Sphoords.isDeviceOrientationSupported = true;
+				window.removeEventListener('deviceorientation', testDeviceOrientation);
+			}
+		}
+
+		window.addEventListener('deviceorientation', testDeviceOrientation);
+	}
+})();
diff --git a/test.html b/test.html
new file mode 100644
index 000000000..90171829f
--- /dev/null
+++ b/test.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+
+	<head>
+		<meta charset="utf-8" />
+		<title>Photo Sphere Viewer</title>
+		<meta name="viewport" content="initial-scale=1.0" />
+		<link rel="stylesheet" href="./examples/example1.css" />
+	</head>
+
+	<body>
+		<header>
+			<h1>Photo Sphere Viewer's test file</h1>
+		</header>
+
+		<div id="content">
+			<p>This file seems to be a copy of the <code>example1.html</code> file… and it's the case. But there are some differences. As a consequence, you shouldn't take it as an example of use.</p>
+
+			<p>In fact, in this file, Photo Sphere Viewer is not included in its minified version. Not even in its complete build version. No, this file includes all the source files used by Photo Sphere Viewer.</p>
+
+			<p>It's not a thing to do on a production website. This file is here for only one reason: testing. As the linked files are the source ones, we can test with it the latest modifications, without building the complete library. The build mustn't be generated before a new version is ready.</p>
+
+			<p>You can test Photo Sphere Viewer right below.</p>
+
+			<div id="container"></div>
+
+			<p style="text-align: center;">
+				<a href="#" id="go">Load the predefined panorama</a>
+			</p>
+
+			<p>And, right below, you can try the "upload way".</p>
+
+			<div id="your-pano"></div>
+
+			<form method="get" action="example1.html">
+				<p style="text-align: center;">
+					<input type="file" name="pano" id="pano" />
+				</p>
+			</form>
+		</div>
+
+		<!-- External library -->
+		<script src="./three.min.js"></script>
+
+		<!-- External library, but included in the build -->
+		<script src="./src/sphoords.js"></script>
+
+		<!-- Photo Sphere Viewer files -->
+		<script src="./src/PhotoSphereViewer.js"></script>
+		<script src="./src/PSVNavBar.js"></script>
+		<script src="./src/PSVNavBarButton.js"></script>
+
+		<!-- Test script -->
+		<script src="./test.js"></script>
+	</body>
+
+</html>
diff --git a/test.js b/test.js
new file mode 100644
index 000000000..a68a7dba2
--- /dev/null
+++ b/test.js
@@ -0,0 +1,77 @@
+window.onload = function() {
+	document.getElementById('go').addEventListener('click', loadPredefinedPanorama, false);
+
+	document.getElementById('pano').addEventListener('change', upload, false);
+};
+
+// Load the predefined panorama
+function loadPredefinedPanorama(evt) {
+	evt.preventDefault();
+
+	// Loader
+	var loader = document.createElement('div');
+	loader.className = 'loader';
+
+	// Panorama display
+	var div = document.getElementById('container');
+	div.style.height = '30px';
+
+	var PSV = new PhotoSphereViewer({
+		// Path to the panorama
+		panorama: 'examples/sun.jpg',
+
+		// Container
+		container: div,
+
+		// Deactivate the animation
+		time_anim: false,
+
+		// Display the navigation bar
+		navbar: true,
+
+		// Resize the panorama
+		size: {
+			width: '100%',
+			height: '500px'
+		},
+
+		// HTML loader
+		loading_html: loader
+	});
+}
+
+// Load a panorama stored on the user's computer
+function upload() {
+	// Retrieve the chosen file and create the FileReader object
+	var file = document.getElementById('pano').files[0];
+	var reader = new FileReader();
+
+	reader.onload = function() {
+		var div = document.getElementById('your-pano');
+
+		var PSV = new PhotoSphereViewer({
+			// Panorama, given in base 64
+			panorama: reader.result,
+
+			// Container
+			container: div,
+
+			// Deactivate the animation
+			time_anim: false,
+
+			// Display the navigation bar
+			navbar: true,
+
+			// Resize the panorama
+			size: {
+				width: '100%',
+				height: '500px'
+			},
+
+			// No XMP data
+			usexmpdata: false
+		});
+	};
+
+	reader.readAsDataURL(file);
+}