native_client_sdk/src/doc/overview.rst

   1 .. _overview:
   2
   3 ##################
   4 Technical Overview
   5 ##################
   6
   7 .. contents::
   8   :local:
   9   :backlinks: none
  10   :depth: 2
  11
  12 Introduction
  13 ============
  14
  15 **Native Client** (NaCl) is an open-source technology for running native
  16 compiled code in the browser, with the goal of maintaining the portability
  17 and safety that users expect from web applications. Native Client expands web
  18 programming beyond JavaScript, enabling developers to enhance their web
  19 applications using their preferred language. This document describes some of
  20 the key benefits and common use cases of Native Client.
  21
  22 Google has implemented the open-source `Native Client project
  23 <http://www.chromium.org/nativeclient>`_ in the Chrome browser on Windows, Mac,
  24 Linux, and Chrome OS. The :doc:`Native Client Software Development Kit (SDK)
  25 <sdk/download>`, itself an open-source project, lets developers create web
  26 applications that use NaCl and run in Chrome across multiple platforms.
  27
  28 A web application that uses Native Client generally consists of a combination of
  29 JavaScript, HTML, CSS, and a NaCl module that is written in a language supported
  30 by the SDK. The NaCl SDK currently supports C and C++; as compilers for
  31 additional languages are developed, the SDK will be updated to support those
  32 languages as well.
  33
  34 .. image:: /images/web-app-with-nacl.png
  35
  36 Why use Native Client?
  37 ======================
  38
  39 Native Client open-source technology is designed to run compiled code
  40 securely inside a browser at near-native speeds. Native Client puts web
  41 applications on the same playing field as desktop software---it provides the
  42 means to fully harness the client's computational resources for applications
  43 such as 3D games, multimedia editors, CAD modeling,
  44 client-side data analytics, and interactive simulations.
  45 Native Client also aims to give C and C++ (and eventually other languages) the
  46 same level of portability and safety that JavaScript provides on the web today.
  47
  48 Important benefits of Native Client include:
  49
  50 * **Graphics, audio, and much more:** Running native code modules that render 2D
  51   and 3D graphics, play audio, respond to mouse and keyboard events, run on
  52   multiple threads, and access memory directly---all without requiring
  53   the user to install a plugin.
  54 * **Portability:** Writing your applications once and running them on operating
  55   systems (Windows, Linux, Mac, and Chrome OS) and CPU architectures (x86 and
  56   ARM).
  57 * **Easy migration path to the web:** Leveraging years of work in existing
  58   desktop applications. Native Client makes the transition from the desktop to a
  59   web application significantly easier because it supports C and C++.
  60 * **Security:** Protecting the user's system from malicious or buggy
  61   applications through Native Client's double sandbox model. This model offers
  62   the safety of traditional web applications without sacrificing performance and
  63   without requiring users to install a plugin.
  64 * **Performance:** Running at speeds comparable to desktop applications (within
  65   5-15% of native speed). Native Client also allows applications to harness all
  66   available CPU cores via a threading API; this enables demanding applications
  67   such as console-quality games to run inside the browser.
  68
  69 Common use cases
  70 ================
  71
  72 Typical use cases for Native Client include the following:
  73
  74 * **Existing software components:** With support for C and C++, Native
  75   Client lets you to reuse existing software modules in web applications. You
  76   don't need to rewrite and debug code that already works.
  77 * **Legacy desktop applications:** Native Client provides a smooth migration
  78   path from desktop applications to the web. You can port and recompile existing
  79   code for the computation engine of your application directly to Native Client,
  80   and need rebuild only the user interface and event handling portions for the
  81   browser.
  82 * **Heavy computation in enterprise applications:** Native Client can handle the
  83   number crunching required by large-scale enterprise applications. To ensure
  84   protection of user data, Native Client enables you to build complex
  85   cryptographic algorithms directly into the browser so that unencrypted data
  86   never goes out over the network.
  87 * **Multimedia applications:** Codecs for processing sounds, images, and movies
  88   can be added to the browser in a Native Client module.
  89 * **Games:** Native Client lets web applications run at close to native
  90   speed, reuse existing multithreaded/multicore C/C++ code bases, and
  91   access low-latency audio, networking APIs, and OpenGL ES with programmable
  92   shaders. Native Client is a natural fit for running a physics engine or
  93   artificial intelligence module that powers a sophisticated web game.
  94   Native Client also enables applications to run unchanged across
  95   many platforms.
  96 * **Any application that requires acceleration**: Native Client fits seamlessly
  97   into web applications---it's up to you to decide to what extent to use it.
  98   Use of Native Client covers the full spectrum from complete applications to
  99   small optimized routines that accelerate vital parts of web applications.
 100
 101 .. _link_how_nacl_works:
 102
 103 How Native Client works
 104 =======================
 105
 106 Native Client is an umbrella name for a set of related software components that
 107 provide a way to develop C/C++ applications and run them securely on the web.
 108
 109 At a high level, Native Client consists of:
 110
 111 * **Toolchains**: Collections of development tools (compilers, linkers, etc.)
 112   that transform C/C++ code to Native Client modules.
 113 * **Runtime components**: components embedded in the browser or other
 114   host platforms that allow execution of  Native Client modules
 115   securely and efficiently.
 116
 117 The following diagram shows how these components interact:
 118
 119 .. image:: /images/nacl-pnacl-component-diagram.png
 120
 121 The left side of the diagram shows how to use Portable Native Client
 122 (PNaCl, pronounced "pinnacle"). Developers use the PNaCl toolchain
 123 to produce a single, portable (**pexe**) module. At runtime, a translator
 124 built into the browser translates the pexe into native code for the
 125 relevant client architecture. Translation occurs before any code is executed.
 126
 127 The right side of the diagram shows how to use (non-portable) Native Client.
 128 Developers use a nacl-gcc based toolchain to produce multiple
 129 architecture-dependent (**nexe**) modules, which are packaged into an
 130 application. At runtime, the browser decides which nexe to load based
 131 on the architecture of the client machine.
 132
 133 Security
 134 --------
 135
 136 Since Native Client permits the execution of native code on client machines,
 137 special security measures have to be implemented:
 138
 139 * The NaCl sandbox ensures that code accesses system resources only through
 140   safe, whitelisted APIs, and operates within its limits without attempting to
 141   interfere with other code running either within the browser or outside it.
 142 * The NaCl validator statically analyzes code prior to running it
 143   to make sure it only uses code and data patterns that are permitted and safe.
 144
 145 The above security measures are in addition to the existing sandbox in the
 146 Chrome browser---the Native Client module always executes in a process with
 147 restricted permissions. The only interaction between this process and the
 148 outside world is through sanctioned browser interfaces. Because of the
 149 combination of the NaCl sandbox and the Chrome sandbox, we say that
 150 Native Client employs a double sandbox design.
 151
 152 Portability
 153 -----------
 154
 155 Portable Native Client (PNaCl, prounounced "pinnacle") employs state-of-the-art
 156 compiler technology to compile C/C++ source code to a portable bitcode
 157 executable (**pexe**). PNaCl bitcode is an OS- and architecture-independent
 158 format that can be freely distributed on the web and :ref:`embedded in web
 159 applications<link_nacl_in_web_apps>`.
 160
 161 The PNaCl translator is a component embedded in the Chrome browser; its task is
 162 to run pexe modules. Internally, the translator compiles a pexe to a nexe
 163 (a native executable for the client platform's architecture), and then executes
 164 the nexe within the Native Client sandbox as described above. It also uses
 165 intelligent caching to avoid re-compiling the pexe if it was previously compiled
 166 on the client's browser.
 167
 168 Native Client also supports the execution of nexe modules directly in the
 169 browser. However, since nexes contain architecture-specific machine code,
 170 they are not allowed to be distributed on the open web---they can only be
 171 used as part of applications and extensions that are installed from the
 172 Chrome Web Store.
 173
 174 For more details on the difference between NaCl and PNaCl, see
 175 :doc:`NaCl and PNaCl <nacl-and-pnacl>`.
 176
 177 .. _toolchains:
 178
 179 Toolchains
 180 ----------
 181
 182 A toolchain is a set of tools used to create an application from a set of
 183 source files. In the case of Native Client, a toolchain consists of a compiler,
 184 linker, assembler and other tools that are used to convert an
 185 application written in C/C++ into a module that is loadable by the browser.
 186
 187 The Native Client SDK provides two toolchains:
 188
 189 * a **PNaCl toolchain** for generating portable NaCl modules (pexe files)
 190 * a **gcc-based toolchain (nacl-gcc)** for generating non-portable NaCl modules
 191   (nexe files)
 192
 193 The PNaCl toolchain is recommended for most applications. The nacl-gcc
 194 toolchain should only be used for applications that will not be distributed
 195 on the open web.
 196
 197 .. _link_nacl_in_web_apps:
 198
 199 Native Client in a web application
 200 ==================================
 201
 202 .. _application_files:
 203
 204 A Native Client application consists of a set of files:
 205
 206 * **HTML**, **CSS**, and **JavaScript** files, as in any modern web
 207   application. The JavaScript code is responsible for communicating with the
 208   NaCl module.
 209 * A **pexe** (portable NaCl) file. This module uses the :ref:`Pepper
 210   <link_pepper>` API, which provides the bridge to JavaScript and
 211   browser resources.
 212 * A Native Client **manifest** file that specifies the pexe to load, along with
 213   some loading options. This manifest file is embedded into the HTML page
 214   through an ``<embed>`` tag, as shown in the figure below.
 215
 216 .. image:: /images/nacl-in-a-web-app.png
 217
 218 For more details, see :doc:`Application Structure
 219 <devguide/coding/application-structure>`.
 220
 221 .. _link_pepper:
 222
 223 Pepper Plugin API
 224 -----------------
 225
 226 The Pepper Plugin API (PPAPI), called **Pepper** for convenience, is an
 227 open-source, cross-platform C/C++ API for web browser plugins. From the point
 228 of view of Native Client, Pepper allows a C/C++ module to communicate with
 229 the hosting browser and get access to system-level functions in a safe and
 230 portable way. One of the security constraints in Native Client is that modules
 231 cannot make any OS-level calls directly. Pepper provides analogous APIs that
 232 modules can target instead.
 233
 234 You can use the Pepper APIs to gain access to the full array of browser
 235 capabilities, including:
 236
 237 * :doc:`Talking to the JavaScript code in your application
 238   <devguide/coding/message-system>` from the C++ code in your NaCl module.
 239 * :doc:`Doing file I/O <devguide/coding/file-io>`.
 240 * :doc:`Playing audio <devguide/coding/audio>`.
 241 * :doc:`Rendering 3D graphics <devguide/coding/3D-graphics>`.
 242
 243 Pepper includes both a C API and a C++ API. The C++ API is a set of bindings
 244 written on top of the C API. For additional information about Pepper, see
 245 `Pepper Concepts <http://code.google.com/p/ppapi/wiki/Concepts>`_.
 246
 247 Versioning
 248 ==========
 249
 250 Chrome is released on a six week cycle, and developer versions of Chrome are
 251 pushed to the public beta channel three weeks before each release. As with any
 252 software, each release of Chrome may include changes to Native Client and the
 253 Pepper interfaces that may require modification to existing applications.
 254 However, modules compiled for one version of Pepper/Chrome should work with
 255 subsequent versions of Pepper/Chrome. The SDK includes multiple versions of the
 256 Pepper APIs to help developers make adjustments to API changes and take
 257 advantage of new features: `stable </native-client/pepper_stable>`_, `beta
 258 </native-client/pepper_beta>`_ and `dev </native-client/pepper_dev>`_.
 259
 260 Where to start
 261 ==============
 262
 263 The :doc:`Quick Start <quick-start>` document provides links to downloads and
 264 documentation that should help you get started with developing and distributing
 265 Native Client applications.