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.
A Device Tree (DT) is a data structure used to describe non-discoverable hardware to the OS or bootloader. It is written in a device tree source (.dts/.dtsi) file, which is compiled into the kernel image at build time. This structure provides a standardized way to describe a system’s hardware topology. Device Tree bindings are the rules and conventions used to describe devices within the Device Tree. These bindings define how to represent various hardware components. Device tree bindings were historically written in human readable (.txt) format and developers had to rely upon manually reading these files and writing device tree source files accordingly. Now, these files are being converted to DT schema (.yaml) format so that semantic validation can be done on device tree sources automatically.
The goal of this project is to enable support for the High-Level Shading Language (HLSL) in clangd, allowing shader developers to benefit from modern language-server features such as code completion, diagnostics, semantic highlighting, and symbol navigation. Although HLSL is largely based on the C++11 standard and can already be parsed by Clang, clangd’s support remains incomplete due to missing handling of HLSL-specific constructs, semantics, and resource types. Additionally, shader development introduces unique challenges, such as multiple entry points within a single file (e.g., vertex and pixel shaders), which are not fully addressed by clangd’s current architecture. The project will begin with an evaluation of clangd’s behavior on HLSL code to identify gaps, followed by the design of appropriate extensions. An RFC will be proposed to the LLVM community to validate the design and gather feedback. Based on this, the project will implement key improvements to clangd, focusing on built-in function completion, semantic analysis of shader constructs, improved diagnostics, and better handling of shader-specific configurations. The final deliverables include a documented analysis of current limitations, an RFC describing the proposed design, a structured set of implementation issues, and upstreamed improvements to clangd, along with test coverage and documentation.
CDLI hosts over 340k cuneiform artifacts used by researchers worldwide. The current search stack runs a nightly Logstash pipeline that rebuilds the entire index from scratch, meaning approved edits can take up to 24 hours to appear in search results. Publications, collections, proveniences, and periods have no search infrastructure at all they query the database directly. This project replaces the nightly rebuild with event-driven incremental indexing using a Transactional Outbox pattern, so approved edits appear in search within minutes. It migrates the stack from Elasticsearch to OpenSearch, builds a PHP document builder to replace the existing Ruby transform, brings publications, collections, proveniences, and periods into OpenSearch, and implements cascade hooks so changes to shared entities automatically trigger reindexing of all affected artifacts. A full reindex command and admin UI, handle the initial migration and ongoing recovery scenarios.
The CDLI framework currently sends transactional emails synchronously during web requests, coupling application performance directly to SMTP availability. This project redesigns the email system into a reliable, background-driven pipeline by moving email delivery into asynchronous jobs processed by a dedicated worker. The work builds on the existing Redis and Postfix infrastructure already present in the repository, adding persistent job storage, retry logic, failure tracking, an admin monitoring dashboard, rate limiting, and a shared email template system — making email a first-class, observable part of the application rather than a side effect of user actions.
The current OpenELIS React frontend is primarily written in JavaScript and faces challenges in maintainability, scalability, and performance as data complexity increases. This results in inconsistent type usage, increased bugs, and inefficient rendering in data-heavy workflows such as patient management, sample tracking, and result entry. This project aims to modernize the frontend by incrementally migrating the codebase to TypeScript and applying proven React performance optimization techniques. The migration will introduce a centralized type system for API models, forms, and reusable components, ensuring consistency and reducing duplication across the codebase. The project will follow a phased approach: first establishing a strong TypeScript foundation with shared type definitions, then incrementally migrating utilities, components, and high-impact screens. In parallel, performance optimizations will be implemented using profiling-driven techniques such as memoization, virtualization for large datasets, improved server-state handling, and code splitting. Deliverables include: - Incremental migration of frontend codebase to TypeScript - Centralized and reusable type definition system - Performance improvements in key workflows - Reduced bundle size and improved rendering efficiency - Documentation and migration guide for future contributors This project will significantly improve the maintainability, developer experience, and performance of the OpenELIS frontend, making it more scalable for future growth.
metadata_service returns raw arrays with no pagination or filtering. ui_backend_service in the same repository already supports both via an envelope format. Meanwhile, the DB layer (find_records, DBPagination, runs_v3_idx_epoch_ts_desc) already has everything needed — the gap is that the API layer does not expose it. This project brings metadata_service to parity: pagination via LIMIT+1, tag filtering with four operators (_tags:any/all/likeany/likeall), unified response schema matching ui_backend_service, and GIN index migration — without breaking existing clients. The key design: without _limit, behavior is identical to current. With _limit, the envelope format activates. Beyond pagination and filtering, the project also connects tag cache refresh to notify.py's existing LISTEN/NOTIFY infrastructure (debounce or incremental update strategy confirmed with mentor before implementation), and adds Content-Type header to the format_response decorator. Deliverables: metaflow-service PR covering all 9 GET endpoints, GIN index migration, feature-gating, benchmark results with EXPLAIN ANALYZE verification, backward compatibility test suite, and a pagination implementation guide for future contributors.
Computers with ARM architecture are prevalent but GNU Boot currently doesn't support them. My focus has also shifted from the classic x86_64 laptops compatible with fully free BIOS to newer armv7 and beyond to armv8 computers. The defunct fully free Libreboot has supported a few Chromebooks that didn't require blobs to boot, thanks to efforts of contributors such as PaulK. I checked with him for basic guidance and I'm in need of a mentor from the GNU Boot project under the GNU umbrella (as GSoC 2026 approved organization). Having GNU Boot support ARM computers would play well into the efforts of fully free GNU/Linux-libre distributions such as Trisquel to complete freedom-respecting ARM laptops. My work will involve updating the previous code in Libreboot and (PaulK's fork libettereboot) for the Chromebook C201 and C100 laptops and porting GNU Boot to newer ARM targets found in coreboot. Since I'm a Embedded Systems Master's student, Google Summer of Code seems to be the perfect opportunity to extend the GNU Boot contributor team while providing basic funding for taking GNU Boot to the next architecture.
This project aims to design and implement a complete chat moderation and editing system for Jitsi Meet. Currently, Jitsi’s chat supports basic messaging but lacks important features such as message editing, deletion, moderation controls, and search, which are essential in modern communication platforms. The goal of this project is to introduce these missing capabilities using XMPP standards like XEP-0308 (message editing), XEP-0424 (message retraction), and XEP-0425 (moderation). The implementation will follow a structured approach, starting from the XMPP layer in lib-jitsi-meet and extending to the Redux and UI layers in jitsi-meet. Key features include message editing, message deletion, moderator-controlled actions, chat muting, user reporting, message search, and reply threading. Additionally, server-side enforcement using Prosody plugins will be explored to ensure reliable moderation. This project will improve user experience, provide better control in meetings, and bring Jitsi’s chat system closer to modern messaging standards while maintaining consistency with its existing architecture.
fts(3) is the file hierarchy traversal library used by nearly every recursive utility in FreeBSD like find, rm, ls, chflags, du, and others. It currently cannot operate inside Capsicum capability mode because it relies on path-based filesystem operations throughout traversal: opening the current directory by name, opening subdirectories by path, and resolving symlinks through constructed string paths. None of the utilities that depend on fts(3) can be Capsicumized until this is fixed. This project adds fts_openat(), a new entry point that accepts a pre-opened directory file descriptor as the traversal root, following the openat(2) convention. The existing fts_open() becomes a one-line wrapper over fts_openat(AT_FDCWD, ...), preserving full backward compatibility. The internal traversal engine is refactored to replace all path-based operations with fd-relative equivalents — openat() and fdopendir() for directory opens, dup() for CWD saves, and fstatfs() for filesystem type detection — while leaving the traversal state machine, path buffer, and cycle detection completely unchanged. The project is structured in two phases. The first and larger phase is a comprehensive ATF/Kyua regression test suite covering the complete documented behaviour of fts(3), built against the unmodified library as a safety baseline. The second phase is the internal refactoring, the new fts_openat() API, capability-mode tests using cap_enter() directly in ATF test cases, and a complete Capsicumization of chflags(1) as the end-to-end demonstration.
This project creates a strong, production-ready Behavioral Framework for Mesa by addressing the limits of hardcoded agent logic. Using iterative prototyping, comparing it to classic models like Sugarscape and Wolf-Sheep, and analyzing across different frameworks such as Agents.jl and GAMA, this initiative provides event-driven decision rules, lazy-evaluated states, and constraint patterns.
This proposal aims to strengthen stdlib’s linear algebra capabilities by implementing LAPACK-based solve routines for structured matrix formats such as packed, banded, and tridiagonal systems, which are widely used in scientific and engineering applications. The project focuses on enabling a complete factorization-to-solution workflow, ensuring seamless integration with existing routines while carefully handling specialized storage formats that require precise indexing and memory management. Emphasis will be placed on numerical correctness, consistency with stdlib’s APIs, and robustness through comprehensive testing and validation. Clear documentation and practical examples will also be provided to improve usability, ultimately making stdlib a more reliable and effective toolkit for real-world scientific computing.
This paper proposes a software defined radio (SDR) based ground station to receive and decode Long Range (LoRa) satellite signal, with forwarding to TinyGS and optionally LoRaWAN network. In this project a complete python package for LoRa will be implemented and used for reception and decoding. Key tasks include optimizing existing python code base written by my mentor PhD, Shayan Majumder; implementing sampling time offset (STO) and carrier frequency offset (CFO) algorithms; implementing TinyGS(MQTT) and/or optionally LoRaWAN (UDP/JSON) forwarding; establishing test, hardware in loop tests and CICD procedures; finally detailing documentation of a complete ground station.
The ROS 2 ecosystem has made significant leaps in performance over the last few years, supported by benchmarking tools like buildfarm_perf_tests and ros2-benchmark-container. These tools take care of profiling middleware and client library performance under various configurations. As of now, the recurring monitoring path in continuous integration (CI) is mostly rclcpp-centric, providing good regression visibility for C++ implementations. However, a current limitation of the ecosystem is that it lacks periodic performance monitoring for other heavily used client libraries like rclpy (Python) and rclrs (Rust). This leaves these libraries with weaker regression visibility, making it difficult to measure the performance impact of new topologies involving remote host subscriptions or track the performance of ROS actions and services reliably. This project focuses on vastly extending the suite of tests that run regularly in buildfarm_perf_tests by porting C++ benchmark instrumentation for use with the other client library implementations. This project thus aims to add high-signal, recurring CI coverage across rclcpp, rclpy, and rclrs with minimal CI cost overhead. Furthermore, to enhance the contribution, there will also be a focus on updating the performance test result graphs in CI to use modern observability tools. The final deliverable includes an updated web dashboard (built with Grafana) that tracks key compute metrics such as latency, CPU usage, and memory over time, providing the community with a complete, cross-language performance diagnostic ecosystem.
The pyaslreport package currently has no automated tests for its core processing logic and no CI pipeline that runs on code changes, meaning regressions in validation behavior, parameter extraction, or report generation can go undetected until a user encounters them in a real research context. This project will build a meaningful automated test suite around the real architecture of the package and integrate it into a GitHub Actions CI workflow. The suite has two layers: an example-based integration runner that accepts a directory of input and expected output pairs and verifies the tool produces correct results for each one, and focused unit tests covering the internal normalization pipeline, schema-driven validators, M0 and TSV validation branches, file grouping logic, and sequence factory dispatch. Adding a new test case to the integration layer requires no code changes, only a new subfolder with the right files. The same runner works locally against any directory of examples and in CI against a smaller committed set, which is exactly the design Jan described in his feedback. Deliverables: an expanded test suite for pyaslreport, a committed example set covering clean, warning, error, and major error cases, a GitHub Actions workflow with coverage reporting, and a contributor guide explaining how to run and extend the tests.
This project focuses on systematically expanding regression test coverage for the ESP codebase by targeting high-risk, untested logic paths rather than merely increasing overall coverage percentage. Through detailed codebase exploration, critical gaps have been identified in components such as lottery assignment logic, class registration flows, and mailman integrations. These areas involve complex logic, invariants, and edge cases that currently lack sufficient test coverage and pose a high risk of silent regressions. The project introduces invariant-based testing for the lottery system to ensure correctness properties such as no conflicts, no overcapacity, and valid grade constraints across arbitrary inputs. Additionally, integration tests will be implemented for mailman functionality using mocking to validate subprocess interactions without external dependencies. A reusable testing infrastructure will be developed to support scalable regression testing, along with targeted performance checks to detect potential degradations in critical views. The outcome will be a robust regression testing framework that transforms fragile, untested paths into enforceable guarantees, significantly improving system reliability and maintainability.
Ell-ena is already a working AI product management assistant, but it has some important limitations. It depends on external APIs for transcription, lacks a web interface, and its RAG system only works for meetings while ignoring tasks and tickets. This proposal addresses all of these gaps. I will build a responsive web dashboard that works on desktops while keeping the mobile app unchanged. I will replace the Vexa transcription API with a self-hosted faster-whisper system that runs locally at no cost and writes transcripts directly to the database. I will extend the RAG system to cover tasks and tickets, reducing token usage by 60 to 70 percent and making the AI faster and cheaper. I will also add two way GitHub integration so that tickets labeled for engineering automatically create issues and tasks get marked done when pull requests merge. Finally, I will add proper testing with CI/CD pipelines and write clear documentation for all new features. By the end of this project, Ell-ena will be a production ready web application with self hosted transcription, smarter AI responses, seamless GitHub sync, and zero reliance on paid transcription APIs.
AI Tour Director reimagines geographic visualization as a cinematic experience by treating every tour like a film. There is a set of specialized agents that collaborate to transform a simple user prompt into an immersive tour. Creative Director, Production Designer, Writer, Auditor, and DOP make this magic happen. Each agent contributes to building a cohesive narrative, that is, from selecting locations and designing camera movements to generating narration and validating the flow. The system leverages modern AI and real-time geographic data to direct immersive tours on Liquid Galaxy, complete with synchronized visuals, subtitles, and multilingual narration. It further enables recording these experiences as high-quality videos and turns the exploration into shareable film-like content. The final deliverable is a modular agent-driven platform that blends storytelling, visualization, and open-source extensibility.
This project enhances OWASP Nest by improving visibility of activity and recognition of contributors. OWASP Pulse provides a near real-time feed that aggregates GitHub events across projects with flexible filtering. Alongside this, OWASP Contributor Recognition Program tracks and evaluates contributions using a scoring mechanism. Contributors are assigned tiers and highlighted through certificates, leaderboards, and profile enhancements.
Currently, Haiku's Bluetooth stack only supports basic device pairing, with no Bluetooth profiles implemented yet. I plan to implement the Hands-Free Profile (HFP), which will enable users to connect their earphones or headphones to listen to audio and make hands-free calls. The deliverables for this proposal include working implementations of the HFP and SPP profiles, as well as RFCOMM and SCO. Additionally, the RFCOMM implementation will lay the groundwork for other profiles, such as the File Transfer Profile (FTP).
This project builds GPU-accelerated image processing kernels for kornia-rs and integrates them into a real-time vision-language model (VLM) pipeline on the Bubbaloop framework, targeting the Jetson Orin Nano. The work has two pillars. First, implementing GPU kernels (resize, normalize, color conversion, cast/layout reordering) using CubeCL, eliminating CPU-GPU synchronization bottlenecks in VLM preprocessing. Second, integrating Qwen2.5-VL-3B via ONNX/TensorRT into a live Bubbaloop camera pipeline, handling dynamic resolution tiling, vision token packing, and memory-constrained inference within the Jetson's 8GB limit. Time permitting, V-JEPA 2 will also be evaluated as a complementary world model for latent scene prediction. The end result positions kornia-rs as a practical foundation for deploying vision-language models on edge devices in Rust.
Nominatim currently classifies places using a single OSM class/type pair, which causes duplicate database entries for multi-tagged objects, fragile handling of administrative boundaries, and insufficient granularity for modern search queries. This project adds native category support to Nominatim's PostgreSQL backend by introducing a categories column across the place, placex, and search_name tables using PostgreSQL's ltree[] type for hierarchical querying. Categories are assigned in the Lua import scripts following Photon's osm.<class>.<type> approach, replacing the place_classtype_* tables currently used for POI filtering. Deliverables include: schema changes with migration support for existing installations, Lua-based category assignment, replacement of classtype table lookups with category-based queries in search_name, and as stretch goals, API include/exclude filtering parameters and a flexible YAML-driven CategoryGenerator for enriched categories like cuisine.italian or access.wheelchair.yes.
Every board in a LibreCube CubeSat (power, navigation, communications, payload) speaks SpaceCAN. Today, none of them can run flight firmware without a Python interpreter. This project changes that. The goal is a complete Rust port of the SpaceCAN protocol: a native crate for PC that works alongside the existing Python tooling, and an embedded crate that runs directly on STM32 hardware via the embassy async framework with no interpreter, no runtime overhead, and no dynamic allocation. By the end of GSoC, any LibreCube board can run production SpaceCAN firmware in Rust, and the broader embedded Rust and CubeSat communities gain their first open-source, interpreter-free SpaceCAN stack to build on. Deliverables: native and embedded Rust crates with full five-service protocol coverage, cross-language integration tests against python-spacecan, Embassy firmware with controller and responder examples for the STM32G0B1RE, and a getting-started guide.
Accurate simulation of particle interactions within detectors is one of the most computationally expensive tasks in High Energy Physics (HEP). While classical Monte Carlo simulators like Geant4 are highly accurate, they are too slow to meet the unprecedented data generation demands of the upcoming High-Luminosity LHC. Quantum Generative Models, specifically Quantum Diffusion Models, have been proposed as a faster alternative. However, current pure-quantum approaches struggle to scale beyond low-resolution "toy" datasets due to qubit limitations, deep circuit noise, and training instabilities. This project proposes the development of a hybrid Quantum Latent Diffusion Model (QLDM). By leveraging a classical Variational Autoencoder (VAE) to compress high-dimensional calorimeter data into a lower-dimensional latent space, the quantum diffusion process can be executed efficiently without overwhelming quantum resources. The final deliverable will be an open-source pipeline capable of generating high-resolution physics simulations. This approach allows the quantum model to operate in a regime where its ability to represent complex probability distributions may provide an advantage over classical generative models.
This project brings drawing tablet and touch support to Graphite and builds a modern GPU-accelerated brush engine designed for professional digital art workflows. It introduces non-destructive, resolution-independent stroke rendering with support for stylus features like pressure and tilt, enabling high-quality painting that stays sharp across zoom and resolution changes.