For information about Haiku's participation in GSoC this year, please see this page.

Qualifying students can apply for a Haiku project (see the list of suggested projects below). For details about how to apply, please check out Students: How to Apply for a Haiku Idea.

According to other mentor organizations, the most successful Google Summer of Code projects are often those proposed by the students themselves. The following list represents some of our ideas and wishes for the project. However, suggesting your own idea is always encouraged!

Be aware: API and user interface design requires a higher level of skill. A significantly more convincing proposal is required for tasks involving those. Getting started with the design early (before the coding period starts) is recommended, to maximize your chances of being selected, and allow a larger part of the coding period dedicated to coding tasks.

If you find one of the "big" ideas interesting, but feel that you cannot complete it within the allotted coding time, feel free to suggest splitting it into smaller parts for your proposal.

Students that intend to submit applications on ideas which are also part of other accepted mentoring organizations must coordinate with both Haiku and the other mentoring organization beforehand.

Project Areas


Updating and Extending WebPositive

Haiku uses a WebKit based browser called WebPositive. The browser is still quite simple and can be improved in multiple ways. Some of the missing features are:

  • Advanced session management. There is minimal support for restoring tabs from the last closed window, but a more complete solution is desirable. The web browser should be able to store its whole state (multiple windows and tabs) to a session file, and restore the state from that file.
  • Management of broken HTTPS certificates. There should be a way to remember exceptions to the system-wide certificate list.
  • Support for browser extensions, such as ad-block. This could be done either reusing extensions from other browsers (if possible), or using the native add-ons system.
  • Skill set: userland development, user interface design and programming
  • Possible mentors/knowledgeable people: PulkoMandy

Extending and improving the Services Kit network backend

The WebKit browser and some other Haiku applications such as HaikuDepot use the Services Kit as a network backend. This is a library similar to curl or soup, but nicely integrated into the Haiku API for easy use in native applications. The Services Kit is still a work in progress, however, and can be improved in several ways. The work on this task could include:

  • Reworking the Service Kit to avoid spawning one thread for each network request. The requests should be allowed to run in an existing thread, or to be grouped together (by use of select() or poll() to wait for activity on their sockets, then dispatching events to the BNetworkRequest objects). This would remove some of the overhead of creating a request and solve some design issues in the Services Kit API.
  • Implementing HTTP 1.1 support, allowing the reuse of the connection to an HTTP server to perform multiple requests. BHttpRequest objects should be reworked to be able to use an existing HTTP 1.1 connection, and a way to store existing connections should be added.
  • A caching layer for HTTP requests. There currently is no cache which means some requests are made again and again to the same server. The cache should keep the result of these requests on disk and/or in memory, making it possible to reuse them and load web pages faster.
  • Complete support for HTTP proxies. While there is currently limited support, it is not possible to do HTTPS requests through a proxy. This should be added, as well as a system-wide user interface to configure and manage proxies.
  • Implementing FTP support. The services kit is designed to support multiple protocols, but currently only HTTP and Gopher are supported (as well as the local "file" and "data" protocols). FTP support in the web browser would be helpful.
  • Skill set: userland development, network programming, threads.
  • Possible mentors/knowledgeable people: PulkoMandy, Jessica Hamilton

Improving Haiku's WebKit1 port

Haiku has a native WebKit port which uses the WebKit1 API. This port is not complete and there are several bugs and minor problems which needs to be fixed.

  • There are rendering problems on many web pages. Most of these happen because of missing features both in the WebCore graphics implementation and in the Haiku app_server. This includes missing or incomplete support for dashed lines, shadows, perspective transforms, and probably some bugs in already implemented features. These should be implemented so websites look closer to how they were designed.
  • Another missing feature is the ability to load fonts into app_server dynamically. Currently the Haiku API only allows using existing fonts installed in specific system directories. This should be extended so WebKit can make use of fonts it downloads from the web. Some websites use these as pictograms, and not having the correct font results in unuseable websites.
  • Skill set: userland development, exploring a large code-base (WebCore)
  • Possible mentors/knowledgeable people: PulkoMandy

Migrating Haiku WebKit port to WebKit2

Haiku has a native WebKit port which uses the WebKit1 API. Since this port was made, the WebKit project migrated to WebKit2, which provides several new features and separates the work in several processes to limit the impact of crashes in one or the other.

The goal of this task is to get WebKit2 to run on Haiku. This involves implementing the required inter-process communication primitives in WTF (first reusing the UNIX socket support used on Linux ports, then migrating to BMessages if this is relevant/useful), and writing a WebKit2-style API for WebKit, which can be used in native Haiku applications. Proof of concepts could be a minimal browser, an update to the existing WebPositive, or adding a web view to existing applications such as Mail or fRiSS.

  • Skill set: userland development, exploring a large code-base (WebCore)
  • Possible mentors/knowledgeable people: PulkoMandy

Porting LibreOffice

While the Haiku operating system targets personal comuters, it is currently lacking some very important feature in that use case: an office suite.

The goal of this task is to get the LibreOffice suite running on Haiku. A first part of the work was already done, which consists in porting all the dependencies and getting the LibreOffice core cde to build. The next step is implementing all the platform specific code to get it running on Haiku.

  • Skill set: userland development, exploring a large code-base
  • Possible mentors: KapiX, waddlesplash

VirtualBox port to Haiku

VirtualBox is a virtual machine allowing to run an operating system inside of another. Porting it to Haiku would allow Haiku user to run another system, such as Windows or Linux, when they need to run an application that is not yet available for Haiku. This would make using Haiku as their primary operating system a viable approach for more people.

Starting from this preliminary work, continue and complete the port. This includes writing a native GUI for VirtualBox, getting it to run, and more importantly, work on the virtualization driver which will allow virtualbox to run the emulated machine using the native CPU. This makes the emulated system run at close-to-native speed, whereas a software emulation would be unbearably slow.

  • Skill set: userland development, kernel development, possibly x86 assembly
  • Possible mentors/knowledgeable people: mmu_man

KVM acceleration for Haiku's QEmu port

QEmu is a virtual machine allowing to run an operating system inside of another. While there already is an Haiku port, it currently does not support any acceleration system through native virtualization (KVM/KQemu). This makes it too slow for many uses. Fixing this would allow Haiku user to run another system, such as Windows or Linux, when they need to run an application that is not yet available for Haiku. This would make using Haiku as their primary operating system a viable approach for more people.

  • Work on the virtualization driver which will allow QEmu to run the emulated machine using the native CPU.
  • Skill set: kernel development, userland development, possibly x86 assembly
  • Possible mentors/knowledgeable people: mmu_man

Calendar application

Create a native calendar application or port an existing calendar application to Haiku. The app should support creating events and saving them to event files augmented with attributes similar to how People file work for contacts. Additional features of the calendar app might also include support for recurring events, integration with other calendaring software such as Google Calendar or Microsoft Outlook™, and vCalendar support ; CalDAV synchronization, import of iCal files, and more.

You should review existing calendar applications on Haiku/BeOS and other operating system to find out the key features for such an application. Then, decide if one of the applications linked below may be used as a starting point, or if it is better to start from scratch. Aside writting the application itself, it may be useful to improve the BDate, BTime and BDateTime in Haiku to make it possible to do date math easily, work with different timezones, and format dates represented using these classes, as well as relative durations ("Today", "2 days ago", ...), in a localized way.

Some applications to look at for inspiration/examples:

  • (for screenshots, see:
  • Skill set: userland development, user interface design, possibly network development.
  • Possible mentors: scottmc, Sean Healy, waddlesplash

Other applications

There are many open source 3rd party applications for Haiku that could use improvements. Whether it is resolving bugs, adding features, updating the coding style, updating them to use the Locale and Layout Kits, or anything else imaginable! Writing applications from scratch is also possible.

  • Skill set: userland development, user interface design, exploring an existing code base, others depending on the application retained.
  • Possible mentors/knowledgeable people (depends on chosen application): PulkoMandy, Sean Healy, waddlesplash


USB stack improvements (USB3, isochronous transfers)

Like any other operating system, Haiku has drivers for all types of USB interfaces: OHCI and EHCI for USB1, UHCI for USB2, and XHCI for USB3. However, most of these still need some improvements to improve compatibility and add full support of the USB specification.

The XHCI support is still not complete. On several machines it will not detect devices, generate a lot of hardware interrupts, or even prevent the whole system from booting. Work on XHCI support must be continued so Haiku gets more reliable and complete support for USB3.

USB allows 3 different ways of exchanging data with a device: bulk, interrupt, and isochronous. In bulk mode, the data is transferred when the bus is idle. Interrupt mode has higher priority. Finally, isochronous mode guarantees a minimal rate. This last mode is used for example by USB audio cards and webcams, as they need a constant flow of data at a fixed rate. The UHCI and EHCI drivers are missing support for isochronous USB transfers. This makes it impossible to use most USB sound cards and webcams in Haiku.

The USB tasks consist in implementing either complete USB3 support, or isochronous transfers for USB1 and USB2 devices. This can be complemented with porting a webcam or audio card driver from FreeBSD or Linux (FreeBSD is preferred because of the software license used, we prefer to avoid GPL code if possible).

  • Requirements: an USB webcam or audio device for testing (most laptops have an embedded webcam using USB).
  • Skill set: kernel and driver development, USB, general C and C++ development
  • Possible mentors: kallisti5

virtio network and balloon drivers

virtio ("virtual input and output") is a technology used in virtual machines to reduce overhead of emulation. Instead of simulating an existing device, virtual machines expose a simplified "virtio" device, which is designed to make interfacing between the guest and host system easier. The technology is currently applied to disks, memory, and network.

The virtio memory driver allows to implement "ballooning", that is, the virtual machine can increase or decrease its memory use (just like a balloon is inflated or deflated) when the guest system allocates or releases memory. This makes it easier to share the memory between several virtual machines more efficiently.

Haiku already has a virtio bus driver, and a virtio disk driver. The addition of a virtio network card driver and a virtio memory balloon driver would enable Haiku to take advantage of emulation speedups using the lightweight virtio bus. Haiku could also be deployed in environments such as Amazon S3 or OpenStack. To complete this task, a fully stable virtio network card driver would need to be completed and tested as functional as well as a working virtio balloon memory driver.

3D acceleration support

Haiku does not currently support hardware acceleration of 3D rendering. Using the Gallium infrastructure from Mesa, the goal of this project is to make the existing Mesa renderer allow hardware-accelerated 3D rendering, and not just software. This involves extending the API used by our video drivers (which is currently 2D oriented only), and making Gallium uses that API. Parts of the DRI/DRM model used on Linux may be reusable, but cooperation with the app_server must be possible.

  • Skill set: kernel and driver development, Mesa graphics stack
  • Possible mentors/knowledgeable people: Duggan, PulkoMandy


Add write support for more filesystems (BIG)

Haiku has great support for its own file system, but most others are only available read-only. It is way better for interoperability with other systems to be able to write to these disks from Haiku.

The goal of this project is to complete the existing support for one of the following filesystems in Haiku, working from the existing code base:

  1. ReiserFS existing sources, official specifications, extra documentation on the FS layout
  2. BTRFS: existing code, homepage

A good warm-up task would be to get one of these filesystem to build and run in "userlandfs" mode, as this allows much easier development and testing during the project.

  • Skill set: kernel, and driver development
  • Possible mentors/knowledgeable people: PulkoMandy, Sean Healy

File Systems: general improvements and new filesystems.

Haiku has great support for its own file system, but is completely missing support for some other fielsystems. It is way better for interoperability with other systems to be able to read and write to these disks.

The goal of this project is to port one of the following filesystems to Haiku:

  1. ext4: extend the existing ext2 driver to support new ext3 and ext4 features
  2. UFS2 (as used in *BSD): FreeBSD implementation, u2fstools for windows (BSD licensed, source can be reused)
  3. HAMMER FS: homepage, sourcecode (3-clause BSD, a port of the existing code is ok)
  4. JFS: existing code in Linux is under the GPL, a rewrite under the MIT license is preferred. The filesystem design and disk structures are well documented.
  5. XFS: Development community, homepage (existing code in Linux is under the GPL, a rewrite under the MIT license is preferred)
  6. ZFS: main page, existing code (Existing code is under the CDDL, a rewrite is preferred)
  7. SMB, Windows shares: smbfs from FreeBSD (2-clause BSD, code can be ported to Haiku)
It's okay to port over the code from other systems, although we prefer code that can be distributed under the MIT license.
  • Skill set: kernel, and driver development
  • Possible mentors/knowledgeable people: PulkoMandy

x86-64: Support for 32 bit userland

Haiku is currently available in both 32 and 64 bit versions. However, the 64-bit version is currently unable to run 32-bit applications, forcing application developers to provide a 64-bit version of their applications. This is reducing the adoption of 64bit versions of Haiku for lack of available applications.

The goal of this task is to add a compatibility mode to the 64-bit kernel so it is able to run 32-bit programs. The issues in doing that involve adjusting syscall parameters, and mainly converting pointers from the 32bit userland to the 64-bit addressing used on the kernel side. 32-bit applications compiled for Haiku "x86" architecture should be supported. Handling of gcc2-compiled legacy BeOS applications may also be considered as an extended goal, but not as much important.

  • Skill set: kernel development, x86 architecture/assembly language
  • Possible mentors/knowledgeable people: Jerome Duval

ARM port / device tree support

Unlike x86 systems which have a PCI bus, most ARM devices have peripherals at hardcoded addresses. This means automatic hardware discovery is not possible. The Linux kernel developers designed a solution called "flattened device tree". It is a static description of the hardware, telling the kernel where devices are located and which driver to use.

Haiku plans to use device trees to support several ARM devices with the same kernel. This requires updating our drivers and driver infrastructure to not rely so much on the PCI bus. This work should start with the USB EHCI driver, in order to provide at least one mass storage solution to the ARM port of Haiku.

The ARM port of Haiku is currently in an early state. This project may involve debugging of other issues in the port to get it running further, so the device tree part can be tested. Several parts of the early boot code should be reviewed to make use of the device tree and remove hardcoded addresses (RAM mapping, framebuffer, serial port, etc).

  • Skill set: kernel development, ARM architecture/assembly
  • Possible mentors/knowledgeable people: PulkoMandy


Bluetooth Stack Improvements

Haiku Bluetooth Stack implements only basic functionality on lower and middle layers. This functionality needs to be completed and Bluetooth 2.X and later possibilities explored. This task involves investigating the current state of the Bluetooth code, checking that the basic functionality is still working (pairing devices, etc), and improving the stack to make it more useful by implementing driver(s) for Bluetooth device(s) of your choice (file transfers, audio, HID, networking, etc).

  • Requirements: Bluetooth-enabled Haiku system
  • Skill set: C++, kernel development, userland development, global bluetooth stack knowledge (optional)
  • Tasks: RemoteDevices Database, Userland tools(Preferences), Pairing/Auth/Encryption use cases, etc.
  • Possible mentors/knowledgeable people: waddlesplash (userspace stuff)

IPv6 Finalization

The base framework for IPv6 support was implemented as a Google Summer of Code 2010 project. Even so, there remains a lot of smaller cleanup/finalization tasks that can be done as a project.

  • Tickets:
    • #8293 -- BNetworkAddress needs to check if there is an available IPv6 connection.
    • #7228 -- RFC: BNetworkInterfaceAddress needs to store auto-configuration flags
    • #6489 -- ifconfig needs to validate availability of ipv6 module prior to utilization
    • #2632 -- Possible redefinition for struct sockaddr_in, related to IPv6
    • #8319 -- Haiku needs IPv6 duplicate address detection during link scope ip configuration.
    • #8317 -- Haiku needs IPv6 global scope Auto Configuration (router advertisement + DHCPv6)
    • #11862 -- Net server multi-protocol rework
    • Skill set: IPv4 and IPv6 protocols, kernel and network stack development
    • Possible mentors: jua

    TCP optimization and finetuning

    Haiku of course has TCP support. However, it is rather simplistic and the performance is not so good, especially when there is some latency (for example on Wifi links). The goal of this project is to review the existing implementation, identify the main problems, and address them by implementing the required improvements.

    RFC7414 is a list of reference documents describing the implementation of a well-behaving TCP stack. It can be used as a guide to what is needed, comparing it with our current implementation to implement the missing parts.

    • Skill set: TCP and IPv4 protocols
    • Possible mentors: jessicah, jua, PulkoMandy

    User Interface

    Preferences GUI refactoring

    Haiku is an operating system designed for ease of use on desktop computers. A key part of this work is an easy to use set of preference applications. Some of the currently available preference panels could be merged or improved in several ways.

    Several preference applications (aka preflets) could be redesigned. Furthermore, there might still be code that does not yet use our layout API. This work may include (but is not limited to):

    1. combining Keymap, Keyboard, Mouse and Touchpad in a single "Input devices" preferences panel,
    2. adding support for joysticks and touch screens support to it,
    3. #6983Reworking the Printer preferences to look better and be more intuitive.
    4. #6206integrate scrollbar options into a new Appearance preflet, and provide a live preview for all of the settings available in this window
    5. Improving the user interface of the shortcuts preference to make it easier to setup custom shortcuts
    6. Improving and extending the notifications preferences to allow easy control of allowed notifications, browsing of the notification history.
    7. Research on how to improve the other preference panels further with the goal of making them easier to use.
    • Skill set: C++, UI development, usability basics
    • Possible mentors/knowledgeable people: PulkoMandy, waddlesplash

    Modular edit view (BIG)

    The current solution for text editing in Haiku is the BTextView. It is a rather simple view providing basic text editing features and limited styling. This is, however, not powerful enough for most serious uses. The goal of this project is to design a complete replacement for BTexView, which should be designed to cover more use cases.

    The edit view design should be modular and extensible to make it easy to implement e.g. following features:

    • spell checker
    • line numbers, ruler, 80 character limit line, hyper links
    • working on an input stream rather than on a input file e.g. to be able to open files ~100Mb without loading them into memory in one go
    • Including pictures in the text flow
    • Sourcecode editor: syntax highlighting, code completion
    • Ability to load and save data in different formats (using the Translation Kit)

    Existing work

    The HaikuDepot application includes preliminary work on a rich text view, which it uses to provide the description of packages. This could be used as a starting point for this work.

    • Skill set: C++, API design, UI development
    • Possible mentors: scottmc, Sean Healy


    Add subtitle support to the Media Kit

    Haiku "media" applications rely on a framework called the Media Kit. This provides an unified API to handle audio and video streams, including codec plugins to read and write the stream to files or other sources, as well as transporting the data from one application to another, with a latency as low as possible.

    While our MediaPlayer has support for external subtitle files, the Media Kit itself has not. The most obvious downside of that is that there is no support for subtitle (text or bitmap) embedded in video files within the MediaPlayer or other applications.

    Your job would be to design the necessary API extensions to let subtitles fit in with the rest of the Media Kit, and add native support for them, which will then be available to all applications as part of the framework.

    • implement the required code to extract the subtitles from source files (either standalone .srt files or contained for example in mkv containers), with proper handling of replay time and text encoding
    • integrate this in the existing API (probably as a new kind of BMediaTrack), and update applications such as MediaPlayer and MediaConverter to make use of the feature.
    • See the BeBook introduction for the Media Kit to become familiar with its design.
    • Skill set: general C/C++, userland development, API design
    • Possible mentors: Barrett, jua, PulkoMandy

    Complete and Finalize the MediaPlayer Plugin API

    The MediaPlayer app included in Haiku is able to play most of the media formats around. To be able to do that it includes a monolithic framework that uses most of the important features of the media_kit. To improve maintainability and flexibility we are looking forward to include a plugin API and export or implement as plugins certain functionalities.

    Some examples :

    • Playlist
    • Attributes editor
    • Cover Art
    • Web Remote Control

    Some efforts have been already put and can be found here.

    Other Links:

    • Skill set: general C++, userland development, software design
    • Possible mentors: Barrett

    Implement system wide and application level input/output chooser

    When more than one soundcard is attached to Haiku, you can only change the default input/output in the Media preferences, or reconnect media nodes manually via Cortex to another input/output device. The Media Kit could support default nodes per application (either unset (system default), or set to a specific device), and the Media preferences could offer an UI to change this.

    Additionally, applications like MediaPlayer, and SoundRecorder should be able to change the input/output device within the application, too (which would just be another way to alter the described Media Kit functionality).

    This functionality should only be visible if there actually is more than one audio device attached to the system; if a device is not available, it should automatically use the default output instead.

    Part of this work would be to implement non-volatile storage that the Media Kit uses for each application that is connected to it, and the ability to detect the application on next start. This storage could then also be used to remember other per application sound settings in the future (or if time permits) like the balance, and relative volume.

    • Skill set: general C/C++, userland development
    • Possible mentors: jua


    Add Haiku support to Allegro 5.0

    Allegro is a gaming library. Older version (4.4) did support Haiku, but this support was dropped from the newer versions (starting from 5.0). The library should be ported to Haiku, allowing to run the bundled examples and possibly port some other software using it.

    • Skill set: C++, userland development
    • Possible mentors: scottmc
    • Alternative projects: porting SFML or another similar library

    Tracker add-on for a version control system

    Git is now a very popular version control system. In Haiku, most interactions with it are through the command line. This makes it a bit hard to use for some people.

    The goal of this task is to integrate Git support into Tracker, which is the file browsing application in Haiku. The result should be similar in behavior to what TortoiseGit achieves on Windows: right click menu to perform various actions, overlay on file icons to show the file status, etc.

    This should be implemented as an add-on to Tracker, which can be installed separately. However, it is quite likely that Tracker itself will also need some changes to support the required extensibility: add-ons provided menus, icon overlays, and other features are currently not available.

    • Prior art: MoleSvn - Tracker add-on for Subversion
    • Skill set: userland development, UI design, git
    • Possible mentors: Sean Healy, waddlesplash
    • Possible alternative ideas/extensions: do the same for another version control system

    Multiple monitors output in app_server

    app_server is Haiku's graphics server and the equivalent of X11 or Wayland on other UNIX systems. It currently supports only one video output, but should be able to do more.

    While the API already allows this for the most part (with the BScreen class), there is no actual implementation behind it and parts of the code assume only a single screen.

    Some drivers implement minimal support for multiple displays, but not all of them. This task may involve updating the video drivers to handle multiple monitors correctly.

    • Skill set: C++, graphics development
    • Possible mentors/knowledgeable people: jua, PulkoMandy

    RTL languages support in interface kit

    The interface kit is the part of the API taking care of everything drawing related: windows, buttons, and other widgets. It is not currently able to display right-to-left languages (such as arabic) properly, making Haiku unusable for a lot of people.

    Font rendering should be reworked to use the HarfBuzz library, instead of just Freetype, providing support for ligatures and bidirectional text output. The Layout Kit (which handles positionning widgets in a window) should be made to work as expected with these languages (possibly inverting left and right in the window layout).

    This task can be extended with better support for font overlays (picking the correct font for each language automatically, probably using fontconfig), and work on input methods for some languages.

    • Skill set: C++, graphics development, text rendering
    • Possible mentors/knowledgeable people: PulkoMandy