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.
Gemma Facet is a comprehensive platform that provides an end-to-end solution for fine-tuning Gemma language models through a microservices architecture. The platform implements four core services: dataset preprocessing with support for local and Hugging Face datasets, automated training jobs using Unsloth and Transformers libraries, model inference capabilities, and flexible export functionality supporting multiple formats (adapters, merged models, and GGUF). The backend leverages Google Cloud Run services for scalable compute, Firestore for database operations, and Google Cloud Storage for artifact management. The frontend is built with Next.js, Tailwind CSS, and Shadcn UI, providing an intuitive dashboard interface. Infrastructure is managed through Terraform with containerized services using Docker. The system handles complex workflows including dataset splitting configurations, asynchronous training job management, and multi-format model export pipelines. Key technical implementations include Cloud Run Job integration for resource-intensive operations, comprehensive API design with full documentation, and optimized data processing pipelines for efficient model fine-tuning workflows.
This project aims to create a tool that automatically generates Python typing stubs for the Device Under Test (DUT) in cocotb-based hardware verification testbenches. By leveraging cocotb’s existing introspection capabilities, the tool will produce .pyi stub files describing the DUT’s interface – its hierarchy of modules and signals – in a statically typed fashion. These stubs will enable IDE features like auto-completion via VS Code’s Pylance and allow static type checkers such as mypy to catch errors in testbench code, significantly improving the hardware verification development experience. The generated stubs will mirror the HDL design’s structure (with considerations for hierarchical vs. flat representations) and provide a structured abstraction of the DUT interface that can even be used for mocking or unit-testing components of the testbench. Initially, the stub generator will rely on runtime cocotb introspection only, but it will be designed with extensibility in mind, so that future enhancements (e.g., integrating a SystemVerilog language server like slang for richer type info) can be incorporated. Over a 175-hour Google Summer of Code timeline, the project will deliver a working stub-generation utility, along with documentation, tests, and integration into the cocotb ecosystem, providing a concrete benefit to the open-source hardware verification community.
This project tackles the challenge of time-consuming manual brain segmentation in MRI by developing an automated tool using deep learning (FastSurfer) to accurately segment key brain areas critical for TMS. The approach uses advanced CNN models to quickly and precisely divide the brain into subparts like the cortex, thalamus, and hippocampus. This helps accurately position the TMS coil for effective treatment.
Ultimate Alarm Clock is a cross-platform Flutter application that needs enhancement with advanced features to provide users with a more comprehensive alarm experience. This project aims to develop 12 key features including negative condition alarms that trigger based on inverse conditions, shared alarm notifications for coordinating wake-up times across multiple devices, timezone-aware alarms, Google Calendar integration, and smart home/IoT integration. Additional features include enhanced snooze customization, sunrise alarms that gradually brighten the screen, task lists for alarms, and advanced alarm insights. The implementation will follow a three-month development plan with regular deliverables, focusing on code quality through UI component standardization and reducing third-party dependencies. The end result will be a significantly enhanced open-source alarm clock application that goes beyond basic functionality to serve modern users' complex scheduling needs while maintaining a clean, intuitive interface across all platforms.
The field of computational biology depends significantly on mathematical modeling to simulate complex biological simulations, often involving solution of large systems of ordinary differential equations, which describe dynamic biological processes. Accurate and efficient numerical solvers are essential for these simulations to predict correct behaviour. LSODA (Livermore Solver for Ordinary Differential equations Automatic) is a well-established ODE solver known for its ability to dynamically switch between stiff and nonstiff methods, making it particularly suitable for biological models where stiffness can vary over time. However, LSODA’s widely used implementations are primarily in C/C++ and Fortran, creating a barrier for researchers working in Java-based environments. This project aims to bridge that gap by implementing a robust, optimized, thoroughly tested, and fully functional Java-based version of the LSODA algorithm within the Systems Biology Simulation Core Library (SBSCL).
This project proposes enhancing RTEMS’ In-Memory File System (IMFS) by introducing configurable memory allocators and improving bytes-per-block handling. By replacing hard-coded malloc/free with user-defined allocators, IMFS gains flexibility for constrained systems. Additionally, stricter validation of block sizes and support for larger blocks (1K–2K) will improve error resilience and scalability.
The goal of this project is to enhance the LicenseDB platform by integrating several important features including advanced database migrations, support for refresh tokens, and a notification system to notify users when a license is updated. In addition, it will require setting up a clean backend and fronted monorepo for simplified development. The improvements will ensure the platform is better, reliable, scalable, and more user-friendly.
Prerequisites: Ubuntu and ROS 2 development environment, no need for specialized hardware. Necessary programming skills: Familiarity with C/C++/Python, CMake, ABI/API. Difficulty level: Medium. Potential mentors: Tomoya Fujita Expected size: 100 hours to 150 hours. Expected outcome: A ROS 2 command line interface ros2cli with doctor sub-command and ros2_documentation. Detailed description: Currently, the ROS 2 doctor subcommand, ros2 doctor, is lacking a lot of useful information, such as ROS environment variables, RMW-specific environment variables, and configuration and service information (number of endpoints, QoS compatibility status, etc). This information is really important and useful for debugging issues with ROS 2, and would greatly improve our ability to support issues reported by our user community. In other words, adding this new information to our existing ROS 2 Doctor command would accelerate community communication and make bug reports much more precise! Aligned with ros2cli development, this project also targets the implementation of improved documentation on how to create an issue report with a new issue template. Reference pull requests: Add default github issue templates, add: get clients, servers info
KinFin is a powerful tool for protein clustering analysis, but its current command-line interface limits accessibility and ease of use. This project aims to develop an intuitive, standalone web-based UI that is also easily integrable with GenomeHubs, enabling researchers to visualise, explore, and analyse protein clustering data efficiently. The UI will include interactive visualisation such as taxonomic heat maps, phylogenetic trees, and cluster distribution plots. Additionally, users will be able to cross-reference results with external genomic resources like MolluscDB and Ensembl. Back-end enhancements will ensure seamless data retrieval and scalability, making KinFin more accessible and impactful for genomic research.
Waystation is a transit information display that provides reliable, real-time arrival and departure times at bus stops, train stations, and transit hubs. It also delivers service alerts and supports multiple languages, ensuring accurate information is accessible to a wide range of riders.
This proposal aims to significantly enhance CircuitVerse's user experience and technical foundation by migrating core UI elements to reusable View Components, optimizing search performance and UI/UX using Hotwire/Stimulus, improving overall site navigation with Turbo Drive, fixing UI bugs, streamlining user flows, and implementing RTL language support.
The marine environment is in demand of marine protection, especially in the era of climate change. This protection can only occur when people are informed about the connections between biodiversity, pollution, overfishing and climate warming. To strengthen the sensibility for the marine ecosystem, demo games can be an important tool, especially to have early access to younger generations. Once the awareness of nature is manifested, it can become a guide for further life. In this project I want to combine scientific knowledge with fun. So, I want to create games to reach out for children globally to let them get in touch with marine life.
The current macOS app bundle creation process for Synfig relies on an outdated Bash script that is slow, error-prone with incorrect paths, and lacks code signing, hindering efficient distribution and user trust. This project aims to replace the script with a robust, automated solution to streamline bundle generation, ensure macOS security compliance, and enhance the native user experience. By leveraging Python for dependency collection, C++ for environment setup, and CMake/CPack for packaging, the project will deliver a signed, distributable SynfigStudio.app bundle. Key improvements include faster dependency gathering, proper code signing, embedded environment setup, Python/lxml integration, and macOS-native interface enhancements. Approach: • Develop a Python script to efficiently collect and stage dependencies, optimizing with caching and parallelization. • Implement code signing in reverse dependency order using codesign, including Python and lxml binaries. • Remove the external launcher script by embedding environment setup in the C++ entry point. • Package Python and lxml into the bundle, ensuring compatibility and signing. • Integrate CPack into CMake to generate a polished .dmg installer. • Enhance the UI with macOS-native menu bar and window behaviours using GTK. Deliverables: • A CMake/CPack-based build system producing a signed SynfigStudio.app bundle. • A Python script for automated dependency collection and path rewriting. • Code signing support for all binaries, including Python and lxml. • Embedded environment setup within SynfigStudio, eliminating the launcher script. • A bundled Python runtime with lxml, fully signed and functional. • A distributable .dmg installer generated via CPack. • macOS-native UI improvements (e.g., menu bar, shortcuts, dialogs boxes). • Comprehensive documentation covering installation, usage, and build instructions.
This project aims to develop an AI-powered system for the virtual reconstruction of fragmented cultural heritage artifacts, with a focus on Mayan stelae. These artifacts are often discovered in broken, randomly oriented, and partially eroded states, making manual reassembly both time-consuming and imprecise. The proposed solution combines geometric analysis, graph-based fragment matching, and machine learning techniques to automate the reconstruction process. By leveraging 3D scans of the fragments and training models on real geometric descriptors, the system will predict correct alignments and reassemble the stele in a digital space. The project will be implemented using Open3D for 3D processing and PyTorch for neural network training. This work not only aids in archaeological restoration efforts but also contributes to the broader field of digital heritage preservation.
This project addresses the lack of RNTuple support in JSROOT, a critical gap hindering browser-based visualization and analysis of high-energy physics (HEP) data. My Solution: By developing a JavaScript parser for RNTuple’s binary format, extending JSROOT’s interface to mirror its `TSelector` API for TTrees, and integrating visualization tools (histograms, scatter plots), researchers will gain seamless access to RNTuple data directly in web browsers. Key deliverables include: 1. Validated Parser: Tested against ROOT-generated datasets (via C++ macros) for accuracy. 2. JSROOT Integration: A `TRootupleSelector` interface enabling reuse of existing visualization modules. 3. Interactive Visualizations: Histograms, scatter plots, and UI features (tooltips, zoom) for real-time data exploration. 4. Optimized Performance: Stress-tested with 1M+ entries, cross-browser compatibility (Chrome, Firefox, Safari, Edge). This work will bridge the gap between RNTuple and browser-based HEP analysis, enhancing accessibility for global researchers.
PETSc, the Portable, Extensible Toolkit for Scientific Computation, is for the scalable (parallel) solution of scientific applications modeled by partial differential equations (PDEs). Besides its native API in C it has bindings for Fortran and Python. PETSc also contains TAO, the Toolkit for Advanced Optimization, a software library supporting MPI and GPUs through CUDA, HIP, Kokkos, or OpenCL. While most of the Fortran interfaces can be generated automatically from the C-API, functions with "complex" arguments such as procedure pointers, pointers to arrays, and strings require the manual creation of interface code on both the C and the Fortran side. Moreover, due to the discrepancy of features between C and Fortran, a one-to-one translation of APIs leads to Fortran interfaces that don't leverage the capabilities of modern Fortran. Examples include overloaded functions for different types in Fortran, for which a C-API requires VOID and an explicit type argument and arrays, for which the length is part of the type definition in Fortran but requires a second argument in the C-API. This project aims to improve the automation of generating Fortran interfaces by leveraging modern Fortran features such as BIND(C) and ISO_C_BINDING along with annotation strategies to reduce the need of manual generation of interfaces. The improved system will enhance both usability for end-users and maintainability for developers.
RIPE Atlas publishes traceroute measurement results. A measurement result can have a large volume of data. One example of a large volume measurement is as mentioned below: "Given around 12000 probes worldwide and the system collects traceroute data from these probes every 15 mins. The measurement has been running for 2+ years. The maximum hops a probe made in this measurement was 32." RIPE Atlas provides a REST API to fetch the measurement result. However, the measurement result object can be a large json response. It increases the memory usage on the server while creating a huge response. If the server succeeds in creating a huge response, the client device may not afford to render an SVG graph given the large traceroute data. The main goal for this project is to enable the visualizer to handle traceroute measurement results of any volume. This can mainly be achieved by - Narrowing down the search according to the inputs (probe ids to include, time frame) provided by the user - Paginate the measurement result API call by probe ids, start time and stop time Experiment rendering the network graph using more efficient graph libraries and test. If by testing, the results are improved then replace the current implementation of v-network-graph. Also, there is a scope for UI enhancements. The main thought process behind thinking UI enhancement for this project was this: "The data which we can provide should simply be there on the graph when the user needs it. This UI enhancement can be achieved by adding another “Detailed mode” to the network graph." During the GSoC timeline, I will be executing testing strategies, fixing the underlying issues of the traceroute visualizer and documenting my work.
Training Large Language Models (LLMs) is computationally expensive, often bottlenecked by the performance limitations of Python-based frameworks. This project addresses this challenge by enhancing LLM training efficiency within a C++ environment through the integration of Clad, a Clang/LLVM compiler plugin for automatic differentiation (AD). We will deveop a custom C++ tensor library specifically designed for optimal interaction with Clad. The core objective is to replace traditional runtime or manual gradient computations with Clad's efficient compile-time differentiation for key LLM operations within a GPT-2 training pipeline. This involves investigating effective strategies to bridge Clad's static analysis with dynamic neural network computations, benchmarking the resulting performance gains in speed and memory usage against a non-Clad baseline, and leveraging OpenMP for further parallelization.
This project aims to add Krylov subspace methods for matrices over exact fields: representation of the kernel, co-kernel of a matrix of univariate polynomials over an exact field as a module, and associated invariants, as well as computation of the characteristic polynomial if the matrix is square via recent methods. The performance relies heavily on a few core linear algebra operations, so care must be taken to use the most efficient implementations and to exploit any additional characteristics of the specific use cases. Consideration may also be given to more general optimisation of methods for matrices over univariate polynomials. Key goals for the project are to have the above functionalities implemented efficiently, with accompanying documentation and tests to meet the project standards.
This project addresses a key challenge in biomedical data management: enabling secure, standards-compliant access to clinical FHIR data while integrating with the Gen3 platform. The goal is to develop an open-source, containerized FHIR proxy that enforces Gen3 access control via Arborist and supports asynchronous API interactions for high-performance data access. The solution includes: 1) A proof-of-concept FastAPI proxy that routes FHIR requests to a HAPI FHIR JPA server, adding Gen3 security tags for each resource. 2) Scripted ingestion of synthetic NCPI FHIR resources to facilitate testing and reproducibility. 3) Comprehensive unit tests and example configurations for local and cloud deployment. 4) Full containerization with Docker and Docker Compose, with plans for Kubernetes deployment via Helm. By providing a secure, FAIR-aligned, and standards-based framework for FHIR data, this project empowers researchers and developers to access and manage biomedical data efficiently while maintaining strict compliance with security and privacy requirements.
The primary objective of this project is to enhance BT Studio's capabilities by upgrading the library of behavior trees and composition tools. Currently, BT Studio BT library is simple, really overcomplicated and buggy which makes reusing behaviors trees from the library difficult. This update aims to simplify and improve this tools and to increase the amount of entries in the library. Also it will improve other features of BT Studio such as the custom universes, making them fully functional and with all the features of the already existing ones inside the Robotics Backend, the docker execution enviroment for robotics applications. All of this changes would enable users to test applications across a wider range of scenarios, thereby enhancing debugging and solution robustness.
The PSLab Mini is a compact version of the PSLab board that encompasses similar features but with fewer instruments, with more focus on those individual instruments The main idea behind building the PSLab Mini board is to take the already present PSLab board and use its hardware and firmware, and convert it into a lighter version, which can be achieved by stripping off the files related to other instruments along with their respective drivers. Also, another aim of this project is to refactor the instruments along with their drivers to make the firmware more reliable, lighter and faster. The Key deliverables of this project are: • PSLab Mini schematic and BOM list • PSLab Mini PCB, which is ready for prototyping • A working firmware that is either tested on a prototype or similar ARM-based processor board • Improve the working of the firmware using hardware or software improvements • Optimize the board for low-power applications • Increase the capability of the instruments on board the PSLab Mini • Documentation of the firmware developed during the period
The main objective is to integrate direct syntax support for parsing and emitting JSON, XML, and/or YAML formats in Vala. This will cut back the boilerplate code making it more user-friendly and efficient for developers working with these format languages. To solve this, I first plan to research how other languages implement these integrations. This will allow me to see best practices and common syntax used. At the same time, I will research how Vala currently parses and emits JSON, XML, and YAML formats. Lastly, out of the research, I will know how to properly integrate the format languages into Vala's compiler, which will allow for direct syntax integration. The overall deliverables consist of: 1) Research on how Vala and other programming languages handle JSON, XML, and YAML. 2) Syntax design and mock-ups. 3) Implementation and prototyping. 4) Testing, documentation, and code snippets
My project focuses on developing diffusion models for gravitational lensing simulations. I will implement and evaluate various diffusion-based architectures, including Diffusion Transformers (DiT) and Latent Diffusion Models (LDM). Conditional modeling techniques such as Classifier-Free Guidance and Conditional Flow Matching will also be explored. The project involves creating a diverse dataset of simulated gravitational lensing images under various astrophysical conditions for downstream tasks. All implementations, findings, and documentation will be open-sourced through a GitHub repository.