ACCIDDA has been developing the Flexible Epidemic Modeling Pipeline (flepiMoP) for several years, with its origin during the COVID pandemic. Briefly, flepiMoP is intended to be a low-code orchestration tool for conducting a variety of infectious disease modeling analyses (e.g. inference, scenario comparison, forecasting) within a unified command line interface. The tool effectively reduces the complexity of model specification and analysis by providing a simpler language and solving the book-keeping issues associated with this sort of work.
We have several elements of that overarching project that would make for focused projects for CS / CE students. I'm not sure what level of detail to go into here, but we have an active issues list at
github.com/HopkinsIDD/flepimopand the general documentation at
https://www.flepimop.org/I would say roughly there are 3 categories of projects that could be done, which would pull from / build on those issues:
-- software engineering tasks to do with package / library organization and
continuous integration
-- design architecture modularization / plugin system development
-- particular algorithm implementation / optimization (e.g. work distribution
and collection for parallelization, different stepper / inference numerics)
We have a benchtop project that estimates measles vaccine coverage from school enrollment data, and then presents that data as a dashboard:
https://accidda.github.io/measles/The estimation package (still in beta) is also available:
https://github.com/ACCIDDA/imugap
There are several opportunities for work here:
-- backend ETL work on the data curation, validation, combination,
etc, etc which combines several interesting data streams (all
currently public, some opportunity to expand to incorporating some
restricted sources) - this would be a data engineering project
-- front-end work on the dashboard to make it more interactive,
present more results, improve responsiveness, etc, etc - this would
be web/mobile-enabled web application project
-- scientific work on the statistical / inference package - this would
be a data science project, focused narrowly on the
statistical analysis
-- generalization to cover other states - this would be a data science
project, focused broadly on applying an analysis across many settings
All of these areas have *something* in place, but all of them could also independently pursued (and all reinforce each other).
We seek to expand a project developed by a COMP 523 team (S25). The website is running a Unity viewer which displays the 3D model of the Swayambhu temple environment that we created in 2022. We have a new version of this model and plans to continue to refine it. We need a fully functional website that incorporates a landing page, a model viewer that will allow users to explore an annotated model in a way that is true to life and intuitive to navigate (i.e., trackpad/mouse), additional contextualizing sub- pages, and the possibility of linking to the video database. This will entail work within Unity.
This project involves taking Nepal and Newari language videos, generating a translation and transcript, and creating a searchable web-based data base to store the video and allow it to be accessed.
Previous
This project involves documenting and preserving Buddhist cultural heritage
in Nepal, using annotated VR models. Your coach this semester (Sam Shi) was
a member of the original project team. Thus you have good help for this
proposed continuation.
Last semester, students worked to create a video database that uses a LLM to transcribe and translate video interviews from Nepal (in several languages). We want to expand the database and improve user functionality. The most important feature of this database is being able to search for text within the transcription. However, it must be optimized to be public-facing. Hence, we're also interested in building an intuitive user-interface.
For an accessible description of the project overall, see:
project coverage
The next phase of improvements includes enhancing ingredient parsing and allergen inference by expanding keyword-to-allergen mappings, handling common ingredient variants, and caching results to reduce repeated AI calls. Menu management will become more efficient through bulk editing tools, item duplication, archiving options, and CSV import/export. Restaurants will gain a dedicated profile page to manage contact details, descriptions, dietary policies, and uploaded images. Multi-user functionality will allow shared restaurant management with role-based permissions for owners/managers and staff. Image support will be added by integrating an upload field and storing media through services like Supabase, Firebase, or S3 using secure signed URLs. Finally, the system should gracefully fall back to manual tagging if AI parsing is disabled or costly, with backend configurations updated when switching AI models or providers.
Last semester
As a new college student, I have been tasked with the undoubtedly difficult job of managing almost all facets of my life. Of course, this sounds silly at first, but it is an obstacle that almost all can relate to. For some, it may come earlier or later in life, but the same realization appears nonetheless. That realization being that you have absolute responsibility of managing your own life.
Now, food is one of the most, if not the most important part of your life. I mean, we literally can’t live without it. Your thoughts linger around the question of where you’re going to get your food from, but the answer to that question is not the end of the journey. You must then ask if that food can even be eaten. And I don’t just mean can I viably eat the probably undercooked ramen I made in the corner microwave of the kitchen on my dorm floor. I mean, am I allergic?
It can be hard for a person still learning how to balance the rest of the responsibilities in their life to also correctly manage such an important question. That’s where SafeEats comes in. For the customer trying to manage their food allergies, they simply enter in their known food allergies, and we handle the rest. After a customer enters their allergies, the allergies are cross-referenced with the menus of restaurants to give the customer an easily accessible list of the foods on the menu which they can eat.
SafeEats would be a mobile application that served both iOS and Android devices. Since the app serves as a way to make dining easier for the customer, it would have links to other applications such as DoorDash, Postmates, or the actual online ordering system for the restaurant, and potentially a partnership with any of the previously named organizations.
Because these companies have already mastered online ordering, SafeEats would be unsustainable if it were to have online ordering of its own. Ideally, the application only makes the items on the menu which the customer can actually eat available to them, so as to avoid confusion or any possibility that they choose an item they are allergic to.
Approximately 32 million people in the United States are affected by food allergies, so the problem this app is solving is simple, dining accessibility for those with food allergies. Although I used a college student as an example of someone who would greatly benefit from this app, another relevant demographic is parents, as the safety of their children is of the utmost importance. While dealing with the pressures of raising a child, they would absolutely benefit from an app that ensured the safety of their children when eating food from restaurants. Overall, the app has one goal and one goal alone, easy dining in a safe way.
This is a continuation of an earlier COMP 523 project (S'24).
SafeEats is a mobile application with a format similar to that of DoorDash or GrubHub, and will be available for both iOS and Android devices. Around the world, food allergies have become more widespread and more severe, with hospital visits stemming from food allergies increasing threefold between 1993 and 2006, and hospitals seeing the largest amounts of cases in history. SafeEats serves as a way to make dining out more accessible and safe for those with food allergies. After downloading the app, the user enters their food allergies into the application's database, saving this to their client profile for reference. The application then cross-references the user's food allergies with the ingredients on the menus of restaurants and fast food chains, showing the user the menu items which they can eat. Therefore, the issue of safe online ordering and easier accessibility for those with food allergies (and parents /guardians of children with food allergies) are solved through the application. There are not any other particular systems which SafeEats must interact with.Supporting Doc
Adding agentic behavior and AI chatbot via Gemini to a data site for
a nature preserve.
Details here:
Project Specs
Last semester
This project will work with an extensive Web site that includes information
on an existing ecologically significant conservation
reserve ( chicorylane.com )
and maps it into a dynamic document system to be developed by the project.
The doc systerm is a node/network based structure, having nodes that may contain pages
of mixed media content that can be accessed through a conventional Web browser.
Nodes will be recursive, in the sense of nodes containing other node structures as content. Innovations will also include an automatic feature to feed data incrementally into some to-be-identified existing LLM system as well as explore techniques for incorporating relational database information (ecological attributes concerning plants in the reserve) into the LLM.
Earlier work on several similar data models are available.
I’ve been brainstorming ways to expand the platform. In addition to continuing to develop the web application, I’m especially interested in turning SPFMatch into an app. Some ideas I’ve been exploring include:
-- A daily skin check-in feature (e.g., “How does your skin feel
or look today?”) to personalize recommendations over time
-- A trend tracker that highlights consistency (such as applying
sunscreen for 10 days straight)
-- Weekly summaries that reflect habits, UV exposure, and product
effectiveness
-- A community platform where users can share sunscreen experiences,
routines, and tips—especially valuable for people of color who
are often underrepresented in skincare spaces
-- Image analysis using the phone camera to help determine or confirm
skin tone and supplement questionnaire data (face, arm, hand, etc.)
Last semester
SPFMatch is a web application designed to help users find the most effective sunscreen for their specific skin tone, skin type, and lifestyle needs. While sunscreen is essential for skin cancer prevention and maintaining healthy skin, many people struggle to choose a product that provides adequate protection while suiting their unique needs. This challenge is especially important for individuals with darker skin tones, who are often underserved in dermatological resources, face marketing bias, and may believe sunscreen is unnecessary for them.
This website will guide users through a short questionnaire covering their skin tone (using a visual scale such as the Fitzpatrick classification), skin type (dry, oily, combination, sensitive), lifestyle factors (daily sun exposure, time spent outdoors, activity level), and preferences (mineral vs. chemical sunscreen, fragrance-free, texture). Based on their responses, SPFMatch will generate tailored sunscreen recommendations drawn from a curated, dermatologist-reviewed product database, backed by research on SPF efficacy and skin safety.
Core features will include:
-- AI-powered recommendations based on Dermatologists and Research -- Sunscreen recommendations tailored to all skin tones -- Reapplication reminders based on UV index and user activityThe target audience includes:
-- Individuals looking for personalized sunscreen recommendations -- People of color who lack targeted sun safety recommendations -- Health-conscious users seeking evidence-based skincare guidance
Add to this the ability to glean (or confirm) input questionaire data via image analysis of camera image(s) of a user's face and other skin areas (arm, hand, etc.).
sample dataOur project is a browser-based “grid-builder” that lets social-science researchers design and deploy spatial survey experiments without writing code. In the web interface a researcher chooses the grid size (e.g., 5 × 3), defines attribute lists for each cell (race, gun ownership, political party, etc.), and selects experimental options such as scenario randomization or carry-forward logic across tasks. The tool then renders a responsive preview (desktop and mobile) identical to what participants will later see. Behind the scenes it stores the design as JSON and can regenerate the exact survey any time, ensuring full reproducibility.
When the researcher clicks “Export” the app compiles everything—HTML + CSS + JavaScript, embedded-data field names, and basic validation code—into a package that can be (a) inserted directly into Qualtrics via a single question, or (b) served as a standalone web experiment that posts JSON results to an endpoint . Thus the student team would build a React/TypeScript front end, a lightweight Node/Express back end for user accounts and design storage, and a small build pipeline that bundles the exported files. No native mobile build is needed because the interface is fully responsive; testing shows it works down to a 360 px-wide phone in landscape.
The software serves policymakers, academics, and other researchers undergraduates who study neighborhoods, communities, layouts, or any context where WHERE an attribute is placed matters as much as WHAT attribute it is. Today, such researchers must hand-code grids for each study—time-consuming, error-prone, and hard to share. Our tool makes rigorous spatial experiments as easy as creating a Qualtrics multiple-choice question, lowering barriers to entry and encouraging transparent, open science.
I think this project is interesting because it is about systematizing the generation of code based on both UI and logical specifications.
abstractsAn ongoing research facility for study of waves, and coastal erosion .. located next door in the basement. This project has been to improve the overall UI and UX, and to add intelligent assistance to the ease of defining and setting wave patterns onto the array of actuators.
The environment:Previous Project Details Video (wavemaker at end) previous team website
Recess (https://recessyogastudio.com/) is a yoga studio with locations in Carrboro and Durham. As a small-scale operation that focuses on providing the local communities with accessible, affordable quality yoga instruction, it needs to keep its overhead costs as low as possible and is seeking a reliable but low- to no-cost alternative to some features of the expensive scheduling apps in the health and fitness space, such as Mindbody. In particular, it's looking for an affordable way to handle the notifications, messaging, and schedule changes that allow teachers to request subs for their classes and for other teachers to respond and claim the open classes.
Recess does use Mindbody to handle its basic scheduling and booking, client information, and payment needs. However, access to its teacher messaging/substitute teacher scheduling/swapping/notifications features requires upgrading to a significantly more expensive subscription, which is out of the studio's budget. It currently handles this with a combination of direct texting between teachers and a Google Calendar with a Google Apps Script that sends SMS and email notifications to the group of teachers when subs are requested via the calendar. This system has worked well enough to get them by so far, but it's confusing for new teachers to learn, and the SMS notifications it launches are frequently flagged as spam, blocked, and undelivered.
The studio would love to have a free or low-cost app or website that would handle these processes more reliably and intuitively. This could take the form of a web app or responsive website. Ideally, it would be able to integrate with the existing online studio schedules hosted by Mindbody. Mindbody does have a developer API, and it might be worth looking into, but I suspect that the costs associated with integrating directly with that system might be prohibitive for the studio. So a standalone platform that only handles subs would be fine, too.
This deliverable establishes the automation foundation required to scale ABM/ABX campaign execution across strategic accounts. In the Signals Intelligence program, Kinetik’s primary focus was to build models that create deep insight into accounts, buying centers, and prospects. This is the deliberate bridge into execution: converting those insights into an automated “ABX campaign blueprint” that can be executed repeatably, with minimal manual effort, for many accounts. The output of Deliverable 1 is a working minimum viable product (MVP) automation workflow and the supporting technical specification needed to operationalize it.
The architecture will reflect the intent described in the transcript: a single workflow that orchestrates multiple software packages and multiple Large Language Model (LLM) calls, passing structured outputs from one node to the next. The workflow is designed around two parallel starting points that converge into activation. The first starting point is account and prospect data: extracting known contacts (sourced from Salesforce and, where applicable, made available through Snowflake), and then expanding into a broader prospect universe through enrichment sources where needed. The second starting point is theme assets: ingesting BMC’s theme messaging and supporting assets (initially framed around the resiliency theme in the financial services/banking context). From these theme inputs the workflow will produce a messaging architecture JSON and structured prompt inputs that enable downstream personalization at the account, buying-center, and key-persona levels. Implementation will follow the build strategy outlined in the transcript: start with the end of the chain (automatic segment creation in Salesforce Data Cloud), gain a deep understanding of what the Data Cloud API requires, implement that node, and then work backward to upstream dependencies.
Supporting Docs:
Project Details
I seek an interactive tool, to run on Mac OS, that will allow a user to efficiently and quickly review a media file with audio (and possibly video) content and produce a numbered list of segments with start times and end times. The list will be ordered by start time and will be used with an existing program (ffmpeg) to extract each segment into a separate file. The program will support commonly used audio (and possibly audio / video) file formats. The selection and markup will be based on the audio content alone.
The tool need not (and probably should not) be written stand alone from scratch. Using a wrapper, extension, or source modification with or fo an available, open source, media player such as VLC, MPV or Kodi or audio editor such as Audacity or Ocenaudio is definitely preferred. Note that ffmpeg and similar tools can extract the audio track from an audio/video file and a tool that only deals with audio can be used to generate a segment list for these media types using audio only.
When field recordings are made of live events such as recitals, panel discussions, seminars, etc. It is often useful to index them so that specific sections can be located and retrieved or played. In the cases where the recording is continuous, but contains intervals with no meaningful content, i.e. while one speaker or performer is exiting and another is setting up to speak or perform, it may also be useful to omit these parts of the recording. Increasingly, high quality field recordings are being made using cell phones for audio and video, sometimes substituting a better quality microphone for the one in the phone or getting an audio feed from the public address system. Setups of this kind lend themselves to continuous recording of the event in question but requiring markup and editing to be useful.
Experience to date and intended usage: I have used Ocenaudio, Audacity, and VLC for this purpose and each suffers from defects or awkward interaction. VLC is primarily a playback tool and precise positioning of the audio with sub-second precision is difficult. Audacity and Ocenaudio are capable of the task, but I find identifying the appropriate beginning and end points by visual inspection of the waveform difficult when there are no well defined silences near the mark points. I would like my interactions with the tool to be fairly simple with a limited command set, probably using single key presses for most actions. At this stage, I want to simply identify the segments to be retained. The individual segments can get more extensive processing later.
What I would like is a mechanism that I can use to define tentative mark points by listening to and observing the audio waveform of the file and listing tentative mark points (times) as the file progresses. During this phase, the mark could be associated with the relative time based on nthe start of the file at which a specific key press, e.g. the space bar occurs. It might be useful to be able to either jump forward or backwards by fixed, but adjustable intervals, using other key strokes. During this process, the waveform of the audio should scroll across the screen with a cursor indicating the current time. Once the tentative markers have been placed, it should be possible to refine them by repeatedly listening to the file for a small interval (adjustable) around the tentative marker to refine its location. Being able to do this at reduced speed would help if the underlying system can do pitch adjustment. Allowing visual placement of the marker within the interval is also useful when the waveform is expanded to cover a larger portion of the screen. Allowing playback within the interval to go up to the marker and stop or to start at the marker is also useful in refining the position. It should be possible to delete markers as since false placements are common during an initial listening.
Once a marker is properly positioned, its purpose needs to be indicated. Markers may indicate the start of a segment, the end of the segment started with the previous start marker or the end of one segment and the start of another.
When all markers have been placed, the program should output a CSV file with fields for:
Start time, End time, Title placeholder
Times are in HH:MM:SS.mmm format. HH is hours (0 if the file is shorter than 1 hour), MM is minutes (00 - 59) SS is seconds (00-59) and mmm is milliseconds (000 - 999). Times are relative to the beginning of the file at 00:00:00.000..
The title placeholder is something like "NNN Segment" providing a unique identification of the segment that can be used, as is for a file name that will allow the files to appear in the proper order when listed in a directory used as a playlist. The NNN portion should be zero padded to the left to preserve the file sort order. The user may edit the CSV file to
As a sanity check, the start and end times should increase monotonically. The end time for a segment should be strictly greater than its start time. Thje segments should not overlap, however, the end time of one segment may be equal to the start time of the following segment.
Current practice:
Ocenaudio comes closest, however, there is no way that I have discovered to copy and paste the currsor position (time) and repeatedly playing a small interval is awkward. Audacity marks intervals by dragging the cursor which is simple with well defined silences between selections, but not otherwise. Audacity works within a "project" framework which does not fit my workflow well.
Currently, I use one of the tools to locate the segment start and end points and put them into a spreadsheet which I export as CSV. The user may edit the CSV file to replace the placeholders with more appropriate file names.
I have a program that reads the CSV file and invokes ffmpeg on the input file. My program creates a directory with the name of the input file (without extension or filetype) and ffmpeg creates its files, using the edited placeholders with the extension of the input file, in this directory.
I have several "worked examples" with raw audio files, the CSV files I used and the final files that I can make available to the group.
References:
Ocenaudio https://www.ocenaudio.com/ Audacity https://www.audacityteam.org/ VLC https://www.videolan.org/vlc/There may be other suitable bases. These are the ones that I have used. I believe that the source is available for all of them and they all work on a "current" mac.
Adafruit makes several sizes of their NeoTrellis button devices, the 4x4 is https://www.adafruit.com/product/4352 that exposes a serial device port when its USB is plugged into a computer. VRPN is a cross-platform open-source VR input device library that enables reading from and controlling devices over serial and other interfaces https://github.com/vrpn/vrpn/wiki/. This project consists of two parts:
1) A VRPN driver for the various Trellis devices that reads from the buttons as vrpn_Button devices and controls the lights as vrpn_Analog_Output devices. Ideally it reads the number of buttons from the device itself and configures the appropriate number of controls, but the config file could specify that if needed.
2) A cross-platform computer-side game that talks to the VRPN device and lets people press buttons to make all the lights turn off. Each button on the device will toggle the lights on it and all of its neighbors (up to 8 neighbors per button). The game starts in a configuration that is determined by randomly pushing some number of buttons starting with all of the lights off. The user pushes buttons to get them all off, at which time all buttons flash and it starts another round.
As a stretch goal, the device could run the game internally until it is connected to by a VRPN connection, at which point it becomes a VRPN input device.
Supporting Docs:
Project Details device image
RespiLens (https://www.respilens.com/) is a web app that consolidates respiratory illness forecasts for the 50 U.S. states + D.C. on one visualization dashboard. The main attraction is on the "Forecasts" tab, but there are also a couple of other features; including the "Forecastle" (a wordle-inspired game where users can test their disease forecasting ability against actual models), and "MyRespiLens", (a drag-n-drop feature where users can visualize their own data in the RespiLens format).
RespiLens (built sub-daily via a GitHub workflow) pulls disease data from a variety of sources, converts it to a standardized JSON format, then displays the output in plots. So, in some sense, RespiLens is just a visualization wrapper for content that already exists. The goal of the site is to make respiratory illness burden visualization accessible to public health professionals, disease modelers, and the general public alike.
On the "Forecasts" tab, RespiLens offers a variety of features that allow users to toggle the granularity and breadth of visualization. For example, you can change the "view" that you are in (Flu forecasts, RSV forecasts, CDC ground-truth data, etc), the location that you are viewing for, or the data end point being projected (a.k.a "target". e.g., hospitalizations, or proportion of emergency department visits attributable to a certain disease).
All of these specifications are made via the panel on the left of the site. Clicking around the panel, you may notice that hovering over different views in the view selector opens a sidebar for more view selections that fall underneath each umbrella (e.g., hovering over "Flu forecasts" reveals "Detailed view", "projections", and "peak" views). We want to re-design the view selector (possibly even combining this with the target selector) to be more intuitive and user-friendly – open-ended and up to creative interpretation. We do not have a specific vision for how this will look, and will allow students to play around with a variety of approaches. This incorporates elements of UX design and human-computer interaction in addition to the technical coding aspect.
RespiLens uses a tech stack with a Python backend (data fetching and formatting), and a JavaScript frontend. The site is built using React, and uses Mantine components for cohesive design. Students can gain experience participating in continuous integration, designing user-friendly features, coding with URL awareness, and deploying features to multiple release levels (first alpha/staging, then main/beta). The site is actively being developed and evolves frequently. Workflow is entirely managed via GitHub and in our workplace slack.
FANz PLAY, “The Game Within A Game!” FANz PLAY is a free, interactive mobile sports trivia app that transforms fans from spectators into active participants going against their opponents/the other team’s FANS, LIVE on Game Day! Yes, that’s FANs versus FANS!
Every sports fan loves a great game and there are many to speak of, Texas A&M and Texas Football, LSU versus South Carolina Women’s Basketball, and the list could not begin unless we add one of the greatest Duke versus North Carolina men’s basketball. A rivalry that began on January 24, 1920, when the University of North Carolina defeated Trinity College (now Duke University) 36–25. As of February 1, 2025, the teams have faced each other 263+ times. This rivalry is widely regarded as one of the most intense in U.S. sports, fueled by the proximity of the universities—approximately ten miles apart—and their consistent basketball excellence.
These are only a few of the greatest team rivalries in the history of sports—rivalries where winning fans cheer and brag for days and weeks, eagerly awaiting the next matchup. Fans support their teams through snow, rain, or shine, but no matter how passionate they are, the outcome is ultimately determined by the coaches and the athletes. This can be frustrating for fans who want to be more involved in the game and enjoy the bragging rights that come with victory. What if these die-hard fans had the chance to play for their team against the opposing team’s fans using their mobile phones?
I am seeking a strong prototype that could be downloadable and played as in a show and tell. Perhaps something similar to Test flight or similar type of mock up. I also have screenshots, logos and additional information to help make this a seamless as possible.
Supporting Documents:
More about FANzPLAY video YouTube
This project centers on the design and development of a web-based platform (or app) that facilitates meaningful collaboration between clinicians and healthcare staff and research faculty across the UNC campus. The platform addresses a common challenge in academic medicine: clinicians frequently encounter clinical, data, or methodological problems that could benefit from research expertise, yet identifying the right collaborator is often time-consuming, dependent on personal networks, and complicated by the fact that clinicians and researchers often use different language to describe the same problems.
In practice, the two sides of campus do not talk to each other easily, and they rarely share a common vocabulary—particularly when it comes to fundamental or basic science. As a result, many potentially valuable collaborations never get started.
The core idea is to build an application that uses AI-assisted matching to help bridge this gap. The platform relies on a structured database of research faculty from relevant departments, containing enough information about their expertise for the system to make useful matches. Clinicians and healthcare staff submit a brief description of a problem or question, ideally one to two sentences, through a simple, structured interface. The system then analyzes the submission and matches it to a set of research faculty whose expertise, methods, or prior work are most relevant.
Faculty expertise is represented using structured data that is provided to or curated within the system, such as research areas, methods, keywords, and publications. The matching algorithm leverages this information, initially using transparent, explainable methods, and later incorporating more advanced AI techniques, to generate ranked recommendations. Importantly, the platform is not intended to automate collaboration, but to initiate it by making relevant expertise easier to discover and lowering the barrier to starting a conversation.
The ultimate goal of the platform is to make it easier for clinicians and researchers to find each other, collaborate on real problems, and translate research into practice.
Objective: To create an agentic system designed to authenticate and value Pokémon TCG cards using Google Cloud Platform (GCP). Experience to be a low-friction, mobile-accessible webapp & AI agent that enables collectors to instantly determine the market value of Pokémon TCG cards via a smartphone camera.
Details here:
https://docs.google.com/document/d/1tpUmocFFnEDTQciTjUHDCzrFrLs40lkYFHQj84UzyLQ/edit?tab=t.0#heading=h.jxvm8mezcl6x
Project Trace is a sustainability-focused software platform designed to help online shoppers understand and compare the environmental impact of consumer products at the moment of purchase. Today, consumers who care about sustainability face two major challenges: (1) credible, comparable sustainability information is difficult to access, and (2) even motivated consumers lack a simple way to translate sustainability claims into meaningful, decision-ready insights while shopping online. As a result, sustainability intent often fails to translate into action.
Project Trace aims to close this gap by embedding sustainability intelligence directly into the online shopping experience.
The current implementation is a browser-based web extension (initially targeting desktop browsers) that activates when a user browses or searches for products on major e-commerce platforms. When a user views a product, the extension surfaces comparable products and displays a quantified sustainability “impact score” for each option, including the original product and suggested alternatives.
While the front-end browser extension and basic platform infrastructure already exist, the core missing component (and the focus of this proposed student project) is the backend impact-calculation engine that powers these sustainability scores.
The central problem for the student team is to design and prototype a system that can:
* Define a sustainability impact framework. Identify relevant
sustainability dimensions (e.g., carbon footprint, materials,
packaging, certifications, supply chain attributes, recyclability,
etc.). Propose a defensible weighting or scoring model that converts
multiple sustainability signals into a single numerical impact value.
* Identify and ingest data sources. Explore potential data inputs
such as public sustainability datasets, third-party APIs,
certification databases, manufacturer disclosures, or proxy data
models where direct data is unavailable. Evaluate data quality,
gaps, and tradeoffs between precision and feasibility.
* Design the backend architecture. Implement a backend service (e.g.,
REST API) that receives product identifiers or attributes and
returns calculated impact scores. Ensure the system can interact
with the existing browser extension and be extensible for future
data sources or scoring logic.
Explainability and transparency. Provide not just a score, but supporting metadata or explanations that help users understand why a product scores higher or lower—an important real-world requirement for trust and adoption.
Primary users are sustainability-minded consumers shopping online. Secondary stakeholders include retailers, brands, and sustainability researchers interested in understanding consumer behavior and product-level sustainability signals. While the initial use case is consumer-facing, the system is intentionally designed to support future B2B analytics and reporting use cases.
The backend impact engine must interact with:
The project is intentionally scoped to prioritize architectural design, data modeling, API development, and algorithmic reasoning, rather than production-scale deployment.
Why this project is suitable for a course team
This project offers students a real-world, open-ended software problem with no single “correct” answer - mirroring professional product development. It combines system design, backend development, data integration, and ethical considerations around transparency and sustainability. Students will gain experience balancing technical rigor with real-world constraints, while contributing to a mission-driven product with tangible social impact.
The following project requires a team with 4 members that have taken COMP 435 taught by Kris Jordan
Agentic tools like Claude Code and Github Copilot have taken the software engineering industry by storm over the past nine months. In talking to alumni at organizations like Meta, Microsoft, Google, and Apple, it is clear that these tools will increasingly be parts of software engineering workflows.
Agentic coding tools' ability to effectively contribute to large scale software repositories is largely a factor of having a robust acceptance testing suite that the agentic AI can test its changes against (and contribute to), static analysis and formatting tools being standardized in the environment, and contextual instructions or skills that guide the AI's implementation strategies and its own acceptance standards.
The CSXL code base was largely developed prior to the effective Agentic AI tooling we have today. This project's aim is to refactor the code base such that Agentic AI tools can be more effectively used when working in the XL code base: moving forward, we expect students in COMP423 to make significant use of agentic tools in their final projects. This will entail some exploratory work in understanding where the current structure or standards of the code base falls short with some exemplar tasks, refactoring or adding acceptance tests/standards to make the experience better, and developing the contextual documents that guide agentic AI implementation loops.
The goal is to increase the likelihood of well specified agentic tasks succeeding and following the standards of the code base. If this is a success, we can decide on some sample feature improvements to the web site that we can target and whose code implementation is mostly generated by AI.
For the past two years, students in COMP110 have been making use of an in-house open source project called Trailhead that surfaces an interactive user interface for traditional python programs (https://github.com/krisjordan/trailhead) (quick demo: https://youtu.be/Ul9ompArzpY?si=kn0-4lQ1an9H6HCH). This project is implemented in React for the front-end and FastAPI for the backend.
The goal of this project is to make significant quality of life improvements for the student experience. The first priority is improving error messages such that students are surfaced a more useful and well formatted error dump when runtime errors occur in their program. Once this pressing need is addressed, there are other opportunities to improve the product for COMP110 students, including:
-- Investigating and Addressing Accessibility Concerns
-- Special UI for running Pytest Unit Tests
-- Potentially a publishing story for students to be able to publish their
projects easily to a web platform that they could share with peers or parents
There are fun and interesting technical challenges in this project because the student code is being run in subprocesses that the web server manages and pipes information into/out of in order to make it all work.