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 focuses on extending the existing React based Mifos X Web App to make it a strong candidate for the primary Mifos X web interface. The application will be enhanced using React and TypeScript, with improved integration to the Apache Fineract backend through the OpenAPI TypeScript client. This project will result in fully functional multi-step workflows and the implementation of missing or partially developed features. The final outcome will be a stable web application with feature parity with the existing Mifos X platform.
Borg stores each deduplicated chunk as a separate file. On SFTP, that's one network round-trip per chunk. Pack files bundle N chunks into one file. A TOC sits in the trailer, and the pack gets a SHA256 derived pack_id. The client caches a small index per pack locally. Borg compact handles cleanup by mark-and-sweep to find dead chunks, then rewrite sparse packs into dense ones. Deliverables: pack file write and read support in borg2, borg compact with pack rewriting, incremental per-pack index cache, and encrypted pack support.
This project focuses on making SymPy's assumptions system more robust, efficient, and reliable through a three component architectural upgrade. The first component introduces a backend solver for Equality Logic and Uninterpreted Functions (EUF) directly into the SAT engine. The second component upgrades the Linear Real Arithmetic (LRA) solver to safely handle complex domains, irrational boundary limits, and symbolic infinities (like oo) without failing while also refactoring the core ask dispatcher to resolve many recursion loops during query evaluation. Last component, the project will replace thousands of hardcoded static unit tests with dynamic, property-based tests using the Hypothesis library. By automatically generating complex mathematical trees to find hidden bugs, these enhancements will smooth out the rough edges of the assumptions module, making it a significantly faster and mathematically stronger.
This project develops linear-scale attention vision transformers for CMS End-to-End jet classification and proxy mass regression on 8-channel 99.1% sparse detector images. Five architectures were trained and benchmarked under identical conditions during the test task: XCiT with domain MAE pretraining (AUC 0.9237, 2.42x S/sqrt(B)), XCiT with ImageNet pretraining, XCiT from scratch, a custom L2ViT combining local window and linear global attention built from scratch, and Swin-T as the softmax baseline. All models use a dual head for joint classification and proxy mass regression. 11 analysis studies were completed beyond standard benchmarking: channel importance (Ch0 and Ch3 critical, AUC collapses to 0.47 without either), channel pair interactions, Grad-CAM saliency, t-SNE feature representations, layer-by-layer CKA similarity, data efficiency (5x labelled data savings), jet multiplicity analysis, energy threshold study (detector implications for zero-suppression), S/sqrt(B) significance curves, adversarial robustness, and calibration with temperature scaling. Key findings: domain MAE pretraining outperforms scratch by +0.125 AUC and leads to fundamentally different representations (CKA 0.008-0.015 at every layer), linear attention beats softmax by +0.063 AUC under identical conditions, and block 1 of the pretrained model alone exceeds the fully trained scratch model in feature separation. The summer work extends this to multi-class classification (quark/gluon/top/W/Z) with per-class channel importance ablations, token pruning exploiting 99.1% sparsity, sparse convolution baselines, hybrid CNN+ViT architectures, and comparison against ParticleNet and JEDI-net on the same held-out test set.
Git's partial clone allows cloning repositories without downloading all objects (blobs, trees, ...). These objects are fetched on demand from the remote when needed. However, when a user needs metadata about these remote objects (size, type, hash, ...), Git has no efficient way of doing this without downloading all the object content. The server side support for `object-info` protocol was implemented by Calvin Wan in 2021. Eric Ju built the client-side `remote-object-info` for `cat-file --batch-command`. This project finishes Eric Ju's work on `remote-object-info` for `git cat-file --batch-command`, resolves the pending feedback from Junio Hamano and Jeff King, and extends support for `%(objecttype)`. The main technical fix is to replace the insufficient `strstr()` format validation with an `allow_list` to prevent crashes on unsupported placeholders, and extending the v2 protocol server and client to handle `%(objecttype)`. After the project, Git will have a working `remote-object-info` for `cat-file --batch-command` supporting `%(objectsize)`, and a v2 protocol extension adding `%(objecttype)` support on both server and client, with tests and documentation.
The goal of the project is to implement distributed tracing in order to trace individual calls between multiple backend components. The implementation can be broken down into the following stages: Infrastructure: Deploy an OpenTelemetry colector, and a Tempo tracing backend; Instrumentation: Instrument backend components in order to send events to the collector; Tracing: Stitch events together into traces by propagating trace context; Polishing: Iterate the generated events in order to improve the observability of the system; Documentation: Document how to deploy the required components, how to add/modify generated events, and how to visualize the data.
GNOME Gitg is a graphical user interface for Git that aims to be a small, fast, and easy-to-use tool for visualizing repository history and managing projects. It is currently built on the GTK 3 toolkit, which is expected to be deprecated in the future. This proposal focuses on migrating Gitg to GTK 4, ensuring long-term maintainability, better performance, and a more modern user experience.
This project introduces a ‘Cold Start’ Data Factory that turns zero/one-shot prompting into a full data-to-training workflow. The core contribution is a production-grade DatasetWriter pipeline that converts inference outputs into validated, reproducible annotations, supports format-aware serialization, and guarantees reliable flushing/finalization for large export jobs. The generated datasets can be exported in standard formats such as YOLO, COCO, and CVAT, with quality statistics and filtering controls for practical downstream use. Building on that, the project adds direct OTX training integration: once export is finalized, the system can automatically generate training configs, spawn OTX runs, stream logs/status, and track artifacts and run metadata. This shifts geti-instant-learn from a live-inference-only experience to a complete cold-start bootstrapping system where prompt-based “Teacher” labels are transformed into trainable “Student” datasets and model training jobs. The result is a faster and more reliable path from a few prompts to deployable edge models.
Currently there is obsolete `tests/ui/issues`directory in `rustc` test suite which was used to store regression tests in it. Now with the growth of compiler this folder is basically unmanageable, test names don't explain object of testing, and they are not sorted in any way. Nowadays new regression tests are getting into the fitting `tests/ui/`subdir, and my project proposes reorganization of `tests/ui/issues` directory by observing and sorting each test to matching directory.
CCExtractor’s v1.00 release requires confidence across every part of the project. Currently, test results in CCExtractor are not fully reliable — tests break or appear to be fixed by PRs that do not even touch the relevant code, making it difficult to confidently assess regressions and overall stability. This proposal focuses on strengthening the testing infrastructure as a whole and making it reliable again, fixing regressions that lead to incorrect outcomes, expanding test coverage to parts of the codebase that are not properly verified today, syncing the Flutter GUI with the CLI so all supported features are accessible, and stabilizing the release process so v1.00 ships cleanly across platforms. As this project gets completed, CCExtractor will be ready for its v1.00 release, with CI passing, parts of the codebase that are currently untested covered, an up-to-date CCExtractor GUI, and a streamlined release and development workflow.
CrashDragon plays a critical role in transforming VLC crash reports into actionable fixes, but current gaps in API consistency, auth-sensitive behavior, and frontend completeness introduce friction in triage and integration workflows. This project is a continuation of prior work and focuses on improving reliability without breaking existing functionality. The approach includes: Reviewing current API and frontend behavior to identify inconsistencies between public routes and /api/v1. Improving the Go backend by standardizing API response contracts, tightening validation, and hardening auth-sensitive mutation paths while preserving backward compatibility. Completing missing frontend surfaces and aligning Vue service-layer logic with typed API contracts to eliminate fragile response handling. The project will be delivered through incremental, review-driven changes with strong regression testing and CI validation to ensure stability. Deliverables: Consistent and well-defined /api/v1 API behavior with improved validation and error handling. Hardened authentication and mutation route reliability. Completed frontend views (stats, symfiles) with contract-aligned data handling. Expanded backend regression tests and improved documentation. Final implementation report and follow-up issue roadmap.
This project proposes the development of a Kubernetes-native chatbot integrated with NRP's managed LLM service to provide intelligent network diagnostics assistance. The system will enable users to interact conversationally with the model, and get answers to questions about network performance.
Liquid Galaxy Time Machine is an interactive educational application that allows users to explore 100 global points of interest through time. By combining geospatial visualization, historical data, and AI-generated content, users can see how locations looked in the past, present, and possible future using an interactive timeline. The experience includes panoramic visualization on Liquid Galaxy, KML overlays with images and information, AI-generated narration, and detailed sub-events, creating an immersive way to understand how places evolve over time.
Zephyr provides low-level I2S and DMIC driver APIs along with a few narrow samples (echo, codec), but lacks a reusable application-layer audio pipeline that handles real-world complexity. The closest prior effort (GSoC 2025, PR #96657) attempted to integrate TensorFlow Lite Micro Micro Speech with a Linux host streaming setup, but the audio pipeline was tightly coupled with ML logic, limiting extensibility and resulting in fragile real-time behavior. A clean abstraction to support multiple backends is still absent. This proposal addresses these gaps by introducing a modular, backend-agnostic audio pipeline, designed around fixed-size PCM blocks and explicit ownership semantics. The system will support continuous audio streaming at 16 - 48 kHz, 16-bit PCM, targeting 4 - 10 ms frame latency with zero TX underruns and zero RX overruns under sustained load. Key deliverables include a pipeline API, support for multiple backends (I2S, PDM, optional USB), and reusable processing stages such as format conversion, and ML inference as an upstream sample.
gprMax users currently visualize simulation output using static terminal scripts with no interactivity. This project builds a reactive web-based dashboard using marimo, replacing that workflow with four components: parameter controls with live geometry preview, a simulation progress tracker, post-processing visualization for A-scans and B-scans, and a set of Reactive Recipes for common modelling scenarios. A working prototype covering all three visualization components is already built and running against real gprMax HDF5 output on the devel branch.
Standard Bayesian posteriors degrade under model misspecification by collapsing to point estimates. This project implements Predictively Oriented (PrO) posteriors in PyMC, a theoretically principled sampler that provides uncertainty calibrated to predictive reality rather than parameter estimation. The implementation includes a scoring-rule abstraction, Wasserstein gradient computation via PyTensor, vectorised particle simulation, and ArviZ integration with tutorials demonstrating robustness on real datasets.
CampWiz NXT is the jury management platform used during Wiki Loves contests to evaluate media submissions, images, audio, and video, uploaded to Wikimedia Commons. It provides a structured environment for jurors and organisers to assess, score, and process contest entries at scale. The current implementation uses a dual-server architecture: a Next.js frontend and a Golang backend. While functional, this setup introduces real costs. There is server component complexity, a persistent Node.js process required for deployment, and an interface that places more cognitive burden on jurors than the work itself demands. These are solvable problems, and solving them is what this project is about. The goal is to migrate the frontend from Next.js to a pure React application built as a static output with Vite. This is not a surface-level reskin. The migration removes the Node.js server dependency entirely, allowing the frontend to be served over standard HTTP, making deployment simpler, cheaper, and more maintainable. The Golang backend remains unchanged; only the frontend layer is being replaced. Alongside the technical migration, the interface will be redesigned with a deliberate focus on clarity and minimalism. Jurors should be able to open the tool and immediately focus on reviewing submissions, not on navigating a cluttered interface. Non-essential actions will be removed from the juror viewport, decision controls will be streamlined, and keyboard accessibility will be enforced throughout. The organiser dashboard will receive the same treatment: clean workflows for contest setup, juror assignment, and results management, without requiring backend access for routine configuration. The result will be a frontend that is easier to deploy, easier to maintain, and noticeably better to use.
Design a modular switched Ethernet model capable of simulating 1, 10, and 40 GbE links, with MAC-based auto-learning of I/O ports, support for pluggable scheduling algorithms (FCFS, WRR), while remaining extensible for future support of VLAN and Spanning Tree protocols, introduce enhanced EthernetNetDevice model with point-to-point–like NetDevice abstraction for switched Ethernet, an EthernetChannel capable of simulating both half-duplex and full-duplex modes of operation responsible for modeling transmission delay and errors.
The project aims to build a trusted Jenkins CI pipeline that fetches and consolidates raw metadata from metadata-plugin-modernizer repo into a single structured JSON format, which is published to reports.jenkins.io. It also involves building a static visualization UI site on top of it that consumes this data during its build process to present dashboards and per-plugin reports.
This project aims to improve the system testing framework of preCICE to make end-to-end simulations faster, more reliable, and easier to extend. Currently, system tests involve building multiple combinations of tutorials, adapters, and core versions using Docker, executing coupled simulations, and validating outputs against reference data. The project will focus on optimizing test execution time through parallelization and caching strategies, improving result validation and reporting for better debugging, and enhancing the modularity of test configurations to simplify adding new scenarios. Additionally, improvements in CI integration will ensure more robust and automated testing workflows. The expected deliverables include a redesigned and optimized system testing pipeline, improved reporting mechanisms, reduced execution time, and comprehensive documentation for contributors. These enhancements will strengthen the reliability and scalability of preCICE’s testing infrastructure.
OpenPrinting maintains detailed Linux printer compatibility data through Foomatic, but users lack an intuitive way to discover or evaluate printers. This project builds a fully static printer discovery and recommendation portal on the OpenPrinting website, deployable on GitHub Pages with no backend. It enables users to search, filter, compare printers, and receive explainable recommendations based on precomputed similarity data.
This project addresses limitations in Kubeflow Katib current Experiment CRD, which uses a generic and loosely typed interface for hyperparameter optimization. This leads to fragile parameter injection, inefficient resource usage, and unreliable state handling for stateful algorithms. To solve this, I propose designing and implementing a new OptimizationJob CRD v1alpha1, a strongly typed API focused on hyperparameter optimization for TrainJobs. It introduces native parameter injection, persistent algorithm state handling, and a push-based metrics pipeline integrated with the TrainJob Progress API. The project will deliver a production-ready controller with a structured reconciliation loop, support for stateless and stateful optimization algorithms, SDK integration, and comprehensive testing, resulting in a more reliable and efficient HPO workflow.
This solution addresses the problem that BanyanDB / BydbQL has a high usability barrier, making it difficult for users to accurately translate natural language queries into executable query statements. In real-world observability and operations scenarios, users often lack deep understanding of query syntax, schema structures, and query patterns, resulting in low efficiency and high error rates. To solve this, the proposal designs and implements an NL2BydbQL intelligent query agent. Leveraging large language models and the LangGraph reasoning framework, the agent converts natural language into executable BydbQL. The system combines RAG (grammar rules, few-shot examples, schema semantics), MCP-based real-time schema awareness, and a multi-stage reasoning pipeline to form a complete loop from intent understanding to query generation and validation. The core approach includes: Building a structured knowledge system (Grammar Rules, Few-shot Examples, Schema Semantic Docs) Designing a dual-path reasoning mechanism (QA vs. Workflow) with dynamic routing based on query complexity Introducing an intermediate representation (IR) to unify generation and repair Ensuring query correctness via parser validation and automatic repair Incorporating runtime feedback and session memory for continuous improvement The deliverables include: A production-ready NL2BydbQL agent (based on LangGraph) A set of structured RAG datasets (grammar, examples, schema descriptions) A complete and extensible reasoning workflow design End-to-end capabilities including query generation, auto-correction, clarification interaction, and execution feedback loop This solution significantly lowers the query barrier and improves the usability and efficiency of SkyWalking and BanyanDB in intelligent operations scenarios.
My work involves porting the game SNKRX from Lua to Atmos, a versatile programming language that is based on concurrency, event-driven programming. The project focuses on replacing imperative Lua patterns—such as manual flag management and nested callbacks—with the main functionalities of Atmos to simplify complex game logic. Specific tasks include refactoring the screen management system into a hierarchy of scoped tasks, converting global variables into linear sequences, and modularizing character ability chains. Throughout the process, the project will measure how these reactive and parallel features improve code maintenance compared to the original implementation.