• Google is performance-obsessed
• 3 years ago:
  • What if we could run native code in the browser?
• Retain good parts of the web:
  • portability, security ease, reach, etc.
• Leverage bazillions of lines of existing C[++] code
• Ultimately replace insecure NPAPI plugins

• Run untrusted x86 code safely in Chrome
• Fully sandboxed
• No system API access
• May only call blessed "Pepper" APIs

• Box2D: NaCl roughly 10x faster than best Javascript
  • Often closer to 20x for hand-written JS
  • Oddly, best JS results are for C++ cross-compiled to JS (!)
• Flocking Geese benchmark

• Same model as web
• Not NPAPI or ActiveX
• Can only call Pepper APIs
• Double-sandbox:
  • Proof-carrying code
  • Chrome renderer sandbox

• Accelerated 3d rendering
• Real-time stereo audio
• Sandboxed local file storage
• Full-screen, mouse-lock
• Networking
• URL loading
• Async communication with Javascript
• Shared-memory threads
• Dynamic linking
• GNU libc

• Games
• 3D modeling, CAD
• Media editing (photo/video/audio)
• Scientific computing (any heavy number crunching)

• Chrome 14+ (Current is 17)
• Not all machines support 3D rendering (see below)
• Enabled when:
  • Command-line flag (for developers)
  • Triggered by Chrome Web Store

• Bastion (Supergiant)
• Mini Ninjas (Square Enix)
• Cordy & Sleepy Jack (SilverTree Media)
• Pirates of New Horizons & Planet Buster (Exit Strategy Entertainment)
• Various 3D Training tools (Heartwood Studios)
• Lots of emulators — MAME, DOSBox, etc.

• 3D MMO for Android 2.0
• Ported to NaCl in 14 days
  • 1 programmer, 600k lines of code
• Runs across Android, iOS, & NaCl

• Through Chrome Web Store
• Monetize with:
  • Ads
  • In-app purchase
  • Checkout
• Or through Chrome Extension

• Make C++ code ISO/IEC 14882:1998 compliant
  • POSIX style coding / functions
  • OS specific calls not supported
• Removes / tests any unsafe code
• Produces safe compiled x86 code

• OpenGL ES 2.0
• Remember this is stricter than full OpenGL
  • Not all extensions available
  • But the same as most iOS and Android devices
• Can use ANGLE to test on Windows

• Straightforward low-level audio API
  • Stereo
  • Real-time
• More info

• Send messages to NaCl:

   myAppModule.postMessage('w00t?'); 

• Receive messages from NaCl:

   myAppModule.addEventListener('message', messageFunc, false); 

• Send messages to Javascript:

  pp::Var var;
  this->PostMessage(var);
                 

• Handle messages from Javascript:

   void MyAppInstance::HandleMessage(const pp::Var& var_message) { ... } 

• More info

• Just like in Javascript, resource loading is async
• pp:URLLoader() makes this relatively painless

                void MyInstance::StartRequest(const std::string& url) {
                  loader_ = pp::URLLoader(this);
                  loader_.Open(request, factory_.NewRequiredCallback(&MyInstance::OnOpenComplete));
                }
  
                void MyInstance::OnOpenComplete(int32_t result) {
                  response_ = loader_.GetResponseInfo();
  
                  // etc.
                }
                

• Do not call blocking functions on the main thread!

• Pepper APIs calls are Asynchronous
  • ~1 'frame' to get results
• Must be called from the main thread [will be fixed soon]

• This is not how your game engine is designed
• Best idea?
  • Run game logic on separate thread
  • Wrap platform functions to talk with main thread.

  static int32_t RequestAndWait(void (*function)(void*, int32_t), void* param) {
    ASSERT_WORKER_THREAD()
    pp::Module::Get()->core()->CallOnMainThread(0,
        pp::CompletionCallback(function, param), PP_OK);
    pthread_cond_wait(&gData_.cond, &gData_.mutex);
    return data_.result;
  }

  static void ReturnFromMainThread(void* void_data, int32_t result) {
    ASSERT_MAIN_THREAD();
    MainThreadData* data = static_cast<MainThreadData*>(void_data);
    data->result = result;
    pthread_cond_signal(&data->cond);
  }
          

• Disable caching for fast iteration
• Chrome dev tools
  • Debugging network issues, HTML/JS parts of the game, console

• Trace of Chrome rendering internals
• Can emit events from user code!
• Load/Save traces

• Possible to use GDB, though still tricky
  • chromium.org/nativeclient/how-tos/debuggingtips
• Better debugging support and IDE integration coming soon

• 3D APIs can be malicious in the web
• WebGL has a 'blacklist' of 3d drivers
  • Failure to create a webgl context
• Detect early and alert user!

  // Has blacklisted hardware / feature sets?
  function textureSizeTest(size) {
    var canvas = document.createElement('canvas');
    var gl = canvas.getContext('webgl') ||
             canvas.getContext('experimental-webgl');
    if (gl)
      return gl.getParameter(gl.MAX_TEXTURE_SIZE) >= size;
  }
          

• Nacl not enabled until :
  • Devs - enable via flags
  • Users - Install from Chrome Web Store
• Origin of Location white listed
  • NMF and Nexe loc must match!

  // Is using chrome?
  var is_chrome = navigator.userAgent.toLowerCase().indexOf('chrome') > -1;

  // Is app installed?
  if (window.chrome.app.isInstalled)
    // You're running as an installed app, via the app launcher!
  else
    // You're running via a bookmark/link.
          

• Web sockets
• Gamepad support
• Memory-mapped files
• Track all new web features as they're added to Chrome

• "Portable Native Client"
• Already OS-neutral. pNaCl makes it instruction-set neutral
• Uses LLVM bitcode rather than x86
  • Just as portable as Javascript
• Chrome Web Store restriction lifted

• Developer documentation
• Colt McAnlis' GDC Talk