native_client_sdk/src/doc/nacl-and-pnacl.rst

   1 .. _nacl-and-pnacl:
   2
   3 ##############
   4 NaCl and PNaCl
   5 ##############
   6
   7 This document describes the differences between **Native Client** and
   8 **Portable Native Client**, and provides recommendations for when to use each.
   9
  10 .. contents::
  11   :local:
  12   :backlinks: none
  13   :depth: 2
  14
  15 Native Client (NaCl)
  16 ====================
  17
  18 Native Client enables the execution of native code securely inside web
  19 applications through the use of advanced `Software Fault Isolation (SFI)
  20 techniques </native-client/community/talks#research>`_.  Since its launch in
  21 2011, Native Client has provided developers with the ability to harness a
  22 client machine's computational power to a much fuller extent than traditional
  23 web technologies, by running compiled C and C++ code at near-native speeds and
  24 taking advantage of multiple cores with shared memory.
  25
  26 While Native Client provides operating system independence, it requires
  27 developers to generate architecture-specific executable
  28 (**nexe**) modules for each hardware platform. This is not only inconvenient
  29 for developers, but architecture-specific machine code is not portable and thus
  30 not well-suited for the open web. The traditional method of application
  31 distribution on the web is through a self-contained bundle of HTML, CSS,
  32 JavaScript, and other resources (images, etc.) that can be hosted on a server
  33 and run inside a web browser.  With this type of distribution, a website
  34 created today should still work years later, on all platforms.
  35 Architecture-specific executables are clearly not a good fit for distribution
  36 on the web. As a consequence, Native Client has been restricted to
  37 applications and browser extensions that are installed through the
  38 Chrome Web Store.
  39
  40 Portable Native Client (PNaCl)
  41 ==============================
  42
  43 PNaCl solves the portability problem by splitting the compilation process
  44 into two parts:
  45
  46 #. compiling the source code to a portable bitcode format, and
  47 #. translating the bitcode to a host-specific executable just before execution.
  48
  49 PNaCl enables developers to distribute **portable executables** (**pexe**)
  50 modules that the hosting environment (in other words, the Chrome browser) can
  51 translate to native code before executing. This portability aligns Native Client
  52 with existing open web technologies such as JavaScript. A developer can
  53 distribute a **pexe** as part of an application (along with HTML, CSS, and
  54 JavaScript), and the user's machine is simply able to run it.
  55
  56 With PNaCl, a developer generates a single **pexe** from source code,
  57 rather than multiple platform-specific nexes. The **pexe** provides both
  58 architecture- and OS-independence. Since the **pexe** uses an abstract,
  59 architecture-independent format, it does not suffer from the portability
  60 problem described above. Future versions of hosting environments should
  61 have no problem executing the **pexe**, even on new architectures.
  62 Moreover, if an existing architecture is subsequently enhanced, the
  63 **pexe** doesn't even have to be recompiled. In some cases the
  64 client-side translation will automatically be able to take advantage of
  65 the new capabilities. A **pexe** module can be part of any web
  66 application. It does not have to be distributed through the Chrome Web
  67 Store. In short, PNaCl combines the portability of existing web technologies
  68 with the performance and security benefits of Native Client.
  69
  70 PNaCl is a new technology, and as such it still has a few limitations
  71 as compared to NaCl. These limitations are described below.
  72
  73 When to use PNaCl
  74 =================
  75
  76 PNaCl is the preferred toolchain for Native Client, and the only way to deploy
  77 Native Client modules on the open web. Unless your project is subject to one
  78 of the narrow limitations described below
  79 (see :ref:`When to use NaCl<when-to-use-nacl>`), you should use PNaCl.
  80
  81 Beginning with version 31, the Chrome browser supports translation of
  82 **pexe** modules and their use in web applications, without requiring
  83 any installation (either of a browser plugin or of the applications
  84 themselves). Native Client and PNaCl are open-source technologies, and
  85 our hope is that they will be added to other hosting platforms in the
  86 future.
  87
  88 If controlled distribution through the Chrome Web Store is an important part
  89 of your product plan, the benefits of PNaCl are less critical for you. But
  90 you can still use the PNaCl toolchain and distribute your application
  91 through the Chrome Web Store, and thereby take advantage of the
  92 conveniences of PNaCl, such as not having to explicitly compile your application
  93 for all supported architectures.
  94
  95 .. _when-to-use-nacl:
  96
  97 When to use NaCl
  98 ================
  99
 100 The limitations below apply to the current release of PNaCl. If any of
 101 these limitations are critical for your application, you should use
 102 non-portable NaCl:
 103
 104 * PNaCl does not support architecture-specific
 105   instructions in an application (i.e., inline assembly), but tries to
 106   offer high-performance portable equivalents. One such example is
 107   PNaCl's :ref:`Portable SIMD Vectors <portable_simd_vectors>`.
 108 * PNaCl only supports static linking with the ``newlib``
 109   C standard library (the Native Client SDK provides a PNaCl port of
 110   ``newlib``). Dynamic linking and ``glibc`` are not yet supported.
 111   Work is under way to enable dynamic linking in future versions of PNaCl.
 112 * PNaCl does not support some GNU extensions
 113   like taking the address of a label for computed ``goto``, or nested
 114   functions.