release-notes.rst revision 1320f92c476a1ad9d19dba2a48c72b75566198e9
1.. _sdk-release-notes: 2 3############# 4Release Notes 5############# 6 7Chrome/Pepper 38 (15 August 2014) 8================================= 9 10PNaCl 11----- 12 13* Compilation speed improvements due to validation caching of the translator and 14 linker. 15* Performance improvement of SIMD vector shuffle. 16 17Chrome/Pepper 37 (20 June 2014) 18=============================== 19 20PNaCl 21----- 22 23* 2–10% translation time improvement. 24* Improved vector load/store and shuffle performance. 25 26Pepper 27------ 28 29* Media Streams Input support. 30* Compositor API. 31* Hardware Decode API in development preview. 32* Sync API in development preview. 33 34SDK 35--- 36 37* Demo of a :ref:`full development environment in the browser <io2014>`. 38 39Chrome/Pepper 36 (09 May 2014) 40============================== 41 42PNaCl 43----- 44* Support `LLVM vectors 45 <http://clang.llvm.org/docs/LanguageExtensions.html#vectors-and-extended-vectors>`_ 46 and `GCC vectors 47 <http://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html>`_ for SIMD 48 vectors through :ref:`Portable SIMD Vectors 49 <portable_simd_vectors>`. Note that this is still an early release, 50 and performance is expected to become acceptable for version 37 of 51 Chrome. More SIMD instructions will be added in later releases. 52 53Chrome/Pepper 35 (31 Mar 2014) 54============================== 55 56PNaCl 57----- 58* Upgraded LLVM to version 3.4. 59* Translation now uses dynamic load balancing, making translation time faster. 60* Unstable pexes (i.e. non-finalized) with debug information can be loaded by 61 Chrome, simplifying debugging with PNaCl. See :ref:`Debugging PNaCl pexes 62 <debugging_pnacl_pexes>` 63 64 65Chrome/Pepper 34 (20 Feb 2014) 66============================== 67 68Pepper 69------ 70* Filesystems can now be passed from JavaScript to NaCl. The resulting 71 ``pp::Var`` will contain a ``pp::Resource`` that can be given to the 72 ``pp::FileSystem`` constructor. 73* New Audio and Video input APIs have been added as dev interfaces. See 74 `pp::MediaStreamAudioTrack 75 </native-client/pepper_dev/cpp/classpp_1_1_media_stream_audio_track>`_ and 76 `pp::MediaStreamVideoTrack 77 </native-client/pepper_dev/cpp/classpp_1_1_media_stream_video_track>`_ for 78 more details. 79 80PNaCl 81----- 82* Parallel translation: at least 1.7x faster, even with older pexes. 83* Intelligent abbreviations in the bitcode: 20% reduction in binary size using 84 the :ref:`pnacl-compress <pnacl_compress>` tool. 85 86Chrome/Pepper 33 (16 Dec 2013) 87============================== 88 89Portable Native Client 90---------------------- 91 92* PNaCl's default C++ standard library is now LLVM's own libc++, based on 93 LLVM 3.3. This library now supports optional ``setjmp``/``longjmp`` exception 94 handling (see `announcement 95 <https://groups.google.com/forum/#!topic/native-client-discuss/0spfg6O04FM>`_ 96 for details). 97 98SDK 99--- 100 101* The ``nacl_io`` library now includes a FUSE mount. 102* In the SDK examples, ``common.js`` now loads the Release version of the 103 nexes/pexes that are built (by default). 104* "``make debug``" and "``make run``" have been fixed on Mac. 105 106PNaCl enabled by default in Chrome 31 (12 Nov 2013) 107=================================================== 108 109* Portable Native Client (PNaCl) is enabled by default in Chrome 31. See 110 :doc:`NaCl and PNaCl </nacl-and-pnacl>` for details on the differences between 111 NaCl and PNaCl. 112* The PNaCl ABI has changed from the preview release in Chrome 30. 113 Pexe modules built with the ``pepper_30`` bundle in the SDK must be recompiled 114 with the ``pepper_31`` bundle or later. 115 As a general rule, we always recommended building applications with the latest 116 stable bundle in the Native Client SDK. 117 The PNaCl ABI will remain stable starting with the release of Chrome 31. 118* Additional changes in the Chrome/Pepper 31 release: 119 120 * Updates to the Pepper API, including socket and network support 121 * Improved socket support in the ``nacl_io`` library 122 123PNaCl in Chrome 30 Dev channel (01 Aug 2013) 124============================================ 125 126* Portable Native Client (PNaCl) is currently available for preview in Chrome 127 30 (currently in the Dev channel). Apps and sites built with PNaCl can run in 128 Chrome 30 without an explicit flag. 129* See `Introduction to Portable Native Client 130 <http://www.chromium.org/nativeclient/pnacl/introduction-to-portable-native-client>`_ 131 for information on developing for PNaCl. More documentation will be available 132 soon. 133* Please note that the `PNaCl bitcode ABI 134 <http://www.chromium.org/nativeclient/pnacl/bitcode-abi>`_ may still change 135 before the official public release; if you're developing a PNaCl-based 136 application, be sure to build your code with the latest version of the Native 137 Client SDK. 138* Update: PNaCl is not enabled by default in beta or stable versions of M30. 139 140PNaCl (15 May 2013) 141=================== 142 143* Portable Native Client (PNaCl) is currently available for developer preview 144 in Chrome 29 or higher. 145* To produce a PNaCl executable (.pexe) file, you must use the pnacl toolchain 146 in the current ``pepper_canary`` bundle. Chrome 29 does not support .pexe 147 files produced by earlier versions of the pnacl toolchain (that is, 148 executables compiled with the ``pepper_28`` bundle or earlier). 149* To run an application with a PNaCl module, you must launch Chrome 29 with the 150 ``--enable-pnacl`` flag (for `packaged apps </apps/about_apps>`_), or the 151 ``--enable-nacl`` flag (for other apps). 152* When you launch Chrome with the ``--enable-pnacl`` flag, Chrome loads a PNaCl 153 translator in the background. Wait about a minute after you launch Chrome and 154 check `chrome://nacl <chrome://nacl>`_ to verify that the translator loaded. 155* PNaCl translators are currently available for 32-bit x86, 64-bit x86, and ARM 156 architectures. 157* PNaCl applications must use the newlib C library (glibc and dynamic linking 158 are not supported yet). 159* The intermediate representation (IR) format may change prior to the release 160 of PNaCl. If so, you will need to recompile your application with the pnacl 161 toolchain in a new SDK bundle. 162 163Pepper 27 (12 April 2013) 164========================= 165 166The Pepper 27 bundle features a significant number of new libraries that have 167been incorporated directly into the SDK. 168 169Libraries 170--------- 171 172* A number of libraries from the naclports project have been incorporated 173 directly into the Native Client SDK. These libraries include: 174 175 * image encoding/decoding: jpeg, tiff, png, webp 176 * multimedia: openal, freealut, ogg, vorbis 177 * XML parsing: tinyxml, xml2 178 * miscellaneous: zlib (general purpose compression), freetype (font 179 rendering), lua (Lua interpreter) 180 181 The libraries are located in ``ports/lib``, and the header files are in 182 ``ports/include``. 183 184* The ``httpfs`` filesystem in the nacl_io library now caches content in memory 185 by default; this improves performance considerably. 186* For applications compiled with a glibc toolchain, ``dlopen()`` can now be 187 used to open shared libraries that are not specified in an application's 188 Native Client manifest (.nmf) file. This allows applications, for example, to 189 download a shared object and then use ``dlopen()`` to access the shared 190 object. The ``dlopen`` example has been modified to demonstrate this 191 functionality: reverse.cc is built into a shared object (.so) file, which is 192 downloaded and opened using an ``httpfs`` mount. 193 194Examples 195-------- 196 197* Each example now has a single ``index.html`` file, instead of multiple HTML 198 files corresponding to NaCl modules built using different toolchains and 199 configurations. By default, most examples are built using one toolchain 200 (newlib) and one configuration (Debug). If you build an example using 201 multiple toolchains or configurations, you can specify which version to run 202 in Chrome using the query parameters ``tc`` and ``config``. For example, 203 assuming you are serving an example from the local server localhost:5103, you 204 can run a version of the example built with the glibc toolchain in the 205 Release configuration by specifying the following URL in Chrome: 206 ``http://localhost:5103/index.html?tc=glibc&config=Release``. For additional 207 information about how different NaCl modules are loaded into ``index.html``, 208 see the ``common.js`` file in each example. 209 210Build tools and toolchains 211-------------------------- 212 213* Common makefiles, including ``tools/common.mk``, can now handle source files 214 located outside of an application's root directory. For example, a Makefile 215 for an application can specify a source file to compile such as 216 ``../../some/other/place.cpp``. 217 218Pepper 26 (29 March 2013) 219========================= 220 221The Pepper 26 bundle includes a new HTTP filesystem type in the nacl_mounts 222library (which has been renamed nacl_io), changes to the example Makefiles, a 223simple new 3D example, and a threaded file IO example. 224 225Build tools and toolchains 226-------------------------- 227 228* Makefiles have been changed significantly: 229 230 * Build commands are now specified in a number of common files 231 (``tools/*.mk``), which are included in the Makefiles in the examples. 232 * By default, make displays a simplified list of build steps (e.g., ``CC 233 newlib/Debug/hello_world_x86_32.o``) rather than the actual build commands. 234 To see the actual build commands, run ``make V=1``. 235 * By default, most examples are built using one toolchain (newlib) and one 236 configuration (Debug). To build an example using a different toolchain or 237 configuration, run ``make`` with the parameters ``TOOLCHAIN=<x>`` or 238 ``CONFIG=<y>``. You can also run make ``all_versions`` to build an example 239 with all toolchains. 240 241* Header files have been moved out of the toolchains. All toolchains now share 242 the same set of header files as host builds. Previously host and NaCl builds 243 used different headers, which could cause build problems. 244 245Libraries 246--------- 247 248* The nacl_mounts library has been renamed **nacl_io**, and has been expanded 249 with a new type of mount, httpfs, which can be used to read URLs via HTTP. 250 For details see ``include/nacl_io/nacl_io.h``, as well as the 251 ``hello_nacl_io`` example. 252 253Examples 254-------- 255 256* A new example, **hello_world_instance3d**, has been added to demonstrate a 257 simplified 3D app. 258* The **file_io** example has been rewritten to do all file operations on a 259 thread. The example demonstrates how to use the MessageLoop API and blocking 260 callbacks on a thread. 261 262General 263------- 264 265* Old bundles (``pepper_20`` and earlier) have been removed from the Native 266 Client SDK Manifest, and will no longer be updated by the ``naclsdk`` 267 command. 268 269Pepper 25 (21 December 2012) 270============================ 271 272The Pepper 25 bundle features an ARM toolchain to build Native Client modules 273for ARM devices, two new Pepper APIs (including the MessageLoop API, which lets 274you make Pepper calls on background threads), two new libraries (nacl_mounts, 275which provides a virtual file system that you can use with standard C file 276operations, and ppapi_main, which lets you implement a Native Client module 277using a simple ppapi_main function), and two new examples that demonstrate how 278to use the nacl_mounts and ppapi_main libraries. 279 280Build tools and toolchains 281-------------------------- 282 283* The SDK includes a new toolchain to build Native Client executables (.nexe 284 files) for **ARM devices**. 285 286 * Currently the ARM toolchain can only be used to compile modules that use 287 the :ref:`newlib C library <c_libraries>`. You cannot use the ARM toolchain 288 to compile modules that use the glibc library. 289 * The ARM toolchain is in the directory 290 ``pepper_25/toolchain/<host>_arm_newlib``. The bin subdirectory contains 291 the compiler (``arm-nacl-gcc``), the linker (``arm-nacl-g++``), and the 292 other tools in the toolchain. 293 * Take a look at the ``hello_world`` example to see how to use the ARM 294 toolchain. Go to ``examples/hello_world`` and run ``make``. When the build 295 finishes, the newlib/Debug and newlib/Release subdirectories will contain 296 .nexe files for the x86-32, x86-64, and ARM target architecutes, and a 297 Native Client manifest (.nmf file) that references those three .nexe files. 298 299* The simple web server included in the SDK, ``httpd.py``, has been moved from 300 the ``examples/`` directory to the ``tools/`` directory. On Windows, you can 301 run ``httpd.cmd`` (in the ``examples/`` directory) to start the server. 302 303PPAPI 304----- 305 306Pepper 25 includes two new APIs: 307 308* The `Console API 309 </native-client/pepper_stable/c/struct_p_p_b___console__1__0>`_ lets your 310 module log messages to the JavaScript console in the Chrome browser. 311* The `MessageLoop 312 </native-client/pepper_stable/cpp/classpp_1_1_message_loop>`_ API lets your 313 module make PPAPI calls on a background thread. Once you've created a 314 message loop resource, attached it to a thread, and run it, you can post work 315 to the thread, including completion callbacks for asynchronous operations. 316 For a C++ example of how to use the MessageLoop API, see 317 ``pepper_25/include/ppapi/utility/threading/simple_thread.h``. Note that you 318 cannot make asynchronous PPAPI calls on a background thread without creating 319 and using a message loop. 320 321Libraries 322--------- 323 324The SDK includes two new libraries: 325 326* The **nacl_mounts** library provides a virtual file system that your module 327 can "mount" in a given directory tree. The file system can be one of several 328 types: 329 330 * "memfs" is an in-memory file system, 331 * "dev" is a file system with various utility nodes (e.g., ``/dev/null``, 332 ``/dev/console[0-3]``, ``/dev/tty``), and 333 * "html5fs" is a persistent file system. 334 335 Once you've mounted a file system in your module, you can use standard C 336 library file operations: fopen, fread, fwrite, fseek, and fclose. How those 337 operations are performed depends on the type of file system (e.g., for 338 html5fs, the operations are performed using the Pepper FileIO API). For a 339 list of the types of file systems you can mount, see 340 include/nacl_mounts/nacl_mounts.h. For an example of how to use nacl_mounts, 341 see examples/hello_nacl_mounts. Note that html5fs is subject to the same 342 constraints as persistent :ref:`local file IO <devguide-coding-fileio>` in 343 Chrome (for example, prior to using an html5fs file system, you must `enable 344 local file IO <enabling_file_access>`_). 345 346* The **ppapi_main** library simplifies the creation of a NaCl module by 347 providing a familiar C programming environment. With this library, your 348 module can have a simple entry point called ppapi_main(), which is similar to 349 the standard C main() function, complete with argc and argv[] parameters. 350 Your module can also use standard C functions such as printf(), fopen(), and 351 fwrite(). For details see include/ppapi_main/ppapi_main.h. For an example of 352 how to use ppapi_main, see examples/hello_world_stdio. 353 354Header files for the new libraries are in the ``include/`` directory, source 355files are in the ``src/`` directory, and compiled libraries are in the ``lib/`` 356directory. 357 358Examples 359-------- 360 361* The SDK includes two new examples: 362 363 * **hello_nacl_mounts** illustrates how to use standard C library file 364 operations in a Native Client module through the use of the nacl_mounts 365 library. 366 * **hello_world_stdio** illustrates how to implement a Native Client module 367 with a ppapi_main() function, and how to write to STDOUT and STDERR in a 368 module, through the use of the nacl_mounts and ppapi_main libraries. This 369 example makes it easy for new users to get started with Native Client by 370 letting them start making changes in a familiar C environment. 371 372* With a few exceptions, the Makefile for each example now builds the following 373 versions of each example: 374 375 * glibc toolchain: 32-bit and 64-bit .nexes for the x86 target architecture 376 * newlib toolchain: 32-bit and 64-bit .nexes for the x86 target architecture, 377 and ARM .nexe for the ARM architecture 378 * pnacl toolchain: .pexe (which is subsequently tranlsated to .nexes for the 379 x86-32, x86-64, and ARM architectures) 380 * hosted toolchain: .so or .dll (to be executed as a Pepper plug-in in 381 Chrome) 382 383* Additionally, each version is built in both a Debug and a Release 384 configuration. 385* The Makefile for each example includes two new targets: ``make RUN`` and 386 ``make LAUNCH``. These targets, which are interchangeable, launch a local 387 server and an instance of Chrome to run an example. When the instance of 388 Chrome is closed, the local server is shut down as well. 389* The hello_world_stdio example includes a simplified Makefile that only lists 390 source dependencies, and invokes the build rules in a separate file 391 (common.mk). 392 393Pepper 24 (5 December 2012) 394=========================== 395 396The Pepper 24 bundle features a new, experimental toolchain called PNaCl (short 397for "Portable Native Client"), a new library (pthreads-win32) for the Windows 398SDK, and an expanded list of attributes for Pepper 3D contexts that lets 399applications specify a GPU preference for low power or performance. 400 401Build tools and toolchains 402-------------------------- 403 404* The SDK includes a new, experimental toolchain called `PNaCl 405 <http://nativeclient.googlecode.com/svn/data/site/pnacl.pdf>`_ (pronounced 406 "pinnacle"). The PNaCl toolchain produces architecture-independent executable 407 files (.pexe files). Chrome doesn't yet support .pexe files directly, but if 408 you want to experiment with this early preview of PNaCl, the toolchain 409 includes a tool to translate .pexe files into architecture-specific .nexe 410 files. Take a look at the ``hello_world`` example to see how to build a .pexe 411 file and translate it into multiple .nexe files. Note that PNaCl is currently 412 restricted to the newlib C standard library – if your application uses glibc, 413 you can't build it with PNaCl. 414* The ``create_nmf.py`` script uses ELF headers (rather than file names) to 415 determine the architecture of .nexe files. That means you can change the 416 names of your .nexe files and ``create_nmf.py`` will still be able to 417 generate the appropriate Native Client manifest file for your application. 418 419Examples 420-------- 421 422* The SDK examples now build with four toolchains: the glibc and newlib 423 toolchains, the experimental PNaCl toolchain, and the hosted toolchain on 424 your development machine. Within each toolchain build, each example also 425 builds both a debug and a release version. 426* The example Makefiles use dependency (.d) files to enable incremental builds. 427* The pong example has been cleaned up and modified to run more smoothly. The 428 drawing function is now set up as the Flush() callback, which allows 2D 429 drawing to occur as quickly as possible. 430 431PPAPI 432----- 433 434* When creating a 3D rendering context, the `attribute list 435 </native-client/pepper_stable/c/group___enums#ga7df48e1c55f6401beea2a1b9c07967e8>`_ 436 for the context can specify whether to prefer low power or performance for 437 the GPU. Contexts with a low power preference may be created on an integrated 438 GPU; contexts with a performance preference may be created on a discrete GPU. 439 440Windows SDK 441----------- 442 443* The Windows SDK includes the pthreads-win32 library to assist in porting from 444 win32 code. You can use this library when developing your module as a Pepper 445 plug-in (.dll). See pepper_24/include/win/pthread.h and 446 pepper_24/src/pthread/README for additional information. 447* The update utility naclsdk.bat works when it is run from a path with spaces. 448 449Pepper 23 (15 October 2012) 450=========================== 451 452The Pepper 23 bundle includes support for the nacl-gdb debugger on Mac and 45332-bit Windows, resources to enable hosted development on Linux, and changes to 454make the SDK examples compliant with version 2 of the Chrome Web Store manifest 455file format. 456 457Tools 458----- 459 460* The :ref:`nacl-gdb debugger <using_gdb>` now works on all systems (Mac, 461 Windows, and Linux). 462 463* The output of the SDK update utility has been simplified. When you run the 464 command ``naclsdk list``, the utility displays one line for each available 465 bundle, annotated with an "``I``" if the bundle is already installed on your 466 system, and a "``*``" if the bundle has an update available. To see full 467 information about a bundle, use the command ``naclsdk info <bundle>`` (for 468 example, ``naclsdk info pepper_28``). 469 470Linux SDK 471--------- 472 473* Developers using the Linux SDK now have resources, including pre-built 474 libraries and example Makefiles, that make it easier to **build a module as a 475 Pepper plugin** (sometimes called a "trusted" or "in-process" plugin) using 476 the native C/C++ compiler on their development system. In essence this makes 477 developing a Native Client module a two-step process: 478 479 #. Build the module into a shared library (.so file) using your system's 480 C/C++ compiler. Test and debug the .so file using the tools in your normal 481 development environment. 482 #. Build the module into a .nexe file using the compiler from one of the 483 Native Client toolchains in the SDK (nacl-gcc or nacl-g++). Test and debug 484 the .nexe file using nacl-gdb. 485 486 This two step development process has many benefits—in particular, you can 487 use the compilers, debuggers, profilers, and other tools that you're already 488 familiar with. But there are a few potential issues to keep in mind: 489 490 * Chrome uses different threading models for trusted plugins and Native 491 Client modules. 492 * Certain operations such as platform-specific library calls and system calls 493 may succeed during trusted development, but fail in Native Client. 494 495 Here are the resources you can use to build your module into a Pepper plugin: 496 497 * header files are in ``pepper_23/include`` 498 * source files are in ``pepper_23/src`` 499 * pre-built libraries are in ``pepper_23/lib`` 500 501 You can now build and run most of the examples in the SDK as Pepper plugins. 502 503 * Look at the example Makefiles or run ``make`` in the example directories to 504 see the commands and flags used to build modules as Pepper plugins. 505 * Run ``make LAUNCH`` in the example directories to see how to use the 506 ``--register-pepper-plugins`` argument to load a Pepper plugin in Chrome. 507 Note that you must set the ``CHROME_PATH`` environment variable and start a 508 :ref:`local server <web_server>` prior to running this command. 509 510Examples 511-------- 512 513* On Linux and Windows systems, most of the examples now build with three 514 toolchains: the Native Client glibc and newlib toolchains, and the native 515 toolchain on the host system. Modules built with the native toolchain on the 516 host system can only run as Pepper plugins. 517* All examples in the SDK now comply with version 2 of the Chrome Web Store 518 `manifest file format </extensions/manifest>`_. By default, 519 applications that use version 2 of the manifest file format apply a strict 520 `content security policy </extensions/contentSecurityPolicy>`_, which 521 includes a restriction against inline JavaScript. This restriction prohibits 522 both inline ``<script>`` blocks and inline event handlers (e.g., ``<button 523 onclick="...">``). See `Manifest Version </extensions/manifestVersion>`_ for 524 a list of changes between version 1 and version 2 of the manifest file 525 format, and a support schedule for applications that use version 1. 526 527PPAPI 528----- 529 530* `PP_InputEvent_Modifier 531 </native-client/pepper_stable/c/group___enums#ga21b811ac0484a214a8751aa3e1c959d9>`_ 532 has two new enum values (_ISLEFT and _ISRIGHT). 533* The memory leak in the `WebSocket 534 </native-client/pepper_stable/c/struct_p_p_b___web_socket__1__0>`_ API has 535 been fixed. 536 537Pepper 22 (22 August 2012) 538========================== 539 540The Pepper 22 bundle includes a **command-line debugger**, resources to enable 541**hosted development on Windows**, and changes to the example Makefiles (each 542example now builds both a debug and a release version). 543 544Tools 545----- 546 547* The SDK now includes a **command-line debugger** that you can use to debug 548 Native Client modules. See :ref:`Debugging with nacl-gdb 549 <devcycle-debugging>` for instructions on how to use this debugger. For now, 550 nacl-gdb only works on 64-bit Windows, 64-bit Linux, and 32-bit Linux 551 systems. Support for Mac and 32-bit Windows systems will be added soon. 552 553Windows SDK 554----------- 555 556* Developers using the Windows SDK can now **build a module as a Pepper 557 plugin** (sometimes called a "trusted" or "in-process" plugin) using the 558 native C/C++ compiler on their development system. In essence this makes 559 developing a Native Client module a two-step process: 560 561 #. Build the module into a DLL using your system's C/C++ compiler. Test and 562 debug the DLL using the tools in your normal development environment. 563 #. Build the module into a .nexe using the compiler from one of the Native 564 Client toolchains in the SDK (nacl-gcc or nacl-g++). Test and debug the 565 .nexe using nacl-gdb. 566 567 This two step development process has many benefits—in particular, you can 568 use the compilers, debuggers, profilers, and other tools that you're already 569 familiar with. But there are a few potential issues to keep in mind: 570 571 * Some libraries that are commonly used with Native Client may not build 572 easily on Windows. 573 * You may need to put in extra effort to get source code to compile with 574 multiple compilers, e.g., Microsoft Visual Studio and GCC. 575 * Chrome uses different threading models for trusted plugins and Native 576 Client modules. 577 * Certain operations such as platform-specific library calls and system calls 578 may succeed during trusted development, but fail in Native Client. 579 580 Here are the resources you can use to build your module into a DLL: 581 582 * header files are in ``pepper_22\include`` 583 * source files are in ``pepper_22\src`` 584 * pre-built libraries are in ``pepper_22\lib`` 585 586* A Visual Studio add-in will be available in the near future with 587 configurations that include platforms for both Pepper plugins and NaCl 588 modules. 589 590.. Note:: 591 :class: note 592 593 **Note:** It's also possible to build a module as a trusted plugin on Mac and 594 Linux systems, but doing so requires more work because the SDK does not yet 595 include the above resources (library source files and pre-built libraries) 596 for Mac and Linux systems. To build and debug a trusted plugin on Mac and 597 Linux systems, you need to `get the Chromium code 598 <http://dev.chromium.org/developers/how-tos/get-the-code>`_ and then follow 599 the `Mac instructions 600 <http://www.chromium.org/nativeclient/how-tos/debugging-documentation/debugging-a-trusted-plugin/trusted-debugging-on-mac>`_ 601 or `Linux instructions 602 <http://www.chromium.org/nativeclient/how-tos/debugging-documentation/debugging-a-trusted-plugin/debugging-a-trusted-plugin-on-linux>`_. 603 In the future, the SDK will include resources for hosted development on Mac 604 and Linux as well as Windows. 605 606Examples 607-------- 608 609* Each example in the SDK now builds both a debug and a release version. As 610 before, most examples also build newlib and glibc versions, which means that 611 there are now four versions for each example. Take a look at the Makefiles in 612 the examples to see the compiler flags that are used for debug and release 613 versions. For a description of those flags, see :ref:`Compile flags for 614 different development scenarios <compile_flags>`. 615* Comments have been added to common.js, which is used in all the examples. The 616 JavaScript in common.js inserts an <embed> element that loads the NaCl module 617 in each example's web page, attaches event listeners to monitor the loading 618 of the module, and implements handleMessage() to respond to messages sent 619 from the NaCl module to the JavaScript side of the application 620 621PPAPI 622----- 623 624* The ``CompletionCallbackFactory`` class template now takes a thread traits 625 class as its second parameter. For details see the `CompletionCallbackFactory 626 class template reference 627 </native-client/pepper_stable/cpp/classpp_1_1_completion_callback_factory#details>`_. 628 629.. TODO: Port release notes for older releases 630