NOTE: Deprecation of the technologies described here has been announced for platforms other than ChromeOS.
Please visit our migration guide for details.

Contributor Ideas

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.

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.

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.

Ports

New Filesystems

Project: Expose new filesystems to 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 webports.
Brief explanation: webports 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 webports, 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 webports.
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.

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.

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 doesn’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.

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.

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.

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 within 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.

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.

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.

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.

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.

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.