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.
GPUs and CUDA have revolutionized computing beyond graphics rendering, becoming essential in various fields due to their parallel processing capabilities. Clad, a Clang plugin, provides automatic differentiation for C++ functions by modifying Abstract-Syntax-Tree using LLVM compiler features. While Clad supports reverse-mode differentiation of CUDA kernels, data-race conditions are very frequent and considerably slow down the execution. Thread Safety Analysis helps detect data races to optimize performance by potentially reducing atomic operations in generated code.
This project aims to enhance the GCompris educational suite by introducing a set of intuitive, GUI-based tools tailored for teachers. These tools will allow educators to easily create and manage custom datasets for various activities, improving adaptability and personalization in the learning experience. The activities targeted for dataset creation include: 1.Grammar Analysis 2.Graduated Lines 3.Decimal Numbers 4. Share 5.Fractions Create The core of the solution involves building user-friendly interfaces using QML, allowing teachers to input data without dealing with raw JSON or technical configurations. On the backend, we will enhance and adapt the activity logic using JavaScript to ensure compatibility with both newly created and existing datasets. These tools will be implemented as modular plugins integrated into the GCompris infrastructure. By empowering teachers to contribute customized content directly, the project fosters a more dynamic and inclusive educational environment, catering to diverse learning needs.
In Metals, the LSP implementation for Scala, there is currently no built-in support for Play Framework-specific files such as .scala.html templates and routes files. This limitation affects essential features like syntax highlighting, linting, and navigation, making it difficult for developers to work efficiently with Play Framework projects in editors that rely on metals. eg. VSCode. This is exacerbated by people who wish to migrate from proprietary editors like IntelliJ which provides such facilities.
The Airavata Cybershuttle Research Catalog is a web platform that enables researchers to share and run Jupyter Notebooks, GitHub repositories, datasets, and scientific models. It supports project creation by combining resources for collaborative, reproducible research, with direct cloud execution of notebooks and models. To enhance flexibility and performance, a desktop application is being developed: Web Research Catalog - Audience: General users - Pros: No installation required; easy access to shared resources - Cons: Limited by cloud compute resources Local Research Catalog (Desktop App) - Audience: Power users needing high performance - Pros: - Utilizes local machine resources (GPU, RAM) for better performance - Offline access to notebooks, datasets, and models - Integration with local tools and file systems - Seamless synchronization with the web catalog when online - Runs JupyterLab and VSCode sessions locally without needing Docker or external dependencies The local agent is designed to be lightweight, extensible, and user-friendly, with built-in support for running scientific workflows entirely from a desktop environment.
This project aims to add support for IEEE 802.3-2022 10BASE-T1x Ethernet in NuttX using MAC-PHY devices with the Open Alliance SPI interface. These low-cost Ethernet solutions are well-suited for embedded systems, aligning with NuttX’s target use cases. The core deliverables include implementing a reusable driver infrastructure for Open Alliance 10BASE-T1x Serial Interface-compatible MAC-PHYs, with initial focus on the NCV7410 driver, supporting PLCA configuration, porting the driver to the ARM-based platform, and developing a test application. An optional goal is to include support for additional devices (e.g., ADIN1110) following the specification.
LibreMesh relies on continuous testing to ensure its robustness across various network conditions and hardware setups. Currently, testing new firmware images lacks a standardized method to include Wi-Fi simulations within a virtualized environment. This project aims to add Wi-Fi support to existing QEMU simulations for LibreMesh, allowing near-realistic network testing using virtual Wi-Fi interfaces. By leveraging the mac80211_hwsim module and integrating existing OpenWrt-friendly virtual Wi-Fi tools, we can enhance testing automation and reproducibility. Benefits to the Community - Improved Testing Framework: This project will enable LibreMesh developers to run “almost real” tests in a virtualized environment, improving debugging and validation before deploying changes to physical hardware. - Enhanced Automation: By integrating virtual Wi-Fi support into QEMU, developers can automate complex test scenarios without requiring physical routers. - A set of scripted tests that can be run on real hardware: Currently, real tests on physical hardware are performed manually at each release. With this new set of test scripts for QEMU and Wi-Fi, many tests will be automated and easily adapted to real hardware. - Collaboration with OpenWrt: Given that OpenWrt is also working on virtual Wi-Fi support, this project can align efforts with the broader open-source networking community, benefiting multiple projects. - Lower Barrier to Entry: New contributors will find it easier to test their changes without needing specialized hardware.
The Peersky browser currently lacks a unified system for managing both user-installed WebExtensions and core browser preferences. This project will implement full WebExtension support alongside a customizable peersky://settings page, creating a modular and privacy-focused experience within Peersky’s Electron-based environment. Deliverables include support for installing .zip and Git-based extensions, a persistent extension loader, Manifest V3 validation, CSP-based sandboxing, and a toolbar for pinning and managing extensions. The settings page will also allow users to change themes, set search engines, configure the home page, and manage built-in privacy tools like uBlock Origin and DScan. By the end of the project, Peersky will support a secure, extensible, and decentralized customization system—without relying on centralized extension stores.
Project Title: Flutter Badge Magic App Mentors: Aditya, MarioB, cweitat Problem: The current Badge Magic app offers limited customization (fixed fonts/colors), lacks interactive features, and restricts users to basic animations and Bluetooth configurations. Additionally, platform-specific deployment and unresolved bugs hinder accessibility and user creativity. Solution: Revamp the Flutter-based app to deliver: Advanced Customization: Support multiple fonts (Google Fonts integration), hex-code color pickers, and 8 editable animation storage slots. Interactive Games: Integrate Snake and Tetris with swipe/tap controls optimized for LED displays. Scalability: Auto-adapt content for diverse LED badge sizes (e.g., 11x44 to 16x45 matrices). Firmware Upgrades: Enable "Bluetooth always-on" mode and power management for stable, energy-efficient connections. Multi-Platform Reach: Automate CI/CD pipelines (GitHub Actions) for Windows, Linux, macOS, and web builds. Deliverables: Feature Enhancements: Font/color picker, editable animation storage (8 slots). Mini-games (Snake, Tetris) with collision detection. Firmware updates for advanced badge configurations. Cross-Platform Support: CI/CD workflows for 5+ platforms/app stores. Testing: 10+ unit/integration tests (90% coverage). Documentation: User guides, API references, and Quick tutorials. Bug Fixes: Resolve existing issues for a polished user experience. Impact: Empower users to create vibrant, interactive LED displays effortlessly while ensuring seamless performance across devices and platforms.
sbi is an open-source Python package used for simulation-based inference. It provides an interface for running algorithms that are used to identify model parameters that are consistent with data. Currently, this project uses “stringly typed” values for its functions' arguments. Even though stringly typed code is flexible and easier to implement, it comes with a set of drawbacks. Using stringly typed code leads to a suboptimal developer experience with limited IDE support and subtle bugs that are hard to identify and fix. This project aims to improve the developer experience and mitigate these issues by updating arguments in functions to use strongly typed code. In addition, it plans to create a pattern for sbi contributors to follow when defining new functions and classes that would otherwise use stringly typed arguments.
This project aims to bring VLC's media capabilities to Apple Watch by developing both a companion app and standalone functionality. The app will enable users to consume audio media directly on their watch by syncing files from their iPhone or streaming content independently. By leveraging the recently added VLCKit support for watchOS and implementing a modern SwiftUI interface, the project will extend VLC's reach to a new platform while maintaining the same commitment to accessibility and quality that VLC is known for.
The project, "Data Processing Pipeline for the LSST," is designed to bridge the gap between the LSST data ecosystem and DeepLense's deep learning workflows. The proposal outlines the development of a modular, efficient pipeline that automatically retrieves relevant LSST images and catalogues via the official LSST Butler API, applies configurable preprocessing (such as cutout extraction, normalization, resizing, and channel management), and finally delivers analysis-ready data into DeepLense ML models for tasks like lens detection, classification, and super-resolution. Key deliverables include: 1. A robust LSST Data Access Module that reliably fetches data. 2. A flexible preprocessing module for transforming raw images into ML-compatible formats. 3. Seamless integration with DeepLense’s deep learning workflows, enabling end-to-end processing. 4. Comprehensive documentation and reusable, well-structured code.
Closed-loop peripheral neuromodulation systems, essential for developing adaptive therapies like vagus nerve stimulation that can be modularly simulated using the CONTROL-CORE framework. Although CONTROL-CORE currently supports file-based and shared-memory communication, these approaches have limitations about distributed execution, scalability, and latency. To overcome these obstacles, this project suggests utilizing ZeroMQ that will contribute as a high-performance messaging library as another means of communication.
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.