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.
This project develops a high-precision, clinically viable pipeline for segmenting Coronary Artery Calcium (CAC) from non contrast cardiac CT scans using the Stanford COCA dataset. The core innovation is a Hybrid 3D U Net architecture that balances the local inductive bias of CNNs with the global context of Transformers, specifically optimized for the extreme sparsity of calcified lesions. The architecture integrates 3D Deformable Attention to bypass O(N^2) scaling and CoordConv for anatomical grounding, effectively suppressing false positives from osseous structures like ribs. A primary research contribution is the experimental Fourier Neural Operator (FNO) bottleneck, which tests the hypothesis that calcified plaques can be isolated as high-frequency signals in the spectral domain. To ensure clinical utility, the model is trained using Scoring-Driven Consistency (SDC) a differentiable volume score loss that aligns optimization with the Agatston metric. Deliverables include a MONAI based preprocessing pipeline, a rigorous benchmark against an nnUNet gold standard, and a fully automated Agatston scoring engine for risk categorization (0, 1–99, 100–399, ≥400). This work aims to bridge the gap between architectural novelty and real world diagnostic accuracy for cardiovascular risk stratification.
Accessing medical data through the care web app can be daunting for patients in rural or remote areas who often face challenges with digital literacy, internet connectivity or lack of access to computers. Currently, retrieving appointments, health records etc requires users to log in and navigate the care web app, which makes it difficult for those with limited digital exposure to access their essential medical information. This project introduces an Instant Messaging wrapper for the care EMR, built as a django plugin. Which allows patients and staff to securely fetch medical records, check appointments etc and receive alerts and notifications through familiar, easy to use messaging apps like WhatsApp. To ensure HIPAA security compliance, the system uses a 2 step authentication process which includes (1). matching phone number and (2). verifying requestor's date of birth. It will also include redis based caching, ratelimiting of requests to prevent abuse and async task management via celery to handle sending of notifications in the background. A frontend plugin will also be developed to give staff the ability to easily send alerts and notifications and allow patients to download PDFs, such as medications and lab reports. Deliverables: 1. A functional, django based backend plugin, capable of securely serving patient and staff queries via various instant messaging providers. 2. A frontend developed using care_hello_fe to manage notifications and handle PDF downloads. 3. Proper tests utilizing pytest and Playwright for both the backend and frontend. 4. Complete and comprehensive documentation using sphinx and swagger, along with setup guides and demo videos. 5. Production ready deployments of both the backend and frontend plugins integrated within care.
Casanovo is a transformer-based de novo peptide sequencer that is too slow for real-time instrument use. I will profile the new non-autoregressive pipeline, apply CUDA graphs, mixed precision, and FlashAttention-2 to reduce per-spectrum latency, then train lightweight student models via knowledge distillation to reach the 20-100 Hz real-time target required by modern mass spectrometers.
This project adds native PEM keystore support to WildFly Elytron, enabling WildFly to load Kubernetes TLS secrets directly without any manual conversion. Kubernetes exposes TLS certificates and private keys as PEM files, typically as tls.crt and tls.key. Elytron currently requires JKS or PKCS12 keystores, which creates unnecessary friction when deploying applications in containerized environments. This project introduces a new KeyStoreSpi implementation that reads PEM-encoded certificates and private keys from separate files and exposes them as a standard keystore type (PEM). The implementation integrates seamlessly with Elytron’s existing KeyManager and TrustManager infrastructure, allowing it to be used transparently in current configurations. The main deliverables include a robust PEM parser, the PemKeyStoreSpi implementation, support for separate certificate and key files, Elytron configuration integration, comprehensive test coverage, validation using Kubernetes-style TLS secrets, and clear user documentation.
This proposal aims to create a production-ready, single-command deployment integrating the OpenHands AI coding agent with the OpenVINO Model Server (OVMS) on Intel AIPC hardware. The project resolves three critical friction layers: the API routing mismatch between OVMS (/v3) and OpenHands (/v1), the failure of structured tool-call execution which leads to model hallucinations, and system crashes caused by memory exhaustion from concurrent Docker sandboxes. By implementing a Docker Compose manifest with shared bridge networking and host Docker socket passthrough, the architecture offloads heavy LLM inference to iGPU or NPU targets while keeping orchestration on the CPU. Key technical deliverables include configuring native tool-guided generation for models like Qwen3-Coder-7B, enabling prefix caching to reduce multi-turn latency by over 50%, and enforcing strict container memory limits to ensure stability on 8 GB and 16 GB RAM profiles. The project concludes with a formal usability gap analysis and a finalized deployment setup to provide a seamless, local, and private AI development environment
This project aims to deliver comprehensive, end-to-end non-uniform grid support for MethodOfLines.jl. Currently, basic advection schemes lack graceful error handling for ill-posed boundary conditions, and advanced high-order schemes (specifically WENOScheme) completely lack non-uniform method dispatch, leading to fatal compilation errors on irregular domains. The proposed solution utilizes Julia's multiple dispatch to route non-uniform grids to a newly developed, isolated mathematical weight calculator within the WENO module, ensuring zero breaking changes for existing uniform grid users. Key deliverables include refactored basic advection schemes with robust well-posedness validation, a native non-uniform WENO implementation featuring dynamic smoothness indicators and negative weight regularization, rigorous L₂ convergence tests, performance benchmarking, and comprehensive documentation to enable highly precise real-world physics simulations.
This project's goal is to improve the accessibility and sustainability of the glmmTMB R package by replacing its C++-based TMB backend with a more user-friendly, R-like RTMB framework. While TMB provides high performance, its reliance on C++ limits contributions from the broader R community. Transitioning to RTMB will lower this barrier and allow more developers to extend the package. I will convert the core computational parts of glmmTMB into RTMB, validate correctness using existing unit tests, and benchmark performance on large datasets. The project will include updating the build infrastructure and improving documentation to support future contributions. The final deliverable will be a fully functional RTMB-based backend with strong performance and increased usability.
Lokalize has Translation Memory tab that opens up after selecting from Tools menu or pressing F7. It has TM(Translation Memory) entries, each for a distinct project listed in a drop down to select from. Translators would like to select not a single TM but a bunch of TMs, for each project, pertaining to their needs. Manage TMs option which opens up in a new window. Logically and for the ease of work, it should be situated in the TM tab itself. The key idea is to use QListWidget with checkboxes instead of KComboBox to enable multi-TM selection. Then, the setFilter() will be modified to iterate over each selected TM. A new method mergeAndDisplay() will be created for merging, deduplication, and sorting of entries according to score. TM selection will persist with the help of KConfig. The core base classes, DBs and architecture are to be retained. A QSplitter will be used to create a left panel to integrate TM Manager into TM Tab to list TMs and a right-click context menu for operations like Add, Remove etc. which will be wired to existing methods. Deliverables: ·List of TM entries with a checkbox for each ·Display results from all selected TMs after Search in TM Tab ·Save TMs for each project ·TM Manager in the left panel of TM tab
RFDiffusion (Watson et al., Nature 2023) is the state-of-the-art protein backbone diffusion model but DeepChem currently has no protein structure generative model. This project implements RFDiffusion and RFDiffusion All-Atom as native DeepChem TorchModel subclasses, covering a SE(3)-equivariant denoiser with Invariant Point Attention, a RoseTTAFold-style multi-track architecture, SO(3) diffusion for rotations, conditioning mechanisms (motif scaffolding, symmetry, binder design), the all-atom extension for side chains and small molecules, and a full evaluation pipeline. Deliverables include merged PRs for the featurizer, CATH dataset loader, core layers, and the complete model, along with benchmark results and a tutorial notebook.
The Ensembl Assembly/Annotation tracking application stores rich quality metrics for thousands of genome annotations but currently lacks tooling to surface or compare them in a way annotators can act on. This project builds two Python modules on top of the existing backend services. The first generates structured per-genome annotation reports including BUSCO scores, coding gene counts, annotation method, and visualisations. The second enables taxonomy-grouped comparative analysis using PCA and outlier detection across clades, so annotators can immediately see whether a genome looks unusual relative to phylogenetically similar species. Both modules extend the existing services layer (annotations_service.py, report_annotation_service.py, report_assembly_service.py, taxonomy_service.py) without replacing anything, follow the ensembl-genes coding standards (pylint, mypy, black, pytest), and are built to be extended as the data model grows.
This project implements a browser-native genomic feature search system for efficiently querying large GFF3 annotation datasets without requiring backend infrastructure. Traditional approaches either rely on slow client-side parsing or require server-side APIs, both of which introduce scalability and maintenance challenges. The proposed solution converts GFF3 files into an indexed SQLite database offline and performs full-text search queries directly in the browser using SQLite WASM within a Web Worker. The system integrates with JBrowse to enable seamless navigation from search results to genomic locations, providing a responsive and interactive user experience. To support large metagenomic datasets, the system will incorporate range-based loading and progressive data access strategies. The final outcome will include a production-ready indexing pipeline, a browser-based query engine, performance benchmarks, and a reusable React component that can be integrated across multiple EMBL-EBI web applications without requiring backend services.
The Jenkins Resources AI Chatbot can answer "how do I install this plugin?" but it can't tell you why your build broke, whether two plugins conflict, or whether last week's prompt change made answers worse. This project fixes that: an LLM-as-a-Judge evaluation pipeline, GraphRAG for relational plugin queries, a Build Failure Diagnosis Agent, and simplifed plugin setup all built directly on top of the existing chatbot-core architecture.
LensMint is an innovative Web3 hardware camera, but its reliance on strict cryptographic hashing makes Zero Knowledge proofs fail upon benign image compression. This project upgrades the authenticity pipeline by introducing Perceptual Hashing and a Hamming Distance ZK circuit in Rust to tolerate compression. Additionally, it implements a comprehensive Foundry security suite with maximum test coverage and optimizes gas consumption for the core smart contracts.
Classical force fields in molecular dynamics are fast but cannot capture bond breaking, charge transfer, or complex many-body chemistry. Machine learning potentials (MLPs) close this gap — offering near-quantum accuracy at a fraction of ab initio cost. Molly.jl currently supports MLPs only through a Python bridge (ASECalculator), which requires a Python runtime and bypasses Julia's differentiable programming stack entirely. This project delivers native Julia support for four widely-used MLP families: ANI (neural network potential for organic molecules), ACE (linear body-ordered basis expansion), NequIP, and Allegro (E(3)-equivariant graph neural networks). ANI is implemented from scratch in pure Julia using Lux.jl, with pre-trained ANI-1x/ANI-2x weights loaded from HDF5. ACE is integrated via the mature ACEpotentials.jl package. NequIP and Allegro are wrapped from TorchScript-exported models via PythonCall, following the existing ASECalculator pattern. All four potentials plug into Molly.jl's general_inters dispatch loop with zero changes to core simulation code. Pure-Julia models (ANI, ACE) are fully differentiable via Enzyme reverse-mode AD and GPU-accelerated via KernelAbstractions. The result: researchers can run differentiable, ML-accelerated molecular dynamics entirely within Julia — no Python, no overhead, composable with the full SciML ecosystem.
The CTTC 5G-LENA NR module provides a highly detailed and validated simulation of the 5G NR protocol stack within ns-3. However, a critical dimension currently missing is energy consumption modeling. Neither the UE nor the gNB reports power draw or connects to the existing ns-3 Energy Framework. This gap prevents researchers from studying vital metrics like UE battery lifetime, gNB operational expenditure, and overall green networking sustainability. This project will introduce a mature, callback driven energy tracking architecture to the 5G NR module by integrating it with the ns-3 Energy Framework.
This project addresses a key challenge in High Energy Physics: efficient and accurate end-to-end reconstruction of particle properties from detector data. In the CMS experiment at the Large Hadron Collider, particle collision events can be represented as high-resolution, multi-channel images. The goal is to simultaneously classify particle types and regress their invariant mass directly from these images. A major limitation of existing Vision Transformer (ViT) approaches is the quadratic computational complexity of softmax attention, which makes them inefficient for large-scale detector data. While linear attention mechanisms reduce this complexity, they often struggle to capture rich global interactions and multi-channel dependencies required for physics tasks. To address this, this project proposes the development of linear-attention-based Vision Transformers tailored for CMS E2E tasks, with a strong focus on extending the DepthViT architecture. The approach consists of three key components: Efficient Representation Learning A linear attention ViT with Masked Autoencoder (MAE) pretraining will be used to learn strong representations from large-scale unlabeled CMS data, improving downstream performance and convergence. Architecture Adaptation (DepthViT Extension) The DepthViT architecture will be adapted for supervised classification and regression by: Introducing dual-task heads for classification and mass regression Preserving depth-channel and rank structure in later layers to avoid information collapse Integrating Hierarchical Attention Permutable (HAP) blocks to enable efficient cross-window and cross-channel information flow while maintaining linear complexity Systematic Benchmarking The proposed models will be rigorously compared against standard and efficient transformer baselines (ViT, Swin, L²ViT, XCiT) using: Physics metrics (accuracy, MAE, R²) Efficiency metrics (FLOPs, memory, throughput)
Problem: Currently, Joomla items such as articles are limited to a single category, which makes it difficult to organize content that belongs to multiple contexts. While tags are sometimes used as a workaround, they do not integrate with core features such as routing, menus, and structured layouts in the same way as categories. Solution: This project introduces multi-category support by implementing a generic mapping table (#__category_item_map). It preserves backward compatibility and SEO integrity by using a "Primary Category" as the main reference for routing, workflows, and parameter inheritance. Deliverables: A new database schema, an updated backend interface for multi-category selection, frontend updates to reflect multi-category assignments in item views and category listings, model-level integration for custom fields, extended batch operations, unit tests, and documentation.
RNTuple is ROOT's next-generation columnar data format for High Energy Physics. Its storage layer is decoupled from its format layer, enabling new backends. This project implements a S3 storage backend for RNTuple, allowing datasets to be written to and read from S3-compatible object stores such as CERN's Ceph S3 and AWS S3. The approach introduces a new S3 locator type with two addressing modes: packed pages with multi-range GET for servers that support it, and one-page-per-object with concurrent GETs for those that do not. A JSON anchor at the base URL provides the entry point with a templated URL scheme for forward compatibility. The implementation adds RPageSinkS3 and RPageSourceS3 classes using the existing RCurlConnection as the transport layer, extended with PUT support and concurrent I/O via curl multi handles. Deliverables include the complete write path (Phase 1-2), complete read path with optimized cluster loading (Phase 3-4), RCurlConnection extensions for PUT and concurrent I/O, and a comprehensive test suite covering wire-level tests, locator round-trips, integration tests against MinIO and CERN Ceph S3, and performance benchmarks.
The OpenMRS O3 Service Queues app manages outpatient clinic flow but suffers from performance issues due to over-fetching deeply nested objects via custom REST representations, UI components that diverge from O3 design conventions and broken interactions including non-functional buttons and silent failures. This project builds a dedicated REST endpoint in openmrs-module-queue following the emrapi PR #250 pattern, returning only the data the queue table needs with server-side pagination and batch loading. Visit details are lazy-loaded on row expansion. On the frontend, the custom vitals component is replaced with the shared patient-vitals-info extension, encounter parsing is standardized to use configurable concept UUIDs and SWR data-fetching is optimized with activity-aware revalidation. All broken buttons are either fixed or removed. Deliverables include the dedicated backend endpoint with database indexes, frontend migration with lazy-loaded visit details, UI alignment with O3 conventions, fixed interactions with proper error handling, activity-aware SWR optimizations and comprehensive Playwright E2E tests with before/after performance benchmarks.
Teleradiology in underserved regions such as rural Alaska depends on reliable, low-latency transfer of large DICOM medical imaging files between remote clinics and reading centers. Today, these transfers are governed by static configurations - a fixed IP address, port, and Application Entity (AE) Title standardized decades ago. This breaks silently when SCP nodes restart, IPs change, or storage queues fill. This proposal introduces Dynamic DICOM Endpoints, an intelligent orchestration layer integrated with the open-source Orthanc PACS server and Docker containers on the Cloud. A FastAPI Orchestrator backed by a real-time Redis registry continuously monitors the health, latency, queue depth, and storage capacity of every Orthanc node in a multi-region deployment, selecting the optimal routing destination in milliseconds and replacing fragile static pipes with a self-healing, load-aware mesh. Deliverables include a four-region Docker Compose simulation environment; a Python telemetry daemon; a pluggable scoring algorithm; a thin Edge Agent bridging legacy scanners (GE, Siemens); a comprehensive test and benchmarking suite validating routing correctness, failover behavior, and transfer performance; and a documentation suite. All code will be contributed as open-source to the Diomede repository, directly improving imaging infrastructure for remote and resource-constrained healthcare settings. As part of my pre-proposal engagement with the host organization, I submitted Issues #59, #79, and #85, along with the corresponding PRs #60, #80, and #86, to the Diomede repository. This contribution demonstrates my familiarity with the project's codebase and development workflow, and establishes a collaborative relationship with the maintainers ahead of the GSoC coding period.
This proposal aims to modernize the OneBusAway iOS app by replacing the current tab bar navigation with a SwiftUI-based, Apple Maps–style sheet interface. It involves removing the legacy navigation system and introducing a new SwiftUI root view with a persistent bottom sheet that unifies key features, including search, nearby stops, arrivals, bookmarks, recent stops, and settings. The project will also ensure full VoiceOver accessibility support and establish a scalable SwiftUI foundation, enabling future features and incremental migration without revisiting the navigation architecture.
This project is to improve the P4Sim module by enhancing its Traffic Manager and integrating ns-3's built-in QueueDisc class into it. This will help developers and researchers in testing P4 switches with more complex scenarios and get accurate results for their experiments.
This project introduces a formal Experimental API Framework for Django by modernizing DEP 2. It implements a three-tier opt-in architecture utilizing virtual namespaces (django.experimental), centralized feature flags, and decorator engines. By establishing strict governance lifecycles and build-time safety mechanisms like an "LTS Kill-Switch", this project allows the core team to safely test, iterate, and graduate new features based on real-world feedback without compromising Django's strict backward compatibility guarantees.
This proposal aims at implementing the following quality-of-life improvements to FreeBSD's Zoned Storage support: NVMe ZNS support; Zone-aware gconcat(8), gpart(8) and gmirror(8); Two new GEOM drivers: one for emulating zoned storage, another to emulate regular disks backed by a zoned drive.