.. _ideas:

#################
Contributor Ideas
#################

.. contents::
   :local:
   :backlinks: none
   :depth: 3

Contributing? Me‽
=================

NaCl and PNaCl are very big projects: they expose an entire operating system to
developers, interact with all of the Web platform, and deal with compilers
extensively to allow code written in essentially any programming language to
execute on a variety of CPU architectures. This can be daunting when trying to
figure out how to contribute to the open-source project! This page tries to make
contributing easier by listing project ideas by broad area of interest, and
detailing the required experience and expectations for each idea.

This isn't meant to constrain contributions! If you have ideas that aren't on
this page please contact the native-client-discuss_ mailing list.

If you like an idea on this page and would like to get started, contact the
native-client-discuss_ mailing list so that we can help you find a mentor.

.. _native-client-discuss: https://groups.google.com/group/native-client-discuss

Google Summer of Code
=====================

PNaCl participates in the `2015 Google Summer of Code`_ (see the `PNaCl GSoC
page`_). `Student applications`_ are open March 16–27. Discuss project ideas no
native-client-discuss_, and submit your proposal on the GSoC page by the
deadline.

.. _PNaCl GSoC page: https://www.google-melange.com/gsoc/org2/google/gsoc2015/pnacl
.. _2015 Google Summer of Code: https://www.google-melange.com/gsoc/homepage/google/gsoc2015
.. _Student applications: https://www.google-melange.com/gsoc/document/show/gsoc_program/google/gsoc2015/help_page#4._How_does_a_student_apply

Ideas
=====

We've separated contributor ideas into broad areas of interest:

* **Ports** encompass all the code that *uses* the PNaCl platform. Put simply,
  the point of ports is to make existing open-source code work.
* **Programming languages** sometimes involves compiler work, and sometimes
  requires getting an interpreter and its APIs to work well within the Web
  platform.
* **LLVM and PNaCl** requires compiler work: PNaCl is based on the LLVM
  toolchain, and most of the work in this area would occur in the upstream LLVM
  repository.
* **NaCl** mostly deals with low-level systems work and security.


..
  Adding a proposal to this document should follow this format:
    Project:                *project title*
    Brief explanation:      *brief description*
    Expected results:       *how do we evaluate the project's success?*
    Knowledge Prerequisite: *programming languages, CS topics, ...*
    Mentor:                 *one or multiple, their roles in this project*
  The above list is inspired by the Google Summer of Code guidelines, and the
  KDE project list.

Ports
-----

New Filesystems
^^^^^^^^^^^^^^^

* **Project:** Expose new filesystems to :doc:`nacl_io
  </devguide/coding/nacl_io>`.
* **Brief explanation:** nacl_io exposes filesystems like html5fs and RAM disk,
  which can be mounted and then accessed through regular POSIX APIs. New types
  of filesystems could be exposed in a similar way, allowing developers to build
  apps that "just work" on the Web platform while using Web APIs. A few ideas
  include connecting to: Google Drive, Github, Dropbox.
* **Expected results:** A new filesystem is mountable using nacl_io, is well
  tested, and used in a demo application.
* **Knowledge Prerequisite:** C++.
* **Mentor:** Sam Clegg.

Open Source Porting
^^^^^^^^^^^^^^^^^^^

* **Project:** Port substantial open source projects to work in naclports.
* **Brief explanation:** naclports contains a large collection of open source
  projects that properly compile and run on the PNaCl platform. This project
  involves adding new useful projects to naclports, and upstreaming any patches
  to the original project: running on PNaCl effective involves porting to a new
  architecture and operating system. Project ideas include: Gimp, Inkscape, Gtk.
* **Expected results:** New open source projects are usable from naclports.
* **Knowledge Prerequisite:** C/C++.
* **Mentor:** Brad Nelson.


Languages
---------

PNaCl already has support for C and C++, and virtual machines such as
JavaScript, Lua, Python and Ruby. We'd like to support more languages, either by
having these languages target LLVM bitcode or by making sure that the language
virtual machine's APIs work well on the Web platform.

Rust
^^^^

* **Project:** Support the Rust programming languages.
* **Brief explanation:** The Rust_ programming language uses LLVM. The aim of
  this project is to allow it to deliver PNaCl ``.pexe`` files.
* **Expected results:** The Rust test suite passes within the browser. How to
  use Rust to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** Compilers, LLVM.
* **Mentor:** Ben Smith.

.. _Rust: http://www.rust-lang.org

Haskell
^^^^^^^

* **Project:** Support the Haskell programming language.
* **Brief explanation:** GHC_ targets LLVM. The aim of this project is to allow
  it to deliver PNaCl ``.pexe`` files. One interesting difficulty will be to
  ensure that tail call optimization occurs properly in all targets.
* **Expected results:** The Haskell test suite passes within the browser. How to
  use Haskell to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** Compilers, LLVM.
* **Mentor:** Ben Smith.

.. _GHC:
   http://www.haskell.org/ghc/docs/latest/html/users_guide/code-generators.html

Julia
^^^^^

* **Project:** Support the Julia programming language.
* **Brief explanation:** Julia_ targets LLVM, but it does so through LLVM's
  Just-in-Time compiler which PNaCl doens't support. The aim of this project is
  to allow it to deliver PNaCl ``.pexe`` files.
* **Expected results:** The Julia test suite passes within the browser. How to
  use Julia to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** Compilers, LLVM.
* **Mentor:** Ben Smith.

.. _Julia: http://julialang.org

Scala
^^^^^

* **Project:** Support the Scala programming language.
* **Brief explanation:** The aim of this project is to allow Scala_ to deliver
  PNaCl ``.pexe`` files.
* **Expected results:** The Scala test suite passes within the browser. How to
  use Scala to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** Compilers.
* **Mentor:** Ben Smith.

.. _Scala: http://www.scala-lang.org

Elm
^^^

* **Project:** Support the Elm programming language.
* **Brief explanation:** The aim of this project is to allow Elm_ to deliver
  PNaCl ``.pexe`` files.
* **Expected results:** The Elm test suite passes within the browser. How to use
  Elm to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** Compilers.
* **Mentor:** Jan Voung.

.. _Elm: http://elm-lang.org

Mono
^^^^

* **Project:** Support C# running inside Mono.
* **Brief explanation:** C# is traditionally a Just-in-Time compiled language,
  the aim of this project is to be able to run C# code withing Mono_ while
  compiling ahead-of-time.
* **Expected results:** The Mono test suite passes within the browser. How to
  use Mono to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** Compilers.
* **Mentor:** Derek Schuff.

.. _Mono: http://www.mono-project.com

Perl
^^^^

* **Project:** Support Perl.
* **Brief explanation:** Port the Perl programming language and its packages to
  the PNaCl platform.
* **Expected results:** The Perl test suite passes within the browser. How to
  use Perl to target PNaCl is well documented and easy to do.
* **Knowledge Prerequisite:** C.
* **Mentor:** Brad Nelson.

TCC
---

* **Project:** Port Fabrice Ballard's Tiny C Compiler _TCC to NaCl and PNaCl.
* **Brief explanation:** Port TCC to NaCl and enhance to follow `NaCl sandboxing
  rules`_, as well as emitting `PNaCl bitcode`_. The same could be done with
  `Pico C`_.
* **Expected results:** Compiler ported and code generator working. Can run a
  small benchmark of your choice.
* **Knowledge Prerequisite:** C, assembly, compilers.
* **Mentor:** JF Bastien.

.. _`NaCl sandboxing rules`: https://developer.chrome.com/native-client/reference/sandbox_internals/index
.. _`PNaCl bitcode`: https://developer.chrome.com/native-client/reference/pnacl-bitcode-manual
.. _TCC: http://bellard.org/tcc/
.. _`Pico C`: https://code.google.com/p/picoc


LLVM and PNaCl
--------------

PNaCl relies heavily on LLVM in two key areas:

* On the developer's machine, LLVM is used as a regular toolchain to parse code,
  optimize it, and create a portable executable.
* On user devices, LLVM is installed as part of Chrome to translate a portable
  executable into a machine-specific sandboxed executable.

Most of the contribution ideas around LLVM would occur in the upstream LLVM
repository, and would improve LLVM for more than just PNaCl's sake (though PNaCl
is of course benefiting from these improvements!). Some of these ideas would
also apply to Subzero_, a small and fast translator from portable executable to
machine-specific code.

.. _Subzero: https://chromium.googlesource.com/native_client/pnacl-subzero/+/master/README.rst

Sandboxing Optimizations
^^^^^^^^^^^^^^^^^^^^^^^^

* **Project:** Improved sandboxed code generation.
* **Brief explanation:** PNaCl generates code that targets the NaCl sandbox, but
  this code generation isn't always optimal and sometimes results in a
  performance lost of 10% to 25% compared to unsandboxed code. This project
  would require looking at the x86-32, x86-64, ARM and MIPS code being generated
  by LLVM or Subzero and figuring out how it can be improved to execute
  faster. As an example, one could write a compiler pass to figure out when
  doing a zero-extending ``lea`` on NaCl x86-64 would be useful (increment and
  sandbox), or see if ``%rbp`` can be used more for loads/stores unrelated to
  the call frame.
* **Expected results:** Sandboxed code runs measurably faster, and gets much
  closer to unsandboxed code performance. PNaCl has a fairly extensive
  performance test suite to measure these improvements.
* **Knowledge Prerequisite:** Compilers, assembly.
* **Mentor:** Jan Voung.

Binary Size Reduction
^^^^^^^^^^^^^^^^^^^^^

* **Project:** Reduce the size of binaries generated by LLVM.
* **Brief explanation:** This is generally useful for the LLVM project, but is
  especially important for PNaCl and Emscripten because we deliver code on the
  Web (transfer size and compile time matter!). This stands to drastically
  improve transfer time, and load time. Reduces the size of the PNaCl translator
  as well as user code, makes the generated portable executables smaller and
  translation size faster. Improve LLVM’s ``mergefuncs`` pass to reduce
  redundancy of code. Detect functions and data that aren’t used. Improve
  partial evaluation: can e.g. LLVM’s command-line parsing be mostly removed
  from the PNaCl translator?  Potentially add a pass where a developer manually
  marks functions as unused, and have LLVM replace them with ``abort`` (this
  should propagate and mark other code as dead). This list could be created by
  using code coverage information.
* **Expected results:** Portable executables in the PNaCl repository are
  measurably smaller and translate faster.
* **Knowledge Prerequisite:** LLVM bitcode.
* **Mentor:** JF Bastien.

Vector Support
^^^^^^^^^^^^^^

* **Project:** Improve PNaCl SIMD support.
* **Brief explanation:** PNaCl offers speed on the Web, and generating good SIMD
  code allows developers to use the full capabilities of the device (better user
  experience, longer battery life). The goal of this project is to allow
  developers to use more hardware features in a portable manner by exposing
  portable SIMD primitives and using auto-vectorization. This could also mean
  making the architecture-specific intrinsics “just work” within PNaCl (lower
  them to equivalent architecture-independent intrinsics).
* **Expected results:** Sample code and existing applications run measurably
  faster by using portable SIMD and/or by auto-vectorizing.
* **Knowledge Prerequisite:** Compilers, high-performance code tuning.
* **Mentor:** JF Bastien.

Atomics
^^^^^^^

* **Project:** Improve the performance of C++11 atomics.
* **Brief explanation:** C++11 atomics allow programmers to shed inline assembly
  and use language-level features to express high-performance code. This is
  great for portability, but atomics currently aren't as fast as they could be
  on all platforms. We had an intern work on this in the summer of 2014, see his
  LLVM developer conference presentation `Blowing up the atomic barrier`_. This
  project would be a continuation of this work: improve LLVM's code generation
  for atomics.
* **Expected results:** Code using C++11 atomics runs measurably faster on
  different architectures.
* **Knowledge Prerequisite:** Compilers, memory models.
* **Mentor:** JF Bastien.

.. _`Blowing up the atomic barrier`: http://llvm.org/devmtg/2014-10/#talk10

Security-enhanced PNaCl
^^^^^^^^^^^^^^^^^^^^^^^

* **Project:** Security in-depth for PNaCl.
* **Brief explanation:** PNaCl brings native code to the Web, and we want to
  improve the security of the platform as well as explore novel mitigations.
  This allows PNaCl to take better advantage of the hardware and operating
  system it's running on and makes the platform even faster while keeping users
  safe. It’s also useful for non-browser uses of PNaCl such as running untrusted
  code in the Cloud. A few areas to explore are: code randomization for LLVM and
  Subzero, fuzzing of the translator, code hiding at compilation time, and code
  tuning to the hardware and operating system the untrusted code is running on.
* **Expected results:** The security design and implementation successfully pass
  a review with the Chrome security team.
* **Knowledge Prerequisite:** Security.
* **Mentor:** JF Bastien.

Sanitizer Support
^^^^^^^^^^^^^^^^^

* **Project:** Sanitizer support for untrusted code.
* **Brief explanation:** LLVM supports many sanitizers_ for C/C++ using the
  ``-fsanitize=<name>``. Some of these sanitizers currently work, and some don't
  because they use clever tricks to perform their work, such as using ``mmap``
  to allocate a special shadow memory region with a specific address. This
  project requires adding full support to all of LLVM's sanitizers for untrusted
  user code within PNaCl.
* **Expected results:** The sanitizer tests successfully run as untrusted code
  within PNaCl.
* **Knowledge Prerequisite:** Compilers.
* **Mentor:** JF Bastien.

.. _sanitizers: http://clang.llvm.org/docs/UsersManual.html#controlling-code-generation

NaCl
----

Auto-Sandboxing
^^^^^^^^^^^^^^^

* **Project:** Auto-sandboxing assembler.
* **Brief explanation:** NaCl has a toolchain which can sandbox native
  code. This toolchain can consume C/C++ as well as pre-sandboxed assembly, or
  assembly which uses special sandboxing macros. The goal of this project is to
  follow NaCl's sandboxing requirements automatically which compiling assembly
  files.
* **Expected results:** Existing assembly code can be compiled to a native
  executable that follows NaCl's sandboxing rules.
* **Knowledge Prerequisite:** Assemblers.
* **Mentor:** Derek Schuff, Roland McGrath.

New Sandbox
^^^^^^^^^^^

* **Project:** Create a new software-fault isolation sandbox.
* **Brief explanation:** NaCl pioneered production-quality sandboxes based on
  software-fault isolation, and currently supports x86-32, x86-64, ARMv7's ARM,
  and MIPS. This project involves designing and implementing new sandboxes. Of
  particular interest are ARMv8's aarch64 and Power8. This also requires
  implementing sandboxing in the compiler.
* **Expected results:** The new sandbox's design and implementation successfully
  pass a review with the Chrome security team. Existing NaCl code successfully
  runs in the new sandbox.
* **Knowledge Prerequisite:** Security, low-level assembly, compilers, LLVM.
* **Mentor:** David Sehr.

64-bit Sandbox
^^^^^^^^^^^^^^

* **Project:** Create a 64-bit sandbox.
* **Brief explanation:** NaCl currently supports sandboxes where pointers are
  32-bits. Some applications, both in-browser and not in-browser, would benefit
  from a larger address space. This project involves designing and implementing
  a model for 64-bit sandboxes on all architecture NaCl currently supports. This
  also requires supporting 64-bit pointers in PNaCl using the ``le64`` platform,
  and updating the code generation for each platform.
* **Expected results:** The new sandbox's design and implementation successfully
  pass a review with the Chrome security team. Existing NaCl code successfully
  runs in the new sandbox.
* **Knowledge Prerequisite:** Security, low-level assembly, compilers, LLVM.
* **Mentor:** David Sehr.