This page contains a list of possible student projects related to Open Watcom. I am involved in Open Watcom's development, and I would love to get some students involved as well. The purpose of this document is to answer the question: "What can I do?"
I've tried to come up with projects that would be a useful contribution to Open Watcom and at the same time cater to different skill levels and areas of interest. You don't have to be a programming expert to contribute in a useful way. However, my primary interest is in the C++ compiler, libraries, tools, and documentation. The list of projects below reflect that bias. If you are interested in some other aspect of Open Watcom (the editor, the IDE, MS-DOS support, Linux support, the Fortran compiler, etc), that is fine as well. Let me know what your area of interest is, and I can try to give you some other ideas for ways to contribute. Keep in mind that most of the Open Watcom code base is written in C, with some C++.
I've tried to organize the list of projects below approximately in order of increasing difficulty. However, don't be afraid of the more complex projects. Keep in mind that you do not have to know how to do any one of these projects right now. As you study a particular project and start to work with it, you will find your skills increasing. Also, you will not be working on any of these projects in isolation. I will work with you—both to help you get up to speed and throughout the project as well. In addition, I will put you in contact with the Open Watcom community where you can get help from other Open Watcom contributors.
Create a Build Server for OS/2. Currently, Open Watcom is built regularly using GitHub Actions under Windows and Linux. Reasonably comprehensive testing is also done on those platforms. However, Open Watcom intends to fully support OS/2 development, but right now the system is not adequately tested on that platform. What is needed is for someone to set up and configure a continuous integration server on OS/2.
Increase the Scope of Automated Testing. Currently, the continuous integration servers only run the regression tests on the C, C++, and Fortran compilers, and on the Assembler. There are, however, many other components to Open Watcom that are currently not being tested with regularity. What is needed is someone to look into automating the testing of some of these other components. Note that test suites exist in some cases; it is "just" a matter of automating their execution and evaluation.
Create a FreeDOS Test System. Currently, Open Watcom can not be built on FreeDOS, but it does support FreeDOS as a target. However, there is no methodical testing being done on the FreeDOS platform. What is needed is someone to set up a FreeDOS test station (could be in a virtual machine) that can automatically run all the regression tests on a daily basis. This would be similar in configuration to a continuous integration server, except that it would not actually do any building. Instead, it would transfer the results of a recent build from one of the full continuous integration servers.
Enhance Open Watcom's Linux Support. Support for Open Watcom on Linux is still classified as experimental. Although it is currently possible to use Open Watcom to build Linux programs, there are many limitations and restrictions on what can be done and on how well things work. What is needed is for someone to work on cleaning up the Linux support. There are many aspects to this, some tasks would be fairly simple (testing, tweaking header files, etc.) and some would be advanced (getting the GUI library working on Linux). This project is in progress. If you are interested in it, I can put you in contact with the other Open Watcom contributors who are working on it.
Build Open Watcom on OpenIndiana. The OpenIndiana system is another free Unix system with a significant following. It is unknown how well Open Watcom would build on that system (Open Watcom's "bootstrap" builder can supposedly build Open Watcom on any "reasonable" Unix. However, it may not really work). What is needed is for someone to try building Open Watcom on OpenIndiana and document or fix any problems that arise.
Reactivate the QNX Target. The old commercial Watcom compiler could use QNX as both a host and a target. Support for QNX disappeared when Watcom went open source because it relied on a critical library that could not be legally redistributed. What is needed is for someone to look into obtaining (perhaps writing) a replacement for that library and then reactivating the QNX support. Note that most of the QNX support is still present in the code base. This project is advanced.
Enhance the Sample Programs. Open Watcom is distributed with a collection of sample programs illustrating how to do various things with the system. Many of these samples are quite old and, in some cases, no longer work properly. What is needed is someone to check and update the existing sample programs, and add new sample programs as appropriate.
Port Third Party Libraries. The more libraries that support Open Watcom, the more useful Open Watcom will be. The idea here is for you to try compiling a third party library of your choice with Open Watcom and then fixing, or at least documenting, the problems that arise. The steps needed to make each library work with Open Watcom should be added to the Open Watcom wiki. In some cases bugs in Open Watcom itself may be discovered and these should be added to Open Watcom's issues list. Ideally you would also get connected with the developers of the third party library and get any Open Watcom related fixes copied back into their code base.
Open Watcom STL Functional Tests. The OWSTL test suite could use enhancement. Many of the components are inadequately tested or even, in some cases, not tested at all. The testing framework is already in place. What is needed is someone to review existing test cases and add new ones.
Activate the "Safer C" Library in C++. Open Watcom supports an extension to the C library designed to make C programming safer. Currently, this extension is not available to C++ programs. What is needed is for someone to enable this extension for C++. This might only entail making a few adjustments to the library header files.
Fix the Browser. One of the tools supplied with Open Watcom is a code browser. Currently, it does not work properly with C++ because of an incompatibility between the debugging information emitted by the compiler, and that expected by the browser (the problem is related to C++ namespaces). It would be nice to get this fixed. What is needed is someone to dig into this matter and resolve it.
Implement a Modern IOStreams Library. Currently, Open Watcom comes with an old style IOStreams library. That library needs to be completely overhauled and modernized. What is needed is for someone to build and test a new IOStreams library in parallel with the existing one. Once complete, the new library could be "swapped in" as the main IOStreams library for Open Watcom C++. This project is advanced.
Implement Standard Threads. C 2011 (and C++2011) require a standard interface for writing multithreaded programs. The idea would be to write a C library that implements that interface for all target platforms that can reasonably support it (Windows, Linux, OS/2). The C library could then be used to implement C++ standard threads as part of the evolving C++ 2011 library. This project is advanced.
Finish C++98 Support. Open Watcom C++ still lacks some critical, even if relatively exotic, features from C++98. Implementing them would make the compiler C++98 compliant and would enable more use cases. This entails both changing the compiler itself, and completing the C++ library (many missing components rely on missing language features). See the Wiki for more information. This project is very advanced.
Implement C++2011 Support. Open Watcom's C++ 2011 support is currently minimal. Ultimately it would be desirable to fully support C++2011 so any work that makes progress on that goal would be welcome. This entails about language and library enhancements. This project is very advanced.
Connect Open Watcom to the LLVM Back End. LLVM is an advanced compiler back end that can do whole program optimization, and that targets a wide variety of processors. It is an active project of its own and supports several language front ends from various suppliers. What is needed is for someone to write a special code generator that can take the intermediate language produced by the Open Watcom compilers and output LLVM assembly language. This would enable Open Watcom to take advantage of LLVM and of all the processor targets supported by LLVM. This project is very advanced.
Implement the Preprocessor Scopes Proposal. Bjarne Stroustrup has proposed a new preprocessor feature that would resolve the preprocessor's current lack of scope control and make C/C++ libraries much more reliable. I would like to implement this proposal for Open Watcom. This project is advanced.
Implement Modules. C++ 2020 adds support for real modules to C++. This is an important feature with far ranging consequences. It would be wonderful to see this capability in Open Watcom C++. This project is very advanced.
Document Open Watcom STL. Right now the OWSTL components are completely undocumented. We have felt we could get away with this temporarily because the standard library is well documented in other places. However, eventually we should add complete OWSTL documentation to the C++ Library documents we distribute with the compiler.
Maintain the Wiki. The Open Watcom Wiki depends on members of the community to maintain and update it in order to keep it current, relevant, and accurate. There are many potential aspects to this project. I invite you to browse the wiki and see what is there. Consider what kind of information you might want to see there and add it. Consider ways to improve the way the current information is organized and reorganize it.