Ideas

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.

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 design and kernel-related work requires a higher level of skill, and user interface design usually involves a lot more thought than other work. A significantly more convincing proposal is required for tasks involving those. Getting started with the design early (before the application period ends) 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

Applications

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
  • Source code
  • Opened tickets

Extending and improving the Services Kit network backend

The Haiku API includes a framework for performing requests to websites using HTTP and other protocols. This is similar to curl or soup which are often used for that purpose on other systems.

This library is used by many Haiku applications, including the WebPositive web browser, package manager, e-mail client, etc.

The goal of this task is to rework the implementation to improve performance and fix design issues. As a result, the code would be cleaner, safer, and faster.

  • 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, jessicah, waddlesplash
  • Sourcecode

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
  • Sourcecode
  • Opened tickets

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
  • Sourcecode

better XMPP client for Haiku

Most of Haiku communication channels are hosted on IRC servers. IRC is a simple protocol, but it lacks modern features. As a result, people are migrating to other chat services such as keybase, Telegram, and many others.

We would prefer to use an open source solution, and XMPP is a good candidate. However, there exists no good native client on Haiku, so its use is limited.

The goal of this project is to either take one of the xisting XMPP clients (Caya or Jabber4Haiku) and improve it, or rewrite one from scratch if nothing from the existing clients is reusable.

Features could include automated account creation, basic messages (private and "conferences" group chats), file transfers, user avatars and moods, rich messages (colors, pictures, ...).

  • Skill set: userland development, XML, network programming
  • Possible mentors/knowledgeable people: PulkoMandy, 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, waddlesplash
  • Sourcecode (QEmu for Haku)

Unify input preferences

Haiku comes with multiple preference panels for input devices: keyboard, keymap, mouse, and touchpad. The goal of this project is to merge these into a single redesigned "Input devices" preference panel. It should allow having different settings for each device (for example, a different speed for a mouse and a touchpad on the same machine, or different keymaps for multiple keyboards). The panel can also be extended to support joysticks/gamepads and other USB HID input devices.

  • Skill set: user interface, C++
  • Possible mentors: PulkoMandy

Devices preferences/Hardware manager

Haiku is meant to be an easy to use graphical operating system. It should provide a GUI to manage devices and drivers. This is currently implemented in the "Devices" preferences, however it does little more than listing devices found on the machine.

The goal of this project is to extend the functionality of Devices preferences to make it a more complete and useful tool. This includes working on the following features:

  • Telling wether a driver is loaded for a given device and where the matching /dev entry is
  • Giving user readable information on the device type and subtype
  • Allowing to blacklist/disable the driver for a given device
  • Support for USB and bluetooth devices (currently not listed at all)
  • Generation of a "compatibility report" to help populate an hardware compatibility database for Haiku

Note that a lot of the work may be in making the required information available from the drivers and existing device management infrastructure, and not just in building the GUI itself.

  • Skill set: user interface, kernel and drivers interfacing (ioctl, devfs...)
  • Possible mentors: PulkoMandy, waddlesplash
  • Existing code: "Devices"

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

Drivers

Improving intel video driver

Haiku comes with a video driver for intel chipsets. However, on many supposedly supported devices, the driver will only produce a black screen with no output, confusing users and forcing them to fallback to VESA video modes.

The goal of this project is to improve the driver and fix the different problems, making sure we get video output working on all supported devices. This includes support for HDMI, DisplayPort and VGA outputs.

Intel provides documentation for each generation of device, a lot of the work is figuring out what the differences between generations are, and which part the driver is currently not properly implementing.

  • Skill set: drivers development
  • Possible mentors/knowledgeable people: PulkoMandy, waddlesplash

USB Support for FreeBSD network compatibility layer

Haiku uses a FreeBSD network compatibility layer to support many network devices (ethernet and wireless) using drivers written for the FreeBSD project. This allows reusing network drivers with very little changes, considerably decreasing the effort needed to get good hardware support in Haiku.

However, this layer only supports PCI devices, and doesn't work with USB ones. Adding support for USB to the compatibility layer would bring us support for a range of devices like so-called USB tethering, as well as USB to Ethernet and WiFi dongles.

This project consists in importing one or more USB network drivers from FreeBSD into Haiku sources. The compatibility layer should then be extended to expose the FreeBSD USB APIs to the drivers, and forwarding the calls to Haiku's USB stack. Other parts of the compatibility layers may need to be extended as well.

This should be tested either with real hardware or an emulated device in a virtual machine.

  • Skill set: kernel and driver development, USB, general C and C++ development
  • Possible mentors: waddlesplash, korli

NVMe driver

NVMe is a standard protocol for SSD attached to the PCI-express port. Unlike SATA and AHCI, it is designed from the ground up to work with solid state drives (where SATA was first designed for spinning hard disks). This allows NVMe to be an order of magnitude faster and more flexible.

The goal of this project is to implement NVMe support and make Haiku able to boot from such devices, without the need to go into AHCI mode. FreeBSD (or other *BSD) drivers may be used for reference.

  • Required hardware: computer or virtual machine with NVMe support
  • Skill set: kernel and driver development, general C and C++ development
  • Possible mentors: waddlesplash, kallisti5, jessicah, PulkoMandy

Isochronous USB transfers (USB Webcam & soundcard support)

Currently Haiku has very limited support for webcams and USB sound cards. The goal of this task is to improve the WebCam or USB audio drivers, in order to make them production ready. For both of these, the USB specification has a well-documented standardized way to communicate with the devices. Haiku has a working driver for sound cards, and an incomplete one for webcams.

The main area of work for this project would be getting isochronous USB transfers to work in Haiku. The USB specification defines various types of transfers on the USB bus, which affects the scheduling and how the data is exchanged between the computer and USB devices. The isochronous mode is used for low latency applications where a reliable and predictible timing is required (as is the case for video and audio streams).

Unfortunately, Haiku implements these transfers completely only for some USB1 controllers. There is partial support, but it is not fully working.

The first part of this task is to investigate the state of isochronous transfers and what is missing to get them working. Then, of course, actually making things work. Once this part is sorted out, the audio and webcam drivers may also need some work to get everything running smoothly.

  • Requirements: USB audio or webcam device (a laptop with built-in webcam should do)
  • Skill set: kernel and driver development, USB, C and C++ development
  • Possible mentors: PulkoMandy

GPU acceleration support

Haiku does not currently support GPU acceleration, for 3D or otherwise. Reusing most of the DRM drivers from Linux, and Mesa's Gallium userspace components, the goal of this project is to enable the use of GPU-accelerated OpenGL, and eventually also OpenCL and Vulkan.

Haiku's current video drivers are mostly modesetting-only, and split in two parts: the driver itself, which is quite minimal and only provides low level access to the video card, and the "accelerant", which runs inside app_server and communicates with the driver in order to configure the card and use its features.

Porting the DRM drivers from Linux will be a rather daunting task, as they use a large subset of the Linux kernel APIs. It may be possible to reuse OpenBSD's or DragonFlyBSD's work rather than writing our own Linux API compatibilty layer; more investigation is needed here.

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

Kernel

Power Management

Haiku already has some power management support in the form of a CPU idling driver. This is however clearly not sufficient, and there is room for improvements in several areas in order to make Haiku use less power and make laptops running Haiku last longer on battery.

Some investigation is required to identify the main issues in Haiku leading to suboptimal performance. There are however a few already known problems:

  • Some subsystems such as the network and wireless stack wake up the system at regular intervals (10 or 100 times per second) to perform some tasks. Whenever possible they should be modified to trigger these tasks in anevent-driven way (triggering them from hardware interrupts for example).
  • Some applications (such as the always-running DeskBar) are polling for events in a similar way. The APIs should be adjusted where possible to make those applications wait on notifications instead.
  • None of the device drivers in Haiku include powersaving modes. When a device is idle, it should be put to sleep and powered off until it is needed again.
  • Skill set: kernel development, general C/C++, userland development, debugging, power management / measurement

Improving the btrfs filesystem

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 btrfs filesystem, to allow it to write btrfs volumes (reading works already). During GSoC 2017, a student already got as far as creating directories, but it is not possible yet to write files. The first part of the work is to review the existing code, and report on the current status and the work needed to get everything in place.

After completion of this project, it should be possible to read and write files to btrfs volumes, making sure they are interoperable with Linux (mount without errors, file data is accessible, fsck detects no problems). Stress-testing should also be performed using bonnie++, and other test suites may also be used.

  • Skill set: kernel, and driver development
  • Possible mentors/knowledgeable people: PulkoMandy, Sean Healy, Hy Che
  • Sourcecode
  • GSoC 2017 log

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/ext3 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)
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, waddlesplash, Hy Che

x86-64: Implement support for Process Context Identifiers (PCID)

on Intel CPUs. The feature tags TLB entries with the Id of the address space and allows to avoid TLB invalidation on the context switch, it is available only on x86-64.

The goal of this task is to propose possible designs, implement the feature, extend the performance logs to measure impacts when the feature is enabled, and potentially also to mitigate the "Meltdown" vulnerability.

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

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, kallisti5

Network

Bluetooth Stack Improvements

Haiku's Bluetooth stack implements a basic subset of general Bluetooth functionality. 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, improving the existing code on newer devices (pairing, 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)
  • Possible mentors/knowledgeable people: waddlesplash

Integrate our PPP implementation

Finish porting the PPP implementation to our new network stack. Add phone-line modem support, including HDLC framing and VJC compression (porting both algorithms is sufficient, but make sure the license is compatible to MIT). Implement CHAP authentication, and add support for configuring these to the new network preflet GUI. Find and fix bugs.

  • Tickets: #812, #869, #873, #922, #923, #1059, maybe: #1057, #1058
  • Skill set: multi-threading basics, maybe network protocols and some kernel/drivers development, maybe UI development

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

User Interface

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: waddlesplash, Sean Healy, scottmc

Media

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

Other

Jam (build system) replacement/rewrite

Haiku uses Jam as its main build system. Unfortunately, Perforce is not actively maintaining the tool anymore and the codebase is not very clean. Ingo Weinhold started work on a complete rewrite of the tool in C++, with the aim of being compatible with the existing build files, but provide a cleaner codebase to build upon and do away with most of the legacy stuff.

The goal of this project is to continue this work and make ham usable to build Haiku, as well as other projects currently using Jam as a buildtool.

  • Skill set: C++, threading, build systems
  • Possible mentors: waddlesplash

Coding style checker bot for Gerrit

Haiku has its own coding guidelines which describe how the code should be formatted. There is a tool for reformatting or checking if code follows these guidelines, but it has to be compiled on the developer machine and then run manually.

The goal of this project is to integrate this tool with Gerrit, the web app we use for code reviews. It could then give quick feedback on the coding style as soon as a patch is submitted, making the review process smoother and easier.

Ideally, the changes could be run through a specific buildbot configuration, which would run haiku-format, and then post the result as comments in Gerrit pointing out the lines that need to be fixed, and give a review score to the change.

  • Skill set: REST APIs, code formatting tools
  • Possible mentors: PulkoMandy

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

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

Complex font rendering in app_server

app_server is the graphics server in Haiku. It handles the rendering and display of application windows, desktop, and everything that is shown on screen.

Freetype (in combination with agg) is used to render text. While it provides good results on its own for latin and cyrillic alphabets, Freetype is not enough on its own to properly render other scripts with more complex rules, such as Devanagari or Arabic.

The goal of this task is to integrate Harfbuzz into app_server, so that the complex rules for text rendering are properly applied. This would allow rendering of complex languages as mentioned above, as well as mixing different languages (picking appropriate fonts automatically).

This task can be further extended with investigations of API changes required in the interface kit (and in particular BView and BFont) to properly handle left to right text.

  • Skill set: C++
  • Possible mentors: stippi, PulkoMandy