Introduction
For Fall 2026 and Spring 2027, I have opportunities available to work on open-source software projects for experience and academic credit. These projects are expected to be long-running. Some of the applications are intended for use within the University, while others are to support a custom Linux desktop environment. This custom desktop environment will be usable on both general-purpose systems and resilient, off-grid small computers (such as Raspberry Pi devices running on battery or solar power).
Interested Coastal Carolina University students are welcome to contact me at mmurphy2@coastal.edu for more information about project availability. Academic credit for CSCI 399 (1-3 credits per semester, up to 12 total credits) is available for qualified students. Please note that I generally require a 2.75 or higher GPA for CSCI 399 eligibility. There are no GPA requirements for non-credit participation, but I strongly advise you to focus on your regular coursework to raise your GPA before pursuing side projects.
Audio Visualization for TealPlay
TealPlay is an open-source (MIT licensed) media center application that can play media files. It supports a locally-hosted media library, which can be used in offline/off-grid applications. Since TealPlay does not send out any data, it is also private. One can use TealPlay to watch a video without being watched by a video hosting platform.
One major feature that is still lacking in TealPlay is support for proper audio visualizations when playing music. There appears to be a way to decode the audio file programmatically in Qt for Python, which is the GUI framework that TealPlay uses. However, the resulting data from the decode will be in the form of raw bytes. In order to visualize the audio, Fast Fourier Transforms (FFTs) will be required to extract frequency data. From there, other mathematical algorithms and graphics programming techniques will be needed to generate the visualizations.
This project requires the following skill set:
- Strong Python programming ability.
- Good software design/engineering and problem-solving skills.
- An interest in experimenting and tinkering. This project will be at the outer edges of Qt for Python and will likely require NumPy or a similar library. Multiple solution attempts will likely be needed to find one that works.
- Math skills are required, ideally an Applied Mathematics minor or at least differential and integral calculus (MATH 132 or 160).
CSS Parser
An ongoing but not yet released project is the TealSite static site generator. TealSite uses HTML and CSS Selectors Level 3 to implement its template system, so it already has a CSS selector parser. However, it would also be nice if TealSite could manage, merge, and supplement CSS stylesheets automatically. Such a capability would benefit more complex websites without requiring additional software like Sass.
The first step in processing general CSS stylesheets is to implement a stylesheet parser, which uses a context-free grammar. Since this code will be pure Python to match the rest of TealSite, a hand-coded recursive descent parser will be used.
This project requires the following skill set:
- Strong Python programming ability.
- An interest in learning about parsers, including context-free grammars, Extended Backus-Naur Form, and recursive-descent parsing. Some prior exposure to a few of these concepts would be helpful but is not strictly required.
- An interest in learning to use regular expressions in Python, since the stylesheet tokenization step will use a regular grammar. Some experience with regular expressions would be helpful.
Desktop Panel for Wayland
An ongoing project is in progress to create a lightweight but easy-to-modify desktop environment for Linux using the Labwc Wayland compositor. Labwc does not include its own desktop panel, so the current iteration borrows the panel from LXQt. We'd like to have our own panel instead, coded in Python and Qt for Python to make it easy for future students to explore and modify.
In order to implement the panel properly, it will be necessary to generate bindings for LayerShellQt, which allows a Qt widget or window to speak the wlroots layer shell protocol in order to position itself correctly on the screen. An existing project to create Python bindings already exists under a compatible license, although it might need to be updated for recent Qt versions.
This project requires the following skill set:
- Strong Python programming ability.
- Familiarity with Linux operating systems and desktop environments.
- Graphic design skills sufficient to create a panel that isn't too ugly.
Live Desktop Creator
I have created a framework and prototype toolchain for building Alpine Linux desktop environments that run entirely from RAM. At today's RAM prices, however, it would be beneficial to have the ability to run from a read-only backing store using SquashFS as an alternative. The toolchain should also be rewritten in Python to make it easier to read and maintain in the long run.
Since most existing Linux live environments already use SquashFS, plenty of examples are available. The main challenges with this project will be to understand my existing Bourne/Almquist shell code and find pragmatic Python idioms to replace convenient shell script expressions.
This project requires the following skill set:
- Strong Python programming ability.
- Strong Linux operating system skills. Exposure to a variety of distributions would be beneficial.
- Some prior experience with shell scripts (sh, ash, bash, or zsh).
Scientific Data Plotter
One desired capability for the (not-yet-released) TealSite static site generator is to ingest a raw data file and produce a plot, chart, or other visualization in Scalable Vector Graphics (SVG) format. SVG is desirable, since it can scale cleanly on the Web regardless of the device used to display the plot (cell phone, laptop, projector, etc.). An author would only need to include a custom HTML tag that refers to the data file and configures the plot. TealSite would produce the graphic file and optionally generate a link to download the raw data.
The excellent Matplotlib package can generate SVG plots from Python code already. Most of this project will involve designing the custom HTML tag and integrating Matplotlib into the existing TealSite code (also Python).
This project requires the following skill set:
- Python programming ability.
- Ability to follow tutorials and read instructions for using and integrating Matplotlib.
Web Browser
I generally recommend and use LibreWolf as my primary browser. However, there are some websites that have only been coded and tested using Blink-based browsers like Chrome or Edge. Through initial testing, I've found that most of these sites work with Qt WebEngine, which can be easily incorporated into a Qt for Python GUI.
Thus far, I have a rather primitive example browser that contains the Qt WebEngine widget, an address bar, and a back button. A long-term project would be to create a proper browser that has the usual features with content blocking capability. Given the primitive nature of the existing code, this option is essentially a greenfield project with a lot of options.
This project requires the following skill set:
- Python programming.
- An ability to read documentation and do a lot of experimentation. Qt's documentation is generally good, but there is still a lot of trial and error involved in GUI programming.
- Prior experience creating GUIs is beneficial but not strictly required.
ZIM Viewer
The Kiwix Association has developed an efficient way to provide offline copies of resources including Wikipedia, Project Gutenberg, and various programming documentation, among others. Kiwix compresses these resources into the binary ZIM file format, with a 1-to-1 relationship between resources and ZIM files. For example, a recent snapshot of Wikipedia is available as a 115 GB ZIM file. Kiwix supplies various viewers and servers for ZIM files with a focus on serving areas without Internet access.
As part of a project to create a standalone, resilient computing system that could operate off the grid after a hurricane or other disaster, it is desirable to have a local ZIM file viewer. Several choices exist, but they have some drawbacks. For instance, the official Kiwix viewer insists upon having a torrent client available at run time and complains if it isn't present. To complicate matters further, the Kiwix Association released their official library for interacting with ZIM files under the GNU General Public License, version 2. While this license isn't problematic by itself, it also isn't the best choice for a library license.
Instead of creating a GPLv2-licensed application that relies on the Kiwix library, this project will instead use the ZIM file format documentation to implement a pure Python reader module. A GUI can then be added using Qt for Python to be consistent with the other projects. This is a greenfield project: no code has been written yet.
This project requires the following skill set:
- Strong Python programming ability.
- An ability to read and utilize documentation.
- An ability and willingness to experiment and tinker when the aforementioned documentation is incomplete and/or wrong.
- An interest in processing low-level binary data.