GODOT IS OPEN SOURCE

24 files changed, 3457 insertions, 0 deletions

diff --git a/platform/nacl/SCsub b/platform/nacl/SCsub
new file mode 100644
index 0000000000..ac01752dbb
--- /dev/null
+++ b/platform/nacl/SCsub
@@ -0,0 +1,30 @@
+Import('env')
+
+nacl_lib = [
+
+	'os_nacl.cpp',
+	'audio_driver_nacl.cpp',
+	'godot_nacl.cpp',
+	#'pepper_main.cpp',
+	'opengl_context.cpp',
+	'godot_module.cpp',
+	'geturl_handler.cpp',
+]
+
+nacl_posix = [
+
+	'#drivers/unix/thread_posix.cpp',
+	'#drivers/unix/mutex_posix.cpp',
+	'#drivers/unix/semaphore_posix.cpp',
+]
+
+posix_lib = []
+for f in nacl_posix:
+	posix_lib.append(env.Object(f, CPPFLAGS = env['CPPFLAGS']+['-DUNIX_ENABLED'], OBJSUFFIX = '.posix'+env['OBJSUFFIX']))
+
+prog = env.Program('#bin/godot_nacl', nacl_lib + posix_lib)
+
+if (env['nacl_arch'] == 'i686'):
+	env.Alias("nacl_32", prog)
+if (env['nacl_arch'] == 'x86_64'):
+	env.Alias("nacl_64", prog)
diff --git a/platform/nacl/audio_driver_nacl.cpp b/platform/nacl/audio_driver_nacl.cpp
new file mode 100644
index 0000000000..8f1861eee3
--- /dev/null
+++ b/platform/nacl/audio_driver_nacl.cpp
@@ -0,0 +1,106 @@
+/*************************************************************************/
+/*  audio_driver_nacl.cpp                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "audio_driver_nacl.h"
+
+#include "ppapi/cpp/instance.h"
+
+extern pp::Instance* godot_instance;
+
+const char* AudioDriverNacl::get_name() const {
+
+	return "Nacl";
+}
+
+void AudioDriverNacl::output_callback(void* samples, uint32_t buffer_size, void* data) {
+
+	AudioDriverNacl* ad = (AudioDriverNacl*)data;
+	int16_t* out = (int16_t*)samples;
+
+	ad->lock();
+	ad->audio_server_process(ad->sample_frame_count_, ad->samples_in);
+	ad->unlock();
+
+	for (int i=0; i<ad->sample_count; i++) {
+
+		out[i] = ad->samples_in[i]>>16;
+	};
+
+};
+
+Error AudioDriverNacl::init(){
+
+	int frame_size = 4096;
+	sample_frame_count_ = pp::AudioConfig::RecommendSampleFrameCount(godot_instance,PP_AUDIOSAMPLERATE_44100, frame_size);
+	sample_count = sample_frame_count_ * 2;
+
+	audio_ = pp::Audio(godot_instance,
+					   pp::AudioConfig(godot_instance,
+									   PP_AUDIOSAMPLERATE_44100,
+									   sample_frame_count_),
+					   &AudioDriverNacl::output_callback,
+					   this);
+
+	samples_in = memnew_arr(int32_t, sample_frame_count_ * 2);
+
+	return OK;
+}
+void AudioDriverNacl::start(){
+
+	audio_.StartPlayback();
+}
+int AudioDriverNacl::get_mix_rate() const {
+
+	return 44100;
+}
+AudioDriverSW::OutputFormat AudioDriverNacl::get_output_format() const{
+
+	return OUTPUT_STEREO;
+}
+void AudioDriverNacl::lock(){
+
+}
+void AudioDriverNacl::unlock() {
+
+
+}
+void AudioDriverNacl::finish(){
+
+	audio_.StopPlayback();
+}
+
+
+AudioDriverNacl::AudioDriverNacl() {
+}
+
+AudioDriverNacl::~AudioDriverNacl() {
+
+	memdelete_arr(samples_in);
+}
+
+
diff --git a/platform/nacl/audio_driver_nacl.h b/platform/nacl/audio_driver_nacl.h
new file mode 100644
index 0000000000..4a45d0bb4b
--- /dev/null
+++ b/platform/nacl/audio_driver_nacl.h
@@ -0,0 +1,63 @@
+/*************************************************************************/
+/*  audio_driver_nacl.h                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#ifndef AUDIO_DRIVER_NACL_H
+#define AUDIO_DRIVER_NACL_H
+
+#include "servers/audio/audio_server_sw.h"
+
+#include "ppapi/cpp/audio.h"
+
+class AudioDriverNacl : public AudioDriverSW {
+
+	static void output_callback(void* samples, uint32_t buffer_size, void* data);
+
+	int32_t* samples_in;
+	int sample_frame_count_;
+	int sample_count;
+	pp::Audio audio_;
+
+public:
+
+	virtual const char* get_name() const;
+
+	virtual Error init();
+	virtual void start();
+	virtual int get_mix_rate() const ;
+	virtual OutputFormat get_output_format() const;
+	virtual void lock();
+	virtual void unlock();
+	virtual void finish();
+
+
+	AudioDriverNacl();
+	~AudioDriverNacl();
+};
+
+#endif // AUDIO_DRIVER_NACL_H
+
diff --git a/platform/nacl/context_gl_nacl.cpp b/platform/nacl/context_gl_nacl.cpp
new file mode 100644
index 0000000000..70cf01a16e
--- /dev/null
+++ b/platform/nacl/context_gl_nacl.cpp
@@ -0,0 +1,67 @@
+/*************************************************************************/
+/*  context_gl_nacl.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "context_gl_nacl.h"
+
+#include <nacl/npapi.h>
+#include <nacl/npruntime.h>
+#include <nacl/npapi_extensions.h>
+#include <nacl/npupp.h>
+#include <pgl/pgl.h>
+#include <GLES2/gl2.h>
+
+void ContextGLNacl::make_current() {
+
+};
+
+int ContextGLNacl::get_window_width() {
+
+};
+
+int ContextGLNacl::get_window_height() {
+
+};
+
+void ContextGLNacl::swap_buffers() {
+
+};
+
+Error ContextGLNacl::initialize() {
+
+};
+
+
+ContextGLNacl::ContextGLNacl() {
+
+
+};
+
+ContextGLNacl::~ContextGLNacl() {
+
+};
+
diff --git a/platform/nacl/context_gl_nacl.h b/platform/nacl/context_gl_nacl.h
new file mode 100644
index 0000000000..a5cf7a728c
--- /dev/null
+++ b/platform/nacl/context_gl_nacl.h
@@ -0,0 +1,58 @@
+/*************************************************************************/
+/*  context_gl_nacl.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#ifndef CONTEXT_GL_NACL_H
+#define CONTEXT_GL_NACL_H
+
+#include "drivers/gl_context/context_gl.h"
+
+class NPDevice;
+
+class ContextGLNacl : public ContextGL {
+
+	enum {
+		COMMAND_BUFFER_SIZE = 1024 * 1024,
+	};
+
+	NPDevice* device3d_;
+
+public:
+
+	virtual void make_current();
+
+	virtual int get_window_width();
+	virtual int get_window_height();
+	virtual void swap_buffers();
+
+	virtual Error initialize();
+
+    ContextGLNacl();
+	~ContextGLNacl();
+};
+
+#endif // CONTEXT_GL_NACL_H
diff --git a/platform/nacl/detect.py b/platform/nacl/detect.py
new file mode 100644
index 0000000000..f8849cfd25
--- /dev/null
+++ b/platform/nacl/detect.py
@@ -0,0 +1,71 @@
+import os
+import sys
+
+def is_active():
+	return True
+	
+def get_name():
+	return "NaCl"
+
+def can_build():
+
+	import os
+	if not os.environ.has_key("NACLPATH"):
+		return False
+	return True
+
+def get_opts():
+
+	return [
+		('NACLPATH', 'the path to nacl', os.environ.get("NACLPATH", 0)),
+		('nacl_arch', 'The architecture for Nacl build (can be i686 or x86_64', 'i686'),
+	]
+
+def get_flags():
+
+	return [
+		('nedmalloc', 'no'),
+		('tools', 'no'),
+	]
+
+
+
+def configure(env):
+
+	env.Append(CPPPATH=['#platform/nacl'])
+
+	env['OBJSUFFIX'] = ".nacl.${nacl_arch}.o"
+	env['LIBSUFFIX'] = ".nacl.${nacl_arch}.a"
+	env['PROGSUFFIX'] = ".${nacl_arch}.nexe"
+
+	env['ENV']['PATH'] = env['ENV']['PATH']+":"+env['NACLPATH']+"/toolchain/linux_x86_newlib/bin"
+
+	env['CC'] = '${nacl_arch}-nacl-gcc'
+	env['CXX'] = '${nacl_arch}-nacl-g++'
+	env['AR'] = '${nacl_arch}-nacl-ar'
+
+	env.Append(CCFLAGS=['-fexceptions', '-Wno-long-long', '-pthread', '-DXP_UNIX'])
+
+	env.Append(CPPPATH=env['NACLPATH'])
+
+	if (env["target"]=="release"):
+
+		env.Append(CCFLAGS=['-O2','-ffast-math','-fomit-frame-pointer', '-ffunction-sections', '-fdata-sections', '-fno-default-inline'])
+
+	elif (env["target"]=="debug"):
+
+		env.Append(CCFLAGS=['-g', '-O0', '-Wall','-DDEBUG_ENABLED'])
+
+
+	elif (env["target"]=="profile"):
+
+		env.Append(CCFLAGS=['-g','-pg'])
+		env.Append(LINKFLAGS=['-pg'])
+
+	env.Append(CCFLAGS=['-DNACL_ENABLED', '-DGLES2_ENABLED'])
+
+	env.Append(LIBFLAGS=['m32'])
+	env.Append(LIBS=env.Split('ppapi ppapi_cpp pthread srpc ppapi_gles22'))
+
+	import methods
+	env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
diff --git a/platform/nacl/geturl_handler.cpp b/platform/nacl/geturl_handler.cpp
new file mode 100644
index 0000000000..4873d691ce
--- /dev/null
+++ b/platform/nacl/geturl_handler.cpp
@@ -0,0 +1,150 @@
+/*************************************************************************/
+/*  geturl_handler.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "geturl_handler.h"
+
+#include "core/os/copymem.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/ppb_instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/var.h"
+
+void GetURLHandler::Start() {
+  pp::CompletionCallback cc =
+     cc_factory_.NewCallback(&GetURLHandler::OnOpen);
+  url_loader_.Open(url_request_, cc);
+}
+
+void GetURLHandler::OnOpen(int32_t result) {
+  if (result != PP_OK) {
+	status = STATUS_ERROR;
+    return;
+  }
+  // Here you would process the headers. A real program would want to at least
+  // check the HTTP code and potentially cancel the request.
+  // pp::URLResponseInfo response = loader_.GetResponseInfo();
+
+  // Start streaming.
+  ReadBody();
+}
+
+void GetURLHandler::AppendDataBytes(const char* buffer, int32_t num_bytes) {
+  if (num_bytes <= 0)
+    return;
+  // Make sure we don't get a buffer overrun.
+  num_bytes = std::min(READ_BUFFER_SIZE, num_bytes);
+  int ofs = data.size();
+  data.resize(ofs + num_bytes);
+  copymem(&data[ofs], buffer, num_bytes);
+}
+
+void GetURLHandler::OnRead(int32_t result) {
+  if (result == PP_OK) {
+    // Streaming the file is complete.
+	status = STATUS_COMPLETED;
+	instance_->HandleMessage("package_finished");
+	instance_->HandleMessage(0);
+	printf("completed!\n");
+  } else if (result > 0) {
+    // The URLLoader just filled "result" number of bytes into our buffer.
+    // Save them and perform another read.
+    AppendDataBytes(buffer_, result);
+    ReadBody();
+  } else {
+    // A read error occurred.
+	status = STATUS_ERROR;
+	ERR_FAIL_COND(result < 0);
+  }
+}
+
+void GetURLHandler::ReadBody() {
+  // Note that you specifically want an "optional" callback here. This will
+  // allow ReadBody() to return synchronously, ignoring your completion
+  // callback, if data is available. For fast connections and large files,
+  // reading as fast as we can will make a large performance difference
+  // However, in the case of a synchronous return, we need to be sure to run
+  // the callback we created since the loader won't do anything with it.
+  pp::CompletionCallback cc =
+      cc_factory_.NewOptionalCallback(&GetURLHandler::OnRead);
+  int32_t result = PP_OK;
+  do {
+    result = url_loader_.ReadResponseBody(buffer_, sizeof(buffer_), cc);
+    // Handle streaming data directly. Note that we *don't* want to call
+    // OnRead here, since in the case of result > 0 it will schedule
+    // another call to this function. If the network is very fast, we could
+    // end up with a deeply recursive stack.
+    if (result > 0) {
+      AppendDataBytes(buffer_, result);
+    }
+  } while (result > 0);
+
+  if (result != PP_OK_COMPLETIONPENDING) {
+    // Either we reached the end of the stream (result == PP_OK) or there was
+    // an error. We want OnRead to get called no matter what to handle
+    // that case, whether the error is synchronous or asynchronous. If the
+    // result code *is* COMPLETIONPENDING, our callback will be called
+    // asynchronously.
+    cc.Run(result);
+  }
+}
+
+GetURLHandler::Status GetURLHandler::get_status() const {
+
+	return status;
+};
+
+Vector<uint8_t> GetURLHandler::get_data() const {
+
+	return data;
+};
+
+int GetURLHandler::get_bytes_read() const {
+
+	return data.size();
+};
+
+GetURLHandler::GetURLHandler(pp::Instance* instance,
+							 const String& url)
+	: instance_(instance),
+	  url_(url),
+	  url_request_(instance),
+	  url_loader_(instance),
+	  cc_factory_(this) {
+  url_request_.SetURL(std::string(url.utf8().get_data()));
+  url_request_.SetMethod("GET");
+  status = STATUS_NONE;
+  printf("url handler for url %ls!\n", url.c_str());
+}
+
+GetURLHandler::~GetURLHandler() {
+}
+
+
diff --git a/platform/nacl/geturl_handler.h b/platform/nacl/geturl_handler.h
new file mode 100644
index 0000000000..44086ae7c1
--- /dev/null
+++ b/platform/nacl/geturl_handler.h
@@ -0,0 +1,115 @@
+/*************************************************************************/
+/*  geturl_handler.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#ifndef EXAMPLES_GETURL_GETURL_HANDLER_H_
+#define EXAMPLES_GETURL_GETURL_HANDLER_H_
+
+#include "core/ustring.h"
+#include "core/vector.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/cpp/url_loader.h"
+#include "ppapi/cpp/url_request_info.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/utility/completion_callback_factory.h"
+
+#define READ_BUFFER_SIZE 32768
+
+// GetURLHandler is used to download data from |url|. When download is
+// finished or when an error occurs, it posts a message back to the browser
+// with the results encoded in the message as a string and self-destroys.
+//
+// EXAMPLE USAGE:
+// GetURLHandler* handler* = GetURLHandler::Create(instance,url);
+// handler->Start();
+//
+class GetURLHandler {
+
+public:
+
+	enum Status {
+
+		STATUS_NONE,
+		STATUS_IN_PROGRESS,
+		STATUS_COMPLETED,
+		STATUS_ERROR,
+	};
+
+private:
+
+	Status status;
+
+	// Callback fo the pp::URLLoader::Open().
+	// Called by pp::URLLoader when response headers are received or when an
+	// error occurs (in response to the call of pp::URLLoader::Open()).
+	// Look at <ppapi/c/ppb_url_loader.h> and
+	// <ppapi/cpp/url_loader.h> for more information about pp::URLLoader.
+	void OnOpen(int32_t result);
+
+	// Callback fo the pp::URLLoader::ReadResponseBody().
+	// |result| contains the number of bytes read or an error code.
+	// Appends data from this->buffer_ to this->url_response_body_.
+	void OnRead(int32_t result);
+
+	// Reads the response body (asynchronously) into this->buffer_.
+	// OnRead() will be called when bytes are received or when an error occurs.
+	void ReadBody();
+
+	// Append data bytes read from the URL onto the internal buffer.  Does
+	// nothing if |num_bytes| is 0.
+	void AppendDataBytes(const char* buffer, int32_t num_bytes);
+
+	pp::Instance* instance_;  // Weak pointer.
+	String url_;  // URL to be downloaded.
+	pp::URLRequestInfo url_request_;
+	pp::URLLoader url_loader_;  // URLLoader provides an API to download URLs.
+	char buffer_[READ_BUFFER_SIZE];  // Temporary buffer for reads.
+	Vector<uint8_t> data;  // Contains accumulated downloaded data.
+	pp::CompletionCallbackFactory<GetURLHandler> cc_factory_;
+	bool complete;
+
+	GetURLHandler(const GetURLHandler&);
+	void operator=(const GetURLHandler&);
+
+public:
+	// Creates instance of GetURLHandler on the heap.
+	// GetURLHandler objects shall be created only on the heap (they
+	// self-destroy when all data is in).
+	// Initiates page (URL) download.
+	void Start();
+
+	Status get_status() const;
+	Vector<uint8_t> get_data() const;
+
+	int get_bytes_read() const;
+
+	GetURLHandler(pp::Instance* instance_, const String& url);
+	~GetURLHandler();
+};
+
+#endif  // EXAMPLES_GETURL_GETURL_HANDLER_H_
+
diff --git a/platform/nacl/godot_module.cpp b/platform/nacl/godot_module.cpp
new file mode 100644
index 0000000000..b5a049d9bf
--- /dev/null
+++ b/platform/nacl/godot_module.cpp
@@ -0,0 +1,332 @@
+/*************************************************************************/
+/*  godot_module.cpp                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "opengl_context.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/gles2/gl2ext_ppapi.h"
+
+#include "ppapi/cpp/rect.h"
+#include "ppapi/cpp/size.h"
+#include "ppapi/cpp/var.h"
+#include "geturl_handler.h"
+
+#include "core/variant.h"
+#include "os_nacl.h"
+
+extern int nacl_main(int argc, const char** argn, const char** argv);
+extern void nacl_cleanup();
+
+static String pkg_url;
+
+pp::Instance* godot_instance = NULL;
+
+struct StateData {
+	int arg_count;
+	Array args;
+	String method;
+};
+
+extern OSNacl* os_nacl;
+
+class GodotInstance : public pp::Instance {
+
+	enum State {
+		STATE_METHOD,
+		STATE_PARAM_COUNT,
+		STATE_PARAMS,
+		STATE_CALL,
+	};
+
+	State state;
+	StateData* sd;
+	SharedOpenGLContext opengl_context_;
+	int width;
+	int height;
+
+	#define MAX_ARGS 64
+	uint32_t init_argc;
+	char* init_argn[MAX_ARGS];
+	char* init_argv[MAX_ARGS];
+
+	bool package_loaded;
+	GetURLHandler* package_pending;
+
+public:
+	explicit GodotInstance(PP_Instance instance) : pp::Instance(instance) {
+		printf("GodotInstance!\n");
+		state = STATE_METHOD;
+		RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_KEYBOARD | PP_INPUTEVENT_CLASS_WHEEL | PP_INPUTEVENT_CLASS_TOUCH);
+		sd = NULL;
+		package_pending = NULL;
+		package_loaded = false;
+		godot_instance = this;
+	}
+	virtual ~GodotInstance() {
+
+		nacl_cleanup();
+	}
+
+	/// Called by the browser to handle the postMessage() call in Javascript.
+	/// Detects which method is being called from the message contents, and
+	/// calls the appropriate function.  Posts the result back to the browser
+	/// asynchronously.
+	/// @param[in] var_message The message posted by the browser.  The possible
+	///     messages are 'fortyTwo' and 'reverseText:Hello World'.  Note that
+	///     the 'reverseText' form contains the string to reverse following a ':'
+	///     separator.
+	virtual void HandleMessage(const pp::Var& var_message);
+
+	bool HandleInputEvent(const pp::InputEvent& event);
+
+	bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
+
+		printf("******* init! %i, %p, %p\n", argc, argn, argv);
+		fflush(stdout);
+		if (opengl_context_ == NULL) {
+			opengl_context_.reset(new OpenGLContext(this));
+		};
+		opengl_context_->InvalidateContext(this);
+		opengl_context_->ResizeContext(pp::Size(0, 0));
+		int current = opengl_context_->MakeContextCurrent(this);
+		printf("current is %i\n", current);
+
+		os_nacl = new OSNacl;
+
+		pkg_url = "";
+		for (uint32_t i=0; i<argc; i++) {
+			if (strcmp(argn[i], "package") == 0) {
+				pkg_url = argv[i];
+			};
+		};
+
+		sd = memnew(StateData);
+
+		if (pkg_url == "") {
+			nacl_main(argc, argn, argv);
+		} else {
+			printf("starting package %ls\n", pkg_url.c_str());
+			init_argc = MIN(argc, MAX_ARGS-1);
+			for (uint32_t i=0; i<argc; i++) {
+
+				int nlen = strlen(argn[i]);
+				init_argn[i] = (char*)memalloc(nlen+1);
+				strcpy(init_argn[i], argn[i]);
+				init_argn[i+1] = NULL;
+
+				int len = strlen(argv[i]);
+				init_argv[i] = (char*)memalloc(len+1);
+				strcpy(init_argv[i], argv[i]);
+				init_argv[i+1] = NULL;
+			};
+			package_pending = memnew(GetURLHandler(this, pkg_url));
+			package_pending->Start();
+		};
+		return true;
+	};
+
+	// Called whenever the in-browser window changes size.
+	virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
+
+		if (position.size().width() == width &&
+			position.size().height() == height)
+			return;  // Size didn't change, no need to update anything.
+
+		if (opengl_context_ == NULL) {
+			opengl_context_.reset(new OpenGLContext(this));
+		};
+		opengl_context_->InvalidateContext(this);
+		opengl_context_->ResizeContext(position.size());
+		if (!opengl_context_->MakeContextCurrent(this))
+			return;
+
+		width = position.size().width();
+		height = position.size().height();
+		// init gl here?
+		OS::VideoMode vm;
+		vm.width = width;
+		vm.height = height;
+		vm.resizable = false;
+		vm.fullscreen = true;
+		OS::get_singleton()->set_video_mode(vm, 0);
+
+		DrawSelf();
+	};
+
+	// Called to draw the contents of the module's browser area.
+	void DrawSelf() {
+
+		if (opengl_context_ == NULL)
+			return;
+
+		opengl_context_->FlushContext();
+	};
+};
+
+static Variant to_variant(const pp::Var& p_var) {
+
+	if (p_var.is_undefined() || p_var.is_null())
+		return Variant();
+	if (p_var.is_bool())
+		return Variant(p_var.AsBool());
+	if (p_var.is_double())
+		return Variant(p_var.AsDouble());
+	if (p_var.is_int())
+		return Variant((int64_t)p_var.AsInt());
+	if (p_var.is_string())
+		return Variant(String::utf8(p_var.AsString().c_str()));
+
+	return Variant();
+};
+
+void GodotInstance::HandleMessage(const pp::Var& var_message) {
+
+	switch (state) {
+
+		case STATE_METHOD: {
+
+			ERR_FAIL_COND(!var_message.is_string());
+			sd->method = var_message.AsString().c_str();
+			state = STATE_PARAM_COUNT;
+		} break;
+		case STATE_PARAM_COUNT: {
+
+			ERR_FAIL_COND(!var_message.is_number());
+			sd->arg_count = var_message.AsInt();
+			state = sd->arg_count>0?STATE_PARAMS:STATE_CALL;
+
+		} break;
+		case STATE_PARAMS: {
+
+			Variant p = to_variant(var_message);
+			sd->args.push_back(p);
+			if (sd->args.size() >= sd->arg_count)
+				state = STATE_CALL;
+		} break;
+		default:
+			break;
+	};
+
+	if (state == STATE_CALL) {
+
+		// call
+		state = STATE_METHOD;
+
+
+		if (sd->method == "package_finished") {
+
+			GetURLHandler::Status status = package_pending->get_status();
+			printf("status is %i, %i, %i\n", status, GetURLHandler::STATUS_ERROR, GetURLHandler::STATUS_COMPLETED);
+			if (status == GetURLHandler::STATUS_ERROR) {
+				printf("Error fetching package!\n");
+			};
+            if (status == GetURLHandler::STATUS_COMPLETED) {
+
+				OSNacl* os = (OSNacl*)OS::get_singleton();
+				os->add_package(pkg_url, package_pending->get_data());
+			};
+            memdelete(package_pending);
+			package_pending = NULL;
+
+            package_loaded = true;
+
+            opengl_context_->MakeContextCurrent(this);
+            nacl_main(init_argc, (const char**)init_argn, (const char**)init_argv);
+            for (uint32_t i=0; i<init_argc; i++) {
+				memfree(init_argn[i]);
+				memfree(init_argv[i]);
+			};
+		};
+
+		if (sd->method == "get_package_status") {
+
+			if (package_loaded) {
+				// post "loaded"
+				PostMessage("loaded");
+			} else if (package_pending == NULL) {
+				// post "none"
+				PostMessage("none");
+			} else {
+				// post package_pending->get_bytes_read();
+				PostMessage(package_pending->get_bytes_read());
+			};
+		};
+	};
+}
+
+bool GodotInstance::HandleInputEvent(const pp::InputEvent& event) {
+
+	OSNacl* os = (OSNacl*)OS::get_singleton();
+	os->handle_event(event);
+	return true;
+};
+
+class GodotModule : public pp::Module {
+ public:
+  GodotModule() : pp::Module() {}
+  virtual ~GodotModule() {
+	  glTerminatePPAPI();
+  }
+
+  /// Create and return a GodotInstance object.
+  /// @param[in] instance a handle to a plug-in instance.
+  /// @return a newly created GodotInstance.
+  /// @note The browser is responsible for calling @a delete when done.
+  virtual pp::Instance* CreateInstance(PP_Instance instance) {
+	printf("CreateInstance! %x\n", instance);
+	return new GodotInstance(instance);
+  }
+
+  /// Called by the browser when the module is first loaded and ready to run.
+  /// This is called once per module, not once per instance of the module on
+  /// the page.
+  virtual bool Init() {
+	printf("GodotModule::init!\n");
+	return glInitializePPAPI(get_browser_interface());
+  }
+};
+
+namespace pp {
+/// Factory function called by the browser when the module is first loaded.
+/// The browser keeps a singleton of this module.  It calls the
+/// CreateInstance() method on the object you return to make instances.  There
+/// is one instance per <embed> tag on the page.  This is the main binding
+/// point for your NaCl module with the browser.
+/// @return new GodotModule.
+/// @note The browser is responsible for deleting returned @a Module.
+Module* CreateModule() {
+  printf("CreateModule!\n");
+  return new GodotModule();
+}
+}  // namespace pp
diff --git a/platform/nacl/godot_nacl.cpp b/platform/nacl/godot_nacl.cpp
new file mode 100644
index 0000000000..753f4124f8
--- /dev/null
+++ b/platform/nacl/godot_nacl.cpp
@@ -0,0 +1,80 @@
+/*************************************************************************/
+/*  godot_nacl.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "os_nacl.h"
+#include "main/main.h"
+
+#include <stdio.h>
+#include <string.h>
+
+OSNacl* os_nacl = NULL;
+
+int nacl_main(int argc, const char** argn, const char** argv) {
+
+	// os is created in GodotModule::Init for the nacl module
+	printf("called with %i args, %p, %p\n", argc, argn, argv);
+	char* nargv[64];
+	int nargc = 1;
+	nargv[0] = (char*)argv[0];
+	for (int i=1; i<argc; i++) {
+
+		printf("arg %i is %s, %s\n", i, argn[i], argv[i]);
+		if (strncmp(argn[i], "arg", 3) == 0) {
+
+			printf("using arg %i, %s\n", nargc, argv[i]);
+			nargv[nargc++] = (char*)argv[i];
+		};
+	};
+	printf("total %i\n", nargc);
+	nargv[nargc] = 0;
+
+	printf("godot_nacl\n");
+	for (int i=0; i<argc; i++) {
+		printf("arg %i: %s\n", i, argv[i]);
+	};
+
+	printf("os created\n");
+    Error err  = Main::setup("", nargc-1, &nargv[1]);
+	printf("setup %i\n", err);
+	if (err!=OK)
+		return 255;
+
+    printf("calling start\n");
+    Main::start();
+
+    return 0;
+};
+
+
+void nacl_cleanup() {
+
+	Main::cleanup();
+	delete os_nacl;
+};
+
+
diff --git a/platform/nacl/html/check_browser.js b/platform/nacl/html/check_browser.js
new file mode 100644
index 0000000000..9636ad0384
--- /dev/null
+++ b/platform/nacl/html/check_browser.js
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2011 The Native Client Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/**
+ * @fileoverview This file provides a BrowserChecker Javascript class.
+ * Users can create a BrowserChecker object, invoke checkBrowser(|version|),
+ * and then use getIsValidBrowser() and getBrowserSupportStatus()
+ * to determine if the browser version is greater than |version|
+ * and if the Native Client plugin is found.
+ */
+
+// Create a namespace object
+var browser_version = browser_version || {};
+
+/**
+ * Class to provide checking for version and NativeClient.
+ * @param {integer} arg1 An argument that indicates major version of Chrome we
+ *     require, such as 14.
+ */
+
+/**
+ * Constructor for the BrowserChecker.  Sets the major version of
+ * Chrome that is required to |minChromeVersion|.
+ * @param minChromeVersion   The earliest major version of chrome that
+ *     is supported.  If the Chrome browser version is less than
+ *     |minChromeVersion| then |isValidBrowswer| will be set to false.
+ * @param opt_maxChromeVersion   Ignored.  Retained for backwards compatibility.
+ * @param appVersion  The application version string.
+ * @param plugins     The plugins that exist in the browser.
+ * @constructor
+ */
+browser_version.BrowserChecker = function(minChromeVersion,
+                                          appVersion, plugins,
+                                          opt_maxChromeVersion) {
+  /**
+   * Version specified by the user. This class looks to see if the browser
+   * version is >= |minChromeVersion_|.
+   * @type {integer}
+   * @private
+   */
+  this.minChromeVersion_ = minChromeVersion;
+
+  /**
+   * List of Browser plugin objects.
+   * @type {Ojbect array}
+   * @private
+   */
+  this.plugins_ = plugins;
+
+  /**
+   * Application version string from the Browser.
+   * @type {integer}
+   * @private
+   */
+  this.appVersion_ = appVersion;
+
+  /**
+   * Flag used to indicate if the browser has Native Client and is if the
+   * browser version is recent enough.
+   * @type {boolean}
+   * @private
+   */
+  this.isValidBrowser_ = false;
+
+  /**
+   * Actual major version of Chrome -- found by querying the browser.
+   * @type {integer}
+   * @private
+   */
+  this.chromeVersion_ = null;
+
+  /**
+   * Browser support status. This allows the user to get a detailed status
+   * rather than using this.browserSupportMessage.
+   */
+  this.browserSupportStatus_ =
+      browser_version.BrowserChecker.StatusValues.UNKNOWN;
+}
+
+/**
+ * The values used for BrowserChecker status to indicate success or
+ * a specific error.
+ * @enum {id}
+ */
+browser_version.BrowserChecker.StatusValues = {
+  UNKNOWN: 0,
+  NACL_ENABLED: 1,
+  UNKNOWN_BROWSER: 2,
+  CHROME_VERSION_TOO_OLD: 3,
+  NACL_NOT_ENABLED: 4,
+  NOT_USING_SERVER: 5
+};
+
+/**
+ * Determines if the plugin with name |name| exists in the browser.
+ * @param {string} name The name of the plugin.
+ * @param {Object array} plugins The plugins in this browser.
+ * @return {bool} |true| if the plugin is found.
+ */
+browser_version.BrowserChecker.prototype.pluginExists = function(name,
+                                                                 plugins) {
+  for (var index=0; index < plugins.length; index++) {
+    var plugin = this.plugins_[index];
+    var plugin_name = plugin['name'];
+    // If the plugin is not found, you can use the Javascript console
+    // to see the names of the plugins that were found when debugging.
+    if (plugin_name.indexOf(name) != -1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Returns browserSupportStatus_ which indicates if the browser supports
+ * Native Client.  Values are defined as literals in
+ * browser_version.BrowserChecker.StatusValues.
+ * @ return {int} Level of NaCl support.
+ */
+browser_version.BrowserChecker.prototype.getBrowserSupportStatus = function() {
+  return this.browserSupportStatus_;
+}
+
+/**
+ * Returns isValidBrowser (true/false) to indicate if the browser supports
+ * Native Client.
+ * @ return {bool} If this browser has NativeClient and correct version.
+ */
+browser_version.BrowserChecker.prototype.getIsValidBrowser = function() {
+  return this.isValidBrowser_;
+}
+
+/**
+ * Checks to see if this browser can support Native Client applications.
+ * For Chrome browsers, checks to see if the "Native Client" plugin is
+ * enabled.
+ */
+browser_version.BrowserChecker.prototype.checkBrowser = function() {
+  var versionPatt = /Chrome\/(\d+)\.(\d+)\.(\d+)\.(\d+)/;
+  var result = this.appVersion_.match(versionPatt);
+
+  // |result| stores the Chrome version number.
+  if (!result) {
+    this.isValidBrowser_ = false;
+    this.browserSupportStatus_ =
+        browser_version.BrowserChecker.StatusValues.UNKNOWN_BROWSER;
+  } else {
+    this.chromeVersion_ = result[1];
+    // We know we have Chrome, check version and/or plugin named Native Client
+    if (this.chromeVersion_ >= this.minChromeVersion_) {
+      var found_nacl = this.pluginExists('Native Client', this.plugins_);
+      if (found_nacl) {
+        this.isValidBrowser_ = true;
+        this.browserSupportStatus_ =
+            browser_version.BrowserChecker.StatusValues.NACL_ENABLED;
+      } else {
+        this.isValidBrowser_ = false;
+        this.browserSupportStatus_ =
+            browser_version.BrowserChecker.StatusValues.NACL_NOT_ENABLED;
+      }
+    } else {
+      // We are in a version that is less than |minChromeVersion_|
+      this.isValidBrowser_ = false;
+      this.browserSupportStatus_ =
+          browser_version.BrowserChecker.StatusValues.CHROME_VERSION_TOO_OLD;
+    }
+  }
+  var my_protocol = window.location.protocol;
+  if (my_protocol.indexOf('file') == 0) {
+    this.isValidBrowser_ = false;
+    this.browserSupportStatus_ =
+        browser_version.BrowserChecker.StatusValues.NOT_USING_SERVER;
+  }
+}
+
diff --git a/platform/nacl/html/godot_nacl.nmf b/platform/nacl/html/godot_nacl.nmf
new file mode 100644
index 0000000000..eca039ec1e
--- /dev/null
+++ b/platform/nacl/html/godot_nacl.nmf
@@ -0,0 +1,6 @@
+{
+  "program": {
+	"x86-64": {"url": "godot_nacl.x86_64.nexe"},
+	"x86-32": {"url": "godot_nacl.i686.nexe"}
+  }
+}
diff --git a/platform/nacl/html/icon_128.png b/platform/nacl/html/icon_128.png
new file mode 100644
index 0000000000..1793aa7e7a
--- /dev/null
+++ b/platform/nacl/html/icon_128.png
diff --git a/platform/nacl/html/icon_16.png b/platform/nacl/html/icon_16.png
new file mode 100644
index 0000000000..09de19e418
--- /dev/null
+++ b/platform/nacl/html/icon_16.png
diff --git a/platform/nacl/html/index.html b/platform/nacl/html/index.html
new file mode 100644
index 0000000000..e8be6f69b9
--- /dev/null
+++ b/platform/nacl/html/index.html
@@ -0,0 +1,258 @@
+<!DOCTYPE html>
+<html>
+  <!--
+  Copyright (c) 2011 The Native Client Authors. All rights reserved.
+  Use of this source code is governed by a BSD-style license that can be
+  found in the LICENSE file.
+  -->
+<head>
+  <title>Load Progress Example</title>
+  <script type="text/javascript" src="check_browser.js"></script>
+  <script type="text/javascript">
+	// Check for Native Client support in the browser before the DOM loads.
+	var isValidBrowser = false;
+	var browserSupportStatus = 0;
+	var checker = new browser_version.BrowserChecker(
+		14,  // Minumum Chrome version.
+		navigator["appVersion"],
+		navigator["plugins"]);
+	checker.checkBrowser();
+
+	loadProgressModule = null;  // Global application object.
+	statusText = 'NO-STATUS';
+
+	isValidBrowser = checker.getIsValidBrowser();
+	browserSupportStatus = checker.getBrowserSupportStatus();
+
+	// Handler that gets called when the NaCl module starts loading.  This
+	// event is always triggered when an <EMBED> tag has a MIME type of
+	// application/x-nacl.
+	function moduleDidStartLoad() {
+	  appendToEventLog('loadstart');
+	}
+
+	// Progress event handler.  |event| contains a couple of interesting
+	// properties that are used in this example:
+	//     total The size of the NaCl module in bytes.  Note that this value
+	//         is 0 until |lengthComputable| is true.  In particular, this
+	//         value is 0 for the first 'progress' event.
+	//     loaded The number of bytes loaded so far.
+	//     lengthComputable A boolean indicating that the |total| field
+	//         represents a valid length.
+	//
+	// event The ProgressEvent that triggered this handler.
+	function moduleLoadProgress(event) {
+	  var loadPercent = 0.0;
+	  var loadPercentString;
+	  if (event.lengthComputable && event.total > 0) {
+		loadPercent = event.loaded / event.total * 100.0;
+		loadPercentString = loadPercent + '%';
+	  } else {
+		// The total length is not yet known.
+		loadPercent = -1.0;
+		loadPercentString = 'Computing...';
+	  }
+	  //appendToEventLog('progress: ' + loadPercentString + ' (' + event.loaded + ' of ' + event.total + ' bytes)');
+		updateStatus("Loading module : "+ Math.floor(event.loaded / event.total * 100.0) + "% complete");
+	}
+
+	// Handler that gets called if an error occurred while loading the NaCl
+	// module.  Note that the event does not carry any meaningful data about
+	// the error, you have to check lastError on the <EMBED> element to find
+	// out what happened.
+	function moduleLoadError() {
+	  appendToEventLog('error: ' + loadProgressModule.lastError);
+	}
+
+	// Handler that gets called if the NaCl module load is aborted.
+	function moduleLoadAbort() {
+	  appendToEventLog('abort');
+	}
+
+	// When the NaCl module has loaded indicate success.
+	function moduleDidLoad() {
+	  loadProgressModule = document.getElementById('load_progress');
+	  appendToEventLog('load');
+	  updateStatus('SUCCESS');
+	}
+
+	function check_dl_status() {
+		var module = document.getElementById('load_progress');
+		module.postMessage("get_package_status");
+		module.postMessage(0);
+	};
+
+	// Handler that gets called when the NaCl module loading has completed.
+	// You will always get one of these events, regardless of whether the NaCl
+	// module loaded successfully or not.  For example, if there is an error
+	// during load, you will get an 'error' event and a 'loadend' event.  Note
+	// that if the NaCl module loads successfully, you will get both a 'load'
+	// event and a 'loadend' event.
+	function moduleDidEndLoad() {
+	  appendToEventLog('loadend');
+	  var lastError = event.target.lastError;
+	  if (lastError == undefined || lastError.length == 0) {
+		lastError = '&lt;none&gt;';
+		window.setTimeout(check_dl_status, 1000);
+	  }
+	  appendToEventLog('lastError: ' + lastError);
+	}
+
+
+	// Handle a message coming from the NaCl module.
+	function handleMessage(message_event) {
+		var data = message_event.data;
+		if (data == "loaded") {
+			updateStatus("Data Loaded!");
+		} else if (data == "none") {
+			// nothing
+			updateStatus("Downloading package: connecting");
+			window.setTimeout(check_dl_status, 1000);
+		} else {
+			updateStatus("Downloading package: " + data + " bytes");
+			window.setTimeout(check_dl_status, 1000);
+		};
+	}
+
+	// Set the global status message.  Updates the 'status_field' element with
+	// the new text.
+	// opt_message The message text.  If this is null or undefined, then
+	//     attempt to set the element with id 'status_field' to the value of
+	//     |statusText|.
+	function updateStatus(opt_message) {
+	  if (opt_message)
+		statusText = opt_message;
+	  var statusField = document.getElementById('status_field');
+	  if (statusField) {
+		statusField.innerHTML = statusText;
+	  }
+	}
+
+	// Append an event name to the 'event_log_field' element.  Event names
+	// are separated by a <br> tag so they get listed one per line.
+	// logMessage The message to append to the log.
+	function appendToEventLog(logMessage) {
+	  var eventLogField = document.getElementById('event_log_field');
+	  if (eventLogField.innerHTML.length == 0) {
+		eventLogField.innerHTML = logMessage;
+	  } else {
+		eventLogField.innerHTML = eventLogField.innerHTML +
+								  '<br />' +
+								  logMessage;
+	  }
+	}
+
+  </script>
+</head>
+<body bgcolor=#000000>
+
+<font color=#FFFFFF>
+
+<h1>Native Client Load Event Example</h1>
+
+<h2>Status</h2>
+<div id="status_field">NO-STATUS</div>
+
+<div id="listener">
+  <script type="text/javascript">
+	var listener = document.getElementById('listener');
+	listener.addEventListener('loadstart', moduleDidStartLoad, true);
+	listener.addEventListener('progress', moduleLoadProgress, true);
+	listener.addEventListener('error', moduleLoadError, true);
+	listener.addEventListener('abort', moduleLoadAbort, true);
+	listener.addEventListener('load', moduleDidLoad, true);
+	listener.addEventListener('loadend', moduleDidEndLoad, true);
+	listener.addEventListener('message', handleMessage, true);
+
+  switch (browserSupportStatus) {
+	case browser_version.BrowserChecker.StatusValues.NACL_ENABLED:
+	  appendToEventLog('Native Client plugin enabled.');
+	  break;
+	case browser_version.BrowserChecker.StatusValues.UNKNOWN_BROWSER:
+	  updateStatus('UNKNOWN BROWSER');
+	  break;
+	case browser_version.BrowserChecker.StatusValues.CHROME_VERSION_TOO_OLD:
+	  appendToEventLog(
+		  'Chrome too old: You must use Chrome version 14 or later.');
+	  updateStatus('NEED CHROME 14 OR LATER');
+	  break;
+	case browser_version.BrowserChecker.StatusValues.NACL_NOT_ENABLED:
+	  appendToEventLog(
+		  'NaCl disabled: Native Client is not enabled.<br>' +
+		  'Please go to <b>chrome://plugins</b> and enable Native Client ' +
+		  'plugin.');
+	  updateStatus('NaCl NOT ENABLED');
+	  break;
+	case browser_version.BrowserChecker.StatusValues.NOT_USING_SERVER:
+	  appendToEventLog(
+		  'file: URL detected, please use a web server to host Native ' +
+		  'Client applications.');
+	  updateStatus('NaCl NOT ENABLED');
+	default:
+	  appendToEventLog('Unknown error: Unable to detect browser and/or ' +
+					   'Native Client support.');
+	  updateStatus('UNKNOWN ERROR');
+	  break;
+	}
+  </script>
+
+  <!-- Load the published .nexe.  This includes the 'src' attribute which
+  shows how to load multi-architecture modules.  Each entry in the "nexes"
+  object in the  .nmf manifest file is a key-value pair: the key is the runtime
+  ('x86-32', 'x86-64', etc.); the value is a URL for the desired NaCl module.
+  To load the debug versions of your .nexes, set the 'src' attribute to the
+  _dbg.nmf version of the manifest file.
+
+  Note: The <EMBED> element is wrapped inside a <DIV>, which has both a 'load'
+  and a 'message' event listener attached.  This wrapping method is used
+  instead of attaching the event listeners directly to the <EMBED> element to
+  ensure that the listeners are active before the NaCl module 'load' event
+  fires.  This also allows you to use PPB_Messaging.PostMessage() (in C) or
+  pp::Instance.PostMessage() (in C++) from within the initialization code in
+  your NaCl module.
+  -->
+  <embed name="nacl_module"
+		 id="load_progress"
+		 width=1024 height=600
+		 src="godot_nacl.nmf"
+		 type="application/x-nacl"
+		 package="data.pcz"
+		 arg1="-path" arg2="."
+		 no_arg1="-test" no_arg2="gui" />
+
+  <script type="text/javascript">
+	loadProgressModule = document.getElementById('load_progress');
+	// Futher diagnose NaCl loading.
+	if (loadProgressModule == null ||
+		typeof loadProgressModule.readyState == 'undefined') {
+	  switch (browserSupportStatus) {
+		case browser_version.BrowserChecker.StatusValues.NACL_ENABLED:
+		  // The NaCl plugin is enabled and running, it's likely that the flag
+		  // isn't set.
+		  appendToEventLog(
+			  'NaCl flag disabled: The Native Client flag is not enabled.<br>' +
+			  'Please go to <b>chrome://flags</b> enable Native Client and ' +
+			  'relaunch your browser.  See also: ' +
+			  '<a href="http://code.google.com/chrome/nativeclient/docs/' +
+			  'running.html">Running Web Applications that Use Native Client' +
+			  '</a>');
+		  updateStatus('NaCl NOT ENABLED');
+		  break;
+		case browser_version.BrowserChecker.StatusValues.UNKNOWN_BROWSER:
+		  appendToEventLog('Native Client applications are not supported by ' +
+						   'this browser.');
+		  break;
+		default:
+		  appendToEventLog('Unknown error when loading Native Client ' +
+						   'application.');
+	  }
+	}
+  </script>
+</div>
+
+<h2>Event Log</h2>
+<div id="event_log_field">event log?</div>
+
+</body>
+</html>
+
diff --git a/platform/nacl/html/manifest.json b/platform/nacl/html/manifest.json
new file mode 100644
index 0000000000..6e271507a9
--- /dev/null
+++ b/platform/nacl/html/manifest.json
@@ -0,0 +1,19 @@
+{
+  "name": "Capsuleman's Castle Adventure",
+  "description": "Capsuleman's Castle Adventure",
+  "version": "1",
+  "app": {
+	"launch": {
+	  "local_path": "index.html"
+	}
+  },
+  "icons": {
+	"16": "icon_16.png",
+	"128": "icon_128.png"
+  },
+  "permissions": [
+	"unlimitedStorage",
+	"notifications",
+	"experimental"
+  ]
+}
diff --git a/platform/nacl/logo.png b/platform/nacl/logo.png
new file mode 100644
index 0000000000..aac72c01b2
--- /dev/null
+++ b/platform/nacl/logo.png
diff --git a/platform/nacl/nacl_keycodes.h b/platform/nacl/nacl_keycodes.h
new file mode 100644
index 0000000000..1cbf379078
--- /dev/null
+++ b/platform/nacl/nacl_keycodes.h
@@ -0,0 +1,422 @@
+/*************************************************************************/
+/*  nacl_keycodes.h                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+ * Copyright (C) 2006 Michael Emmel mike.emmel@gmail.com. All rights reserved.
+ * Copyright (C) 2008, 2009 Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR
+ * PROFITS, OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BASE_KEYBOARD_CODES_POSIX_H_
+#define BASE_KEYBOARD_CODES_POSIX_H_
+#pragma once
+
+#include "core/os/keyboard.h"
+
+enum {
+  VKEY_BACK = 0x08,
+  VKEY_TAB = 0x09,
+  VKEY_CLEAR = 0x0C,
+  VKEY_RETURN = 0x0D,
+  VKEY_SHIFT = 0x10,
+  VKEY_CONTROL = 0x11,
+  VKEY_MENU = 0x12,
+  VKEY_PAUSE = 0x13,
+  VKEY_CAPITAL = 0x14,
+  VKEY_KANA = 0x15,
+  VKEY_HANGUL = 0x15,
+  VKEY_JUNJA = 0x17,
+  VKEY_FINAL = 0x18,
+  VKEY_HANJA = 0x19,
+  VKEY_KANJI = 0x19,
+  VKEY_ESCAPE = 0x1B,
+  VKEY_CONVERT = 0x1C,
+  VKEY_NONCONVERT = 0x1D,
+  VKEY_ACCEPT = 0x1E,
+  VKEY_MODECHANGE = 0x1F,
+  VKEY_SPACE = 0x20,
+  VKEY_PRIOR = 0x21,
+  VKEY_NEXT = 0x22,
+  VKEY_END = 0x23,
+  VKEY_HOME = 0x24,
+  VKEY_LEFT = 0x25,
+  VKEY_UP = 0x26,
+  VKEY_RIGHT = 0x27,
+  VKEY_DOWN = 0x28,
+  VKEY_SELECT = 0x29,
+  VKEY_PRINT = 0x2A,
+  VKEY_EXECUTE = 0x2B,
+  VKEY_SNAPSHOT = 0x2C,
+  VKEY_INSERT = 0x2D,
+  VKEY_DELETE = 0x2E,
+  VKEY_HELP = 0x2F,
+  VKEY_0 = 0x30,
+  VKEY_1 = 0x31,
+  VKEY_2 = 0x32,
+  VKEY_3 = 0x33,
+  VKEY_4 = 0x34,
+  VKEY_5 = 0x35,
+  VKEY_6 = 0x36,
+  VKEY_7 = 0x37,
+  VKEY_8 = 0x38,
+  VKEY_9 = 0x39,
+  VKEY_A = 0x41,
+  VKEY_B = 0x42,
+  VKEY_C = 0x43,
+  VKEY_D = 0x44,
+  VKEY_E = 0x45,
+  VKEY_F = 0x46,
+  VKEY_G = 0x47,
+  VKEY_H = 0x48,
+  VKEY_I = 0x49,
+  VKEY_J = 0x4A,
+  VKEY_K = 0x4B,
+  VKEY_L = 0x4C,
+  VKEY_M = 0x4D,
+  VKEY_N = 0x4E,
+  VKEY_O = 0x4F,
+  VKEY_P = 0x50,
+  VKEY_Q = 0x51,
+  VKEY_R = 0x52,
+  VKEY_S = 0x53,
+  VKEY_T = 0x54,
+  VKEY_U = 0x55,
+  VKEY_V = 0x56,
+  VKEY_W = 0x57,
+  VKEY_X = 0x58,
+  VKEY_Y = 0x59,
+  VKEY_Z = 0x5A,
+  VKEY_LWIN = 0x5B,
+  VKEY_COMMAND = VKEY_LWIN,  // Provide the Mac name for convenience.
+  VKEY_RWIN = 0x5C,
+  VKEY_APPS = 0x5D,
+  VKEY_SLEEP = 0x5F,
+  VKEY_NUMPAD0 = 0x60,
+  VKEY_NUMPAD1 = 0x61,
+  VKEY_NUMPAD2 = 0x62,
+  VKEY_NUMPAD3 = 0x63,
+  VKEY_NUMPAD4 = 0x64,
+  VKEY_NUMPAD5 = 0x65,
+  VKEY_NUMPAD6 = 0x66,
+  VKEY_NUMPAD7 = 0x67,
+  VKEY_NUMPAD8 = 0x68,
+  VKEY_NUMPAD9 = 0x69,
+  VKEY_MULTIPLY = 0x6A,
+  VKEY_ADD = 0x6B,
+  VKEY_SEPARATOR = 0x6C,
+  VKEY_SUBTRACT = 0x6D,
+  VKEY_DECIMAL = 0x6E,
+  VKEY_DIVIDE = 0x6F,
+  VKEY_F1 = 0x70,
+  VKEY_F2 = 0x71,
+  VKEY_F3 = 0x72,
+  VKEY_F4 = 0x73,
+  VKEY_F5 = 0x74,
+  VKEY_F6 = 0x75,
+  VKEY_F7 = 0x76,
+  VKEY_F8 = 0x77,
+  VKEY_F9 = 0x78,
+  VKEY_F10 = 0x79,
+  VKEY_F11 = 0x7A,
+  VKEY_F12 = 0x7B,
+  VKEY_F13 = 0x7C,
+  VKEY_F14 = 0x7D,
+  VKEY_F15 = 0x7E,
+  VKEY_F16 = 0x7F,
+  VKEY_F17 = 0x80,
+  VKEY_F18 = 0x81,
+  VKEY_F19 = 0x82,
+  VKEY_F20 = 0x83,
+  VKEY_F21 = 0x84,
+  VKEY_F22 = 0x85,
+  VKEY_F23 = 0x86,
+  VKEY_F24 = 0x87,
+  VKEY_NUMLOCK = 0x90,
+  VKEY_SCROLL = 0x91,
+  VKEY_LSHIFT = 0xA0,
+  VKEY_RSHIFT = 0xA1,
+  VKEY_LCONTROL = 0xA2,
+  VKEY_RCONTROL = 0xA3,
+  VKEY_LMENU = 0xA4,
+  VKEY_RMENU = 0xA5,
+  VKEY_BROWSER_BACK = 0xA6,
+  VKEY_BROWSER_FORWARD = 0xA7,
+  VKEY_BROWSER_REFRESH = 0xA8,
+  VKEY_BROWSER_STOP = 0xA9,
+  VKEY_BROWSER_SEARCH = 0xAA,
+  VKEY_BROWSER_FAVORITES = 0xAB,
+  VKEY_BROWSER_HOME = 0xAC,
+  VKEY_VOLUME_MUTE = 0xAD,
+  VKEY_VOLUME_DOWN = 0xAE,
+  VKEY_VOLUME_UP = 0xAF,
+  VKEY_MEDIA_NEXT_TRACK = 0xB0,
+  VKEY_MEDIA_PREV_TRACK = 0xB1,
+  VKEY_MEDIA_STOP = 0xB2,
+  VKEY_MEDIA_PLAY_PAUSE = 0xB3,
+  VKEY_MEDIA_LAUNCH_MAIL = 0xB4,
+  VKEY_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5,
+  VKEY_MEDIA_LAUNCH_APP1 = 0xB6,
+  VKEY_MEDIA_LAUNCH_APP2 = 0xB7,
+  VKEY_OEM_1 = 0xBA,
+  VKEY_OEM_PLUS = 0xBB,
+  VKEY_OEM_COMMA = 0xBC,
+  VKEY_OEM_MINUS = 0xBD,
+  VKEY_OEM_PERIOD = 0xBE,
+  VKEY_OEM_2 = 0xBF,
+  VKEY_OEM_3 = 0xC0,
+  VKEY_OEM_4 = 0xDB,
+  VKEY_OEM_5 = 0xDC,
+  VKEY_OEM_6 = 0xDD,
+  VKEY_OEM_7 = 0xDE,
+  VKEY_OEM_8 = 0xDF,
+  VKEY_OEM_102 = 0xE2,
+  VKEY_PROCESSKEY = 0xE5,
+  VKEY_PACKET = 0xE7,
+  VKEY_ATTN = 0xF6,
+  VKEY_CRSEL = 0xF7,
+  VKEY_EXSEL = 0xF8,
+  VKEY_EREOF = 0xF9,
+  VKEY_PLAY = 0xFA,
+  VKEY_ZOOM = 0xFB,
+  VKEY_NONAME = 0xFC,
+  VKEY_PA1 = 0xFD,
+  VKEY_OEM_CLEAR = 0xFE,
+  VKEY_UNKNOWN = 0
+};
+
+static uint32_t godot_key(uint32_t p_key, bool& is_char) {
+
+	is_char = false;
+
+	switch (p_key) {
+
+	case VKEY_BACK: return KEY_BACKSPACE;
+	case VKEY_TAB: return KEY_TAB;
+	case VKEY_CLEAR: return KEY_CLEAR;
+	case VKEY_RETURN: return KEY_RETURN;
+	case VKEY_SHIFT: return KEY_SHIFT;
+	case VKEY_CONTROL: return KEY_CONTROL;
+	case VKEY_MENU: return KEY_MENU;
+	case VKEY_PAUSE: return KEY_PAUSE;
+//	case VKEY_CAPITAL: return KEY_CAPITAL;
+//	case VKEY_KANA: return KEY_KANA;
+//	case VKEY_HANGUL: return KEY_HANGUL;
+//	case VKEY_JUNJA: return KEY_JUNJA;
+//	case VKEY_FINAL: return KEY_FINAL;
+//	case VKEY_HANJA: return KEY_HANJA;
+//	case VKEY_KANJI: return KEY_KANJI;
+	case VKEY_ESCAPE: return KEY_ESCAPE;
+//	case VKEY_CONVERT: return KEY_CONVERT;
+//	case VKEY_NONCONVERT: return KEY_NONCONVERT;
+//	case VKEY_ACCEPT: return KEY_ACCEPT;
+//	case VKEY_MODECHANGE: return KEY_MODECHANGE;
+//	case VKEY_PRIOR: return KEY_PRIOR;
+//	case VKEY_NEXT: return KEY_NEXT;
+	case VKEY_END: return KEY_END;
+	case VKEY_HOME: return KEY_HOME;
+	case VKEY_LEFT: return KEY_LEFT;
+	case VKEY_UP: return KEY_UP;
+	case VKEY_RIGHT: return KEY_RIGHT;
+	case VKEY_DOWN: return KEY_DOWN;
+//	case VKEY_SELECT: return KEY_SELECT;
+	case VKEY_PRINT: return KEY_PRINT;
+//	case VKEY_EXECUTE: return KEY_EXECUTE;
+//	case VKEY_SNAPSHOT: return KEY_SNAPSHOT;
+	case VKEY_INSERT: return KEY_INSERT;
+	case VKEY_DELETE: return KEY_DELETE;
+	case VKEY_HELP: return KEY_HELP;
+//	case VKEY_LWIN: return KEY_LWIN;
+//	case VKEY_RWIN: return KEY_RWIN;
+//	case VKEY_APPS: return KEY_APPS;
+//	case VKEY_SLEEP: return KEY_SLEEP;
+	case VKEY_NUMPAD0: return KEY_KP_0;
+	case VKEY_NUMPAD1: return KEY_KP_1;
+	case VKEY_NUMPAD2: return KEY_KP_2;
+	case VKEY_NUMPAD3: return KEY_KP_3;
+	case VKEY_NUMPAD4: return KEY_KP_4;
+	case VKEY_NUMPAD5: return KEY_KP_5;
+	case VKEY_NUMPAD6: return KEY_KP_6;
+	case VKEY_NUMPAD7: return KEY_KP_7;
+	case VKEY_NUMPAD8: return KEY_KP_8;
+	case VKEY_NUMPAD9: return KEY_KP_9;
+	case VKEY_MULTIPLY: return KEY_KP_MULTIPLY;
+	case VKEY_ADD: return KEY_KP_ADD;
+//	case VKEY_SEPARATOR: return KEY_SEPARATOR;
+	case VKEY_SUBTRACT: return KEY_KP_SUBSTRACT;
+	case VKEY_DECIMAL: return KEY_KP_PERIOD;
+	case VKEY_DIVIDE: return KEY_KP_DIVIDE;
+	case VKEY_F1: return KEY_F1;
+	case VKEY_F2: return KEY_F2;
+	case VKEY_F3: return KEY_F3;
+	case VKEY_F4: return KEY_F4;
+	case VKEY_F5: return KEY_F5;
+	case VKEY_F6: return KEY_F6;
+	case VKEY_F7: return KEY_F7;
+	case VKEY_F8: return KEY_F8;
+	case VKEY_F9: return KEY_F9;
+	case VKEY_F10: return KEY_F10;
+	case VKEY_F11: return KEY_F11;
+	case VKEY_F12: return KEY_F12;
+	case VKEY_F13: return KEY_F13;
+	case VKEY_F14: return KEY_F14;
+	case VKEY_F15: return KEY_F15;
+	case VKEY_F16: return KEY_F16;
+	/*
+	case VKEY_F17: return KEY_F17;
+	case VKEY_F18: return KEY_F18;
+	case VKEY_F19: return KEY_F19;
+	case VKEY_F20: return KEY_F20;
+	case VKEY_F21: return KEY_F21;
+	case VKEY_F22: return KEY_F22;
+	case VKEY_F23: return KEY_F23;
+	case VKEY_F24: return KEY_F24;
+	*/
+	case VKEY_NUMLOCK: return KEY_NUMLOCK;
+	case VKEY_SCROLL: return KEY_SCROLLLOCK;
+	case VKEY_LSHIFT: return KEY_SHIFT;
+	case VKEY_RSHIFT: return KEY_SHIFT;
+	case VKEY_LCONTROL: return KEY_CONTROL;
+	case VKEY_RCONTROL: return KEY_CONTROL;
+	case VKEY_LMENU: return KEY_MENU;
+	case VKEY_RMENU: return KEY_MENU;
+	case VKEY_BROWSER_BACK: return KEY_BACK;
+	case VKEY_BROWSER_FORWARD: return KEY_FORWARD;
+	case VKEY_BROWSER_REFRESH: return KEY_REFRESH;
+	case VKEY_BROWSER_STOP: return KEY_STOP;
+	case VKEY_BROWSER_SEARCH: return KEY_SEARCH;
+	case VKEY_BROWSER_FAVORITES: return KEY_FAVORITES;
+	case VKEY_BROWSER_HOME: return KEY_HOMEPAGE;
+	case VKEY_VOLUME_MUTE: return KEY_VOLUMEMUTE;
+	case VKEY_VOLUME_DOWN: return KEY_VOLUMEDOWN;
+	case VKEY_VOLUME_UP: return KEY_VOLUMEUP;
+	case VKEY_MEDIA_NEXT_TRACK: return KEY_MEDIANEXT;
+	case VKEY_MEDIA_PREV_TRACK: return KEY_MEDIAPREVIOUS;
+	case VKEY_MEDIA_STOP: return KEY_MEDIASTOP;
+	case VKEY_MEDIA_PLAY_PAUSE: return KEY_MEDIAPLAY;
+	case VKEY_MEDIA_LAUNCH_MAIL: return KEY_LAUNCHMAIL;
+	case VKEY_MEDIA_LAUNCH_MEDIA_SELECT: return KEY_LAUNCHMEDIA; // FUCKING USELESS KEYS, HOW DO THEY WORK?
+	case VKEY_MEDIA_LAUNCH_APP1: return KEY_LAUNCH0;
+	case VKEY_MEDIA_LAUNCH_APP2: return KEY_LAUNCH0;
+//	case VKEY_OEM_102: return KEY_OEM_102;
+//	case VKEY_PROCESSKEY: return KEY_PROCESSKEY;
+//	case VKEY_PACKET: return KEY_PACKET;
+//	case VKEY_ATTN: return KEY_ATTN;
+//	case VKEY_CRSEL: return KEY_CRSEL;
+//	case VKEY_EXSEL: return KEY_EXSEL;
+//	case VKEY_EREOF: return KEY_EREOF;
+//	case VKEY_PLAY: return KEY_PLAY;
+//	case VKEY_ZOOM: return KEY_ZOOM;
+//	case VKEY_NONAME: return KEY_NONAME;
+//	case VKEY_PA1: return KEY_PA1;
+//	case VKEY_OEM_CLEAR: return KEY_OEM_CLEAR;
+
+	default: break;
+	};
+
+	is_char = true;
+
+	switch (p_key) {
+
+	case VKEY_SPACE: return KEY_SPACE;
+	case VKEY_0: return KEY_0;
+	case VKEY_1: return KEY_1;
+	case VKEY_2: return KEY_2;
+	case VKEY_3: return KEY_3;
+	case VKEY_4: return KEY_4;
+	case VKEY_5: return KEY_5;
+	case VKEY_6: return KEY_6;
+	case VKEY_7: return KEY_7;
+	case VKEY_8: return KEY_8;
+	case VKEY_9: return KEY_9;
+	case VKEY_A: return KEY_A;
+	case VKEY_B: return KEY_B;
+	case VKEY_C: return KEY_C;
+	case VKEY_D: return KEY_D;
+	case VKEY_E: return KEY_E;
+	case VKEY_F: return KEY_F;
+	case VKEY_G: return KEY_G;
+	case VKEY_H: return KEY_H;
+	case VKEY_I: return KEY_I;
+	case VKEY_J: return KEY_J;
+	case VKEY_K: return KEY_K;
+	case VKEY_L: return KEY_L;
+	case VKEY_M: return KEY_M;
+	case VKEY_N: return KEY_N;
+	case VKEY_O: return KEY_O;
+	case VKEY_P: return KEY_P;
+	case VKEY_Q: return KEY_Q;
+	case VKEY_R: return KEY_R;
+	case VKEY_S: return KEY_S;
+	case VKEY_T: return KEY_T;
+	case VKEY_U: return KEY_U;
+	case VKEY_V: return KEY_V;
+	case VKEY_W: return KEY_W;
+	case VKEY_X: return KEY_X;
+	case VKEY_Y: return KEY_Y;
+	case VKEY_Z: return KEY_Z;
+	/*
+	case VKEY_OEM_PLUS: return KEY_PLUS;
+	case VKEY_OEM_COMMA: return KEY_COMMA;
+	case VKEY_OEM_MINUS: return KEY_MINUS;
+	case VKEY_OEM_PERIOD: return KEY_PERIOD;
+	case VKEY_OEM_1: return KEY_OEM_1;
+	case VKEY_OEM_2: return KEY_OEM_2;
+	case VKEY_OEM_3: return KEY_OEM_3;
+	case VKEY_OEM_4: return KEY_OEM_4;
+	case VKEY_OEM_5: return KEY_OEM_5;
+	case VKEY_OEM_6: return KEY_OEM_6;
+	case VKEY_OEM_7: return KEY_OEM_7;
+	case VKEY_OEM_8: return KEY_OEM_8;
+	*/
+	default: break;
+
+	};
+
+	return 0;
+};
+
+#endif  // BASE_KEYBOARD_CODES_POSIX_H_
diff --git a/platform/nacl/opengl_context.cpp b/platform/nacl/opengl_context.cpp
new file mode 100644
index 0000000000..8dafe959a3
--- /dev/null
+++ b/platform/nacl/opengl_context.cpp
@@ -0,0 +1,123 @@
+/*************************************************************************/
+/*  opengl_context.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "opengl_context.h"
+
+#include <pthread.h>
+#include "ppapi/gles2/gl2ext_ppapi.h"
+#include "os_nacl.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/module.h"
+#include "ppapi/cpp/completion_callback.h"
+#include "ppapi/utility/completion_callback_factory.h"
+
+
+namespace {
+// This is called by the brower when the 3D context has been flushed to the
+// browser window.
+void FlushCallback(void* data, int32_t result) {
+  static_cast<OpenGLContext*>(data)->set_flush_pending(false);
+  static_cast<OpenGLContext*>(data)->FlushContext();
+}
+}  // namespace
+
+OpenGLContext::OpenGLContext(pp::Instance* p_instance)
+	: pp::Graphics3DClient(p_instance),
+      flush_pending_(false) {
+
+  instance = p_instance;
+  pp::Module* module = pp::Module::Get();
+  assert(module);
+  gles2_interface_ = static_cast<const struct PPB_OpenGLES2_Dev*>(
+	  module->GetBrowserInterface(PPB_OPENGLES2_INTERFACE));
+  assert(gles2_interface_);
+}
+
+OpenGLContext::~OpenGLContext() {
+  glSetCurrentContextPPAPI(0);
+}
+
+bool OpenGLContext::MakeContextCurrent(pp::Instance* instance) {
+
+  if (instance == NULL) {
+    glSetCurrentContextPPAPI(0);
+    return false;
+  }
+  // Lazily create the Pepper context.
+  if (context_.is_null()) {
+	int32_t attribs[] = {
+		PP_GRAPHICS3DATTRIB_ALPHA_SIZE, 8,
+		PP_GRAPHICS3DATTRIB_DEPTH_SIZE, 24,
+		PP_GRAPHICS3DATTRIB_STENCIL_SIZE, 8,
+		PP_GRAPHICS3DATTRIB_SAMPLES, 0,
+		PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS, 0,
+		PP_GRAPHICS3DATTRIB_WIDTH, width,
+		PP_GRAPHICS3DATTRIB_HEIGHT, height,
+		PP_GRAPHICS3DATTRIB_NONE
+	};
+
+	context_ = pp::Graphics3D(instance, pp::Graphics3D(), attribs);
+	if (context_.is_null()) {
+      glSetCurrentContextPPAPI(0);
+      return false;
+    }
+	instance->BindGraphics(context_);
+  }
+  glSetCurrentContextPPAPI(context_.pp_resource());
+  return true;
+}
+
+void OpenGLContext::ResizeContext(const pp::Size& size) {
+
+	width = size.width();
+	height = size.height();
+
+	if (!context_.is_null()) {
+		context_.ResizeBuffers(size.width(), size.height());
+	}
+}
+
+
+void OpenGLContext::InvalidateContext(pp::Instance* instance) {
+  glSetCurrentContextPPAPI(0);
+}
+
+void OpenGLContext::FlushContext() {
+  if (flush_pending()) {
+    // A flush is pending so do nothing; just drop this flush on the floor.
+    return;
+  }
+  set_flush_pending(true);
+
+	OSNacl* os = (OSNacl*)OS::get_singleton();
+	MakeContextCurrent(instance);
+	os->iterate();
+
+  context_.SwapBuffers(pp::CompletionCallback(&FlushCallback, this));
+}
+
diff --git a/platform/nacl/opengl_context.h b/platform/nacl/opengl_context.h
new file mode 100644
index 0000000000..b0431f29bf
--- /dev/null
+++ b/platform/nacl/opengl_context.h
@@ -0,0 +1,124 @@
+/*************************************************************************/
+/*  opengl_context.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#ifndef EXAMPLES_TUMBLER_OPENGL_CONTEXT_H_
+#define EXAMPLES_TUMBLER_OPENGL_CONTEXT_H_
+
+///
+/// @file
+/// OpenGLContext manages the OpenGL context in the browser that is associated
+/// with a @a pp::Instance instance.
+///
+
+#include <pthread.h>
+
+#include <algorithm>
+#include <string>
+
+#include "ppapi/c/ppb_opengles2.h"
+//#include "ppapi/cpp/dev/context_3d_dev.h"
+#include "ppapi/cpp/graphics_3d_client.h"
+#include "ppapi/cpp/graphics_3d.h"
+//#include "ppapi/cpp/dev/surface_3d_dev.h"
+#include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/size.h"
+
+// A convenience wrapper for a shared OpenGLContext pointer type.  As other
+// smart pointer types are needed, add them here.
+
+#include <tr1/memory>
+
+class OpenGLContext;
+
+typedef std::tr1::shared_ptr<OpenGLContext> SharedOpenGLContext;
+
+/// OpenGLContext manages an OpenGL rendering context in the browser.
+///
+class OpenGLContext : public pp::Graphics3DClient {
+ public:
+  explicit OpenGLContext(pp::Instance* instance);
+
+  /// Release all the in-browser resources used by this context, and make this
+  /// context invalid.
+  virtual ~OpenGLContext();
+
+  /// The Graphics3DClient interfcace.
+  virtual void Graphics3DContextLost() {
+    assert(!"Unexpectedly lost graphics context");
+  }
+
+  /// Make @a this the current 3D context in @a instance.
+  /// @param instance The instance of the NaCl module that will receive the
+  ///                 the current 3D context.
+  /// @return success.
+  bool MakeContextCurrent(pp::Instance* instance);
+
+  /// Flush the contents of this context to the browser's 3D device.
+  void FlushContext();
+
+  /// Make the underlying 3D device invalid, so that any subsequent rendering
+  /// commands will have no effect.  The next call to MakeContextCurrent() will
+  /// cause the underlying 3D device to get rebound and start receiving
+  /// receiving rendering commands again.  Use InvalidateContext(), for
+  /// example, when resizing the context's viewing area.
+  void InvalidateContext(pp::Instance* instance);
+
+  void ResizeContext(const pp::Size& size);
+
+  /// The OpenGL ES 2.0 interface.
+  const struct PPB_OpenGLES2_Dev* gles2() const {
+    return gles2_interface_;
+  }
+
+  /// The PP_Resource needed to make GLES2 calls through the Pepper interface.
+  const PP_Resource gl_context() const {
+    return context_.pp_resource();
+  }
+
+  /// Indicate whether a flush is pending.  This can only be called from the
+  /// main thread; it is not thread safe.
+  bool flush_pending() const {
+    return flush_pending_;
+  }
+  void set_flush_pending(bool flag) {
+    flush_pending_ = flag;
+  }
+
+ private:
+  pp::Graphics3D context_;
+  bool flush_pending_;
+
+  int width, height;
+
+  pp::Instance* instance;
+
+  const struct PPB_OpenGLES2_Dev* gles2_interface_;
+};
+
+#endif  // EXAMPLES_TUMBLER_OPENGL_CONTEXT_H_
+
diff --git a/platform/nacl/os_nacl.cpp b/platform/nacl/os_nacl.cpp
new file mode 100644
index 0000000000..d97195c50d
--- /dev/null
+++ b/platform/nacl/os_nacl.cpp
@@ -0,0 +1,529 @@
+/*************************************************************************/
+/*  os_nacl.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include "os_nacl.h"
+
+#include "drivers/unix/memory_pool_static_malloc.h"
+#include "os/memory_pool_dynamic_static.h"
+#include "main/main.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <time.h>
+
+#include "io/file_access_memory.h"
+#include "core/io/file_access_pack.h"
+#include "scene/io/scene_loader.h"
+#include "scene/main/scene_main_loop.h"
+
+#include "servers/visual/visual_server_raster.h"
+
+#include "drivers/gles2/rasterizer_gles2.h"
+#include "nacl_keycodes.h"
+
+#include "core/globals.h"
+#include "core/input_map.h"
+
+#include <ppapi/cpp/point.h>
+#include <ppapi/cpp/var.h>
+
+#define UNIX_ENABLED
+#include "drivers/unix/thread_posix.h"
+#include "drivers/unix/semaphore_posix.h"
+#include "drivers/unix/mutex_posix.h"
+
+
+int OSNacl::get_video_driver_count() const {
+
+	return 1;
+};
+const char * OSNacl::get_video_driver_name(int p_driver) const {
+
+	return "gles2";
+};
+
+OS::VideoMode OSNacl::get_default_video_mode() const {
+
+	return OS::VideoMode(800,600,false);
+};
+
+int OSNacl::get_audio_driver_count() const {
+
+	return 1;
+};
+
+const char * OSNacl::get_audio_driver_name(int p_driver) const {
+
+	return "nacl_audio";
+};
+
+static MemoryPoolStaticMalloc *mempool_static=NULL;
+static MemoryPoolDynamicStatic *mempool_dynamic=NULL;
+
+void OSNacl::initialize_core() {
+
+	ticks_start=0;
+	ticks_start=get_ticks_usec();
+};
+
+void OSNacl::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
+
+	rasterizer = memnew( RasterizerGLES2 );
+	visual_server = memnew( VisualServerRaster(rasterizer) );
+	visual_server->init();
+	visual_server->cursor_set_visible(false, 0);
+
+	audio_driver = memnew(AudioDriverNacl);
+	audio_driver->set_singleton();
+	audio_driver->init();
+
+	sample_manager = memnew( SampleManagerMallocSW );
+	audio_server = memnew( AudioServerSW(sample_manager) );
+	audio_server->set_mixer_params(AudioMixerSW::INTERPOLATION_LINEAR,false);
+	audio_server->init();
+
+	spatial_sound_server = memnew( SpatialSoundServerSW );
+	spatial_sound_server->init();
+
+	spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
+	spatial_sound_2d_server->init();
+
+	//
+	physics_server = memnew( PhysicsServerSW );
+	physics_server->init();
+
+	physics_2d_server = memnew( Physics2DServerSW );
+	physics_2d_server->init();
+
+    input = memnew(InputDefault);
+};
+
+void OSNacl::set_main_loop( MainLoop * p_main_loop ) {
+
+	main_loop = p_main_loop;
+    input->set_main_loop(p_main_loop);
+    main_loop->init();
+};
+
+void OSNacl::delete_main_loop() {
+
+	if (main_loop)
+		memdelete(main_loop);
+};
+
+void OSNacl::finalize() {
+
+
+};
+void OSNacl::finalize_core() {
+
+	if (mempool_dynamic)
+		memdelete( mempool_dynamic );
+	if (mempool_static)
+		delete mempool_static;
+
+};
+
+void OSNacl::alert(const String& p_alert,const String& p_title) {
+
+	fprintf(stderr,"ERROR: %s\n",p_alert.utf8().get_data());
+};
+
+void OSNacl::vprint(const char* p_format, va_list p_list, bool p_strerr) {
+
+	vprintf(p_format,p_list);
+	fflush(stdout);
+}
+
+
+String OSNacl::get_stdin_string(bool p_block) {
+
+	char buff[1024];
+	return fgets(buff,1024,stdin);
+};
+
+void OSNacl::set_mouse_show(bool p_show) {
+
+};
+
+void OSNacl::set_mouse_grab(bool p_grab) {
+
+};
+
+bool OSNacl::is_mouse_grab_enabled() const {
+
+	return false;
+};
+
+int OSNacl::get_mouse_button_state() const {
+
+	return mouse_mask;
+};
+
+
+Point2 OSNacl::get_mouse_pos() const {
+
+	return Point2();
+};
+
+void OSNacl::set_window_title(const String& p_title) {
+};
+
+void OSNacl::set_video_mode(const VideoMode& p_video_mode, int p_screen) {
+
+	video_mode = p_video_mode;
+};
+
+OS::VideoMode OSNacl::get_video_mode(int p_screen) const {
+
+	return video_mode;
+};
+
+void OSNacl::get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen) const {
+
+};
+
+Error OSNacl::execute(const String& p_path, const List<String>& p_arguments,bool p_blocking, OS::ProcessID *r_child_id, String* r_pipe, int *r_exitcode) {
+
+	return ERR_UNAVAILABLE;
+};
+
+Error OSNacl::kill(const ProcessID& p_pid) {
+
+	return ERR_UNAVAILABLE;
+};
+
+bool OSNacl::has_environment(const String& p_var) const {
+
+	return getenv(p_var.utf8().get_data())!=NULL;
+};
+
+String OSNacl::get_environment(const String& p_var) const {
+
+	if (getenv(p_var.utf8().get_data()))
+		return getenv(p_var.utf8().get_data());
+	return "";
+};
+
+String OSNacl::get_name() {
+
+	return "NaCl";
+};
+
+MainLoop *OSNacl::get_main_loop() const {
+
+	return main_loop;
+};
+
+OS::Date OSNacl::get_date() const {
+
+	time_t t=time(NULL);
+	struct tm *lt=localtime(&t);
+	Date ret;
+	ret.year=lt->tm_year;
+	ret.month=(Month)lt->tm_mon;
+	ret.day=lt->tm_mday;
+	ret.weekday=(Weekday)lt->tm_wday;
+	ret.dst=lt->tm_isdst;
+
+	return ret;
+};
+
+OS::Time OSNacl::get_time() const {
+
+	time_t t=time(NULL);
+	struct tm *lt=localtime(&t);
+	Time ret;
+	ret.hour=lt->tm_hour;
+	ret.min=lt->tm_min;
+	ret.sec=lt->tm_sec;
+	return ret;
+};
+
+void OSNacl::delay_usec(uint32_t p_usec) const {
+
+	//usleep(p_usec);
+};
+
+uint64_t OSNacl::get_ticks_usec() const {
+
+	struct timeval tv_now;
+	gettimeofday(&tv_now,NULL);
+
+	uint64_t longtime = (uint64_t)tv_now.tv_usec + (uint64_t)tv_now.tv_sec*1000000L;
+	longtime-=ticks_start;
+
+	return longtime;
+};
+
+bool OSNacl::can_draw() const {
+
+	return minimized != true;
+};
+
+void OSNacl::queue_event(const InputEvent& p_event) {
+
+	ERR_FAIL_INDEX( event_count, MAX_EVENTS );
+
+	event_queue[event_count++] = p_event;
+};
+
+void OSNacl::add_package(String p_name, Vector<uint8_t> p_data) {
+
+	FileAccessMemory::register_file(p_name, p_data);
+    FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_RESOURCES);
+    FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_USERDATA);
+    FileAccess::make_default<FileAccessMemory>(FileAccess::ACCESS_FILESYSTEM);
+
+    if (!PackedData::get_singleton())
+        memnew(PackedData);
+
+    printf("adding package %ls, %x\n", p_name.c_str(), PackedData::get_singleton());
+    PackedData::get_singleton()->set_disabled(true);
+    PackedData::get_singleton()->add_pack(p_name);
+    PackedData::get_singleton()->set_disabled(false);
+    printf("added\n");
+};
+
+void OSNacl::set_cursor_shape(CursorShape p_shape) {
+
+
+};
+
+String OSNacl::get_resource_dir() const {
+
+    return ".";
+};
+
+static int mouse_button(int p_nacl_but) {
+
+	switch (p_nacl_but) {
+
+	case PP_INPUTEVENT_MOUSEBUTTON_LEFT:
+		return BUTTON_LEFT;
+	case PP_INPUTEVENT_MOUSEBUTTON_MIDDLE:
+		return BUTTON_MIDDLE;
+	case PP_INPUTEVENT_MOUSEBUTTON_RIGHT:
+		return BUTTON_RIGHT;
+	};
+
+	return 0;
+};
+
+static InputModifierState modifier(uint32_t p_mod) {
+
+	InputModifierState mod_mask;
+
+	mod_mask.shift = p_mod & PP_INPUTEVENT_MODIFIER_SHIFTKEY;
+	mod_mask.alt = p_mod & PP_INPUTEVENT_MODIFIER_ALTKEY;
+	mod_mask.control = p_mod & PP_INPUTEVENT_MODIFIER_CONTROLKEY;
+	mod_mask.meta = p_mod & PP_INPUTEVENT_MODIFIER_METAKEY;
+
+	return mod_mask;
+};
+
+
+
+void OSNacl::handle_event(const pp::InputEvent& p_event) {
+
+	int type = p_event.GetType();
+	switch (type) {
+
+	case PP_INPUTEVENT_TYPE_MOUSEDOWN:
+	case PP_INPUTEVENT_TYPE_MOUSEUP:
+	case PP_INPUTEVENT_TYPE_WHEEL: {
+
+		InputEvent event;
+		event.ID=++event_id;
+		event.type = InputEvent::MOUSE_BUTTON;
+		event.device=0;
+
+		pp::MouseInputEvent mevent(p_event);
+		if (type == PP_INPUTEVENT_TYPE_WHEEL) {
+
+			pp::WheelInputEvent wevent(p_event);;
+			float ticks = wevent.GetTicks().y();
+			if (ticks == 0)
+				break; // whut?
+
+			event.mouse_button.pressed = true;
+			event.mouse_button.button_index = ticks > 0 ? BUTTON_WHEEL_UP : BUTTON_WHEEL_DOWN;
+			event.mouse_button.doubleclick = false;
+
+		} else {
+
+			event.mouse_button.pressed = (type == PP_INPUTEVENT_TYPE_MOUSEDOWN);
+			event.mouse_button.button_index = mouse_button(mevent.GetButton());
+			event.mouse_button.doubleclick = (mevent.GetClickCount() % 2) == 0;
+
+			mouse_mask &= ~(1<< (event.mouse_button.button_index - 1));
+			mouse_mask |= (event.mouse_button.pressed << (event.mouse_button.button_index - 1));
+		};
+		pp::Point pos = mevent.GetPosition();
+		event.mouse_button.button_mask = mouse_mask;
+		event.mouse_button.global_x = pos.x();
+		event.mouse_button.x = pos.x();
+		event.mouse_button.global_y = pos.y();
+		event.mouse_button.y = pos.y();
+		event.mouse_button.pointer_index = 0;
+		event.mouse_button.mod = modifier(p_event.GetModifiers());
+		queue_event(event);
+
+	} break;
+
+	case PP_INPUTEVENT_TYPE_MOUSEMOVE: {
+
+		pp::MouseInputEvent mevent(p_event);
+		pp::Point pos = mevent.GetPosition();
+
+		InputEvent event;
+		event.ID=++event_id;
+		event.type = InputEvent::MOUSE_MOTION;
+		event.mouse_motion.pointer_index = 0;
+		event.mouse_motion.global_x = pos.x();
+		event.mouse_motion.global_y = pos.y();
+		event.mouse_motion.x = pos.x();
+		event.mouse_motion.y = pos.y();
+		event.mouse_motion.button_mask = mouse_mask;
+		event.mouse_motion.mod = modifier(p_event.GetModifiers());
+
+		event.mouse_motion.relative_x = pos.x() - mouse_last_x;
+		event.mouse_motion.relative_y = pos.y() - mouse_last_y;
+		mouse_last_x = pos.x();
+		mouse_last_y = pos.y();
+
+		queue_event(event);
+
+	} break;
+
+	case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
+	case PP_INPUTEVENT_TYPE_KEYDOWN:
+	case PP_INPUTEVENT_TYPE_KEYUP: {
+
+		pp::KeyboardInputEvent kevent(p_event);
+		bool is_char;
+		uint32_t key = godot_key(kevent.GetKeyCode(), is_char);
+		if (type != PP_INPUTEVENT_TYPE_KEYUP && is_char) {
+
+			last_scancode = key;
+			break;
+		};
+
+		InputEvent event;
+		event.ID=++event_id;
+		event.type = InputEvent::KEY;
+		event.key.pressed = (type != PP_INPUTEVENT_TYPE_KEYUP);
+		event.key.scancode = key;
+		event.key.unicode = key;
+
+		event.key.echo = p_event.GetModifiers() & PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT;
+		event.key.mod = modifier(p_event.GetModifiers());
+		queue_event(event);
+	} break;
+
+	case PP_INPUTEVENT_TYPE_CHAR: {
+
+		pp::KeyboardInputEvent kevent(p_event);
+		InputEvent event;
+		event.ID = ++event_id;
+		event.type = InputEvent::KEY;
+		event.key.pressed = true;
+		event.key.scancode = last_scancode;
+		event.key.unicode = kevent.GetCharacterText().AsString().c_str()[0];
+		event.key.mod = modifier(p_event.GetModifiers());
+		event.key.echo = p_event.GetModifiers() & PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT;
+		queue_event(event);
+
+	} break;
+
+	/*
+	case NPEventType_Minimize: {
+
+		minimized = p_event->u.minimize.value == 1;
+
+	} break;
+
+
+	case NPEventType_Focus: {
+
+		if (p_event->u.focus.value == 1) {
+			main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
+		} else {
+			main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
+		};
+	} break;
+
+	*/
+
+	default:
+		;
+	};
+};
+
+bool OSNacl::iterate() {
+
+	if (!main_loop) {
+		event_count = 0;
+		return true;
+	};
+
+	for (int i=0; i<event_count; i++) {
+
+        input->parse_input_event(event_queue[i]);
+	};
+
+	event_count = 0;
+
+	return Main::iteration();
+};
+
+
+OSNacl::OSNacl() {
+
+	main_loop=NULL;
+	mempool_dynamic = NULL;
+	mempool_static = NULL;
+	mouse_last_x = 0;
+	mouse_last_y = 0;
+	event_count = 0;
+	event_id = 0;
+	mouse_mask = 0;
+	video_mode = get_default_video_mode();
+	last_scancode = 0;
+	minimized = false;
+
+	ThreadPosix::make_default();
+	SemaphorePosix::make_default();
+	MutexPosix::make_default();
+	mempool_static = new MemoryPoolStaticMalloc;
+	mempool_dynamic = memnew( MemoryPoolDynamicStatic );
+};
+
+OSNacl::~OSNacl() {
+
+};
diff --git a/platform/nacl/os_nacl.h b/platform/nacl/os_nacl.h
new file mode 100644
index 0000000000..b8173ef61c
--- /dev/null
+++ b/platform/nacl/os_nacl.h
@@ -0,0 +1,156 @@
+/*************************************************************************/
+/*  os_nacl.h                                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#ifndef OS_NACL_H
+#define OS_NACL_H
+
+#include "core/os/os.h"
+
+#include "servers/visual_server.h"
+#include "servers/visual/rasterizer.h"
+#include "servers/physics/physics_server_sw.h"
+#include "servers/spatial_sound/spatial_sound_server_sw.h"
+#include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h"
+#include "servers/audio/audio_server_sw.h"
+#include "servers/physics_2d/physics_2d_server_sw.h"
+#include "audio_driver_nacl.h"
+#include "os/input.h"
+
+
+#include <ppapi/cpp/input_event.h>
+
+class OSNacl : OS {
+
+	uint64_t ticks_start;
+
+protected:
+
+	enum {
+		MAX_EVENTS = 64,
+	};
+
+	MainLoop *main_loop;
+
+	Rasterizer *rasterizer;
+	VisualServer *visual_server;
+	PhysicsServer *physics_server;
+	SpatialSoundServerSW *spatial_sound_server;
+
+	AudioServerSW *audio_server;
+	SampleManagerMallocSW *sample_manager;
+	SpatialSound2DServerSW *spatial_sound_2d_server;
+	Physics2DServer *physics_2d_server;
+	AudioDriverNacl* audio_driver;
+
+
+	// functions used by main to initialize/deintialize the OS
+	virtual int get_video_driver_count() const;
+	virtual const char * get_video_driver_name(int p_driver) const;
+
+	virtual VideoMode get_default_video_mode() const;
+
+	virtual int get_audio_driver_count() const;
+	virtual const char * get_audio_driver_name(int p_driver) const;
+
+	void vprint(const char* p_format, va_list p_list, bool p_stderr);
+
+	virtual void initialize_core();
+	virtual void initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver);
+
+	virtual void set_main_loop( MainLoop * p_main_loop );
+	virtual void delete_main_loop();
+
+	virtual void finalize();
+	virtual void finalize_core();
+
+	int mouse_last_x, mouse_last_y;
+
+	InputEvent event_queue[MAX_EVENTS];
+	int event_count;
+	void queue_event(const InputEvent& p_event);
+
+	int event_id;
+	uint32_t mouse_mask;
+
+	uint32_t last_scancode;
+
+	bool minimized;
+
+	VideoMode video_mode;
+
+    InputDefault *input;
+
+public:
+
+	void add_package(String p_name, Vector<uint8_t> p_data);
+
+	void handle_event(const pp::InputEvent& p_event);
+
+	virtual void alert(const String& p_alert,const String& p_title);
+	virtual String get_stdin_string(bool p_block);
+
+	virtual void set_mouse_show(bool p_show);
+	virtual void set_mouse_grab(bool p_grab);
+	virtual bool is_mouse_grab_enabled() const;
+	virtual Point2 get_mouse_pos() const;
+	virtual int get_mouse_button_state() const;
+	virtual void set_window_title(const String& p_title);
+
+	virtual void set_video_mode(const VideoMode& p_video_mode,int p_screen);
+	virtual VideoMode get_video_mode(int p_screen) const;
+	virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen) const;
+
+    virtual Error execute(const String& p_path, const List<String>& p_arguments,bool p_blocking,ProcessID *r_child_id=NULL,String* r_pipe=NULL,int *r_exitcode=NULL);
+	virtual Error kill(const ProcessID& p_pid);
+
+	virtual bool has_environment(const String& p_var) const;
+	virtual String get_environment(const String& p_var) const;
+
+	virtual void set_cursor_shape(CursorShape p_shape);
+
+	virtual String get_name();
+
+	virtual MainLoop *get_main_loop() const;
+
+	virtual Date get_date() const;
+	virtual Time get_time() const;
+
+	virtual void delay_usec(uint32_t p_usec) const;
+	virtual uint64_t get_ticks_usec() const;
+
+    virtual String get_resource_dir() const;
+
+	virtual bool can_draw() const;
+
+	bool iterate();
+
+	OSNacl();
+	~OSNacl();
+};
+
+#endif // OS_NACL_H
diff --git a/platform/nacl/pepper_main.cpp b/platform/nacl/pepper_main.cpp
new file mode 100644
index 0000000000..6a1f4acbe7
--- /dev/null
+++ b/platform/nacl/pepper_main.cpp
@@ -0,0 +1,541 @@
+/*************************************************************************/
+/*  pepper_main.cpp                                                      */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+ IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.
+ ("Apple") in consideration of your agreement to the following terms, and
+ your use, installation, modification or redistribution of this Apple software
+ constitutes acceptance of these terms.  If you do not agree with these terms,
+ please do not use, install, modify or redistribute this Apple software.
+
+ In consideration of your agreement to abide by the following terms, and
+ subject to these terms, Apple grants you a personal, non-exclusive license,
+ under Apple's copyrights in this original Apple software
+ (the "Apple Software"), to use, reproduce, modify and redistribute the Apple
+ Software, with or without modifications, in source and/or binary forms;
+ provided that if you redistribute the Apple Software in its entirety and
+ without modifications, you must retain this notice and the following text and
+ disclaimers in all such redistributions of the Apple Software.  Neither the
+ name, trademarks, service marks or logos of Apple Computer, Inc. may be used
+ to endorse or promote products derived from the Apple Software without
+ specific prior written permission from Apple. Except as expressly stated in
+ this notice, no other rights or licenses, express or implied, are granted by
+ Apple herein, including but not limited to any patent rights that may be
+ infringed by your derivative works or by other works in which the Apple
+ Software may be incorporated.
+
+ The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO
+ WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
+ WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
+ COMBINATION WITH YOUR PRODUCTS.
+
+ IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION
+ AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER
+ THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR
+ OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+
+#include "os_nacl.h"
+#include <GLES2/gl2.h>
+
+#include <nacl/npupp.h>
+#include <pgl/pgl.h>
+#include <string.h>
+#include <stdint.h>
+
+static NPNetscapeFuncs kBrowserFuncs = { 0 };
+static NPNetscapeFuncs* browser = &kBrowserFuncs;
+
+static NPDevice* device3d_ = NULL;
+static PGLContext pgl_context_;
+static NPDeviceContext3D context3d_;
+static int width_;
+static int height_;
+
+extern int nacl_main(int argc, char** argn, char** argv);
+extern void nacl_cleanup();
+
+NPExtensions* extensions = NULL;
+static NPP npp_;
+
+const int32_t kCommandBufferSize = 1024 * 1024;
+
+// Plugin entry points
+extern "C" {
+
+// Plugin entry points
+
+// Entrypoints -----------------------------------------------------------------
+
+NPError NP_GetEntryPoints(NPPluginFuncs* plugin_funcs) {
+  plugin_funcs->version = 11;
+  plugin_funcs->size = sizeof(plugin_funcs);
+  plugin_funcs->newp = NPP_New;
+  plugin_funcs->destroy = NPP_Destroy;
+  plugin_funcs->setwindow = NPP_SetWindow;
+  plugin_funcs->newstream = NPP_NewStream;
+  plugin_funcs->destroystream = NPP_DestroyStream;
+  plugin_funcs->asfile = NPP_StreamAsFile;
+  plugin_funcs->writeready = NPP_WriteReady;
+  plugin_funcs->write = (NPP_WriteUPP)NPP_Write;
+  plugin_funcs->print = NPP_Print;
+  plugin_funcs->event = NPP_HandleEvent;
+  plugin_funcs->urlnotify = NPP_URLNotify;
+  plugin_funcs->getvalue = NPP_GetValue;
+  plugin_funcs->setvalue = NPP_SetValue;
+
+  return NPERR_NO_ERROR;
+}
+
+NPError NP_Shutdown() {
+  pglTerminate();
+  return NPERR_NO_ERROR;
+}
+
+NPError NP_GetValue(void* instance, NPPVariable variable, void* value);
+char* NP_GetMIMEDescription();
+
+NPError NP_Initialize(NPNetscapeFuncs* browser_funcs,
+							NPPluginFuncs* plugin_funcs) {
+	printf("NPP_Initialize\n");
+  memcpy(&kBrowserFuncs, browser_funcs, sizeof(kBrowserFuncs));
+  pglInitialize();
+  return NP_GetEntryPoints(plugin_funcs);
+}
+
+
+}  // extern "C"
+
+void Initialize3D() {
+	// Initialize a 3D context.
+	NPDeviceContext3DConfig config;
+	config.commandBufferSize = kCommandBufferSize;
+	NPError err = device3d_->initializeContext(npp_, &config, &context3d_);
+	if (err != NPERR_NO_ERROR) {
+		printf("Failed to initialize 3D context\n");
+		exit(1);
+	}
+
+	// Create a PGL context.
+	pgl_context_ = pglCreateContext(npp_, device3d_, &context3d_);
+
+	// Initialize the demo GL state.
+	//pglMakeCurrent(pgl_context_);
+	//GLFromCPPInit();
+	//pglMakeCurrent(NULL);
+}
+
+NPError NPP_New(NPMIMEType pluginType,
+                NPP instance,
+				uint16_t mode,
+				int16_t argc, char* argn[], char* argv[],
+                NPSavedData* saved) {
+	printf("NPP_New\n");
+	if (browser->version >= 14) {
+
+		npp_ = instance;
+		if (!extensions) {
+			browser->getvalue(npp_, NPNVPepperExtensions,
+			reinterpret_cast<void*>(&extensions));
+			// CHECK(extensions);
+		}
+
+		printf("%s: %i\n", __FUNCTION__, __LINE__);
+
+		device3d_ = extensions->acquireDevice(npp_, NPPepper3DDevice);
+		if (device3d_ == NULL) {
+			printf("Failed to acquire 3DDevice\n");
+			exit(1);
+		}
+		printf("%s: %i\n", __FUNCTION__, __LINE__);
+
+		/*
+		deviceaudio_ = extensions->acquireDevice(npp_, NPPepperAudioDevice);
+		if (deviceaudio_ == NULL) {
+			printf("Failed to acquire AudioDevice\n");
+			exit(1);
+		}
+		*/
+		Initialize3D();
+		pglMakeCurrent(pgl_context_);
+		nacl_main(argc, argn, argv);
+		pglMakeCurrent(NULL);
+	};
+
+  return NPERR_NO_ERROR;
+}
+
+NPError NPP_Destroy(NPP instance, NPSavedData** save) {
+
+	nacl_cleanup();
+	
+	return NPERR_NO_ERROR;
+}
+
+void Destroy3D() {
+	printf("destroy 3d\n");
+	// Destroy the PGL context.
+	pglDestroyContext(pgl_context_);
+	pgl_context_ = NULL;
+
+	// Destroy the Device3D context.
+	device3d_->destroyContext(npp_, &context3d_);
+}
+
+static void iteration(void* data) {
+
+	(void)data;
+	OSNacl* os = (OSNacl*)OS::get_singleton();
+
+	if (!pglMakeCurrent(pgl_context_) && pglGetError() == PGL_CONTEXT_LOST) {
+		printf("******* Lost context! :O\n");
+		Destroy3D();
+		Initialize3D();
+		pglMakeCurrent(pgl_context_);
+	}
+
+	glViewport(0, 0, width_, height_);
+
+	os->iterate();
+
+	pglSwapBuffers();
+	pglMakeCurrent(NULL);
+
+	browser->pluginthreadasynccall(npp_, iteration, NULL);
+};
+
+NPError NPP_SetWindow(NPP instance, NPWindow* window) {
+
+	width_ = window->width;
+	height_ = window->height;
+
+	if (!pgl_context_)
+		Initialize3D();
+
+	// Schedule the first call to Draw.
+	OSNacl* os = (OSNacl*)OS::get_singleton();
+	OS::VideoMode vm;
+	vm.width = width_;
+	vm.height = height_;
+	vm.resizable = false;
+	vm.fullscreen = false;
+	os->set_video_mode(vm);
+
+	browser->pluginthreadasynccall(npp_, iteration, NULL);
+
+	return NPERR_NO_ERROR;
+}
+
+NPError NPP_NewStream(NPP instance,
+                      NPMIMEType type,
+                      NPStream* stream,
+                      NPBool seekable,
+					  uint16_t* stype) {
+  *stype = NP_ASFILEONLY;
+  return NPERR_NO_ERROR;
+}
+
+NPError NPP_DestroyStream(NPP instance, NPStream* stream, NPReason reason) {
+  return NPERR_NO_ERROR;
+}
+
+void NPP_StreamAsFile(NPP instance, NPStream* stream, const char* fname) {
+}
+
+int32_t NPP_Write(NPP instance,
+                NPStream* stream,
+				int32_t offset,
+				int32_t len,
+                void* buffer) {
+  return 0;
+}
+
+int32_t NPP_WriteReady(NPP instance, NPStream* stream) {
+  return 0;
+}
+
+void NPP_Print(NPP instance, NPPrint* platformPrint) {
+}
+
+int16_t NPP_HandleEvent(NPP instance, void* event) {
+
+	OSNacl* os = (OSNacl*)OS::get_singleton();
+	os->handle_event(event);
+	return 1;
+}
+
+void NPP_URLNotify(NPP instance,
+                   const char* url,
+                   NPReason reason,
+                   void* notify_data) {
+  // PluginObject* obj = static_cast<PluginObject*>(instance->pdata);
+}
+
+static NPObject* Allocate(NPP npp, NPClass* npclass) {
+  return new NPObject;
+}
+
+static void Deallocate(NPObject* object) {
+  delete object;
+}
+
+// Return |true| if |method_name| is a recognized method.
+static bool HasMethod(NPObject* obj, NPIdentifier method_name) {
+
+  char *name = NPN_UTF8FromIdentifier(method_name);
+  bool is_method = false;
+  if (strcmp((const char *)name, "start_package") == 0) {
+	is_method = true;
+  } else if (strcmp((const char*)name, "add_package_chunk") == 0) {
+	is_method = true;
+  } else if (strcmp((const char*)name, "end_package") == 0) {
+	is_method = true;
+  } else if (strcmp((const char*)name, "start_scene") == 0) {
+	is_method = true;
+  }
+  NPN_MemFree(name);
+  return is_method;
+}
+
+// I don't know what this is
+static bool InvokeDefault(NPObject *obj, const NPVariant *args,
+						  uint32_t argCount, NPVariant *result) {
+  if (result) {
+	NULL_TO_NPVARIANT(*result);
+  }
+  return true;
+}
+
+static uint8_t* mem = NULL;
+static int pkg_size = 0;
+static String pkgname;
+
+static bool variant_is_number(const NPVariant& v) {
+
+	switch (v.type) {
+
+	case NPVariantType_Int32:
+	case NPVariantType_Double:
+		return true;
+
+	default:
+		return false;
+	}
+	return false;
+};
+
+static double variant_as_number(const NPVariant& v) {
+
+	switch (v.type) {
+
+	case NPVariantType_Int32:
+		return (double)v.value.intValue;
+	case NPVariantType_Double:
+		return (double)v.value.doubleValue;
+	default:
+		return 0;
+	}
+
+	return 0;
+};
+
+// Invoke() is called by the browser to invoke a function object whose name
+// is |method_name|.
+static bool Invoke(NPObject* obj,
+				   NPIdentifier method_name,
+				   const NPVariant *args,
+				   uint32_t arg_count,
+				   NPVariant *result) {
+  NULL_TO_NPVARIANT(*result);
+  char *name = NPN_UTF8FromIdentifier(method_name);
+  if (name == NULL)
+	return false;
+  bool rval = false;
+
+  OSNacl* os = (OSNacl*)OS::get_singleton();
+
+  if (strcmp(name, "start_package") == 0) {
+
+	  printf("arg count is %i\n", arg_count);
+	  for (int i=0; i<arg_count; i++) {
+		  printf("type for %i is %i\n", i, args[i].type);
+	  }
+	  if (arg_count != 2) {
+		  return false;	// assuming "false" means error
+	  };
+
+	  if (args[0].type != NPVariantType_String) {
+		  printf("arg 0 not string type %i\n", args[1].type);
+		  return false;
+	  };
+
+	  if (!variant_is_number(args[1])) {
+
+		  printf("arg 1 not number, type %i\n", args[1].type);
+		  return false;
+	  };
+
+	  pkgname = String::utf8(args[0].value.stringValue.UTF8Characters, args[0].value.stringValue.UTF8Length);
+	  pkg_size = (int)variant_as_number(args[1]);
+	  mem = (uint8_t*)malloc(pkg_size);
+
+	  printf("args %ls, %lf\n", pkgname.c_str(), variant_as_number(args[1]));
+
+	  return true;
+  };
+
+  if (strcmp(name, "add_package_chunk") == 0) {
+
+	  if (arg_count != 3) { // assuming arg_count starts from 1
+		  return false;	// assuming "false" means error
+	  };
+
+	  if (!variant_is_number(args[0])) return false;
+	  if (args[1].type != NPVariantType_String) return false;
+	  if (!variant_is_number(args[2])) return false;
+
+	  if (!mem)
+		  return false;
+
+	  int ofs = variant_as_number(args[0]);
+	  int len = variant_as_number(args[2]);
+
+	  String s;
+	  if (s.parse_utf8(args[1].value.stringValue.UTF8Characters, args[1].value.stringValue.UTF8Length)) {
+		  printf("error parsing?\n");
+	  };
+	  uint8_t* dst = mem + ofs;
+	  for (int i=0; i<len; i++) {
+
+		  dst[i] = s[i];
+	  };
+
+	  //memcpy(mem + ofs, args[1].value.stringValue.UTF8Characters, len);
+	  return true;
+  };
+
+  if (strcmp(name, "end_package") == 0) {
+
+	  os->add_package(pkgname, mem, pkg_size);
+	  return true;
+  };
+
+
+  if (strcmp(name, "start_scene") == 0) {
+printf("start_scene!\n");
+	  if (arg_count != 1) {
+		  return false;
+	  };
+
+	  if (args[0].type != NPVariantType_String) return false;
+printf("calling with param %s\n", args[0].value.stringValue.UTF8Characters);
+
+	printf("pepper iteration\n");
+	if (!pglMakeCurrent(pgl_context_) && pglGetError() == PGL_CONTEXT_LOST) {
+		printf("******* Lost context! :O\n");
+		Destroy3D();
+		Initialize3D();
+		pglMakeCurrent(pgl_context_);
+	}
+	os->start_scene(String::utf8(args[0].value.stringValue.UTF8Characters));
+	pglSwapBuffers();
+	pglMakeCurrent(NULL);
+
+printf("returning true\n");
+	  return true;
+  };
+
+  NPN_MemFree(name);
+
+  return rval;
+}
+
+
+static NPClass GodotClass = {
+  NP_CLASS_STRUCT_VERSION,
+  Allocate,
+  Deallocate,
+  NULL,  // Invalidate is not implemented
+  HasMethod,
+  Invoke,
+  InvokeDefault,
+  NULL,  // HasProperty is not implemented
+  NULL,  // GetProperty is not implemented
+  NULL,  // SetProperty is not implemented
+};
+
+static NPObject* npobject = NULL;
+
+NPError NPP_GetValue(NPP instance, NPPVariable variable, void* value) {
+  NPError err = NPERR_NO_ERROR;
+
+  switch (variable) {
+    case NPPVpluginNameString:
+      *(reinterpret_cast<const char**>(value)) = "Pepper Test PlugIn";
+      break;
+    case NPPVpluginDescriptionString:
+      *(reinterpret_cast<const char**>(value)) =
+          "Simple Pepper plug-in for manual testing.";
+      break;
+    case NPPVpluginNeedsXEmbed:
+	  *(reinterpret_cast<NPBool*>(value)) = 1;
+      break;
+	case NPPVpluginScriptableNPObject: {
+	  if (npobject == NULL) {
+		  npobject = NPN_CreateObject(instance, &GodotClass);
+	  } else {
+		  NPN_RetainObject(npobject);
+	  };
+	  void** v = reinterpret_cast<void**>(value);
+	  *v = npobject;
+	} break;
+    default:
+      fprintf(stderr, "Unhandled variable to NPP_GetValue\n");
+      err = NPERR_GENERIC_ERROR;
+      break;
+  }
+
+  return err;
+}
+
+NPError NPP_SetValue(NPP instance, NPNVariable variable, void* value) {
+  return NPERR_GENERIC_ERROR;
+}
+
+NPError NP_GetValue(void* instance, NPPVariable variable, void* value) {
+  return NPP_GetValue(reinterpret_cast<NPP>(instance), variable, value);
+}
+
+char* NP_GetMIMEDescription() {
+  return const_cast<char*>("pepper-application/x-pepper-test-plugin;");
+}
diff --git a/platform/nacl/platform_config.h b/platform/nacl/platform_config.h
new file mode 100644
index 0000000000..38fc934ae4
--- /dev/null
+++ b/platform/nacl/platform_config.h
@@ -0,0 +1,29 @@
+/*************************************************************************/
+/*  platform_config.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+#include <alloca.h>