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.
CDLI’s tablet applications provide access to curated cuneiform artifacts, making ancient records accessible to researchers, educators, and the public on mobile devices. This project proposes rebuilding the CDLI tablet apps as a single React Native application for both Android and iOS, integrated with the existing CDLI backend and admin panel. The app will preserve existing functionality such as browsing tablet collections, viewing high-resolution images with zoom, searching content, and accessing featured highlights, while also introducing offline support, bookmarking, and sharing. On the backend, the project will enhance the tablet feed, add structured JSON support for highlights, and enable role-based access for tablet management. With a unified codebase, the application will be easier to maintain, extend, and support for future contributors.
Spatial domain identification is a fundamental task in spatial transcriptomics, yet state-of-the-art methods exhibit pronounced sensitivity to random initialization. Evaluating four representative methods—STAGATE, GraphST, SpaceFlow, and STcluster—across 1,000 random seeds on all 12 sections of the DLPFC benchmark reveals worst-to-best ARI ranges of up to 0.396, a gap that rivals reported inter-method differences in published benchmarks. We propose StaR (Stability-Aware Representation Learning), a plug-in training framework that addresses this limitation without modifying the base encoder architecture. As a proof of concept, our first instantiation P-StaR-A (Prototype-Anchored Adaptive Fine-Tuning) achieves a 55% relative CV reduction on STAGATE across all 12 DLPFC sections (mean CV: 11.6% → 5.2%), with the most volatile sample improving from CV = 28.4% to 1.9%. The OSRE project will extend StaR to the remaining three backbones, develop a learned cross-backbone stability gate, and release a scanpy-compatible library.
The recent release of serialport 4.9.0 has provided an opportunity to thoughtfully plan the next major release, catching up on features that have been postponed for years which includes trait-object architecture, internal panics that manifest unexpectedly and an outdated MSRV 1.59(which was being leveled up to 1.75 recently) causing actual dependency resolution problems. This project lays the foundation for the next big release. I will start with a downstream usage audit of public dependents to guarantee that the refactoring decisions have minimal migration difficulties. This will be followed by the implementation of struct unification where backends using Box<dyn SerialPort> will be replaced with concrete structs while maintaining compile time compatibility for typical usage scenarios. Capabilities such as exclusive locking and RS485 settings will be provided using extension traits for platform specific operations. Panicking conversions such as FromRawFd will be replaced with fallible TryFrom variants. The MSRV will be bumped along with CI extension of cargo-minimal-versions.
This proposal aims to design and implement a canonical meta-agent architecture for Mesa. The project addresses the current gap between Mesa’s experimental meta-agent support and the needs of users who want to model overlapping group structures such as households, workplaces, alliances, and teams. The work will focus on building a single canonical backend for representing overlapping typed memberships, along with a clean Mesa-facing API for creating groups, updating memberships, handling lifecycle operations, and supporting group-level state aggregation. The expected deliverables are a canonical backend, a user-facing API, lifecycle and aggregation support, tests for correctness and overlapping memberships, and documentation with example-driven validation. The result will be a stronger foundation for multi-level modeling in Mesa and a better base for future group-level extensions.
This proposal aims to improve the infrastructure of the BrainGlobe ecosystem and make it easier to maintain and contribute to as it continues to grow. This will be done by simplifying the BrainGlobe meta-package API, aligning function and argument naming across tools, improving CI workflows by migrating from tox to uv, automating API documentation, and refining the conda-forge release process. Deliverables: Expose a simplified API from individual BrainGlobe tools via the meta-package. Standardise naming, arguments, and structure across tools. Migrate CI workflows from tox to uv. Improve conda-forge packaging and release setup. Automate API documentation and publishing, clean up badges and project metadata across repos.
This project focuses on redesigning the Oppia Topic Page to make it more intuitive and easier for learners to navigate. Currently, lessons are presented in a story-centric layout, while practice and revision content are separated into different tabs, which can cause learners to miss important activities and struggle to decide what to do next. The redesign introduces a unified interface where lessons, practice, and revision content are combined into a single continuous flow. Learners will see a structured, scrollable sequence of lesson and practice cards with clear progress indicators and actions such as start, resume, and review. It also improves how language options are displayed and selected directly on the Topic Page.
Currently, OpenAFS provides the afsio command that supports read, writes, and locks to both files and directories in the AFS environment without going through the cache manager. However, it does not support mount point control, ACL manipulation, or directory operations, which would allow a fully functional cell to be created without the cache manager; This would be convenient for administrators, as it avoids the kernel module having to be installed on the machine setup is being performed from, as well as allowing setup in environments not compatible with the kernel module. To address this problem, I will implement all three types of subcommands of afsio; Key deliverables include the code for all of these types of commands, as well as documentation such that administrators know how to use them.
This project aims to integrate the official GHC/WebAssembly backend into xeus-haskell, a Jupyter kernel for Haskell. Currently, the kernel relies on MicroHs, which, while lightweight, lacks support for the vast majority of the Hackage ecosystem. I will implement a dual-backend architecture by introducing a new C++ bridge and a reactor-model Wasm REPL module based on the GHC API. Key deliverables include: GhcRepl: A GHC-based WebAssembly REPL module maintaining persistent session state. C++ Bridge: A new interface (ghc_repl.cpp) to communicate with the GHC/Wasm runtime via the Wasm C API. Backend Abstraction: A unified virtual interface to allow seamless switching between MicroHs and GHC/Wasm. WASI Integration: A configured browser shim to handle I/O and package database access within JupyterLite
Edge-disjoint spanning arborescences are a fundamental structure in directed graph theory, with applications in connectivity and network design. SageMath currently relies on Mixed Integer Linear Programming (MILP) to compute them, which can be slow on complex instances and depends on external solvers. This project will add a native combinatorial backend based on Gabow’s algorithm, implemented in Cython and integrated into SageMath’s public API. Deliverables include validation tools, randomized regression tests, documentation, and performance benchmarks against the existing MILP-based implementation.
Kale compiles a single Jupyter notebook into a Kubeflow Pipeline by parsing cell tags, detecting data dependencies with PyFlakes, and generating KFP DSL. But real ML work rarely fits in one notebook ,teams split preprocessing, training, and evaluation across separate notebooks, and today there's no way to compose them through Kale without dropping down to the KFP SDK manually. This project extends Kale with multi-notebook composition and a visual pipeline editor. Each notebook declares typed inputs and outputs (KFP artifacts like Dataset, Model, Metrics or parameter types). A new workflow compiler processes multiple notebooks and compiles them into a single Kubeflow Pipeline, with each notebook becoming a KFP sub-pipeline that preserves its internal steps. A visual editor built as a JupyterLab DocumentWidget handles assembly ,drag notebooks onto a canvas, connect typed ports, compile and run. Deliverables: #1.Notebook interface declaration system (backend + frontend) — explicit typed inputs/outputs per notebook, integrated into existing NotebookConfig and the Kale sidebar UI #2. Workflow data model and .kale-workflow file format with DAG validation (cycle detection, type checking, reference resolution) #3. Workflow compiler that processes each notebook through the existing NotebookProcessor → Compiler pipeline, wraps output as sub-pipelines, and generates a top-level KFP pipeline wiring them together through artifacts #4. CLI support: kale --workflow path/to/workflow.json #5. Visual DAG editor in JupyterLab using React Flow — drag-and-drop from file browser, typed port connections, properties panel, compile/run actions via Kale's existing RPC layer #6. End-to-end tests on a real KFP cluster, user documentation, and example workflows
The High Luminosity LHC program requires novel computational approaches to process massive datasets and identify rare signals. This project implements Quantum Kolmogorov Arnold Networks using the PennyLane framework to classify high energy physics events, such as quark gluon jet discrimination. By substituting classical linear weights with parameterized quantum circuits, we aim to benchmark the expressivity, parameter efficiency, and performance of quantum KANs against classical Multi Layer Perceptrons using CMS open datasets.
GnuCOBOL currently has no support for the Object-Oriented Programming (OOP) features defined by the ISO standards ISO/IEC 1989:2002 through ISO/IEC 1989:2023. Object-Oriented (OO) code currently leads to syntax errors due to lack of parsing support. The project aims to build support for parsing all OO syntax, and for a subset, also implement AST and codegen support to get a minimal working prototype of calling class methods through objects. Support for complex OOP features like method overriding and single inheritance will also be implemented. Multiple inheritance, method prototypes and parameterised classes are excluded for now. As a result, future releases of GnuCOBOL 3 will be able to parse OO code and report a simple error message about the pending feature. GnuCOBOL 4 will introduce the new paradigm to users. It will be able to generate working binaries for OO code and handle complex features like method overriding and single inheritance. The project will help bring GnuCOBOL closer to being compliant with ISO standards for OO COBOL and establish it as a significant choice among institutions looking for a free COBOL compiler with OOP support.
Developers are enthusiastic about leveraging Java's latest language features, which offer more powerful, declarative, and expressive code; these features include Flexible constructor bodies (JEP 513), JEP 512: Compact Source Files and Instance Main Methods. However, Checkstyle currently lacks robust support for these features. This project aims to bridge this gap by updating existing checks and potentially introducing new ones to ensure thorough coverage of Java 25 syntax and conventions proposed by the JEPs associated with these language advancements. The objective is to deliver comprehensive support for the new language features through revising check modules, exhaustive testing, and detailed documentation updates. This effort not only aligns Checkstyle with cutting-edge best practices in the Java community but also contributes to the project's ongoing evolution
To validate ecological models against new data sources, PEcAn researchers currently bypass the rigid, database-dependent benchmarking module, instead writing fragmented, "one-off" scripts. This project solves this by replacing the rigid benchmarking module with a highly flexible, general-purpose Validation Toolkit. Built entirely on R data frames, the toolkit extracts successful design patterns from existing scripts to let users ingest arbitrary data via YAML configurations (bypassing the database entirely), align time/space, and calculate statistical metrics. The toolkit will be rigorously tested on a Biogeochemistry Minimum Viable Product (MVP) using specific AmeriFlux sites and targeted global meta-datasets. Final deliverables include the fully documented Toolkit R Package, automated Quarto reporting templates, robust test suites, and an educational tutorial vignette.
Qubes OS uses TemplateVMs as the base for most application qubes. These templates track upstream operating system releases such as Fedora and Debian, which eventually reach end-of-life and must be upgraded. Today, users generally have two options: 1. Install a fresh template and manually recreate customizations and packages. 2. Perform an in-place upgrade manually by following a multi-step process across dom0 and the template terminal. The first option is safer but discards customization. The second preserves customization but is cumbersome, error-prone, and inaccessible to many users. This project proposes an automated template version upgrade workflow built on top of Qubes OS's existing update architecture. The primary deliverable is a dom0 command-line tool that performs distro version upgrades for Fedora- and Debian-based templates while preserving safeguards, reporting progress, and leaving a clear recovery path on failure. GUI integration is a stretch goal after the CLI workflow is stable and tested.
This initiative focuses first on creating a Rust runtime platform for Concerto. Presently, Concerto's runtime logic resides in JavaScript and we use Node/Browser execution to conduct that logic, however; the logic is becoming more difficult to be reused as expected in other execution environments. The long term plan is to create a reusable Validation Core written in the Rust programming language which loads Concerto entity metamodels in JSON format, validates against the requested Concerto entity types based on the appropriate input metamodel and allows both access to the same validation core as a WASM module which is used from JavaScript executed environments, and also through a native interface for callers that are not executing using vanilla JavaScript.
This project aims to build a context-first AI infrastructure to improve how contributors, maintainers, and repositories interact in open-source development. I will design and implement a system consisting of a Skill Bot (for answering contributor queries using repository-specific knowledge), a Skill Updater (to convert maintainer discussions into structured, reusable documentation), and a PR Dashboard (to help maintainers analyze and manage multiple pull requests efficiently). These components will be connected through a shared knowledge layer, ensuring that AI assistance is grounded in real repository context rather than generic responses, while maintaining a human-in-the-loop approach for reliability and control. In parallel, I will work on XOps, a CI/CD-native infrastructure for programmable value transfer in open-source workflows. This involves building a reusable execution engine that enables secure, policy-driven payouts triggered by repository events such as PR merges. The system will support multi-chain execution, configurable policies, and auditable workflows, reducing manual accounting overhead and enabling scalable, transparent contributor reward systems. Together, these systems aim to improve contribution quality, reduce maintainer workload, and introduce a standardized, automation-first approach to both collaboration and value distribution in open source.
This proposal integrates IRx with the Apache Arrow C Data Interface (CDI) to enable zero-copy interoperability with systems such as PyArrow and DuckDB. Currently, IRx lacks a complete Arrow export path, supports only int32, and contains a critical issue where finish() hardcodes type metadata, leading to silent data corruption for other types. The project introduces a full Arrow lowering pipeline covering all fixed-width types and UTF-8 strings, implements a correct ArrowArray export mechanism, and resolves type handling through a generalized type_id-based runtime design. This ensures that future type additions remain localized and scalable without modifying shared logic. The outcome is a production-ready integration that allows IRx programs to exchange data directly with Arrow-compatible systems without copying or serialization, enabling its use in real-world data processing pipelines.
This project aims to bring dark mode support to Django’s issue tracker and improve its visual consistency with the main Django website. Currently, the main site supports dark mode while the Trac-based issue tracker does not, creating an inconsistent user experience. The project will implement a maintainable dark mode styling system, add a theme toggle supporting light, dark, and system preferences, and improve readability and accessibility across key pages such as tickets, reports, and wiki pages. The final deliverables include the dark mode implementation, UI refinements for important components, and documentation to support future maintenance and improvements.
This project will produce RobStatTM-Py, a Python library exposing the target RobStatTM function set for this project through lightweight rpy2 wrappers whose numerical outputs reproduce the R originals exactly. Every wrapper will ship with Python-style documentation modelled on the RobStatTM R man pages, a pytest validation suite, and reproducible Jupyter notebook examples.
This proposal is about adding IPP-Scan support to go-mfp, OpenPrinting’s Go toolkit for multi-function printers and scanners maintained by Alexander Pevzner. Right now, go-mfp has solid IPP support for printing and a full eSCL implementation for scanning (WS-Scan is also being added). But there’s no IPP-Scan support yet, and that’s a gap. IPP-Scan (defined in PWG 5100.17) is the open standard for driverless scanning over IPP. It’s what Scanner Applications need to move away from the current eSCL-based approach. I’m proposing to build both a client and a server for IPP-Scan - the client for testing PAPPL scanner apps, and the server as a reference implementation that will also help with developing a future SANE backend for IPP-Scan.
After video decoding in VLC it might be that the user wants to use a specific filter like deinterlace and/or adjust and/or other filters that run on the GPU before the frame gets displayed. Vulkan branch now misses filters support and many GPU-accelerated filters in VLC that some of them currently existed in OpenGL pipeline (deinterlace) not yet available for the Vulkan pipeline. And other filters are not implemented in Vulkan and OpenGL (adjust). This project will introduce the Vulkan-based filtering abstraction and implement some filters such as deinterlace and adjust-style filters (brightness, contrast, saturation, gamma) using Vulkan shaders.
Self Introduction: My name is Yimo Wang.I am a Master’s candidate in Software Engineering at Dalian University of Technology, expected to graduate in June 2027. I am an active contributor to the Gazebo simulator project, with extensive experience in C/C++, ROS 2, and related development tools such as CMake and GDB. Brief Plan of proposal: First, we should know how to design the basic process of a single plugin test. It should be as lists: 1. start simulation and collect state before calling reset 2. call reset and step forward 3. verify if old states of the plugin are reset 4. step forward again to verify if works well after calling reset Second, we should extract functions from every step to build a standard test suite. Finally, we use the standard test suite to build integration tests for every single plugin in the core system. Then run tests and audit their behaviors. After auditing, we should fix plugins that lead to state leaks after calling reset. Adding the Reset function explicitly and mounting ISystemReset is a good option. After the fixes are completed, we can then incorporate tests into the CI pipeline to prevent regressions.
This project extends OWASP FinBot by implementing a guardrail and detection framework for agent based AI systems. The system will monitor tool usage, detect unsafe agent behavior, generate security events, and enable defense focused CTF scenarios aligned with the OWASP Agentic Top 10.