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.
<p>Harbor CLI needs two foundational improvements this term. First, migrate the TUI from Bubbletea v1 to v2 and refactor the fragmented list/table/selection models into a unified `loadingtablelist` abstraction with consistent loading, pagination, and error states across all commands. Second, replace static credentials with an OAuth 2.0 Device Authorization Grant (RFC 8628) and OIDC login flow so users and CI/CD pipelines can authenticate against Harbor through their identity provider without long-lived secrets.</p><p><br></p><p>Expected Outcome:</p><p><br></p><ul><li>Bubbletea v2 upgrade and unified `loadingtablelist` model adopted across all list-style commands</li><li>harbor login --sso` device-code flow plus a non-interactive CI/CD path with short-lived tokens</li><li>Encrypted local token storage with automatic refresh and provider-agnostic OIDC config</li><li>Tests for TUI state transitions and a mock OIDC provider covering device flow and refresh</li><li>Updated docs covering the new TUI patterns and OIDC setup for common providers</li></ul>
The convergence of blockchain and 5G security presents an opportunity to redefine authentication mechanisms within the core network. Traditional OAuth 2.0 authorization mechanisms in 5G rely on centralized components such as the Network Repository Function (NRF) to verify NF identities and issue access tokens. This introduces risks, including single points of failure, insider threats, and identity spoofing. This research explores a decentralized trust model for NF authentication using blockchain-based OAuth 2.0 authorization. The study will analyze the feasibility of leveraging blockchain smart contracts for secure, verifiable access token issuance, ensuring immutable NF identity records and distributed validation. By integrating blockchain with an open-source 5G core, the project aims to enhance security, mitigate attack vectors, and reduce dependency on centralized trust anchors. Expected Outcome and Deliverables - Design and prototype of a blockchain-integrated OAuth 2.0 authorization mechanism for NF authentication. - Implementation and testing of the system using an open-source 5G core solution. - Performance benchmarking against traditional NRF-based authorization models. - Security evaluation covering resilience to identity spoofing, insider attacks, and token misuse. - Documentation and research insights into blockchain-driven 5G security enhancements.
This project represents the orbit of a satellite orbiting earth on an Arduino-controlled pointer and a Liquid Galaxy rig through a mobile application. The application offers a unique way to visualize satellite orbits using the Liquid Galaxy rig (Google Earth) and a real-world Arduino-controlled pointer. It also provides insights into satellites' movements and access to vital satellite information seamlessly within the app. I plan to develop this by getting all the satellite data from SatNOGS database through API calls. Then, we use SGP-4 model to convert TLE of a satellite to get the state (position and velocity). Then we convert the satellite state to KML format. We segregate the KML data into the various tracks to get a neater visualization of the satellite's orbit data. Then, we write the code to send KML data from our Flutter app to the Liquid Galaxy to visualize this data on the Liquid Galaxy rig. Next, we make Arduino controlled pointer which emits green laser in the direction of satellite, which is controlled by the app. First, we 3D print the STL files of the 3D projector. Then, we assemble all the components of the Arduino-controlled pointer. Then, for the application, we use flutter_bluetooth_serial package to connect and send data to HC-05 module. Then, we use SGP-4 model to get the servo motor angles for the Arduino pointer. Then, we upload code to Arduino to receive data.
This project focuses on building a robust end-to-end testing framework for the KubeStellar UI using Playwright. The goal is to ensure seamless user experiences by automating critical workflows, enhancing test coverage, and catching UI issues early across various browsers and environments. This includes setting up Playwright from scratch, writing reusable and scalable test suites using the Page Object Model (POM), and integrating these tests into the CI/CD pipeline. Special focus will be given to WebSocket-based testing, authentication, and resource-heavy scenarios in a multi-cluster Kubernetes context. Expected Outcome: 1. End-to-end testing setup with Playwright integrated into the KubeStellar frontend 2. Comprehensive test suites for login, cluster/resource management, and binding policy workflows 3. Page Object Model-based modular test architecture 4. Mocking framework for WebSocket and REST API-based interactions 5. Visual regression testing integrated into GitHub Actions CI 6. Test coverage for key workflows 7. Cross-browser testing across Chromium, Firefox, Safari, and WebKit 8. Flaky test rate under 5% with parallel test execution and retry strategies 9. Documentation for writing, running, and debugging tests locally and in CI
Project Summary: Real-Time Traffic Prediction and Management System Problem: Urban traffic congestion poses significant challenges, leading to delays, increased pollution, and inefficient resource allocation. Existing systems often lack real-time predictive capabilities and edge-based solutions, limiting their effectiveness in dynamic environments. Solution: This project will develop a scalable, real-time traffic prediction and management system using AI-driven models (e.g., LSTM, GRU) trained on diverse data sources (Kaggle, OpenStreetMap, real-time APIs). The solution will integrate a data ingestion pipeline (using Apache Kafka/Airflow,ML), deploy models on edge devices via Docker and Kubernetes, and provide a Streamlit-based web UI for visualization and alerts. The system will predict traffic flow, detect anomalies, and trigger congestion alerts to optimize traffic management. Deliverables: A fully deployed edge-based traffic prediction microservice with low-latency inference. An automated data pipeline integrating multiple traffic data sources. A user-friendly Streamlit web interface for real-time monitoring and alerts. Comprehensive documentation (setup, architecture, deployment) and a 5-minute demo video showcasing the system’s capabilities.
This project addresses the critical challenge of GPU resource management in ML/AI research environments where researchers often face delays due to inefficient resource allocation. I'll develop a comprehensive CPU-based control plane that efficiently orchestrates GPU resources through four key components: an advanced job scheduler with priority management and preemption capabilities, a comprehensive observability platform with real-time dashboards, a streamlined model deployment pipeline with CI/CD integration, and robust infrastructure automation. By implementing technologies like Slurm for scheduling, Prometheus/Grafana for monitoring, Terraform/Ansible for infrastructure automation, and integrating ML-specific tools like MLflow and NVIDIA Triton, the system will deliver significant benefits to researchers: reduced wait times for GPU access, transparent visibility into resource availability, priority access for time-sensitive research, and a seamless deployment pipeline from training to serving. Deliverables include a functioning scheduler with priority queue support, a comprehensive monitoring system with custom dashboards, infrastructure-as-code modules, a model deployment pipeline with CI/CD integration, and an intelligent alerting system. The complete solution will serve as a reference implementation for academic GPU cluster management, providing reusable components and best practices for similar infrastructure requirements in the ML research community.
<p>Robust statistics are useful in finance since all classical estimates are vulnerable to extreme distortion by outliers. Because financial data has outliers to various degrees, practitioners need robust estimates that:</p> <ul> <li>Are not strongly influenced by outliers,</li> <li>Fit a good model to the bulk of the data,</li> <li>Detect and ignore outliers, and</li> <li>Provide for stable inference and prediction</li> </ul> <p>PerformanceAnalytics is a collection of econometric functions for performance and risk analysis, long considered a core package by the finance community. In addition to standard risk and performance metrics, this package aims to assist practitioners and researchers in using the latest research in the analysis of non-normal return streams.</p> <p>So I will be doing the following 2 things:-</p> <ul> <li>Creating functionality for calculating outlier-insensitive risk estimates in the Capital Asset Pricing Model</li> <li>Publishing a vignette on CRAN to demonstrate new features & formulating unit-tests to ensure consistency</li> </ul> <p>Impact:-</p> <ul> <li>Facilitating faster development & easier maintenance by reducing the technical debts of the package</li> <li>Aiding 120K+ risk professionals & researchers in making better risk analysis informed investment choices</li> </ul>
LLM inference acceleration is increasingly important for cloud-edge collaborative AI deployments. Speculative decoding can improve end-to-end generation speed by using a lightweight draft model to propose token candidates and a larger target model to verify them, but its real-world gains depend heavily on cloud-edge constraints such as network latency, bandwidth limits, and heterogeneous compute. Ianvs provides a unified benchmarking framework, and KubeEdge scenarios often require evaluating AI workloads under cloud-edge conditions. This project proposes a single-host cloud-edge simulation benchmark in Ianvs to evaluate speculative decoding for LLM inference. The benchmark will simulate edge (draft) and cloud (verify) roles as separate processes, inject configurable network constraints, and report standardized throughput and latency metrics, enabling reproducible comparison between baseline decoding and speculative decoding under different cloud-edge budgets. Expected Outcome: - An Ianvs benchmark test case for cloud-edge speculative decoding (PyTorch + HuggingFace). - A single-host simulation runner that emulates edge/cloud roles and configurable network constraints (e.g., latency, bandwidth). - Benchmark reports comparing baseline vs speculative decoding with key metrics (e.g., TTFT, end-to-end latency, tokens/s), and reproducible configs/scripts.
Problem: While Large Language Models (LLMs) like ChatGPT can generate R code, they often lack precision when answering questions about third-party R packages or contributing to the R language itself. This can limit their usefulness for R users, particularly for new contributors seeking to understand the R core or engage in package development. Furthermore, many of these AI tools are proprietary or resource-intensive, excluding users with limited hardware or funding. Solution: ChatR proposes a specialized R chatbot that is lightweight, locally runnable (even without a GPU), and customized to provide reliable support on R packages, documentation, and contribution practices. The project will use Retrieval-Augmented Generation (RAG), prompt engineering, and a lightweight open-source LLM (via Ollama and llama3.2:3b-instruct) to deliver targeted responses. It will be delivered as an R package with both CLI and Shiny UI interfaces. Deliverables: An R package wrapping the chatbot and customizable prompts Local model integration using Ollama and ellmer RAG-based indexing of documentation (e.g., CRAN, Writing R Extensions) A Shiny widget interface for interactive usage in RStudio Documentation, test suite, and demo applications This project will significantly support learners, developers, and contributors by democratizing access to reliable AI-based R support and onboarding tools.
This project addresses the growing challenge of managing Software Bill of Materials (SBOM) data at scale. While SBOMs in the SPDX format are essential for software supply chain security, current file-based approaches (e.g., JSON or RDF/XML) are not well-suited for complex querying, or large-scale analysis. To overcome these limitations, this project proposes a set of tools that leverage RDF triplestores for storing and managing SBOM data. SPDX documents will be parsed into structured Python objects, transformed into RDF triples, and stored using a unified triplestore abstraction layer. This approach enables powerful querying through SPARQL while remaining database-agnostic, supporting multiple backends such as Apache Jena, GraphDB, Blazegraph, AllegroGraph, and Oxigraph. The project will deliver a complete pipeline for SBOM ingestion, storage, and reconstruction. Key deliverables include: (1) a CLI-based ingestion tool for importing SPDX documents into RDF databases, (2) an export tool for reconstructing valid SPDX documents from queried data, (3) management utilities for CRUD operations on SBOM data, (4) a comprehensive test suite to ensure correctness across multiple backends, and (5) detailed documentation for both users and developers. This approach transforms SBOM data from static documents into a structured, queryable knowledge graph, enabling more efficient retrieval and analysis across different systems and backends.
This project focuses on end-to-end Handwritten Text Recognition (HTR) for early modern Spanish manuscripts. Unlike traditional OCR systems, which process isolated characters or lines, end-to-end HTR captures entire documents, preserving not only the text but also structural elements such as layout and reading order. Although this approach holds significant promise for both research and practical applications, it remains underexplored, especially for historical texts. This project proposes to apply end-to-end HTR techniques to early modern Spanish manuscripts, a historically rich yet computationally challenging corpus. Leveraging recent advances in deep learning. The project aims to improve recognition accuracy on handwritten and printed texts from this period by building on models which focus on document-wide attention mechanisms, the system will be able to better handle complex layouts and diverse handwriting styles typical of early modern Spanish texts. Ultimately, this research sits at the intersection of machine learning and historical document analysis, contributing both to technical innovation and cultural preservation. By improving the accessibility of early Spanish documents, the project not only supports scholars in the humanities but also contributes to the growing field of AI-driven humanities research. The integration of cutting-edge HTR models into historical workflows can open new possibilities for indexing, searching, and analyzing large volumes of archival material in a scalable, automated fashion.
Arterial Spin Labeling (ASL) is a non-invasive MRI technique that measures cerebral blood flow and supports studies on Alzheimer’s disease, stroke, and other neurological conditions. Yet existing software remains rigid, difficult to customize, and often restricted to brain-only research. Flexible ASL (PyASL) introduces a redesigned, developer- and user-friendly architecture that makes advanced ASL analysis accessible to a wider scientific community. Key innovations include: (1) Minimum programming knowledge required — run complete pipelines with more intuitive alternatives, such as YAML config, python notebook, command line interface, etc; (2) Mix & match preprocessing steps — combine algorithms from different pipelines without rewriting the code; (3) Easy plug-ins — add new preprocessing modules with minimal setup; (4) Support for integrating machine-learning models, custom statistics, and quality-control tools; (5) Extensibility beyond the brain to other organs, promoting cross-disciplinary imaging research. This system can cut integration time for new models or analysis steps by 60–80%, reduce development overhead, and foster reproducibility and cross-functional collaboration among clinical and technical teams. By bridging clinical imaging and modern AI, Flexible ASL lowers barriers for both novices and experts, helping to accelerate innovation in non-invasive perfusion imaging.
The goal of this project is to develop an Active Learning based Bayesian Geometry Optimizer(ALBGO) using PyTorch and BoTorch for optimizing the conformers locally and globally in internal coordinates, with support for several computational models like force fields, quantum chemistry and ML-based force fields. Bayesian Optimization is a highly effective technique for global optimization of "black box" functions and tuning hyperparameters. Since it does not require gradients, it can efficiently optimize hyper parameters for a Deep neural network or even electronic structure methods without derivatives. The project involves using Bayesian Optimization with an active learning approach to optimize conformers. The major work involves finding the right set of kernels for the Gaussian Process model for different types of molecular variables like Vibrational energy, bond lengths etc. and tuning them. We also an active learning approach to help the algorithm converge towards the solution much more quickly. Finally, we benchmark and compare the performance of our optimizer against other conformer optimization methods in use, like BFGS and gradient-based optimization algorithms. This project has the potential to significantly improve the optimization capabilities of researchers in several fields by reducing the cost of optimization and improving optimization performance. The ALBGO algorithm will be a valuable addition to the optimization landscape, and its PyTorch-based implementation will make it easily accessible to a wide range of users including non-chemists.
Problem to Solve : Build a system which performs the following: Enables full-text search of documents; filtered by agency, date, views Recommends similar documents based on semantic similarity of document contents Extracts significant document features such as topics, persons, locations, etc. Clusters and sorts documents by artifact topic (i.e. aerospace, environmental, nuclear, civil rights, etc.) Including: Natural language summaries for each artifact in the collection. Solution: To build the requested system, we will need several components and technologies. Here are the basic steps to achieve the functionality we require: Data ingestion: Loading the documents from a data source and extract the relevant information such as the document ID, title, content, agency, date, and views. Full-text search: Indexing the documents in a search engine such as Elasticsearch and enable full-text search with filters on agency, date, and views. Semantic similarity: Using a natural language processing model such as Doc2Vec to calculate the semantic similarity between documents and recommend similar documents. Document feature extraction: Using a named entity recognition model such as Spacy to extract significant document features such as topics, persons, locations, etc. Clustering and sorting: Using a clustering algorithm such as KMeans to group the documents into clusters based on artifact topic and sort them accordingly. Natural language summaries: we can use a summarization algorithm such as Gensim to generate natural language summaries for each document in the collection.
Financial factor investing relies on rigorous quantitative research to explain asset returns and generate alpha. While many academic models and institutional frameworks exist, open-source tools that replicate these methods — especially in R — are few and far between. This project aims to close that gap by contributing to the ExpectedReturns package, developing clean, modular functions that implement and generalize key factor construction techniques inspired by Antti Ilmanen’s Investing Amid Low Expected Returns. The focus will be on engineering reusable code for factors like value, momentum, profitability, and investment using raw or semi-structured financial data. These will be built using lightweight, testable components supported by packages like FactorAnalytics, PerformanceAnalytics, and tinytest, while following conventions used by Chen, Zimmermann, and Kelly. Also included will be vignettes and documentation that show how to reproduce these concepts in practice — making the tools both transparent and portable. This will be a two-month project. Deliverables will include: – Core functions for factor construction and data prep – Lightweight unit tests and clean vignettes – Documentation of inputs, outputs, and assumptions – A reproducible build setup that works across systems The goal is to make these concepts accessible — not just for researchers, but for anyone trying to understand and apply factor models in real-world contexts. If successful, this project will leave behind a set of tools that are as useful to the open-source community as they are to academic replication.
<p>The <strong>Fineract-cn-mobile</strong> application is the Android client of Apache Fineract CN, built on top of the FIneract CN Platform. It provides banking solutions for people around the world who are unbacked. This app is for field officers who go to their customers and provide them with financial services.</p> <p><strong>Achieved Goals:</strong></p> <p>-> Added support for all the Teller functionalities such as creating, editing, Viewing Tellers.</p> <p>-> Improved offline functionality in the application via Couchbase Implementation.</p> <p>-> Added support for viewing, creating and editing products.</p> <p>-> Added support for various Account-related functionalities, including viewing, creating and editing accounts. Also added support to lock, close, and reopen Accounts.</p> <p>-> Added Task management features for the Tellers, Account and products section.</p> <p>-> Extended the Kotlin support in App and replaced the already implemented MVP architecture with the Google recommended Model-View-View-Model (MVVM) architecture. Also extended.</p> <p>-> Added UI/Integration tests.</p> <p><strong>Work in progress:</strong></p> <p>-> UI for payment-hub integration is almost complete; APIs would be integrated once ready.</p> <p>-> Improve GIS features once the Endpoints are made.</p>
This project aims to implement full coarray support in the LFortran compiler, enabling native parallel programming capabilities based on the Partitioned Global Address Space (PGAS) model defined in the Fortran 2008/2018 standards. Currently, while LFortran’s parser supports coarray syntax, the feature is not implemented beyond basic stubs, preventing execution of even minimal coarray programs. The project will bridge this gap by extending LFortran’s Abstract Semantic Representation (ASR) to model coarrays, implementing semantic analysis for coarray constructs, and introducing a dedicated coarray runtime library. A key component is an ASR-to-ASR lowering pass that translates high-level coarray operations (such as coindexed access, synchronization, and collective intrinsics) into runtime calls. This design follows LFortran’s existing OpenMP architecture, ensuring backend-agnostic support across LLVM, C, and other targets. The implementation will proceed in two phases: first, establishing a fully functional single-image mode with correct semantics and runtime integration; second, enabling multi-image execution using an MPI-based runtime backend. By the end of the project, LFortran will be capable of compiling and executing coarray programs in both single-node and distributed environments. This work lays the foundation for supporting real-world coarray-based HPC applications and positions LFortran as a leading LLVM-based Fortran compiler with modern parallel programming support.
MathWorks Simulink is a graphical programming language that allows one to create nonlinear vehicle models, and perform control system design and development. Using Simulink code generation tools to add a custom attitude controller to the ArduPilot will allow the researcher to test their novel control algorithm in ArduPilot without spending too much time in manual coding which will further increase ArduPilot usage in academia. Currently, ArduPilot does not have a short and concise way to implement and test custom controllers. This project’s main aim is to create a systematic and sustainable way to implement a custom controller into ArduPilot using Simulink code generation and set an example for other researchers on how to use ArduPilot as a control system development platform. I implemented a new controller in the ArduCopter and has a Simulink model of this controller, thus I will continue with this vehicle type. But the methods laid during this project should be transferable to the other vehicle types. There are multiple-step I identified to achieve this goal. Firstly, the ArduCopter attitude controller code structure needs to be changed to allow running custom controller concurrently and safely switching between two-controller. Second, a hook in ArduCopter for Simulink code generation to bind should be created. Third, human-readable source code from Simulink without any dependencies on the Matlab libraries should be generated. Fourth, prepare a Matlab script to automatically merge generated libraries into ArduCopter source code, and configure and build it. Last, prepare detailed documentation and video to show how to utilize this functionality.
In evanix we explored making the scheduling of Nix builds more controllable. in particular, we look into implementing constraints such as –max-builds and –max-build-time, which ensure that build operations remain within manageable limits while maximizing throughput. Here the scheduling problem is framed as a mixed integer linear programming(MILP) problem. The input is a graph G=(V,E), where each vertex v represents a Nix package with a cost w(v) and a value p(v). packages that are classified as transitive dependencies—those required solely for other packages carry a value of 0. In contrast, packages that are requested for direct building are assigned a value of 1. This value structure reflects the prioritization of building requested packages over their dependencies. Our approach aims to identify a set of vertices or packages following the precedence constraints that maximizes the value or the number of packages built with value 1. It is crucial that a vertex or package can only be selected if all of its dependencies are also selected. An edge in the graph represents a dependency, with the indegree of a vertex denoting the number of packages that depend on it and the outdegree representing the number of dependencies of the package. We also developed a linear regression model to predict build times based on input derivations, enabling us to incorporate this information into our solver when it’s unavailable in Hydra. This predictive modeling greatly enhances our ability to estimate build durations for packages not built by Hydra, particularly those outside of Nixpkgs. By integrating these predictive insights with our MILP-based scheduling strategy, we aim to create a more robust nix build scheduler.
The project aims to enhance the cBioPortal platform by generating a list of recommended default genes for each OncoTree code, which are often used for molecular classification of specific cancer subtypes. This will improve the effectiveness of the cBioPortal database by prioritizing the display of relevant genes to each disease subtype. To achieve this goal, a Large Language Model (LLM) such as GPT-4o, will be fine-tuned with prompt engineering and Retrieval-Augmented Generation (RAG) techniques to provide domain-specific knowledge and context. The goal is to train the LLM to connect relevant genes to each OncoTree code. Approach: LLM Selection: GPT-4o is a strong candidate due to its versatility and performance in various NLP tasks. Prompt Engineering: Develop efficient prompts for the selected LLM to generate gene lists. RAG Component: Implement a RAG component to provide context to the LLM and enhance accuracy using e-utilities to retrieve curated literature from NCBI GeneReviews and ClinVar. Validation: Cross-reference the generated gene lists with expert-curated resources like ClinGen and variant frequencies in cBioPortal, and COSMIC. Evaluation: Continuously monitor the model's performance using validation sets and adjust hyperparameters as needed. Deployment: Integrate the solution into the cBioPortal platform such as sorting variants on patient view pages by relevant genes first. Conclusion: Completion of this project will significantly improve the usability of cBioPortal, providing users like researchers and clinicians with relevant gene and pathway information based on the cancer type they are exploring.
Offline change-point detection is a widely used statistical technique for identifying structural breaks in sequential data, with applications in fields such as signal processing, finance, and bioinformatics. Traditional methods, such as prune exact linear time (Killick et al., 2012) and binary segmentation (Hocking, 2024), are unsupervised, modelling shifts in the underlying data distribution without requiring prior knowledge or labels. While effective, they cannot leverage domain knowledge when it is partially available. Weakly supervised change-point detection methods bridge this gap by incorporating small amounts of coarse, inexact, or noisy labels to guide detection. Unlike unsupervised methods, many of which are efficiently implemented with consistent interfaces in packages such as changepoint (Killick et al., 2024) and rupturesRcpp (Nguyen et al., 2025), implementations of weakly supervised approaches are fragmented across packages, with no standardised tooling or shared interface currently available. This project aims to address this gap by extending the mlr3 ecosystem (Lang et al., 2019), a modular and extensible machine learning framework in R that provides unified interfaces for model training, evaluation, and benchmarking, to support weakly supervised change-point detection. It will also establish common abstractions for tasks, learners, and evaluation protocols tailored to change-point problems within the mlr3 design. The resulting framework will be rigorously tested and benchmarked, benefiting practitioners across various fields, enabling systematic comparison across methods, and providing a foundation for future extensions.
Project Summary: Problem: Renaissance-era Spanish texts remain digitally inaccessible due to modern OCR systems' inability to process archaic glyphs (ligatures, obsolete diacritics), degraded prints, and non-standard orthography. This limits scholars’ ability to analyze historical linguistic evolution and cultural heritage. Solution: Develop an open-source OCR system using a CNN-RNN hybrid architecture tailored for 17th-century Spanish. The model integrates weighted learning to address class imbalance (e.g., rare symbols like ſ or ç) and synthetic data augmentation to simulate historical print degradation. Key innovations include: Weighted loss functions (focal loss, class-aware cross-entropy) to prioritize underrepresented characters. Rule-based post-processing (e.g., positional substitution of ſ → s). Synthetic training data with historical fonts and degradation simulations, alongside real data Deliverables: A trained OCR model achieving ≥80% character accuracy (CER ≤20%). Evaluation metrics (CER/WER) and symbol-specific performance analysis. Codebase with inference scripts, documentation, and sample transcriptions. Impact: This tool will empower digital humanists, archivists, and linguists to transcribe and analyze historical texts at scale, preserving cultural heritage and enabling new research into early modern Spanish. By open-sourcing the system, we aim to democratize access to underserved historical materials and inspire community-driven improvements.
Checkstyle plays an important role in maintaining code quality in Java projects, but many of its reported violations are small, repetitive issues that developers tend to overlook. Although these problems are easy to fix, the effort required to manually locate and resolve each one discourages developers from addressing them, resulting in inconsistent code quality and growing technical debt. This project focuses on reducing that manual overhead by extending Checkstyle’s auto-fix capabilities using OpenRewrite. The main objective is to develop auto-fix recipes targeting frequently occurring Checkstyle violations. These recipes will automatically apply safe and consistent transformations to the codebase, allowing developers to resolve issues quickly and at scale. Beyond adding new recipes, the project will improve the internal design of the auto-fix system by transitioning from a position-based approach to a marker-based approach. The current method relies heavily on fixed code positions, which can become unreliable when the code structure changes. A marker-based strategy, on the other hand, enables more stable and context-aware transformations, making the system easier to maintain and extend. All implemented recipes will follow consistent design principles, include proper test coverage, and be validated on real-world open-source projects to ensure their correctness and effectiveness in practical scenarios. Overall, this project aims to streamline the process of fixing style violations, improve developer efficiency, and strengthen Checkstyle’s ecosystem by making automated code corrections more reliable and scalable.
CellQuery-ST addresses a key gap in computational pathology: while current models can predict gene expression or answer coarse slide-level questions, they do not support cell-aware querying of histology images. In practice, researchers and clinicians want to ask questions such as: Where are B-cell follicles? Which regions show inflammatory myeloid activity? Which neighbourhoods resemble a vascular niche? This project aims to make such biologically grounded querying possible on new histology slides. To solve this, I will build a cell-aware query grounding framework that uses spatial omics data for supervision during training but supports image-only inference at test time. Each slide will be preprocessed into a spatial index of cells, patches, and neighbourhoods, and natural-language queries will be matched against this index to retrieve or score relevant spatial evidence. The system will combine spatial pathology data with CellNet, an existing paired single-cell and language resource, to connect text queries with cell identities, cell states, and higher-level biological concepts. The main deliverables will be: (1) a benchmark covering four task families—cell type grounding, cell state/programme grounding, spatial niche grounding, and communication hotspot grounding; (2) a reusable slide indexing and retrieval pipeline for histology images; (3) reproducible baseline models and evaluation utilities for seen/unseen query generalisation; and (4) documentation and tutorial notebooks showing how to preprocess a new slide, issue queries, and evaluate results.