Google Summer of Code 2020 Ideas

From ReactOS Wiki
Revision as of 06:25, 22 March 2020 by Cyber Toon (talk | contribs) (Added link to shell documentation.)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search

This page lists all the project ideas for our Google Summer of Code 2020 application. Students should also visit our general GSoC 2020 page for more information including a Student Guide and our contact information.

Your Own Idea!

We are eager to hear about your proposal to improve either ReactOS or its infrastructure. Come and propose your project on the ReactOS developers mailing-list or on IRC to get feedback about its feasibility. If your project is doable, we will be glad to provide you with a mentor so you can succeed in your project.

Don't forget that ReactOS is a big project and application fields are wide. You can choose between user-mode or kernel-mode development, between application, or dll/driver development, or between working on ReactOS itself or on extra tools used by developers for their daily work on ReactOS. Also if all you prefer is web development, we also have needs there.

Skills needed
Yours
Difficulty
The one you'll have set
Extras
You'll be working on your own project and be able to choose its direction along with your mentor :-).

Networking

NDIS Miniport Drivers for Common Network Cards

Network card drivers are important for a good out-of-box experience since they are the key requirement for the user's ability to download additional drivers and applications. ReactOS currently includes drivers for AMD PCnet III, Realtek RTL8139, Intel PRO/1000 (Intel 8254x family) and NE2000.

However, these drivers don't cover all modern computer systems. Prominent examples are the Realtek RTL8169/8110, the newer Intel chips connected by PCI-E (handled by the e1000e driver under linux) as well as the Broadcom BCM57XX Gigabit Ethernet adapters, which are very common these days. The latter one is also used by the official ReactOS demo laptop (Dell Latitude D531). ReactOS also lacks a driver for the DC21x4, which is the network adapter emulated by Microsoft Virtual PC/Hyper-V. Another notable example of the missing driver is NVIDIA nForce Ethernet Controller (nvnet). It's integrated into the original Xbox gaming console which is supported by ReactOS Xbox Port. A stretch goal may be getting basic NDIS 6.0 support for drivers.

Benefits
"Just works" experience on many physical computers and laptops as well as virtual machines.
References
MSDN: NDIS 5.1 Miniport Drivers
Existing built-in network driver sources
Digital Semiconductor 21041 PCI Ethernet LAN Controller Hardware Reference Manual
Start point for RTL8169
RTL8169 specification
Datasheet for the Intel 82577 PHY
Driver Overview of Haiku
RTL8169 driver for haiku in 1000 lines
An open source RTL8169 NDIS 6.0 driver
Overview of NDIS 6.0
Porting drivers from NDIS5 to NDIS6 - for getting an overview what needs to be done/adapted
Skills needed
Software Development in C and under Windows
Kernel driver and/or NDIS programming experience
Experience working with hardware specification documents

Fundamental WiFi components

ReactOS already supports the majority of drivers for cabled Ethernet controllers. Supporting wireless WiFi controllers requires additional components for enumerating networks, handling a connection and encrypting the communication. These are almost non-existing in ReactOS right now, and WPA encryption is entirely unsupported. Having WiFi components would greatly improve the ReactOS experience on mobile computers.

The student should implement the basic components for WiFi connections found in modern Windows versions (NT6 and later). The components should support connecting to unencrypted and encrypted WEP/WPA/WPA2 networks. We're deliberately not targeting WinXP (NT5) here, because of major architectural changes in the WiFi components since then.

References
Windows Vista DLLs and function descriptions
802.11 Wireless LAN Objects
Native Wifi functions
wlanmsm.dll RPC Interfaces
Exports of wlansec.dll
WiFi Password Secrets
CORE-11924
CORE-6905
Needed Skills
Software Development in C and under Windows
Familiarity with Windows networking
Previous experience with RPC would be a plus

Automatic Proxy Configuration

Useful for: End-users

Certain network configurations, especially in businesses, require proxy servers to access the internet. If the local network is setup up appropriately, modern operating systems can automatically determine the correct proxy server to use. This is made possible through Proxy Auto-Configuration (PAC) files and the Web Proxy Auto-Discovery Protocol (WPAD).

Benefits
Automatic "just works" internet access in additional environments
Networking support in business settings
References
Wikipedia: WPAD
Proxy Client Autoconfig File Format
Wikipedia: PAC
Skills needed
Software Development in C and under Windows
Familiarity with Win32 APIs
Familiarity with relevant technologies like DHCP and JavaScript

Windows Remote Management

Useful for: End-users and developers

WinRM is a Web Service that allows remote management of Windows machines. This includes authentication as well as remote execution of PowerShell and other scripts.

WinRM can be seen as Windows' equivalent to SSH, and it is useful for remote administration, automated machine setup as well as test automation.

Benefits
External automation tools such as Ansible could control ReactOS machines
Automated testing could make use of WinRM, both in VMs and on real hardware.
References
MSDN: Windows Remote Management
MSDN: WS-Management Protocol
WS-Management Specification
Skills needed
Software Development in C and under Windows
Familiarity with Win32 APIs and Networking
Familiarity with web service development, e.g. HTTP, SOAP, XML

Integrating SMB into ReactOS

Useful for: End-users and developers

SMB/CIFS is omnipresent for file sharing under Windows. It's one of the features new users to ReactOS always expect and then cannot find anywhere.

As such, ReactOS finally needs an implementation of SMB properly integrated into the operating system. SMB heavily relies on RPC and UNC paths and previous work in both areas exists. A potential developer should base the work on the mature Samba Open-Source implementation of SMB. However, Samba is developed for UNIX systems and therefore parts of its code require careful porting to create a native implementation for ReactOS.

Benefits
Having SMB would highly improve ReactOS' abilities to transfer files over the network, both for users and developers! It would also lay the groundwork for other Windows network services such as Printer Sharing.
References
Samba Wiki
MS-SMB Server Message Block (SMB) Protocol Open Specification (and related ones on this site)
Samba-TNG (archive) was an effort to rewrite unix samba libraries into a more NT like architecture. They already work in Windows/ReactOS, archival copies are available here source and binaries. There is even a video of how to use it.
Samba-TNG Wiki (archive)
Skills needed
Software Development in C and under Windows
Familiarity with Win32 APIs and Networking
Experience with gluing code of different projects together
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

Terminal Services

Useful for: End-users and developers

Implement support for terminal services, allowing inbound remote desktop connections to ReactOS. This encompasses implementation of input and video drivers to handle output over the network.

The terminal services system provides functionality for securely connecting remote clients and servers, for channeling communication between components of remote clients and servers, and for managing servers. It implements the Remote Desktop Protocol (RDP) which is a multi-channel protocol that allows users of a remote client to connect to a server over a network.

Benefits
Terminal services support would allow ReactOS to serve as a terminal server/thin client server. Organizations that wish to provide a shared workstation with Windows would have a free alternative that does not have complex licensing terms covering multi-session usage. The display driver for terminal services can also be used to support fast user-switching and even possibly multi-monitor support.
References
ReactOS Terminal Services
https://github.com/FreeRDP/FreeRDP/wiki
Skills needed
Network development experience.
Driver development experience.
Knowledge/familiarity with RDP protocol.

Audio/Video

Get video drivers from AMD/ATI/NVIDIA running stable

As of today, most original drivers from GPU manufacturers do not work at all or only very unstable. Because of that, even our "demo laptop" (a Dell D531) with its ATI Radeon Xpress X1270 is very slow. This project is for getting such a driver up and running in a stable manner. The first step would be to fix the bugs in the PnP manager (e.g. as https://jira.reactos.org/browse/CORE-14464) - some patches are already around (e.g. vgal's ones). Then the base driver needs to get running more stable - which will involve fixes e.g. in win32k (e.g. more parameter checks) or other components (which emit wrong parameter). As extras, the OpenGL part could be tried.

References
Reported bugs for the ATI driver: https://jira.reactos.org/browse/CORE-14479?jql=labels%20%3D%20ATI
ATI Driver: https://mifritscher.de/austausch/reactos/R163694.EXE
Benefits
A much faster demo laptop
Support for a major vendor of GPUs
Skills needed
Software Development in C and under Windows
Experience with hardware drivers
As a plus: Experience with the video stack
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

Intel High Definition Audio Bus Driver

Implement support for the Intel High Definition Audio specification for sound cards. ReactOS has the beginnings of the HD Audio Bus driver but it needs to be completed and tested.

Benefits
Modern audio cards use the Intel High Definition Audio specification. Therefore they rely on a bus driver to communicate with the audio hardware. The goal is to complete the bus driver which supports those new cards. The driver needs to work on a Microsoft NT system, and be ready to support ReactOS now or in the future.
References
Existing hdaudbus driver: https://github.com/reactos/reactos/tree/master/drivers/wdm/audio/hdaudbus
HD Audio Device Driver Interface whitepaper: http://msdn.microsoft.com/en-us/windows/hardware/gg462966
Programming the HD Audio DDI: http://msdn.microsoft.com/en-us/library/ff536442%28v=vs.85%29.aspx
HD Audio Bus Drivers: http://msdn.microsoft.com/en-us/library/ff536434%28v=vs.85%29.aspx
Skills needed
Kernel driver programming experience
Bus driver programming experience
Familiarity with Intel HD Audio specification
Audio kernel streaming

Audio Mixer

Implement support for mixing of audio streams.

Benefits
An audio mixer is responsible for routing of multiple audio streams. This would be very beneficial to ReactOS as audio driver support has improved yet the use of these drivers is limited by the lack of an audio mixer. At the end of the project multiple audio streams should be able to be played at the same time.
References
Audio Mixer Reference
DirectKS Sample Application download
Programming Services
"Secret Rabbit Code" (SRC) Sample Rate Converter aka libsamplerate
Skills needed
Windows Services familiarity
Basic Audio file format familiarity
Audio mixing algorithms / libraries familiarity
Basic kernel streaming familiarity

Durability

Kernel mode test suite

Useful for: Developers

Improve our existing kernel mode test suite (created by a previous successful GSoC student) by adding comprehensive new tests in areas previously untouched by the test suite such as the kernel caching APIs and PnP. The goal is to extensively test Native API functions exported by the kernel. Reference behavior could be checked by running the test suite against the corresponding Windows operating system.

Benefits
Improved system stability.
More information about undocumented behavior.
Improved compatibility with third party drivers.
Skills needed
Native API knowledge
NT driver development skills

Win32k test suite

Useful for: Developers

Right now we have basically no tests that cover the win32k module. As win32k is the cornerstone of the interface between the Win32 Subsystem and the display drivers, lack of tests leads to inconsistency, guesswork and frustration when it comes to improving driver compatibility. A virtual display driver (à la kmtest.sys) allows us to test the functionality and behavior of win32k. If time permits, it would also be possible to add a mechanism to test videoprt.sys functionality, and the relationship between a display driver and its miniport counterpart.

References
Windows 2000 display driver model reference
Benefits
Improved stability.
More information about undocumented behavior.
Improved compatibility with third party drivers.
Skills needed
Display drivers development experience
Win32 API knowledge

Shell Enhancements

Modern Start Menu

ReactOS has the classic start menu implemented, which works well but is somewhat limited.

Implementing the modern start menu would bring us such goodies as pinned Applications, default places and maybe also a search field.

Benefits
A more comfortable browsing experience for applications and places
Some more freedom of choice, regarding look and feel, for the user
References
https://jira.reactos.org/browse/CORE-9277
FIXME: Someone please add a link to the great shell documentation map by Giannis
This one? https://reactos.org/wiki/Shell_Documentation
Skills needed
Development in C/C++ and under Windows
COM knowledge

Implement iernonce.dll

ReactOS is able to launch commands, once the explorer started, just for one single time. This is executed silently and the progress is hard to track.

The graphical alternative would show which command runs at the moment and give the user some kind of feedback.

Benefits
A better possibility to add bundled Software
A better optical feedback for the user
References
http://robhaupt.blogspot.com/2008/07/using-runonceex.html
https://jira.reactos.org/browse/CORE-7194
Skills needed
Development in C/C++ and under Windows
COM knowledge

System Enhancements

Integrating a modern C++ standard library

To attract new developers, speed up development and make it less error-prone, the ReactOS Project wants to leverage the features of modern C++. This requires a C++ standard library supporting at least C++11 and C++14. However, ReactOS currently uses an unspecified version of GNU libstdc++ when built with GCC and the largely unmaintained stlport when built with MSVC. This limits us to C++98 features, and having two libraries is the root cause for many subtle problems.

As ReactOS is one of the few operating systems, which can be built with both GCC and MSVC (and possibly Clang in the future), we need a modern C++ standard library that is compatible with all of them. Candidates are LLVM libc++ and Microsoft's [STL https://github.com/microsoft/STL/]. Being an operating system, the standard library also needs to be integrated into our source tree and built through CMake.

In this task, the student shall evaluate both C++ standard libraries regarding features, compatibility with our compilers, and required customizations. The student shall then proceed to integrate it into our source tree and get it to build together with the rest of our code. Some of our few current C++ applications may need minor fixes for that.

Note that LLVM's libc++ and Microsoft's STL are just two C++ standard libraries we found. Any other library under an OSI-approved license is welcome as well.

Benefits
Accelerating ReactOS development by attracting more C++ developers and easing the work for the existing ones
Fixing a lot of subtle bugs due to the current usage of two different C++ standard libraries
References
LLVM libc++
Microsoft STL
stlport in our current source tree
cpprt in our current source tree
Skills needed
Development in C++, including modern C++11 and C++14, down to the runtime level
Knowledge about the CMake build system
Basic debugging skills


UI Automation API

Accessibility is an important part of any operating system. Windows supports internal and external accessibility tools using its Automation API.

Adding support for these (currently completely absent) APIs to ReactOS would set the foundation for an OS usable by everyone. One approach for a project may be attempting to get the open source screen reader software "NVDA" to run on ROS.

Parts of this work may be suitable for submission to Wine, which would extend the usefulness beyond just ReactOS as well as simplify future maintenance of those components.

Benefits
Applications depending on these features may start to work in ReactOS
Adding support for accessibility shows that we care about all our users
References
Windows Automation API Overview
MSDN: UI Automation
NVDA Screen Reader
Skills needed
Development in C/C++ and under Windows
COM knowledge
Basic debugging skills


Applications Manager Rapps

Useful for: End-users

RAPPS is a lightweight GUI utility which downloads and installs various popular apps and redistributable packages in Windows and ReactOS. It can be significantly improved in various ways to become a really useful tool for not only for ReactOS but for Windows users also who want to manage their installed applications like Steam manages games installation/updating.

A list of possible features to be implemented:

  • Mainly:
 - document and improve support for command line parameters to RAPPS. For example: "rapps install chrome" (just like your favourite Linux distro package manager) or "rapps remove msvc2010_redist". Currently, RAPPS has very limited command line support.
 - Separate the download and install operations so that a user could choose just to download the apps into a local cache and install some or all of them later (just like Steam or NVidia's driver updaters first does Download then asks to Install, for example)
 - document and improve support of "automated installation" of simple apps by unpacking the archive they come in and execute a script inside it (if any) which creates shortcuts on the desktop


  • Optionally:
 - https://docs.google.com/document/d/1_SVqMk1VU75tjAnnE5oz20iU8fy5fQpPf5vwTf3bnEk/edit?usp=sharing
Skills needed
WinAPI
C/C++
Difficulty
From Low to Medium
Note

This project idea is a stub. Please talk to a mentor for additional information and references.

Extras
A chance to work on an app potentially used by many people throughout the world
See article RAPPS

Paravirtualization Support

Virtual machines are increasingly common in all fields of computing. To increase VM performance, paravirtualization bypasses the emulation of traditional hardware (such as specific network or storage interfaces, or even the entire PCI bus) and uses specially crafted drivers in the guest OS to more directly interface with the hypervisor. The guest OS kernel can also be modified to directly interact with the hypervisor for CPU and memory management operations, leading to improved performance.

There are many choices of projects in this space, such as:

Making Xen's open source drivers work in ReactOS
Creating an initial set of drivers to support "enlightenment" under Hyper-V
Enhance the kernel to make use of hypervisor functionality for low-level operations (e.g. via VMI)
Testing and integrating VirtIO drivers, VirtualBox Guest Additions and/or open-vm-tools into ReactOS
Implementing automatic hypervisor detection during setup or in the applications manager to simplify the installation of the appropriate VM guest drivers

Note that these projects can vary greatly in difficulty. Please consult with a mentor to ensure your skill set and the scope of your proposal match up to make a realistic project.

Benefits
Avoid non-free or unavailable alternative drivers
Improved out-of-the-box functionality in virtual machines
Integration of kernel features that may improve VM performance
References
Xen Windows PV Drivers
open-vm-tools
VirtualBox Guest Additions
Linux Hyper-V drivers
The VMI virtualization interface
Skills needed
Experience with the Hypervisor of your choice, and preferably its paravirtualization interface
Development in C and under Windows

NT6 recycle bin support

In a (much) older GSOC project recycle bin support was added for nt5 operating systems. Now it is time to add support for reading and writing in recycle bin created by more modern operating systems.

Note
This project idea is a stub. Please talk to a mentor for additional information and references.

Improving the quality of our Registry Hive implementation

ReactOS features a basic implementation of the Windows-compatible Registry Hive format for storing system and application settings. There are two major areas where our current implementation could be improved:

  1. When ReactOS crashes, Registry Hives easily get corrupted and render the whole system unbootable. The reliability of the Registry Hive implementation shall be improved to make the effect of crashes less severe and also recover from partly corrupted Hives.
  2. Hives created by our mkhive tool are roughly compatible with the Windows format. The only part that is currently missing are the implementation of Security Descriptors. Implementing these could make the tool more usable and improve interoperability between Windows and ReactOS.

Related components in ReactOS are the cmlib library, the ntoskrnl Cm, and the mkhive tool.

References
"The Internal Structure of the Windows Registry", MSc Thesis by Peter Norris, BSc (Hons), MBCS: http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/
Offline NT Password and Registry Editor: http://pogostick.net/~pnh/ntpasswd/
Bug reports CORE-6762, CORE-9195 and CORE-10793.
Skills needed
Development in C
Kernel-mode development
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

Performance Data Registry

Access to performance data on Windows is done primarily through the registry API, accessing something known as the performance data hive. This hive does not exist as a genuine file but is in reality a collection of data exported by various OS components, drivers, services, and even applications. Many of the performance values provided through the performance data registry is not available in any other form. The absence of support for performance counters renders many diagnostic utilities from Microsoft broken and is also an impediment to application compatibility. Condor is an example of a third party application that uses the performance data registry for process and resource usage tracking.

Benefits
Besides application compatibility, the performance data registry is one of the most difficult to use public interfaces in Windows. The layout of its data structures makes querying and accessing values a highly manual process. Documentation produced from this effort would provide better guidelines for third parties to access the performance data registry and better use the information published by the system and Microsoft's own applications such as the .NET runtime or the IIS service.
References
Description of performance counters and types in Windows 2003: http://technet.microsoft.com/en-us/library/cc776490%28WS.10%29.aspx
Performance counter data structures: http://msdn.microsoft.com/en-us/library/aa373093%28v=VS.85%29.aspx
Example code for accessing performance data through registry: http://msdn.microsoft.com/en-us/library/aa373219%28v=VS.85%29.aspx
Skills needed
Registry API familiarity.
Performance registry structure familiarity.
Performance counter familiarity.

Management Console

Implement Microsoft Management Console (MMC). The MMC provides an interface for various management tools, both from Microsoft and third parties, called snap-ins. These snap-ins are standalone programs dynamically loaded into an MMC console to perform a specific configuration task, such as configuring a network or managing disk drives.

Benefits
Easier snap-ins development.
Consistent user interface of management tools.
One configurable place to access key management and configuration apps.
References
What is MMC
Developing for MMC 3.0
Some early work on MMC
Skills needed
Basic Windows development experience.
Knowledge of COM.

Xbox executable support

ReactOS has an original Xbox port but it can only run Windows applications and lacks the ability to run actual Xbox executable XBE files.

A new non-Desktop variant of ReactOS for running Xbox games must be created to accomplish the task. This variant would be specifically meant to run on Xbox hardware, and would have to support Xbox kernel functionality.

Specifically, the XBE loading must be implemented but probably also various other tasks related to memory management and more.

Benefits
Ability to run original Xbox games on your original Xbox (or in the XQEMU emulator) in a trusty and fully open-source environment
Attract new developers with low-level programming skills to the project
References
Run Xbox Games on ReactOS
Skills needed
Solid skills in C and Reverse-Engineering
Kernel-mode development experience would be a huge plus
Other requirements
Access to a physical Xbox, either:
  • Softmodded original Xbox
  • Hardmodded original Xbox
  • Original Xbox hardware revision from 1.0 to 1.5 - this is required for dumping MCPX ROM for emulation. Revisions from 1.6 and higher are not recommended and harder to work with.
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

Debugging Improvements

PDB support for dbghelp

Making it possible for our dbghelp read pdb files would improve our ability to debug ReactOS directly in user mode with tools like WinDbg, Process Explorer and more. We could also be able to have small tools for reporting crashes and translating addresses automatically.

Cross-platform KD Debugger Implementation

Microsoft's kd.exe and its GUI counterpart WinDbg allow kernel debugging Windows (and ReactOS) machines. Unfortunately these tools are Windows-only and proprietary.

In order to broadly support the more advanced KD debugging protocol instead of the text-based KDBG we use in GCC builds, we need cross-platform versions of these tools.

Benefits
Support for debugging on additional hardware platforms
Improved debugging speed, easier and more reliable setups
References
ReactOS wiki: KD
Radare2 ticket for KD support (links to much existing work and documentation)
Skills needed
Software Development in C/C++
Kernel Debugging experience
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

Support for Additional KD Transports

ReactOS debugging is currently most effective when using a serial port. Many real hardware systems no longer have serial ports, leaving on-screen debugging as the only viable alternative.

Windows supports debugging via the KD protocol using transport mediums other than serial lines: 1394, USB3, ethernet, and the undocumented KDVM protocol supported by Hyper-V and other Hypervisors. ReactOS should be made compatible with these additional transport providers, and open source versions of these providers should be created.

Benefits
Support for debugging on additional hardware platforms
Improved debugging speed, easier and more reliable setups
References
MSDN: 1394 Debugging
MSDN: Network Debugging
MSDN: USB3 Debugging
OSR: KDNET Debugging
Existing KDCOM transport dll
Skills needed
Software Development in C and under Windows
Kernel Development and Debugging experience

Crash Dump Support

When Windows crashes, it writes a memory dump file that can be used for analyzing the crash later. This allows detailed analysis of the problem even if kernel debugging is not set up, and also makes it possible for an expert to investigate on their own computer after the fact.

Benefits
Detailed information about crashes without requiring the user to perform kernel debugging
Possibility of automatic crash reporting
References
Blog post: Understanding Crash Dump Files
Exploring the Microsoft Windows crash dump stack
MSDN: Dump File Format (Windows CE)
Blog post: DMP file structure
Skills needed
Software Development in C and under Windows
Kernel Development and Debugging experience
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

User-mode APIs

Implement NTLM authentication provider in secur32.dll

At this point, ReactOS requires a 3rd-party package (Samba) for NTLM auth which is required for some apps (most notably, Office 2010). Implementing NTLM (and other providers, possibly) will improve out-of-the-box experience of ReactOS.

Benefits

Office 2010 and a lot of other apps will work without hacks

Skills needed
Software Development in C/C++ and under Windows
Win32 API knowledge
Basic debugging skills
Basic understanding of how NTLM protocol works
References
See CORE-12601 ticket for additional information about this task
Word 2010 support weekly report - Part 4
Branch "sspi-bringup" where this work was been started in 2011
NT LAN Manager (NTLM) Authentication Protocol
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

Fixing function Control_RunDLLW in shell32.dll

There is the problem in shell32!Control_RunDLLW. There are several failing tests for that. It is available to anyone feeling like fixing a function that parses a string and tokenizes it.

Benefits

Ability to start 3rd party applets from Control Panel

Skills needed
Software Development in C/C++ and under Windows
Win32 API knowledge
Basic debugging skills
Note

This project idea is a stub. Please talk to a mentor for additional information and references.

References
https://jira.reactos.org/browse/CORE-8981
https://git.reactos.org/?p=reactos.git;a=blob;f=dll/win32/shell32/wine/control.c;hb=5f11c16ca87bdb6528462198a2a5ef284678c7e7#l873
https://www.reactos.org/testman/detail.php?id=40923363&prev=0

Microsoft Delta Compression API (mspatcha.dll)

Multiple application installers require the ApplyPatchToFileW function from mspatcha.dll (Microsoft Delta Compression API) to be implemented.

Delta Compression is a differential compression technology developed by Microsoft. While it has mainly been used for Windows Updates, Delta Compression offers other uses as well. A basic implementation of this is present, but it needs a lot of work and investigation to better support patch files. Most flags and options are currently hard-coded based on a fixed set of test files.

A first step would be to create more tests, using various options and bigger inputs / outputs, and optionally find real-world 'patch' files that can be included in the tree (check the license!). This should result in a better understanding of the patch file format.

The next step would be to actually implement the code to support the extra options in our mspatcha.dll

One **big** unknown is the compression used, which is based on lzx. The compression used in SQL Express 2008 does not seem to decompress with the current lzx implementation. At the moment it is unknown if this is due to the lack of understanding of the patch format, or because lzx needs some patches.

Benefits

Ability to natively install Acrobat Reader 11, MS SQL Express 2008 and many other apps that rely on Microsoft Delta Compression API

Skills needed
Software Development in C or C++ and under Windows
Basic debugging skills
Basic Win32 API knowledge
Knowledge about / understand of compression
Knowledge about binary file formats
Note

This project idea is a stub. Please talk to a mentor for additional information and references.

References
https://docs.microsoft.com/en-us/previous-versions/bb417345(v=msdn.10)
https://blogs.msdn.microsoft.com/jmstall/2006/11/07/binary-patching-tools-mspatcha-mspatchc/
https://bugs.winehq.org/show_bug.cgi?id=12501
https://jira.reactos.org/browse/CORE-8550
https://jira.reactos.org/browse/CORE-15417

Win32 Subsystem

Multi-Monitor Support

Implementation of multi-monitor support has been almost nonexistent until now. Display device drivers expose them thanks to the HwVidGetVideoChildDescriptor callback, which videoprt.sys uses to enumerate monitors attached to it then to pass the information to win32k.sys. It is then the role of win32k.sys to make the link between the two (or more) monitors, either cloning or extending the desktop and exposing the relevant features to client applications.

Benefits
Multi-monitor support would allow ReactOS to become a serious player in professional desktop applications given the increasing number of double-screen installations present in modern workspaces. Document comparison, permanently visible e-mail reader or presentation applications are just a few benefits professionals get when using multiple monitors.
Multi-Monitor support would also find its place in the casual computing experience. Writing e-mails while watching a movie, or chatting with friends about current football play are things people do in the 21st century!
From a technical standpoint, properly supporting this feature would improve driver support and WIN32 application compatibility for APIs such as EnumDisplaySettings.
References
http://msdn.microsoft.com/en-us/library/windows/desktop/dd145071%28v=vs.85%29.aspx
http://msdn.microsoft.com/en-us/library/ff569172%28v=VS.85%29.aspx
http://www.vesa.org/
Virtualbox video driver source
Skills needed
Experience with Windows display drivers.
Experience with WINAPI, especially gdi32/user32.: Experience with PnP, as this feature would require detection of connected monitors: Experience with EDID/VESA standards.
Difficulty Note
This is a formidable task. Please get advice from a mentor regarding the recommended skill level and possible reductions in scope to ensure your project proposal is realistic.

User mode printer driver support

One of the last parts of the printer stack that is missing from printing support is support for user mode printer drivers (renderers). The scope of this project is to implement support for user mode printer drivers in the window manager (win32k).

Note
This project idea is a stub. Please talk to a mentor for additional information and references.

Multi-Session Support

Supporting multiple sessions is a prerequisite for Terminal Services.

Note
This project idea is a stub. Please talk to a mentor for additional information and references.