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.
BLT-Next proposal covers the full migration from Django monolith to static frontend on GitHub Pages with Cloudflare Python Workers at the edge. The core idea is simple migrate all the Django services/features into modular independent services, Which reduces the cost to $0/month.(using free services like cloudflare worker and github pages). BLT-Next is the reset. Everything static services goes to GitHub Pages, anything that needs server logic gets a Cloudflare Worker, with database suppport from cloudflare D1.
World editing in Tiled is functional but minimal. Resizing maps requires a dialog, creating new maps means leaving the world view, and standalone maps can't use world tools at all. This project adds four core improvements: a world grid for coarse snapping, drag handles for visual map resize, creating and deleting maps directly in the world view, and a default world so standalone maps get world tools.
This project proposes a comprehensive strategy to extend the CARTopiaX platform within BioDynaMo to replicate a wider range of in vitro observations relevant to CAR T-cell therapy in solid tumors. By incorporating additional agents, microenvironmental factors, and interaction rules, combined with robust parameter calibration strategies such as Bayesian optimization and evolutionary algorithms, the enhanced model aims to capture critical dynamics that influence therapeutic outcomes, providing a flexible and powerful tool for in silico hypothesis testing. If successful, the extended CARTopiaX model will serve as a reliable platform for exploring CAR T-cell therapies and has the potential to generate high-impact insights in computational cancer biology. By bridging experimental data with predictive modeling, the project could accelerate the translation of in silico findings into actionable guidance for experimental and clinical research.
This project aims to develop a Benchmark Polytope Import Suite for the volesti library, enabling automated conversion of standard Linear Programming instances and metabolic network models into H-Polytopes compatible with volesti. A user-friendly CLI tool will allow researchers to perform conversions easily without directly interacting with the code. Additionally, a curated benchmark collection with regeneration scripts will support reproducible testing and demonstration of the pipeline. The project will follow best software engineering practices, including, unit, integration and end to end tests, as well as comprehensive documentation and tutorials. By providing a robust and easy to use import suite pipeline, this project will expand volesti's accessibility and usability for researchers in volume approximation and sampling of convex bodies.
As highlighted during the 2025 Blender Conference, one of the primary challenges facing the Compositor is managing complexity. To address this, the goal of this proposal is to make it as accessible as possible by porting over familiar nodes from Geometry Nodes. This project aims to: - Develop a future-proof classification between the two modules. - Port matrix & math utility nodes into the Compositor: Matrix SVD, Bit Math, Boolean Math, Integer Math, Compare, Float To Int, Hash Value, and Random Value. - Extend GPUType to include boolean, integer and integer vector types. - Ensure UI and behavior consistency between ported nodes and existing ones, including full support for the GPU Compositor. - Implement regression testing for all newly ported nodes. - Document the rationale behind node selection, implementation and functionality in the new context.
This project tackles the challenge of limited anatomical segmentation in InVesalius by integrating TotalSegmentator through a lightweight inference pipeline using pre-exported JIT and ONNX models. The approach uses nnU-Net-based models to automatically segment 117 CT structures and 80 MRI structures: organs, bones, muscles, and vessels; without requiring nnunetv2 or any heavy dependencies. Users select specific anatomical structures from a categorized checklist and receive color-coded masks directly within InVesalius's existing visualization, editing, and 3D export pipeline. This enables clinicians in resource-constrained hospitals to perform comprehensive anatomical segmentation on the same workstations they already use.
This project aims to enable SageMath to natively use Gambit’s functionality within its game-theory features, allowing seamless conversion between SageMath and Gambit Game objects and the application of each library’s tools to the other’s representations. A draft SageMath pull request already exists that handles packaging and import updates for pygambit, but the core task of updating SageMath’s game theory code to Gambit’s revised 16.6 API remains open. This project will complete and merge that PR, then produce tutorial and documentation materials that demonstrate what the integration enables and how to leverage it.
This proposal is based on the LLVM project for GSoC 2026 with the same title, from Tue Ly, Nicolas Celik and Krishna Pandey. Discourse: https://discourse.llvm.org/t/gsoc-2026-libc-enable-float80-and-float128-math-support-on-unsupported-targets-for-llvm-libc/89647. Float80 (x87 80-bit extended precision) and Float128 (IEEE 754 binary128 quad precision) are high-precision floating-point formats critical for correctly rounded math implementations. However, not all compilers or architectures support these types natively which prevents LLVM libc from building and testing its high-precision math routines on these platforms. The goal of this project is to implement software support for these types in LLVM libc in a compiler and architecture agnostic way. Deliverables: - Implement float80 and float128 in a compiler and architecture agnostic way. Implement generic basic arithmetic operations that work on all supported architectures. - Demonstrate compiling and passing tests on unsupported targets (float80 on Mac ARM64, float128 on MSVC).
For my project with Zulip, I aim to improve its integration ecosystem and core user experience. My project focuses on two primary areas: (1) Secure & Automated Integrations and (2) UX & Accessibility .In alignment with this year’s GSoC focus on security, under integrations, I will strengthen webhook systems by implementing secure payload verification, enabling automated topic resolution for GitHub, improving event handling, and expanding support for external platforms .For UX & accessibility, I will improve keyboard navigation(specifically macOS dropdown support) and refine settings features, including more accurate unread message handling in narrowed views.
The Reference Database project aims to build a high-quality, reliable food data platform to complement and enhance Open Food Facts (OFF) in Canada. While OFF is a valuable open dataset, it can contain incomplete or inconsistent information. This project addresses these challenges by collecting and structuring trusted food product data from Canadian sources such as brand websites, retailers, and public registries. The goal is to create a clean and consistent dataset that improves data quality and supports downstream processing. The database will enable data enrichment, validation, and advanced use cases such as nutritional analysis, product categorization, and machine learning applications. It will also support better alignment with international standards and improve the overall reliability of food data. The project focuses on building a scalable data pipeline for data collection, cleaning, and integration, with the goal of delivering a functional MVP during Summer 2026.
Spatial transcriptomics methods identify tissue domains by clustering spatial gene expression patterns, but current approaches select genes using variance-based heuristics such as highly variable genes (HVGs). Many HVGs reflect donor-specific noise rather than genes that truly drive spatial organization, which leads to poor generalization when models are applied across tissue slices from different donors. This project addresses this limitation by introducing CauST, a framework for identifying causally important genes for spatial domain identification. CauST evaluates each gene through in-silico gene knockout experiments, measuring how much removing the gene changes the learned spatial embedding produced by a spatial graph neural network. To ensure robustness, the method then applies a cross-slice invariance criterion, selecting genes whose effects are both strong and stable across multiple donors. The resulting causally invariant gene set is used to retrain spatial domain identification models, enabling improved cross-donor performance without modifying the underlying model architecture. The project will deliver a production-quality open-source CauST Python package, integration with multiple spatial transcriptomics backbones (STAGATE, GraphST, and SpaGCN), a multi-dataset benchmark evaluating cross-slice robustness, visualization tools for interpreting causal gene importance, and tutorial notebooks and documentation to support adoption by the spatial transcriptomics community.
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.