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 will have the aim to derive the empirical HRF for each brain region and each subject from BOLD recordings, and then to use this HRF in a computational model of brain activity (The Virtual Brain, implemented in EBRAINS). The legacy approach will be compared with the proposed one.The final pipeline will be implemented and validated on EBRAINS, ensuring full compatibility with the TVB cloud environment.
This project aims to extend the existing Marine AR Module Builder into a more accessible, scalable, and educator-friendly toolkit for creating augmented reality learning experiences in Unity. The primary objective is to reduce the technical barrier for educators and developers by introducing intuitive editor tools, structured workflows, and reusable systems for building marine AR modules. The proposed system will include drag-and-drop environment upgradation, streamlined actor placement and configuration, and reusable behavior templates for movement, interaction, and ecological logic. To improve flexibility and maintainability, modules will support extensive JSON/script-based definitions, enabling structured and streamlined content creation. Validation tools will be implemented to detect missing assets, invalid configurations, and performance issues, ensuring reliability and usability.
This project will improve the RenAIssance OCR pipeline for 17th-century Spanish historical documents by strengthening preprocessing, removing marginalia, optimizing TrOCR inference, and adding a flexible correction and deployment stack. The plan is to convert raw scanned pages into cleaner, layout-aware inputs, improve printed-text OCR, extend the system to handwritten OCR with the available handwritten datasets, and integrate local LLM/VLM-based correction with external fallback support when needed. The final deliverables will be a modular OCR pipeline, a deployed Flask application, benchmarking against existing OCR tools, and a paper-style technical report with reproducible documentation.
kornia-rs currently supports only CPU-based computation for image processing operations like resize, warp, and color transforms. This project implements a GPU backend for kornia-tensor and kornia-imgproc, motivated by a concrete Bubbaloop use case: a real-time camera pipeline that needs faster preprocessing to make VLM inference feasible on edge hardware. The work includes a feature-gated GpuAllocator with explicit host-device transfer semantics, allocator-based backend dispatch for tensor operations, and GPU kernels for resize, warp_affine, warp_perspective, and RGB <-> Grayscale conversion using CubeCL.
The 4diac IDE Type Management component provides rename, move, copy, and delete refactorings for FB types and structured data types but has no automated regression tests. This project implements a comprehensive JUnit 5 test suite that programmatically drives all core refactorings via the Eclipse LTK framework, validates EMF model state and workspace resource correctness using a hybrid semantic-assertion and golden-file strategy, and covers full undo/redo for every scenario. Deliverables include the test plugin, a reusable refactoring test framework, fixture projects, and developer documentation.
This project upgrades the AR-based Marine Ecosystem Simulation by improving its realism, scalability, and performance on mobile devices. The current platform offers an interactive AR experience but lacks advanced ecosystem dynamics and scalable infrastructure. This project addresses these gaps by introducing procedurally generated marine environments (reef, open ocean, deep ocean) and more realistic behaviors such as predator-prey interactions, habitat-driven movement, and climate-based ecosystem changes. To ensure smooth performance on mid-range devices, the system will incorporate optimizations such as LOD pipelines, shader efficiency improvements, spatial partitioning, and streaming-based spawning. These enhancements will enable real-time simulation of complex multi-species interactions while maintaining stable frame rates. Firebase integration will provide user authentication, persistent progress storage, and classroom module sharing, making the platform more scalable and suitable for educational use.
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.
P4-SpecTec provides mechanized formal semantics for the P4 language, but its adoption is currently limited by a lack of accessible learning resources. New users face a steep learning curve in understanding how to write, execute, and utilize mechanized specifications in practice. This project proposes to improve the usability of P4-SpecTec by developing a tutorial-style documentation centered around nano-P4, a minimal subset of the language. The tutorial will guide users through writing mechanized specifications, executing them, and generating specification documents, providing a hands-on introduction to the framework. The technical scope includes constructing a complete nano-P4 specification within P4-SpecTec, designing detailed examples, and demonstrating workflows for specification execution and document generation. The end result will be a practical and reproducible learning resource for onboarding new users.
OpenSSL 3.2 introduced native QUIC support, enabling HTTP/3 on top of the world’s most widely deployed TLS library. Apache httpd, however, is still architected around TCP-based connections and its Multi-Processing Modules (MPMs), which makes integrating QUIC and HTTP/3 non-trivial. An example codebase (openssl-h3-examples) already demonstrates HTTP/3 using OpenSSL’s QUIC support and nghttp3 in a standalone server, and reuses patterns inspired by mod_http2, but it remains experimental and is not integrated into httpd as a module. This project proposes a new HTTP/3 module for Apache httpd, building on OpenSSL QUIC and nghttp3, and aims to resolve the architectural mismatch between httpd’s TCP-oriented worker model and QUIC’s UDP-based, stream-multiplexed transport. The goal is a maintainable, reviewable prototype module that the Apache HTTP Server community can evaluate and evolve toward production readiness.
The project solves a common problem in robotics systems: ros2_control already gives teams strong building blocks for hardware and controller control, but it still leaves the coordination of full system transitions to the user. In practice, that means teams often write their own startup scripts, timing delays, and controller-switching logic by hand. My plan is to build a reusable orchestration layer that watches existing ros2_control status, applies YAML-defined presets, and moves controllers and hardware into the right states in a safe, deterministic order. The work will be delivered through five parts: a benchmark multi-robot scenario, a periodic status publisher in controller_manager, status topics on standard controllers, a YAML preset format with validation, and a Mission Control node that executes and verifies each transition without touching the real-time control loop.
The JdeRobot Robotics Academy utilizes massive monolithic Docker images, which result in critical download issues for students, and demands insecure root daemon privileges to execute containers. To address this, I plan to design a highly optimized multi-stage build framework for RoboticsBackend, which will minimize total megabytes for download by students and reduce image size using strict apt layer squashing and source-level pruning of heavy ROS2 meta-packages like Aerostack2 and OMPL. Moreover, I will transform the execution framework to a secure, daemonless Podman-based container execution system, which will enable precise namespace mapping using –userns=keep-id and native display socket passthrough for safe execution of GUI-based Gazebo simulations without compromising host security. Deliverables : 1. Optimized Container: A new, optimized image with a mathematically provable reduction in total megabytes for download and build layers. 2. Rootless Execution: A fully functional Podman-based environment for secure execution of the entire database and frontend stack without a Docker daemon. 3. Developer Documentation: New official documentation on new multi-stage build paradigms and executing containers rootlessly.
Building on the PINNDE proof-of-concept from GSoC 2025, I propose two directions: (1) systematic improvements to the PINN architecture and training — Fourier feature embeddings, GELU activations, and adaptive collocation — informed by my test task results where GELU+Fourier features reduced physics loss by 10x over the baseline tanh network; and (2) a flow matching reformulation that replaces the O(NM) Monte Carlo score estimate with a simulation-free O(N) training objective, producing straighter transport paths that are easier for the PINN to learn. I will implement quantitative evaluation metrics (MMD, Sliced Wasserstein), benchmark both approaches on the existing 3D toy distributions, and apply the best pipeline to Dataset 1 of the Fast Calorimeter Simulation Challenge 2022. Deliverables: improved PINN architectures with benchmarks, a flow-matching PINNDE training mode, a reusable evaluation module, and results on the Calorimeter Challenge.
This project takes the AI Tutor SDK further by fully integrating it into PocketCode, converting its block-based programs into AI-readable context, redesigning the UI to match PocketCode's visual style, and conducting user testing with internal and external users to gather actionable insights. As stretch goals, it explores a direct AI API mode and a RAG-based pipeline using PocketCode documentation stored in a local SQLite vector database to provide accurate, context-aware answers for students.
CAC segmentation is harder than it looks. Calcium deposits are tiny, sparse, and look identical to nearby bone a small miss doesn't just drop your Dice score, it flips a patient's risk category entirely. I already ran a test: a lightweight 2D U-Net hitting 0.9416 median Dice, 63x faster than TotalSegmentator. Strong baseline, but high variance on edge cases showed me exactly where it breaks. So instead of optimizing one model, I'm building a reproducible pipeline to compare five architectures 2D U-Net, 2.5D U-Net, Attention U-Net, TransUNet/SwinUNet, and nnU-Net under identical conditions. Same data, same loss, same optimizer. Only the architecture changes. That way the results actually mean something. Beyond Dice scores, I'll evaluate Agatston score accuracy, risk category agreement, and anatomical localization of plaques to specific coronary arteries. The goal is a framework the PREDICT1 team can actually use not just a leaderboard.
DeepChem supports transformer-based foundation models for chemistry (ChemBERTa, MolFormer) but has no equivalent for genomic data. This project fills that gap by integrating DNABERT-2 into DeepChem, following the same design pattern used by ChemBERTa and MolFormer. The implementation consists of two components: (1) a DNABert model class that wraps HuggingFace's DNABERT-2 inside DeepChem's HuggingFaceModel/TorchModel hierarchy, supporting masked language modeling pretraining and fine-tuning for classification, regression, and multitask regression; and (2) a DNABertTokenizer that serves as both a HuggingFace tokenizer and a DeepChem featurizer, making it compatible with DeepChem's data loading pipeline. Deliverables include the fully integrated model and tokenizer classes, tests across all task modes, and benchmarks on a suitable genomic dataset.
This project aims to implement a Visual Attribute Mapping System that enables users to automatically map node and edge attributes to visual properties within the GraphSpace interface. This system will allow users to generate meaningful graph visualizations where the appearance of graph elements directly reflects underlying attribute data — turning raw data into visual insight. There are two main components in this project: User Interface for Visual Attribute Mapping — A new Visual Attribute Mapping panel integrated into the GraphSpace Layout Editor. This interface will allow users to select graph attributes and map them to visual properties through an interactive configuration panel. Users will choose between Discrete Mapping (categorical attributes) and Continuous Mapping (numerical attributes). The interface will dynamically display configuration options based on the selected mapping type and visual property. Backend Support for Attribute Mapping — Backend services that read graph attributes, validate mapping configurations sent by the frontend, compute Cytoscape-compatible style rules, and store them via the existing layout update API. This component integrates with the existing update_layout controller and the style_json storage mechanism — requiring no new database tables.
I will resolve all false negatives present in the modules (checks) used in the Google Style Guide coverage. I will also identify and fix issues related to the modules used for coverage. Additionally, I will address blocking bugs and update the coverage page for the Google Style Guide.
Currently, p5.js has a frustrating limitation for 3D artists: it flattens every imported model into a single shape that can only hold one texture. If you export a complex character from Blender or Maya with different materials for things like skin, clothing, and eyes, p5.js silently discards that information during the import process. This leaves creators with a flat, grey model instead of the detailed, textured work they actually designed. This project fixes the problem at its core by updating the library to recognize and render multi-material models automatically.
At the CMS detector, jet images are stored at reduced resolution, discarding ~75% of total deposited energy. Standard super-resolution fails here because it optimises for visual similarity, not physical validity — a model without energy constraints converges to a response of 0.52, recovering only half the missing energy. As part of the ML4Sci/CMS test task, I developed a complete physics-aware conditional GAN pipeline (github.com/rajveer43/cms-superres-reconstruction) that maps 3×64×64 LR jet images to 3×125×125 HR reconstructions using a residual CNN generator, PatchGAN discriminator with spectral normalisation, and a three-component hybrid loss (LSGAN + L1 + energy response). The best configuration achieves raw-space L1 of 0.00698 vs 0.00846 for bicubic (17.5% improvement), PSNR 14.32 vs 14.13 dB, and energy response 1.0098 — within 1% of simulation ground truth. This GSoC project extends that validated baseline by implementing and benchmarking SwinIR-style transformer SR adapted for η-φ calorimeter coordinates, and a conditional DDPM/flow-matching diffusion variant as a stretch goal. Every architecture is evaluated on the same physics-constrained suite: energy response must remain within [0.99, 1.01] or the model is rejected regardless of pixel quality. Deliverables: reproducible GAN baseline with full metric suite, trained transformer SR model with benchmark comparison table, mid-project GAN vs transformer report, final benchmark across all architectures, technical report, and organized codebase for CMS collaboration use.
HPX currently requires verbose macros like HPX_PLAIN_ACTION and HPX_REGISTER_ACTION to define remote operations across localities. This boilerplate is error-prone and creates a steep learning curve for new users. With C++26 static reflection (P2996), function signatures can be introspected automatically at compile time, eliminating this boilerplate entirely. This project implements reflection-based action definition for HPX, replacing HPX_DEFINE_PLAIN_ACTION with a clean template API that uses scope_builder and fixed_string for compile-time name extraction — building directly on the serialization reflection foundation from PRs #7010 and #7016 already merged into master. A working prototype has been built and tested in the GCC trunk Docker environment prior to the coding period.
SW360 today uses Apache Thrift for backend-to-backend calls. That choice forces a Thrift toolchain and many .thrift IDLs, ships large WARs via shared Thrift servlet code, makes traffic hard to debug with normal HTTP tools, and limits standard metrics and load testing. Project goal is to migrate the backend incrementally to Spring Boot REST with a shared libraries/service-api contract (plain POJOs instead of generated Thrift types), WebClient from the resource-server, and a Converter pattern where backend-common still uses Thrift-shaped DB types, so each service can move without a big-bang rewrite. Health and Vendor are already implemented as proof of concept with benchmarks and parity checks. Deliverables: migrate all 23 Thrift-backed service clients, shrink/remove Thrift from the build, delete or retire IDLs and ThriftClients factory methods as each service lands, document the migration recipe and architecture tradeoffs (including optional gRPC for hot paths if mentors agree), keep the public REST/HATEOAS API stable for consumers, and finish with full-system tests, updated contributor docs, and final benchmarks. Work is phased by dependency tiers (standalone services first, Schedule and final cleanup last) on GSoC 2026’s extended coding period, with buffers for review and integration risk.
This project aims to scale QuTiP's HEOM solver beyond single-node limitations by integrating PETSc to distribute ODE integration across multiple MPI ranks on HPC clusters. HEOM can exactly simulate open quantum system dynamics, but propagating a full hierarchy of coupled auxiliary density matrices makes it brutally expensive — the current scipy-based single-process implementation hits a hard wall at hierarchy depth > 6 or larger Hilbert spaces. The core design challenge is partitioning the coupled density matrices across ranks without making inter-process communication the new bottleneck. The work covers profiling the existing solver, building the distributed path on PETSc's TS interface, correctness validation against the original solver, and scaling benchmarks across node counts and hierarchy depths — all without touching the existing solver or changing anything the user sees.
This project aims to transition OpenPrinting’s security infrastructure from fragmented unit-testing to a comprehensive, state-aware system fuzzing framework. While current fuzzers target isolated helper functions, they fail to exercise the deep implementation logic of complex media parsers (PDF, PCL, Raster). Utilizing AFL++, Honggfuzz, and OSS-Fuzz-Gen, I will develop API-Sequence-Based harnesses that mimic authentic user-triggered scenarios. Key deliverables include a unified consumption shim for the media pipeline, IR-based recombination algorithms for nested object abstractions, and a curated high-quality seed corpus. My preliminary discovery of a zero-day vulnerability in ipp.c (GHSA-67hg-386m-x83h) underscores the critical need for this systemic approach to harden the open-source printing ecosystem.
The new git repo command doesn't handle file paths yet, and it forces users to dump all repository data at once instead of just requesting what they need. This makes scripting difficult and forces developers to keep using the older git rev-parse command. This project improves the git repo info command in two main ways: First, by adding path.* keys (like path.git-dir) that can return both absolute and relative paths. Second, by building a fast, lightweight search system (O(log N)) so users can easily query specific categories of information. As a stretch goal, the project will evolve git repo structure into a diagnostic tool by introducing metric distributions, such as object size and entry histograms.