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.
OTX supports 15+ detection models but has no built-in tracking.Every real-world video application (conveyor belt counting, asset monitoring, dwell-time measurement, traffic analysis, sports analytics, etc) needs stable object tracking across frames. This project integrates Multi-Object Tracking into OTX, adding five tracker implementations (ByteTrack, SORT, DeepSORT, OC-SORT, BoT-SORT), a SAM-2-inspired memory bank for re-identification, MOT17 benchmarking, and CLI support along with documentation. The design is decoupled: a new OTXTracker base class owns all temporal state while existing OTX detection models remain untouched.
Online conferences are efficient for content delivery, but they still struggle to recreate one core part of in-person events: informal social spaces. Hallway conversations, spontaneous meetups, and unplanned networking moments are often where the most meaningful connections happen. eventyay-flowspace is designed to restore this missing layer by providing a spatial, proximity-based social lounge tightly integrated with Eventyay. The current legacy baseline has major limitations: it is unmaintained, built on Create React App, and depends on the global `window.JitsiMeetJS` integration patterns that are hard to isolate and test.
GNU radio (GR) is used in a variety of applications, especially with the focus of GR4 on being flexible enough to work on a plethora of systems. Some of which access to a GUI may not be available (e.g Embedded systems, edge computing nodes) or sharing of the output of the GR4 flowgraph remotely is required. In GR3.x the solution to this was gr-bokehgui, an OOT module created during GSOC 2017 which allowed for remote access of the output of the GR flowgraph through web based plots & widgets. Currently GR4 is being developed and no equivalent tool exists for it leaving a gap in remote monitoring capabilities. GR4 also currently does not have built in blocks for local plotting, this OOT can be considered a stop gap such blocks are added This proposal outlines the development of a OOT module for GR4, serving as a successor to gr-bokehGUI in functionality.
CircuitVerse currently saves circuits based on visual layout rather than logical connections, resulting in unpredictable save files that prevent meaningful version control, complicate Verilog synthesis, and hinder data analysis. To solve this, this project introduces a deterministic, canonical JSON format. By utilising Kahn's algorithm to map dependencies, the new format ensures components are always saved and loaded in the correct sequence, regardless of where they are drawn on the screen. The key deliverables include a smarter export/import engine, an automated, zero-loss migration tool to smoothly upgrade all legacy .cv files to this new standard, a highly optimised single-pass Verilog generator, and an interactive developer UI featuring real-time JSON previews, copying, and downloading.
ESP-Website administrators currently manage program modules manually with no way to pre-schedule transitions, causing configuration errors that risk corrupting student registration data. This project builds a visual, Gantt-style Module Management UI that lets administrators schedule module open/close windows on a drag-and-drop timeline canvas, with separate student and teacher views, real-time conflict detection, and a time scrubber to preview the student experience at any point. On the backend, ProgramModuleObj will be subclassed from ExpirableModel to add native time-windowing, and five AJAX endpoints will power all frontend interactions. Deliverables include the model migration, time-aware module filtering, the timeline canvas UI, a module picker side panel, full WCAG 2.1 AA accessibility, and bidirectional integration with the existing module questions interface.
Oppia Android's release process currently relies on a 17-page manual document that release coordinators follow step-by-step, covering everything from cutting branches and building binaries to signing, deploying to Play Console, and writing changelogs. This is slow, error-prone, and has caused QA testers to miss builds due to Play Store sync issues. This project replaces that manual process with six GitHub Actions workflows backed by Kotlin scripts that handle building, Cloud KMS signing, Play Console deployment, Firebase App Distribution for QA, LLM-powered changelog generation, and automated weekly alpha releases. All scripts are designed with interface-based abstractions (CloudSigner, PlayConsoleClient, VertexAiClient, GitHubClient) so they can be thoroughly unit-tested with fakes, requiring no real GCP credentials in tests. Security is handled through Workload Identity Federation (keyless auth) and Cloud KMS HSM-backed signing, ensuring the private key never leaves Google's hardware. Deliverables: 6 new Kotlin scripts with full test coverage, 6 GitHub Actions workflows, updated wiki documentation (playbook + manual fallback reference), and an end-to-end demo of the complete release cycle running through CI.
This project implements a debuginfod-compatible server within Debusine to provide automated debug symbol resolution for Debian developers. Currently, debugging binaries built by Debusine requires manual installation of -dbgsym packages. This project aims to eliminate this manual labor by allowing tools like gdb to fetch symbols automatically via HTTP. Based on an analysis of the elf_classify logic in elfutils, I have designed and prototyped a pipeline that identifies and extracts .debug ELF files from -dbgsym.deb packages and parses their Build-IDs. The implementation integrates this extraction into the isolated sbuild worker task. These symbols are then indexed as debian:debug-symbol artifacts and served via a custom Django view that supports the buildid/<id>/debuginfo and executable endpoints, including HTTP Range requests for partial content. Key Deliverables: 1) An isolated extraction pipeline using pyelftools within the sbuild task. 2) A Django-based artifact storage and indexing model (debian:debug-symbol). 3) debuginfod-compliant HTTP endpoints (/debuginfo and /executable) with support for mandatory headers and 206 Partial Content. 4) Documentation and integration tests for gdb symbol resolution.
P4TC enables programmable packet processing in the Linux kernel via TC and eBPF, but its control plane is limited to the tc CLI and shell scripts. This project delivers idiomatic Python (cffi) and Rust (bindgen) wrappers for P4TC's C API, covering both provisioning and runtime CRUDSP operations. Deliverables include: (1) a Python package (p4tc_py) with context managers and type hints, (2) a Rust crate (p4tc-rs) with safe ownership semantics and Drop-based cleanup, (3) ported tutorial examples in both languages, and (4) API documentation with a shell-vs-Python-vs-Rust comparison guide.
This project aims to upgrade the llvm-advisor diagnostic tool into a scalable, active analysis workbench for massive workloads. The implementation restructures the underlying data layer with a high-performance, dual-path ingestion pipeline, primary path being native C++ libRemarks bitstream decoding to process massive LTO builds without memory exhaustion, and the fallback path is YAML ingestion pipeline. It also implements a dependency-free Vanilla JS virtualization grid and injecting "Active Diagnostic" modules (like heuristic hinting and spatial heatmaps) directly into the existing Code Explorer DOM. This provides LLVM developers with bottleneck triage and actionable C++ refactoring advice while still maintaining the tool's lightweight, offline-first design.
CircuitVerse currently handles every user and classroom in isolation with no concept of institutional ownership. This makes it impossible for universities to manage hundreds of classrooms, instructors, and students under one umbrella. This project introduces an Organisation layer to CircuitVerse. It adds a hierarchical structure where an Organisation contains Department Groups, which contain existing CircuitVerse classrooms. Role-Based Access Control enforced via Pundit gives each role: Org Admin, Group Lead, Instructor, and Student, exactly the permissions they need and nothing more. Single Sign-On via OpenID Connect lets students log in using their existing institutional email through Google Workspace or Microsoft Azure AD, with automatic org assignment based on email domain. Optional custom branding adds subdomain support and logo placement for institutional identity. Deliverables: 1. Hierarchical org structure: organisations, org_groups, memberships tables with full admin dashboard 2. RBAC via Pundit: four roles enforced at the server level 3. SSO via OIDC: omniauth-openid-connect with domain-to-org auto-assignment 4. Custom branding: subdomain routing and logo rendering (optional)
This project implements pgr_makeBiconnectedPlanar and pgr_makeMaximalPlanar as new pgRouting SQL functions, completing the planar graph preparation. Together they unlock downstream Boost layout algorithms currently inaccessible to pgRouting users. Stretch goal: pgr_findOddCycle. Estimated 350 hours.
DeepLenseSim (built on lenstronomy) requires substantial manual intervention for configuring parameters, managing outputs, and iterating on failures across multi-step simulation pipelines, creating bottlenecks in large-scale dataset generation and limiting parameter space exploration. I will build an Agentic AI framework following the HEPTAPOD philosophy to autonomously orchestrate DeepLenseSim workflows across three phases: (1) implementing schema-validated Pydantic tools wrapping the DeepLens class for all four model configurations, an LLM orchestration layer via OpenRouter function calling, human-in-the-loop confirmation flow, and a compatibility layer addressing pyHalo/lenstronomy/numpy version conflicts; (2) building a ParameterScanTool for automated multi-point sweeps (axion mass, halo mass, redshift), a ValidationTool for automated image quality checks, and exploration of RL-based parameter optimization; (3) comprehensive documentation, tutorial notebooks, a test suite with >80% tool function coverage, and integration with downstream DeepLense ML training pipelines via standard export formats (numpy, HDF5, FITS).
The project aims to develop a tournament interface for Mankala Engine, utilizing QXMPP to pair users and computerized opponents and create a leaderboard page to display rankings. The implementation would involve Qt, QML, QXMPP, and C++, as well as an algorithm to pair users randomly for tournaments and follow the ranking hierarchy until the last match to display the leaderboard. The project also enhances certain features, including QXMPP and the game experience, by addressing false positives and bugs that occur within the game.
Currently, Synfig artists rely on complex skeleton rigging to achieve organic deformations like squash-and-stretch or facial movements. This project introduces a 2D Free-Form Deformation (FFD) layer, allowing users to intuitively warp artwork using a manipulatable control grid (lattice) instead of bones. The implementation involves creating the core deformation math engine (upgrading from Bilinear to Catmull-Rom spline interpolation for C1 continuity), integrating the grid points with Synfig's Duckmatic UI system .
SW360 currently imports license and obligation data through five disconnected paths with no coordination between them, meaning multiple instances can hold different obligation text for the same license with no way to detect the gap. This project makes LicenseDB the single authoritative source by implementing scheduled REST based synchronization. It covers paginated license and obligation sync, incremental daily updates via the audit log, field-level mapping that preserves SW360-specific compliance fields, read-only gating of legacy import paths, and CouchDB-first lookup for CLI attachment processing. Deliverables include JWT authentication, automated daily scheduling via ScheduleHandler, admin REST endpoints for sync control and health monitoring, encrypted credentials, circuit breaker and rate limiting, a migration guide, and test coverage.
Strong gravitational lensing is among the most powerful observational probes of dark matter substructure. High-resolution lensing images encode the morphological fingerprints of different dark matter models. Most available lensing images today and expected from upcoming surveys such as Euclid and LSST are ground-based and limited in resolution by atmospheric seeing. Obtaining matched high-resolution counterparts from space-based instruments like HST for every ground-based image is impractical at survey scale. This project addresses two main challenges in the proposed ML4Sci topic. First, it explores a super-resolution pipeline that does not require matched real low-resolution and high-resolution lensing observations for training. Instead, the model is trained on simulated high-resolution lensing images constructed with realistic source morphologies and survey-calibrated degradations, while remaining unsupervised with respect to real telescope HR targets. Second, it tests whether using real galaxy morphologies and limited ablations, can reduce the realism gap introduced by purely parametric Sérsic source models.
This project aims to revamp the Wagtail Editor Guide by addressing key limitations in versioning, localization, developer experience, and frontend performance. It introduces an automated versioning system with selective updates and redirect handling, integrates robust multilingual support using wagtail-localize with RTL compatibility, and reduces contributor friction through improved setup and realistic data fixtures. Additionally, the project modernizes the frontend by removing unnecessary dependencies, optimizing fonts, and enhancing UI/UX interactions, resulting in a faster, more maintainable, and globally accessible documentation platform.
Mesa-Geo currently suffers from three structural problems that make it impractical at realistic geographic scale: a memory bottleneck from instantiating one Python object per raster pixel, a fractured coordinate system that silently conflates three incompatible reference frames, and a broken Cell/Agent abstraction that floods the agent registry with millions of ephemeral entries. This project resolves all three problems through four focused changes: refactoring RasterLayer onto a PropertyLayer NumPy backend, decoupling Cell from mesa.Agent through a weakref identity cache, delivering a RasterCellCollection aggregation API with scipy.ndimage-powered spatial statistics, and overhauling the visualization pipeline to render rasters as a single ipyleaflet.ImageOverlay instead of millions of polygon draws. All work is aligned with Mesa 4.0's unified reactive architecture, positioning Mesa-Geo as the geospatial pillar of Mesa's next generation rather than a legacy bolt-on. Core deliverables: PropertyLayer-backed RasterLayer, decoupled Cell with three explicit coordinate properties, RasterCellCollection aggregation API, SolaraViz-compatible make_geospace_component, a geo predator-prey benchmark model, and a full Mesa-Geo 3.x migration guide. Stretch goals: H3 hexagonal grid support, a GeoSpace redesign proof-of-concept (#2585), and a Kalman filter temporal state estimation API for PropertyLayer.
This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between overloaded methods such as foo(int) and foo(double), so annotations are applied to all overloads with the same name rather than to a specific function. The project introduces overload-aware matching for C++ methods, allowing API Notes to target individual overloads based on their parameter types while preserving compatibility with existing notes. This enables more precise annotations and improves interoperability for real-world C++ APIs, such as Swift bindings. The core deliverable is a working and tested implementation for explicit-parameter overloads (Phase 1), including typed-vs-legacy handling and regression tests. The project then extends this to support const- and ref-qualified member functions (Phase 2), completing support for receiver-sensitive overloads.
Clang-Doc is LLVM's modern C/C++ documentation generator built on the compiler AST rather than heuristic text parsing. A key blocker to its adoption is the absence of Markdown support inside documentation comments. Fenced code blocks, pipe tables, and lists currently pass through to output generators as raw text, making generated documentation unreadable for any project that uses Markdown in its comment workflow, which includes LLVM itself. This project implements a standalone Markdown parsing library that takes text and returns typed data structures, with no knowledge of comments or Clang internals. Clang-Doc is the immediate consumer, but the library is usable by any LLVM tool. It follows the same pattern as the Mustache library from GSoC 2024, with no third-party dependencies. Deliverables include the full library, Clang-Doc integration, updated HTML and Markdown generators, end-to-end lit/FileCheck tests, a libFuzzer harness, and an LLVM blog post. Stretch goal: Clang AST support for Doxygen group comments, flagged by mentors as particularly valuable.
BookBrainz is currently English-only, limiting its global reach. This project integrates i18next with BookBrainz's React SSR pipeline to enable full internationalization: locale-detection middleware (Accept-Language + cookie), a language selector in the navbar, English translation JSON files, ~620 strings migrated across ~120 files, and a BookBrainz project on translations.metabrainz.org so volunteer translators can contribute immediately — with no rebuild required per translation update.
This project focuses on improving the developer experience around the Kirigami framework by making the development workflow more connected and efficient. Kirigami already provides well-structured documentation and examples, but these resources are spread across different places, making it harder to explore them interactively and move smoothly from learning to practical hands-on. To address this, I will enhance Kirigami Workbench and integrate it with KAppTemplate. The project introduces an interactive gallery of examples with live previews and editable code, along with a plugin-based system so new examples can be easily added and explored within a single environment. Developers will also be able to generate ready-to-use application projects using KAppTemplate, with selected examples as the starting point, along with added Python support for developing Kirigami applications using PySide6/PyQt6 within Workbench. The main deliverables include the example gallery with search and filtering, plugin support, project generation using KAppTemplate, Python support, and multi-tab functionality for working with multiple files. Overall, this project makes working with Kirigami smoother and more connected, bringing everything into one place.
This project would make the Eventyay badge creator much more user-friendly and also add badge printing in the event check-in workflow itself. Right now, event organizers have to separately go to a different page in order to download badge PDFs before they can even print them out, adding friction during busy events and slowing down the check-in process. This project will integrate badge printing into the webcheckin interface so event staff can print attendee badges immediately after ticket redemption. There are also ticket types, a modal pop-up for the badge layout creations workflow (optional role-based template badges: speaker /attendee/ volunteer/ exhibitor), and improved badge editor experience. Implementation will make a wrapper around existing Django-based badge plugin and Vue. jsWebCheckin application used in Eventyay. Its exact features will include usage of existing badge download APIs, refactored frontend integrations for printing, optional config settings for automatic printing and updated documentation and tests. Deliverables badges design flow; embedded on-line badge printing for check-in app; usability improvements in badge editor;API documentation: performance enhancement (caching, asynchronous generation handling); updated developer and user documentations. This will save a lot of time at check-in and provide a better management experience to the organizers using Eventyay.
Apache Fineract is open-source banking software used by institutions around the world to serve people who don't have access to traditional banks. Every time someone opens an account, creates a loan, or uploads a document, the system has to read the incoming data, validate it, and save it. The current code that does this was written about twenty years ago, the data arrives as plain text, and the system manually picks apart each field by hand. This causes silent bugs, makes the code hard to change, and produces thousands of lines of repetitive plumbing. The Fineract community has already built a modern replacement that uses strongly-typed data objects, so data is automatically structured and validated the moment it arrives. The new system is in production for 13 features; around 57 features still use the old approach. My GSoC project is to move 5–7 of those remaining features onto the new system, one feature at a time, strictly following the migration guide the team has already written. Proposed features (subject to mentor confirmation): Holidays, Account Number Format, Codes / CodeValues, Office, Fund, and Calendar. For each feature, I will design new typed data classes, rewrite the related handler code, simplify the business logic to accept typed inputs, replace hand-written validation with built-in checks, and make sure all existing tests still pass. Where test coverage is thin, I will add new automated tests in line with the community's quality direction. This work reduces long-standing technical debt and makes future development faster and safer in a system that real banks depend on every day.