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.
LLMs rely on floating-point arithmetic for inference, but the Logarithmic Number System (LNS) offers a compelling alternative: multiplication becomes integer addition in the log domain, and 16-bit LNS (xlns16) uses only 2 bytes per element, half the memory bandwidth of float32. This project integrates the open-source xlnscpp C++ LNS library into ggml (the compute backend of llama.cpp) as a proper ggml_backend, enabling LLM inference to run entirely in xlns16 arithmetic as a proof of concept. The implementation introduces GGML_TYPE_LNS16 as a native ggml datatype and implements the 13 operations required for a complete transformer inference pass (matrix multiply, softmax, RMS norm, RoPE, SiLU, residual add, along with some others), all using xlns16 kernels. Activations stay in xlns16 format throughout inference; weights are converted dynamically from their stored quantised formats (Q4_K_M, etc.) per kernel invocation using O(1) lookup tables. The backend is validated at two levels: a unit test confirms sub-0.6% relative error on matrix multiply, and an end-to-end run on SmolLM2-135M-Instruct confirms the full transformer executes without crashing. Deliverables: (1) GGML_TYPE_LNS16 datatype registered in ggml; (2) a complete ggml_backend for xlns16 arithmetic covering all ops needed for LLM inference; (3) integration with llama.cpp; (4) a validation test suite; (5) an accuracy analysis comparing LNS and FP output across model layers
Modernize the Sample Platform with 8 targeted improvements: (1) a unified AI-friendly endpoint that serves all test artifacts — binaries, logs, inputs, outputs from a single URL with signed download links; (2) a has_ever_passed flag to distinguish regressions from tests that never worked; (3) a React-based test management dashboard replacing raw SQL workflows; and (4) a smarter diff algorithm using difflib. SequenceMatcher with subtitle-aware parsing to eliminate cascading mismatches; (5) automated git bisect to pinpoint the exact commit that introduced a failure; (6) cross-platform comparison views for Linux, Windows, and macOS results; and (7) macOS testing support via GitHub Actions runners. (8) Test Suite Expansion
Currently, VulnerableCode lacks built-in insights to demonstrate its effectiveness. This project addresses this by integrating a telemetry dashboard into the Web UI to visualize reliability, growth, and data quality.
This proposal focuses mainly on two points of the `libc` issue tracking the `1.0` release. The first of these addresses the presence of 64-bit and 32-bit wide variants of time- and file offset-related functionality for which it has been stated that only a single, 64-bit type should exist. This should also solve the concern about which of the bit-width variants should `libc` offer, as briefly discussed in the latter comments of https://github.com/rust-lang/libc/pull/5010#issuecomment-4060131422. This proposal also attempts to deprecate a set of constants which, as described in https://github.com/rust-lang/libc/issues/3131, are prone to bugs, but most importantly, require a large amount of manual effort to deprecate in whole. The goal here would be to come up with a solution that, while still manual, would allow bulk deprecation of these symbols throughout the codebase.
MP-BioPath uses rigorous mathematical programming to predict exactly how genetic mutations or drug perturbations cascade through Reactome's biological pathways. The current model needs better integration of tissue-specific realities and address the issue of artificially diluting predictive signals when multiple proteins share similar roles (entity-set dilution). AND While the Reactome team generated an expansion of these logic networks across their entire database, this massive architecture remains unvalidated at scale. This project aims to transform MP-BioPath into a scalable, context-aware predictive engine. I will architect an automated validation pipeline to stress-test the newly generated Reactome-wide logic networks, and then use this infrastructure to systematically benchmark MP-BioPath against traditional, topology-agnostic methods like Gene Set Enrichment Analysis (GSEA). I will build a transcriptomic-weighting module as the context later: by feeding real-world RNA-seq data into the optimization model, this extension will act as "live traffic updates" for the biological pathways, dynamically adjusting node weights based on actual tissue expression to resolve entity-set dilution and enable highly specific predictions.
Concerto is the modeling language of the Accord Project. It supports code generation for 16 target languages and schema formats such as Java, TypeScript, Go, Rust, C#, GraphQL, and Protobuf. At present, CI only checks that the generator runs without crashing. It does not verify that the generated code compiles or validates in its target environment. This allows broken code to reach users without detection. This project adds full compilation and validation checks across all 16 targets through three deliverables. The first deliverable is a set of Docker images, one for each target. Each image includes the Concerto CLI and the required language toolchain. These images are published to the GitHub Container Registry with layer caching enabled. The second deliverable is a GitHub Actions matrix workflow. It generates code from a test corpus, runs it inside the correct image, and executes the compiler or validator for every pull request. The workflow fails immediately if the output is invalid. The third deliverable is a versioned test corpus of .cto model files. These files cover all Concerto language constructs such as primitives, optionals, arrays, inheritance, enumerations, and relationships. This ensures full coverage of code generation features.
MariaDB currently implements the JSON data type as an alias for LONGTEXT rather than as a distinct type, causing JSON columns to be misreported in schema introspection, client metadata, and the wire protocol. This breaks ORM frameworks such as Ruby on Rails ActiveRecord, which cannot identify the column as JSON and silently corrupts data. It also puts MariaDB out of compliance with the SQL:2016 standard. This project implements JSON as a fully distinct type in MariaDB's type system without changing storage so that JSON columns are correctly identified and reported at every layer: schema commands, the Information Schema, wire protocol metadata, and implicit validation. Deliverables include correct SHOW COLUMNS and SHOW CREATE TABLE output, accurate INFORMATION_SCHEMA reporting, proper wire protocol type codes, implicit JSON validation on write, correct JSON function return types, and a full MTR test suite covering all changes.
Wikisource is an online wiki-based digital library operated by the Wikimedia Foundation where volunteers transcribe old books and documents. The Bulk OCR feature allows volunteers to OCR multiple pages of a book at once instead of doing it page by page manually. However the current implementation has several critical issues that reduce productivity and cause poor quality text being saved to wiki pages. This will directly benefit thousands of Wikisource volunteers worldwide who transcribe historical documents daily making their work faster more accurate and more enjoyable
This project intends to implement a Maximum Weighted Matching algorithm for pgRouting within the OSGeo ecosystem, enabling efficient graph-based optimization for spatial networks. Maximum weighted matching is a fundamental problem that identifies a set of non-overlapping edges with maximum total weight, widely applicable in logistics, vehicle assignment, and supply-demand matching. The implementation will include development of a pgr_maximumWeightedMatching() function with a SQL interface and a high-performance C++ backend leveraging Boost Graph Library or optimized custom routines, integrated seamlessly with existing pgRouting structures. The project will also provide support for weighted graphs, comprehensive documentation, unit testing using pgTap, and performance benchmarking on large-scale and real-world datasets. This addition will enhance pgRouting’s analytical capabilities by introducing advanced matching functionality for transportation and network optimization while adhering to project coding standards.
This project aims to advance the SYMBA framework for calculating squared scattering amplitudes in high-energy physics by incorporating physics-informed machine learning principles. While recent transformer-based approaches have shown strong performance by framing amplitude squaring as a sequence-to-sequence problem, they largely rely on syntactic patterns and do not explicitly capture the physical structure of Feynman diagrams or the semantic roles of symbolic entities. This work proposes to bridge that gap by integrating structural and physics-aware representations into the learning process. By embedding domain knowledge into model design, this project seeks to improve accuracy, generalization, and physical consistency, particularly for complex processes such as QCD where symbolic expressions grow rapidly in complexity. The outcome will contribute towards more scalable and interpretable machine learning approaches for symbolic physics computations, while providing reproducible tools and insights that can benefit the broader ML4Sci and high-energy physics communities.
GJS is a JavaScript runtime built on Firefox's SpiderMonkey JavaScript engine and the GNOME platform libraries. It allows the use of the GNOME platform libraries in JavaScript programs. GJS powers GNOME Shell, Maps, Characters, Sound Recorder and many other apps. The Debug Adapter Protocol (DAP) defines the abstract protocol used between a development tool (e.g. IDE or editor) and a debugger. DAP makes it possible to implement a generic debugger for a development tool that can communicate with different debuggers via Debug Adapters. DAP is already supported by the most prominent code editors and tools like VS Code, Zed, Emacs, etc… (https://microsoft.github.io/debug-adapter-protocol/implementors/tools/) Today, you can already debug applications and libraries written for/with Android, Node.js, Deno, C, C++, Rust, Python and more (https://microsoft.github.io/debug-adapter-protocol/implementors/adapters/). This proposal aims to make GJS applications and libraries like GNOME Shell, Maps, Decibels etc… debuggable by implementing a DAP adapter for GJS.
The plasma module is used to determine the ionization and excitation states of the supernova ejecta using the basic structure of the supernova (elemental abundances, densities, radiation temperature). As described in the project description in the GSOC project page, CodeCov does not accurately report coverage of the TARDIS plasma. This is because the plasma module is used as a parameter for models and simulations, and is therefore indirectly tested by the tests of the simulation and model functions. While there are parts of the plasma module that are tested directly, many aspects of the module have no easy to find direct tests. This project aims to increase the test coverage of the plasma module and make the tests of the plasma modules easy to find and read.
This project aims to transform AURA (A User Repository of Artifacts) from a survey-based collection of perfusion imaging artifacts into an interactive, searchable web platform. It will help organize and manage artifact data more effectively while allowing users to explore artifacts based on what they observe in medical images. The platform will include structured data, image galleries, and a moderated submission system to ensure quality and privacy. It will be built using a modern web stack and designed to support future expansion to additional imaging methods and integration with quality control tools.
Blender's UI regression test suite leaves most of the editor surface untested in CI, meaning regressions are caught only by manual review. This project extends the existing UI simulate testing framework with new targeted tests covering Window Manager state transitions, all practical editor/region types, menu and operator search per editor, tool/modifier/preference draw stability, and interaction-heavy flows like drag/drop, pie menus, and selection behavior. All tests integrate into the existing CI, with documentation covering how to run and extend UI regression tests within the framework.
Problem: Git's "partial clone" is a lifesaver for huge repos because it lets you download only the files you actually need. But once you download a file (a "blob"), it stays on your disk forever. Currently, Git has no way to "un-fetch" these files. Over time, your "partial" clone starts looking like a massive full clone, and the only fix is to delete everything and start over. Solution: I want to build a "reverse gear" for partial clones. My project will add a safe way for Git to drop large, local files you no longer need, while keeping a "promise" that it can get them back from the server later. I’ll be focusing on three main things: Safety: Ensuring Git double-checks that the server still has the file before we delete it locally. "Promise" Contract: Updating Git’s internal records so it knows a deleted file isn't missing, just stored remotely. User Control: Adding this to git maintenance so users can easily reclaim space without being C experts. By the end of the summer, Git will have a new capability to prune local blobs safely. This includes the core C logic for identifying and removing objects, integration with the git maintenance command, and a full suite of tests to ensure no data is ever lost.
This project will add native historical metrics storage to pgexporter, enabling users to analyze trends and long-term performance without relying on external time-series stacks. The solution introduces an optional history module, configurable via the main settings, that can store metrics in SQLite, PostgreSQL, or TimescaleDB. Deliverables include the history storage module, a REST API for querying historical data, console integration for visualizing trends, migration/export tooling, and clear documentation for setup and backend selection.
This project explores the problem of estimating how the volume of a high-dimensional convex polytope changes under sequential constraint additions. In genome-scale metabolic models, this is prevalent. The feasible steady states form such a polytope, and biological interventions (gene deletions) correspond to additional linear constraints. Quantifying the resulting volume contraction provides a geometric measure of robustness and enables detection of synthetic lethality, but existing methods require recomputing volume from scratch after each update. A dynamic volume updating algorithm that estimates relative volume changes incrementally is proposed. The method introduces constraints via an annealing schedule of parallel hyperplanes and computes local volume ratios using sample reuse with selective resampling. To maintain efficiency as the polytope becomes thin or anisotropic, the approach incorporates Constrained Riemannian Hamiltonian Monte Carlo (CRHMC). Deliverables include an annealed update framework, an incremental relative volume estimator, integration into volesti with dingo interfaces, and validation on metabolic models for robustness analysis and synthetic lethality detection.
In GSoC 2025, I prepared a novel physics-informed Swin Transformer to classify between lens models in simulated gravitational lensing images. The model overtook its contemporaries in sparse datasets. However, the core challenge often is that models trained on perfect simulation data often fail when applied to noisy, complex, and unlabeled observational data, like the Legacy Survey of Space and Time corpus. Thus, I am proposing an application to that model, through a real-life LSST dataset. The strategy that will be used will be a hybrid of “conventional” substructure classification using vision transformers, and a masked autoencoder, as the dataset itself is largely unlabeled. This will allow us to apply the novel architecture defined in the last project into real-world unlabeled datasets like the LSST corpus. The deliverable will be a foundational model with its core being the HEAL-Swin model, having both the strengths of a a physics-informed relativistic inference, and applicability to real-world unlabeled datasets. The aim will be to deliver publishable results by the end of the program.
AutoEIT is an NLP system for automating scoring of the Elicited Imitation Task (EIT), a language proficiency assessment where participants repeat spoken sentences. The project builds an end-to-end pipeline that transcribes audio and assigns rubric-based scores (0 to 4) by comparing responses with target sentences. It combines speech processing, linguistic rules, semantic similarity, and LLM-based evaluation. The goal is to produce reliable, scalable scoring aligned with human raters.
This project aims to extend the existing cBioAbstractor prototype into a schema-driven formatting pipeline that assists curators in transforming heterogeneous supplemental datasets into cBioPortal-compatible formats. Currently, curation is a manual and time-consuming process due to inconsistent file structures, lack of automated schema mapping, and the need to interpret validation errors manually. This results in inefficiencies, variability, and high onboarding effort. My preliminary extension implementation suggests the feasibility of this approach by connecting existing components, introducing fuzzy column normalization, and providing a simple interface for file upload, transformation, and result inspection. Initial qualitative experiments show that the system can reconstruct correct cBioPortal formats from intentionally perturbed datasets, suggesting strong potential for reducing manual work and improving consistency.
Valhalla currently lacks a scalable way to detect routing and guidance regressions introduced by pull requests. This project builds a three-component QA system: a coverage-driven Python route generator that produces 10,000+ test routes over a static Switzerland OSM extract, exercising all costing models and routing-relevant OSM tag categories; a GitHub Actions pipeline that builds Valhalla graphs from both master and PR code, runs all routes against both, and computes geometry and instruction diffs; and a React review application - built inside valhalla/web-app, where maintainers can inspect diffs route by route, compare map geometry and turn-by-turn instructions side by side, and accept or flag changes before the baseline updates. The deliverable is a maintainer-usable, publicly deployed QA tool that makes routing drift visible and catchable at PR review time.
The Badge Magic device has a hardware constraint that makes firmware updates nearly impossible for most users after first flash. The onboard battery prevents a Power-On Reset, permanently closing the bootloader entry window after first boot. The only existing workarounds — desoldering the battery or shorting a capacitor are unsafe and unsuitable for workshops. This project implements a Stage-1 Gatekeeper that intercepts the boot sequence before any GPIO reconfiguration occurs, checks a retention SRAM location for a magic value, and jumps to the ROM bootloader if triggered. Three entry paths are provided: a USB vendor command, a button press pattern, and the existing first-boot hold — all safe, easily repeatable and requiring no hardware intervention.
This project aims to extend the classbound R package into a general framework for exploring and comparing classification boundaries across a wide range of models and datasets. The project will develop a modular R package that supports additional classification algorithms, including user-defined methods, along with flexible data simulation utilities and support for real datasets. It will also extend functionality to high-dimensional settings using tour-based visualization techniques, allowing users to interactively explore data structure and corresponding decision boundaries. The package will be designed for extensibility and will include comprehensive documentation, examples, and a vignette. Final deliverables will include implementations of additional classifiers, enhanced simulation capabilities, high-dimensional visualization support, and complete documentation, enabling users to better understand and compare classification models through their decision boundaries.
This project transforms TensorMap into a complete neural network design studio by introducing a data driven layer registry, expanding support to 15 layer types, enabling real time training visualization, model export in industry standard formats, post training interpretability tools and automated hyperparameter tuning. The system will improve scalability, usability and developer productivity while allowing users to design, train, analyze and optimize models visually.