Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
Drasi is a Data Change Processing platform that enables developers to detect and react to meaningful data changes using declarative Cypher queries. Drasi excels at complex change detection with unique features like `drasi.trueFor()` (detecting conditions that persist over time) and absence-of-change detection (alerting when expected events don't occur). However, it currently lacks native connectivity to IoT protocols. Drasi Lib provides Drasi's powerful graph-aware decision engine as an embeddable Rust library that can run completely offline on constrained hardware—enabling edge computing scenarios where logic runs directly on sensors and gateways. IoT applications fundamentally need to detect state transitions, but developers typically must write boilerplate code and manage state persistence manually. Drasi's diff-engine handles state management and change computation automatically, emitting events only when meaningful changes occur. MQTT (Message Queuing Telemetry Transport) is the de-facto standard protocol for IoT, used by AWS IoT Core, Azure IoT Hub, and virtually every IoT deployment. Adding MQTT support to Drasi Lib will unlock the entire IoT ecosystem for Drasi users. In this project, the mentee will build a suite of lightweight Rust crates that enable Drasi Lib to communicate with MQTT brokers. They will create connectors to ingest sensor data (MQTT Source), execute local actions (Shell Reaction), and close the control loop (MQTT Reaction).
Haiku's Bluetooth stack currently implements only a basic subset of general Bluetooth functionality. At first during testing with an Android phone, the local device was visible, but the pairing process fails entirely because Haiku does not understand modern Bluetooth events. The pairing process silently failed because the stack drops unsolicited Secure Simple Pairing (SSP) requests. The system was dropping modern discovery packets because the Inquiry subsystem lacked Extended Inquiry Result (EIR) support. Although recently the SSP and EIR issues have had recent patches from GSoC candidates, still there’re several issues in bluetooth pairing and connection that needs handling including: the pairing button doesn't make any action, not showing the pairing number when getting pairing requests from the phone, and lacking persistent remote device information. Hence, many other modern HCI events and commands still need handling. The primary motivation of this project is to modernize Haiku’s Core Bluetooth stack to match 2.X and later to improve the existing code's compatibility with newer devices. By resolving these foundational HCI drops, the stack can finally be used for more than just basic pairing attempts, paving the way for functional Bluetooth HID, audio, or file transfer profiles. This project modernizes the stack by Completing the remaining HCI commands and events, Adding persistent Link Key storage to preserve pairing devices after reboot, Implementing the Service Discovery Protocol (SDP), and Delivering a full Human Interface Device (HID) profile with a working input_server add-on.
Currently, Casbin uses golang built-in map structure to maintain policies in the main memory and persist the policies via adapter abstraction. If policies data grows, however, the growing cost of main memory resources and bad performance make the memory management strategy not tolerable anymore. We need to find a better way to manage the casbin in-memory data when data grows. From my point of view, our main goal is to reduce the cost of memory as well as keep good performance handling policies read and write requests. In order to achieve those key goals, we can introduce an experimental tuple storage to get charge of storing those policies, turning the policies management strategy from memory-oriented to disk-oriented. We can even make a better abstraction of the storage layer so that we can use different engines (row, column) for the different workloads. In general, we can take the following parts into consideration to achieve our goals. 1. API for upper layer. 2. workload optimizer. 3. Buffer Pool management. 4. Indexing. 5. Data Storage Structures. 6. Transaction if necessary. And in the end, the deliverables will be : A Casbin built-in embedded disk-oriented tuple storage engine. The Engine should contain : 1. Carefully designed API for upper Casbin internal module. 2. Storage management. Include file organization and page layout. 3. Buffer pool management. 4. Index management. 5. An workload optimizer for the upper layer. 6. Transaction part if necessary.
Overall, the proposal is about adding a few missing features in the package, like addition of new models, some metaprogramming, lazy evaluation, testing, documentation and linting. Currently, the package only supports four regression models (Linear, Logistic, Poisson and Negative Binomial regression). There is a huge scope of adding many more models to the package. To start with, we can add the Gamma and Inverse Gaussian regression models, and the ARIMA model for time series. Over time, more models can be added to the package. There is also a scope of adding new macros to the package to make the syntax more clean. An example of this is in the fitmodel function of the package (and is explained via a code snippet in the proposal). From the documentation, it can also be seen that any model has many attributes which are computed when the fit function is called. When working on big data, it is possible that not all the attribute values are needed, so it is currently inefficient to compute every attribute. Instead, one can compute the attributes lazily, i.e as and when they are needed. Rigorous unit testing should be added to the package to ensure code correctness. Also, the package code can use a lot of help with its documentation and code coverage. All of these can be implemented using CI/CD. Finally, in its current state, the package lacks strict code conventions (like variable names, commit message rules etc). These are essential to ensure good quality code and to make the job easier for future contributors. To enforce this, linting can be added to the code along with Git hooks to enforce these conventions. Also, a well defined API should be documented for the models, so that new models can be added at ease.
Electricity grids today serve a far more complex mix of consumers than they were designed for. Data centers, EV charging networks, and industrial facilities participate in demand-response programs, shifting flexible workloads to windows where electricity is cheaper or cleaner. Acting on those signals requires software that collects real-time grid data across multiple regions, forecasts how conditions will evolve over the next several hours, and exposes both through a clean API that developers can query directly. Existing open-source infrastructure for grid signal forecasting covers carbon intensity reasonably well, but critical gaps remain: the data acquisition layer and the API serving layer are not connected, fresh data does not automatically trigger model inference, and signals beyond carbon intensity such as demand, price, generation mix, and grid saturation are not exposed through any unified interface. There is also no interactive frontend that makes regional grid conditions spatially visible. EnergyAPI addresses each of these gaps. The platform is structured across five layers: an automated scheduled data acquisition service pulling from NOAA NOMADS, EIA, and ENTSO-E, an extended relational data model covering all five grid signals, a forecasting pipeline connecting fresh data to existing carbon intensity models while adding SARIMA-based demand forecasting and gradient boosting for price, a Django REST API with a workload scheduling interface that accepts SLOs and returns execution plans, and an interactive web frontend with time-series charts and a choropleth map of EU and US regions.
<p>Markup handling has been a problem in Apertium for a long time. It was done using superblanks that encapsulate markup information inside them during the translation process. This works well to protect the formatting of the document. However, languages represent information differently and during translation, words/phrases move around, get deleted, split, merge, etc. The markup information on the words needs to stick with the words, otherwise we end up with erroneous markup in the translation, which is what happened:</p> <pre><code>Spanish Input: <i>El perro</i> <b>blanco</b> English Output: <i>The white</i> <b>dog</b> </code></pre> <p>As part of this project, a new kind of blank was proposed - <strong>a wordbound blank.</strong> It contains any information that needs to stay attached to a word/phrase during the translation process. After modifying most modules in the pipeline to work with these wblanks, writing new de/reformatters, and adding markup in wblanks, the translation we have:</p> <pre><code>Spanish Input: <i>El perro</i> <b>blanco</b> English Output: <i>The</i> <b>white</b> <i>dog</i> </code></pre> <p>It should prove immensely useful for users of Apertium MT system to translate html or any formatted documents such as odt, docx, pptx.</p>
Accurate gene annotation in eukaryotes solely based on genomic data has been a significant obstacle in biology since the introduction of next-generation sequencing technologies and thus the rapid increase of available data. Traditional methods either rely on homology searches to map the open reading frames to previously identified protein-coding genes or utilize additional experimental data, e.g., transcriptomics data. The first approach produces potentially inaccurate results if the genome of interest is not at least somewhat related to an already annotated genome. The second approach is hindered because gathering transcriptomic data is labor-intensive and expensive. For that reason, there is a high demand for models that predict the location of protein-coding genes solely from inherent features of the DNA sequence of the gene. Although theoretically possible, methods that use, for instance, Hidden Markov models to detect protein-coding genes based on known gene features are often inaccurate. In this project, we will train a Deep Learning Transformer model to extract features of protein-coding genes to gain deeper insight into their exact properties that lead to translation. The whole workflow will include first training a Conditional Random Field model to recognize candidate gene regions and then using these as input for a more fine-grained Transformer - Convolutional Neural Network hybrid model. The final pipeline will be tested against a benchmark of gold standard annotations as well as various test sets to evaluate the influence of different parameters like genome sequence quality, protein length or gene structure complexity.
This project enhances the Archi framework by enabling real-time interaction with HTCondor job scheduling infrastructure and introducing a persistent memory system to enhance conclusions drawn on live data with previously encountered similar situations. Currently, Archi operates without access to live system state, limiting it to generic, non-actionable responses when diagnosing job failures. Additionally, solutions discovered during user interactions are not retained, leading to repeated effort and inefficient troubleshooting. To address these limitations, the project introduces a read-only HTCondor tooling layer that allows Archi to query live job data (e.g., via condor_q and condor_history) and provide precise, evidence-based diagnostics. In parallel, a "solution memory" system will be implemented to store validated fixes from past interactions in a vector storage. These solutions will be indexed, embedded, and retrieved through a hybrid search mechanism, enabling Archi to reuse proven resolutions for similar future issues. The main deliverables include: (1) a secure, read-only HTCondor integration layer with structured outputs and error handling, (2) a suite of agent tools for live job inspection and failure diagnosis, (3) a solution memory database with indexing and retrieval capabilities, and (4) full integration into the Archi agent workflow via tools, supported by comprehensive testing, benchmarking, and documentation. By combining live diagnostics with reusable knowledge, this project transforms Archi from a passive assistant into an active, context-aware agent that improves troubleshooting efficiency, reduces computational overhead, and continuously learns from past incidents.
Biologically detailed models are essential tools in neuroscience, and automated methods are frequently used to build and validate such models based on experimental data. The open-source parameter optimization software Neuroptimus was developed to enable easy application of advanced parameter optimization methods, such as evolutionary algorithms and swarm intelligence, to various problems in neuronal modeling. Neuroptimus includes a graphical user interface, and works on various platforms, including PCs and supercomputers. While Neuroptimus uses various built-in cost functions and the eFEL feature extraction library to compare model behavior to experimental data, it severely limits the range of neuronal behaviors that can be targeted by optimization. However, the popular model-testing framework SciUnit allows for the implementation of tests that quantitatively evaluate arbitrary model behaviors. Therefore, the goal of this project is to extend Neuroptimus to use HippoUnit, an open-source neuronal test suite based on SciUnit, to evaluate model performance during optimization. This project aims to develop a seamless integration between HippoUnit and Neuroptimus, enabling the construction of detailed biophysical models of hippocampal neurons. The new Neuroptimus-HippoUnit integration will allow the optimization of a broader range of neuronal behaviors, which can ultimately lead to improved biophysical models of hippocampal neurons. Deliverables: 1- Implementation of an interface between HippoUnit and the new version of Neuroptimus to enable the optimization of a broader range of neuronal behaviors. 2- Extend the current supported tests to include all HippoUnit tests. 3- Integrate the HippoUnit with the Neuroptimus’s GUI so that users can run optimizations directly from the interface.
Inkscape's current Filter Editor limits the user experience for creating Filters significantly, due to it's non-intuitive nature, and poor structing. Filters can be a great tool in any artist's inventory, due to the endless scope of effects they are capable of creating. However, the current Editor does a poor job at inviting artists to utilise the complete power of Filters. To solve this problem, I plan on replacing the current Filter Editor with A Node-Based one, since such a Node based workflow seems like the most natural one, for working with filters. The proposed Node - based Filter Editor promises to have the following deliverables: 1. An intuitive, easy to pick up, node based filter editor, with intuitive, user-friendly controls with a full-fledged editing workflow containing: a) essential features for navigation and canvas operations such as scrolling, zooming, panning, etc., relevant contextual menus, etc. b) Intuitive node operations such as selections, an easy system to make connections between nodes with clean and well planned user interfaces. c) Support for all Filters and Filter Primitives, along with widgets aimed at being easy to understand, which allow editing the properties of the Filter Primitives d) Ability to save and load the state of the editor, when closing and re-opening, or automatically creating a suitable layout for arranging the nodes, in a clean manner. 2. Creating template classes which can be used in future to implement functionalities requiring similar workflows. 3. Documentation and video series to further help users understand the editor and learn about it's various features, along with providing insight into the power of Filters.
Ensembl VEP's web interface offers dozens of configuration options for variant annotation, overwhelming new users and generating recurring helpdesk queries. Ask VEPai is a locally-hosted, open-source AI assistant that translates natural-language descriptions into recommended VEP configurations with justifications. The system uses Retrieval-Augmented Generation (RAG) grounded in a curated knowledge base, with a deterministic constraint checker that catches species violations and option conflicts the model misses. Beyond the project brief's scope of option labelling, training data, and a prototype model, this proposal adds four components: (1) the constraint checker, empirically validated across three model sizes, (2) a quantitative evaluation framework with leave-one-out methodology and multi-run statistical replication, (3) a structured JSON schema mapping recommendations directly to VEP web form sections for "click to apply" integration, and (4) an interpretability layer where every recommendation includes a source citation traceable to the knowledge base. A working demo validated across Qwen 2.5 3B/7B/14B shows +19–30% Enable F1 from the knowledge base, with all code and results published. Core deliverables: expanded KB (~55 options), 15–20 gold-standard examples, RAG pipeline, constraint checker, JSON schema, evaluation report, and documentation. My availability (~400 hours) supports extending to a 350-hour Large project, adding QLoRA fine-tuning, attribution testing, FastAPI wrapper, and VEP output explainer.
OpenTRIM is a C++/Qt Monte Carlo ion transport simulator for radiation damage research. Every parameter study today requires four manual steps: edit config.json, invoke the CLI, load HDF5 output, and plot by hand. No Python interface exists. No live view inside the target. This project delivers both. Feature A - Python Bindings: A pybind11 module wrapping libopentrim so researchers drive simulations directly from Python: result = opentrim.run(config_dict). Tally data is exposed as zero-copy NumPy arrays via ArrayNDd buffer protocol. result.to_xarray() returns a labeled Dataset with element names and nm coordinates for publication-ready depth profiles in one line. result.core exposes mccore internals - ion counts, per-tally SEM, and run merging. GSoC 2025 user_tally binning is bridged to Python. Seven benchmark configurations verify physics parity with the CLI. Feature B - Real-Time 3D Visualization: A QOpenGLWidget tab rendering live ion tracks as GL_LINES during simulation. A two-buffer pipeline handles 30M events/second without stalling. Cascade genealogy is color-coded from ion.recoil_id(): beam ions blue, PKAs orange, sub-cascade recoils red. A SEM convergence overlay tells researchers when to stop. Camera state serializes to JSON; --render produces headless PNG with no display server. Both features are isolated - bindings/ and source/gui/trackview.* - delivered across 14 pull requests in 350 hours.
5G/6G wireless networks based on O-RAN architecture will have O-RAN Network Functions (NFs) deployed on the O-cloud infrastructure. The cloud infrastructure and the NF orchestration is managed by the SMO using the O-RAN O2 interface. Open-source projects such as O-RAN SC, ONAP, Nephio, OAI are actively engaged in developing open-source software for O-RAN networks, in alignment with guidance from the O-RAN Open-Source Focus Group. Building on the progress of open-source implementation of O-RAN NFs, the open-source community is now focusing on implementation of cloud-native O-RAN NF (e.g., O-CU, O-DU) as well as the SMO functionality to manage them via the O2 interface. There is an opportunity to set up an implementation in a university testbed to participate in the open-source projects, and enable research in cloud-native O-RAN (e.g., methods of monitoring the energy consumption of the cloud infrastructure and the NFs) In this project the student will leverage open-source code and - implement an example O-cloud infrastructure hosting one or more O-RAN NF(s) (e.g. O-CU, O-DU) at Rutgers University WINLAB (https://winlab.rutgers.edu/) - develop a setup and tutorial to enable multiple users to replicate the cloud-native open-source implementation and contribute to open source - study and develop open-source software to support management/data collection of the infrastructure and NFs from the SMO, using energy consumption as an example
The existing Open Source Quartz Solar Forecast lacks live data integration from Enphase Inverters, hindering its accuracy and utility for Enphase users. Connecting these two systems would enhance forecast precision by 20% and enable users to compare forecasted data with real-time generation figures. The problem statement thus asks to seamlessly integrate live Enphase Inverter data into the Open Source Quartz Solar Forecast. I will use Python to develop a dedicated module and add it to the Open Source Quartz Solar Forecast library. This integration will involve retrieving live data from Enphase Inverters via the Enphase API and incorporating it into the forecasting algorithm. Upon completion, users will be able to leverage live data from Enphase Inverters within the Open Source Quartz Solar Forecast. I will thoroughly test this integration using authentic Enphase API credentials to ensure reliability. I will additionally deliver comprehensive example code and documentation, improving user experience and facilitating seamless execution of the forecast with genuine credentials. I will extend the project’s reach by compiling a curated list of analogous Solar Inverter companies to Enphase and write dedicated code to facilitate live data retrieval from these identified Solar Inverter systems, which will enable users to fetch live data from various solar inverter platforms and utilize it for forecasting purposes, similar to the capabilities provided for Enphase Inverters. This will empower users with diverse solar setups to benefit from accurate and insightful forecasting capabilities tailored to their specific systems.
The goal for this project is to develop a NeRF model training pipeline within the OpenCV library. The end result will be a fully functioning data processing pipeline that is well integrated with the NeRF model training procedure, as well as online documentation that detail how to use the pipelines properly. There are 3 key deliverables for this project. First, implement data loaders that can process user-taken images of real-world scenes. This will involve using the COLMAP and OpenCV data processing pipelines in order to extract the camera poses and epipolar geometry of the scene; these are requirements for the model's ability to learn a meaningful representation of the given scene. Second, build, train, and test the actual NeRF model. This will involve using PyTorch's built-in CUDA support and extensive usage of the PyTorch library as a whole in order to incorporate critical components of the NeRF architecture such as positional encoding, ray sampling, and regularization into our model design. This step will also include rendering procedures that will allow users to extract images/videos, depth maps, and other logging information such as the training loss curve from the fully trained model. Third, create simple and intuitive documentation on how to use both the data loaders and the NeRF code base. This will involve creating a page on OpenCV's documentation (via Doxygen) that will list out specific terminal commands that the user should use to train the model. It will also include a summary of required packages, recommended environment configurations, and links to other helpful resources such as YouTube video demonstrations, which will all be geared towards increasing the usability and accessibility of the pipeline.
InVesalius's 3D mask editor suffers from two critical bottlenecks: slow single-threaded Python geometry math that freezes the UI on high-resolution medical images, and a memory-intensive undo system that copies entire 500×500×500 voxel matrices on every edit, causing out-of-memory crashes on resource-constrained machines. This project addresses both problems through three tightly integrated deliverables. First, the heavy polygon-to-mask projection math will be ported from Python's skimage into multi-threaded Rust via PyO3, using zero-copy rust-numpy bindings to eliminate expensive matrix duplication across the Python/Rust boundary. Second, a new delta-encoded Undo/Redo engine will be built that records only the coordinates of changed voxels rather than full volume snapshots, paired with a disk-backed crash-recovery system and a visual history panel in wxPython for intuitive workflow management. Third, a native interactive 3D Brush Tool will be introduced, allowing users to paint or erase mask selections directly onto the 3D model with a configurable voxel depth, powered by native Rust ray-casting algorithms. Deliverables include a working invesalius_rs Rust module replacing the skimage dependency, the DeltaHistoryStack integrated across all 3D tools (polygon, brush, select parts, thresholding), the Mask3DEditorState decoupling class to eliminate ghost polygon UI bugs, cross-platform unit tests and CI validation, and a contributor benchmark report comparing performance against the current v3.0 baseline.
DICOMHawk is an open-source honeypot that emulates a vulnerable DICOM medical imaging server to attract and log unauthorized access attempts. The current v3.0 rewrite is functional at the core protocol level but presents a single fixed identity, lacks a web interface, has incomplete DIMSE handler coverage, and performs no analysis on attacker-submitted payloads. This project transforms DICOMHawk into a profile-driven deception platform. A profile system allows the honeypot to impersonate different medical imaging systems through YAML-backed configuration, controlling the DICOM identity, web-facing surface, and honeytrap behavior per deployment. An attacker-facing web extension built with Flask exposes realistic viewer interfaces and honeytrap endpoints, while browser and environment fingerprinting collects telemetry about attacker infrastructure. On the protocol side, the project completes missing DIMSE handlers (associate, release, abort) and adds DICOMweb (QIDO-RS, WADO-RS, STOW-RS) endpoints. A structured logging pipeline with session correlation ties DICOM, web, and fingerprint events together. A static-analysis sandbox quarantines and analyzes uploaded payloads without execution, shipping with starter YARA rules. Finally, Docker deployment is hardened for safer operation. Deliverables: Profile-based architecture with two starter profiles, attacker-facing web extension with per-profile templates, operator Web API, browser fingerprinting with correlation database, completed DIMSE and DICOMweb handlers, unified JSON event logging with session correlation, static-analysis sandbox with YARA support, and hardened Docker deployment.
The project aims to enhance the open-source ticketing system Trudesk by integrating critical accessibility features and advanced functionalities. The primary goal is to make Trudesk more inclusive and efficient for all users, including those with disabilities. The main problems addressed are: 1. Lack of accessibility in existing ticketing systems, making them difficult to use for people with disabilities. 2. Inefficient ticket management due to manual tagging and sorting processes. 3. Absence of community support features like public forums. 4. Inflexibility to cater to organization-specific needs. To solve these problems, the project proposes the following solutions: 1. Accessibility Enhancements: Optimize Trudesk for screen readers and assistive technologies, ensuring full accessibility for users with disabilities. 2. Advanced Functionalities: Implement auto-tagging, auto-categorization, and voice input capabilities to streamline ticket management. 3. Public Forums Integration: Create public forums within Trudesk, enabling users to collaborate and share knowledge. 4. Organization-Specific Enhancements: Develop automatic documentation suggestions and customizable knowledge bases tailored to frequent queries. The key deliverables of the project include: - Accessibility patches for Trudesk to ensure compliance with accessibility standards. - Public question polling interface and public forums for community engagement. - Efficient question searching, answer polling, and thread merging features. - Knowledge base creation and FAQ generation based on user queries. - Document suggestion system and voice-based query creation (stretch goal). - Integration of private ticket tracking and public forums. - Comprehensive testing and documentation.
Uyuni is a powerful systems management platform, but today it lacks a native way to automate actions based on events in real time. As a result, administrators often have to write custom scripts to react to things like patch updates or system changes, which adds unnecessary complexity and effort. This project aims to change that by introducing a simple, scalable event-driven architecture that turns Uyuni into an automation-friendly platform. The idea is to make it easy for administrators to connect Uyuni with other tools and build workflows without writing a lot of custom code. The solution has two main parts. First, an MQTT-based event publisher that hooks into Uyuni’s existing event pipeline and emits real-time events such as patch updates, system registrations, and Salt state results. Second, a custom Node-RED integration that allows administrators to visually design automation workflows using a drag-and-drop interface. The publisher is designed to be lightweight and non-intrusive, running as a passive listener so it does not interfere with Uyuni’s current behavior. It sends structured JSON messages, supports topic-based filtering, and includes reliability features like retries, batching, and rate limiting to handle larger deployments. On top of this, the Node-RED layer provides reusable nodes for consuming events, triggering actions, and interacting with Uyuni APIs. Overall, this project makes automation in Uyuni much more accessible, reduces the need for manual scripting, and enables easy integration with external tools like Slack or Jira. It also lays a solid foundation for building more advanced automation features in the future.
Understanding the architecture of planetary systems is crucial for insights into their formation and evolution. This project aims to leverage the power of equivariant vision networks to predict the number of planets and their orbital configurations within observed systems. Equivariant networks are uniquely suited for this task due to their inherent ability to handle the rotational and reflectional symmetries common in astronomical images, thus maintaining predictive accuracy regardless of orientation changes in spatial data. The project will unfold over 175 hours, meticulously planned across several phases to ensure a thorough approach from conceptualization to deployment. Starting with a comprehensive review of current equivariant neural network architectures and their potential application in analyzing astronomical data, the project will proceed to curate a dataset from existing astronomical surveys. This dataset will include systems with known numbers of planets to serve as a foundation for model training and validation. By developing a model that can accurately regress on the number of planets in a system, this project seeks to create a robust tool capable of adapting to the complexities inherent in observational data, such as direct images, transit data, and radial velocity measurements. The ultimate goal is to provide astronomers with a novel method for analyzing the spatial configurations of planetary systems, thereby enriching our understanding of the universe's myriad worlds. Expected outcomes include a highly accurate equivariant computer vision model, comprehensive performance evaluation, and extensive documentation to support further research and potential real-world applications in exoplanet discovery and characterization. Through this endeavor, we aim to not only advance the field of astrophysics but also to demonstrate the transformative potential of machine learning in uncovering the secrets of the cosmos.
This proposal bridges the gap between audio processing and machine learning by introducing an automatic differentiation (AD) library for the Faust programming language. This library empowers audio engineers to leverage machine learning within their familiar Faust environment. The core of the library will be pre-defined building blocks. These include Faust primitives with built-in derivative functions for common math and audio processing tasks. Additionally, there will be helper functions to simplify program construction and various loss functions specifically suited for audio processing. The proposal also explores Faust Neural Net Blocks (FNNBs), which are pre-written code modules representing specific neural network functionalities. These FNNBs will save development time, improve code maintainability, and allow audio engineers to focus on network architecture rather than low-level programming for each layer. The project deliverables will showcase the utility of the AD library in various phases. Phase I will deliver a working example of a differentiable filter or envelope in Faust. Phase II will focus on implementing a full-scale machine learning algorithm. This will be achieved through an autodiff file and a weights file. Finally, Phase III and IV will deliver an autoencoder implemented using FNNBs. By combining the AD library, FNNBs, and an architecture file specifying the training process, users can design and train complex neural network models for audio processing tasks entirely within Faust. This eliminates the need to switch between Faust and separate machine learning frameworks, while offering the benefits of automatic differentiation for efficient model training.
In this project, I want to create Jupyter notebooks for a real-world machine learning use case, especially image processing using publicly accessible datasets. The goal is to create a reference guide that others can use to build ML pipelines for image processing or computer vision problems. I already have experience working with image processing to detect breast cancer cells in histopathological images and want to leverage that to build a similar pipeline using Apache Beam for image processing use cases. This can also be expanded to other computer vision problems like object detection, facial recognition, optical character recognition, and hand gesture recognition for disabled people. Following are some ideas on notebooks that I can build and contribute to : 1. Image Data Preprocessing: Apache Beam can be used to create a pipeline for different image pre-processing tasks like resizing, cropping, normalizing and filtering for different image file formats like TIFF, PNG and converting it into a more standardized format like JSON. 2. Model Inference: We can showcase how trained models can be used to make real time inferences in a Beam pipeline. 3. Model Evaluation: We can evaluate the model using Apache Beam, utilizing various metrics such as accuracy, precision, recall, and F1 score. 4. Stretch Goal: If time permits, we can do a similar process for video datasets and show how to preprocess videos using Beam. Deliverables Apache Beam notebook with working code to deploy a pipeline for image processing/video processing use case and supporting documentation.
Strong gravitational lensing is a powerful probe of dark matter structure and cosmology, yet no foundation model exists that is purpose-built for lensing data with theoretical training guarantees. This proposal introduces WaveLens-JEPA, a self-supervised vision foundation model for gravitational lensing that extends LeJEPA (Balestriero & LeCun, 2025) to the astrophysical domain. The core idea is to decompose lensing images using a 2D Discrete Wavelet Transform before encoding, separating the physically meaningful frequency scales — Einstein ring morphology, subhalo perturbations, and ALP vortex structure — into orthogonal channels. A physics cross-attention module injects convergence-map priors from the lensing equation at every ViT block, while Einstein-Ring-Aware Masking (ERAM) targets the physically informative annular region during pre-training. Fourier phase regularization preserves substructure-discriminative spatial information that standard encoders discard. The training objective inherits provable collapse-free guarantees via Sketched Isotropic Gaussian Regularization (SIGReg), unlike all prior lensing SSL methods. The pre-trained backbone is evaluated on six downstream tasks: two substructure classification setups, lens finding, mass density regression, super-resolution, and a novel interpretability task via Wavelet Attribution Maps (WAM). Deliverables include: (1) open-source modular codebase, (2) pre-trained backbone weights on Hugging Face Hub, (3) a six-task evaluation benchmark, (4) a sim-to-real domain adaptation protocol targeting COSMOS HST data, and (5) a full research paper.
<p>Distributed tracing is essential for GenAI observability, but observing AI Agents differs fundamentally from observing microservices. While microservice traces focus on network latency and error codes, AI traces focus on the "reasoning process." The current Jaeger UI displays traces in a standard waterfall timeline, making it difficult to distinguish between logical "Tool Calls" and technical operations, and nearly impossible to read multi-paragraph prompts or view generated images. This project aims to transform the Jaeger UI into a first-class GenAI observability tool. When Jaeger detects a trace containing GenAI-specific metadata (following OpenTelemetry semantic conventions), it should automatically adapt its presentation to prioritize the "Agentic Flow."</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Automatic "GenAI Mode" detection: detect `gen_ai.*` attributes and offer/switch to a specialized visualization mode</li><li>Agentic hierarchy with iconography: use distinct icons to differentiate span types (e.g., "brain" for LLM calls, "wrench" for tool calls, "database" for RAG retrieval)</li><li>Rich-media side panel leveraging ADR-0006 side-panel capability, with Markdown support for prompts and completions, pretty-printed JSON for tool inputs/outputs, and direct rendering of images/audio previews</li><li>Simplified "logical" view: toggle to hide infrastructure-level noise and reveal a clean, high-level reasoning flow</li><li>More compact table view of multiple traces on the Search page</li></ul>