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.
Exoplanet Atmosphere Characterisation plays a vital role in understanding chemical compositions, weather patterns and habitability of the exoplanet. Traditional retrieval models take hours per planet so using machine learning for this is a perfect alternative. I have simulated a physically realistic spectral dataset of atmospheres under regimes like equilibrium transmission, disequilibrium transmission, non-isothermal emission, and photochemical emission with instrument specific noise injection. Then two models: disequilibrium-aware GRU model and Variational Autoencoder for Pressure Temperature Profiles are used to predict various atmospheric parameters. Additionally, to detect biosignatures we can use an unsupervised convolutional Autoencoder trained on normal equilibrium spectra to flag anomalous molecular signatures. Finally, I plan on validating all my models on real JWST observational data proving that these models are worthy of real world applications.
This project will improve AnalySim’s core reliability by addressing fragile user workflows, improving query and search behavior, and making the JupyterLite integration more robust and maintainable. The work will also be supported by stronger automated testing and CI checks to help ensure long-term stability and reduce future regressions.
Zulip's REST API documentation framework is well-built but incomplete, approximately 28 actionable endpoints remain undocumented, and the OpenAPI spec has accumulated structural debt through years of organic growth. This project has two phases. Phase 1 achieves complete endpoint coverage by documenting all remaining high and moderate priority endpoints following the full pipeline: OpenAPI schema, Python and cURL examples, sidebar registration, and changelog entries. Phase 2 refactors the spec's structure, promoting inline parameters to shared components, rationalising the Can*Group schema family, and cleaning up repeated inline response blocks. Deliverables: (1) Zero undocumented actionable endpoints in pending_endpoints. (2) A cleaner, more consistent OpenAPI spec with reduced duplication across parameters, schemas, and response blocks.
The Mifos X Web App currently faces a significant quality gap with approximately 1.46% automated test coverage, making releases reliant on risky manual verification. This project implements a production-grade testing infrastructure using Playwright and Jest, built on a robust "Four-Layer Architecture" that separates test logic from framework-specific selectors. My approach ensures long-term maintainability by creating a reusable testing SDK that supports both the current Angular codebase and the future React migration. Key deliverables include: A suite of 240+ automated tests covering the high-value Clients, Groups, and Users modules. A shard-safe CI/CD pipeline using GitHub Actions and Dockerized Fineract. Advanced reliability patterns including Fibonacci backoff retries and storageState authentication bypass to optimize performance. This project moves the Mifos Initiative toward a "Correctness First" culture, providing a scalable blueprint for financial software quality.
GIMP is actively migrating its legacy filter system to proper GEGL operations to enable non-destructive editing, and better PSD compatibility. This project contributes to that effort. First, an Inner Glow layer style will be implemented as a native GEGL operation. The implementation will use a distance transform on the layer's alpha channel to generate a per-pixel glow mask, with parameters including spread, size, opacity, intensity, noise, and blend modes empirically validated against Photopea for PSD compatibility. Once complete, it will be mapped to GIMP's PSD importer so that PSD files with inner glow layer styles import correctly. Second, a Bevel layer style will be implemented as a GEGL operation. Bevel is the remaining unimplemented PSD layer style in GIMP, involving multiple bevel styles, separate highlight and shadow blend modes, and depth and blur interactions. The same empirical approach will be used, systematically studying parameter outputs and implementing each feature step by step. Third, the legacy sharpen filter will be ported to a GEGL meta-operation. The existing implementation relies on the legacy GimpDrawable API with manual pixel loops and is limited to 8-bit images. Since the algorithm is a 3×3 convolution, it can be cleanly expressed as a GEGL meta-op, bringing it into the modern pipeline. Deliverables: A PSD-compatible gegl:inner-glow operation mapped to the PSD importer A PSD-compatible gegl:bevel operation mapped to the PSD importer A ported sharpen filter as a GEGL meta-operation
While Meshery's AWS model catalog contains auto-generated connections for individual services, it currently lacks the critical "cross-model" architectural relationships (like linking an EKS Cluster to EC2 Subnets, or an API Gateway to a Lambda Function) that Site Reliability Engineers need to properly visualize and manage real-world, multi-service cloud deployments on Kanvas. Solution: This project systematically defines these missing inter-model dependencies by combining deep AWS architectural expertise with Meshery's v1alpha3 relationship schema. This involves mapping complex multi-hop infrastructures and accurately structuring evaluation queries, metadata, and mutatorRef/mutatedRef patch paths. Deliverables: 1. A comprehensive audit of cross-model gaps in the current AWS catalog. Implementation of high-priority infrastructural relationships (Networking, IAM Permissions, Firewalls). 2. Definition of complex multi-hop chains (e.g., end-to-end Serverless Event Pipelines, EKS Full Stack dependencies). Visual validation of all new relationships within Kanvas and detailed contributor documentation to guide future model integrations. 3. Definition of complex multi-hop chains (e.g., end-to-end Serverless Event Pipelines, EKS Full Stack dependencies). 4. Visual validation of all new relationships within Kanvas and detailed contributor documentation to guide future model integrations.
Graphite is a powerful graphics editor, but it currently struggles to handle complex SVG files perfectly. Important details like custom text styles or advanced shapes may sometimes get lost when opening or saving files. My goal is to fix this by building a reliable, complete SVG pipeline. Firstly, I plan to add missing core features like gradients, patterns, and a proper Text-on-Path node so that Graphite can edit more SVG artwork natively. Followed by this, for any highly complex SVG features that Graphite still would not be able to edit directly, I will build a fallback system. This system will automatically convert those unsupported parts into static images rather than silently dropping them, ensuring the artwork looks exactly right when opened. Finally, I will improve how Graphite exports files, making sure layer names are saved as clean SVG IDs. Altogether, these changes will make Graphite a tool that artists can fully trust for professional SVG work.
Drawy's current text tool is limited to plain text with no per-character formatting, no undo/redo, no support for non-Latin input methods, and performance issues on large text. The goal of this project is to refactor and extend the text tool into a rich text editor. The implementation will begin by splitting the existing code into three classes (TextItem, TextCursor, TextTool) and replacing the manual rendering logic with QTextLayout, which natively handles BiDi, line breaking, and cursor positioning. On top of this foundation, the project will deliver per-range character formatting, text alignment, word wrapping, spell checking via KDE Sonnet, and a formatting toolbar for the user to control fonts, styles, and alignment. Undo/redo will be integrated. Save/load will be extended to support rich text while remaining backward compatible with existing documents. Finally, the backing data structure will be replaced with a Gap Buffer for O(1) insertions and deletions.
This project adds signing and verification for OSCAL JSON artifacts in compliance-trestle so generated documents can be verified in CI/CD and downstream workflows. The implementation will introduce deterministic RFC 8785 / JCS-style canonicalization for signing input, a detached JSON attestation workflow, and new trestle sign / trestle verify commands with clear failure handling. The MVP will be key-based, JSON-first, and detached so OSCAL artifacts remain unchanged, while signed metadata will capture provenance such as trestle version, signing time, OSCAL type, and optional git/build information. Deliverables include the signing and verification code, automated tests, documentation, and a tutorial.
This project aims to improve the integration between ROS 2 and Gazebo by addressing two key challenges: manual bridge configuration and limited support for scalable multi-robot simulation. Currently, users must manually define topic mappings when using ros_gz_bridge, which becomes error-prone and difficult to maintain in dynamic or large-scale environments. In addition, multi-robot simulation requires modifying SDF/URDF files to avoid topic conflicts, making it hard to reuse robot models. To solve these issues, this project proposes a unified communication layer that introduces (1) dynamic bridge discovery to automatically detect and connect compatible ROS 2 and Gazebo topics. (2) a standardized namespacing mechanism for Gazebo plugins to enable seamless multi-robot deployment without modifying robot descriptions. The expected outcome is a robust and scalable framework that reduces configuration overhead, improves interoperability between ROS 2 and Gazebo, and allows developers to launch multiple robots with minimal effort.
MetaCall currently supports Linux (GCC), Windows (MSVC), and macOS but many platforms where developers want polyglot runtime support are missing.The core layers have partial support for some platforms but no CI, no environment script integration, and no testing to verify they actually work.Follow TDD approach: set up CI first , then fix environment script + build system, then fix test failures.I will go platform by platform for implementation.All platform logic lives in metacall-environment.sh there will be no hardcoded logic in CI YAML. 8 platform targets with CI pipelines with working environment script section, verified CMake detection and build, automated testing.Fixes to metacall/plthook fork for platforms that need it.
An offline-first gamified learning mobile app for p5.js that teaches users how to use the library’s symbols (functions, constants, classes, etc.) through small exercises. Inspired by Google's Grasshopper app.
The Liquid Galaxy ecosystem currently faces an unstructured and fragmented onboarding process. Crucial development information is scattered across various wikis and forums, leading to a steep learning curve and persistent architectural rule violations by new developers. Furthermore, the absence of an interactive sandbox makes it difficult for contributors to safely experiment with code and receive instant feedback, while advanced capabilities like 3D KML modeling remain heavily underutilized due to a lack of guided, hands-on tutorials. LG Interactive Onboarding radically overhauls contributor training by transforming the Liquid Galaxy rig itself into an immersive, interactive classroom. Operating on a "phone-as-driver, rig-as-canvas" philosophy, the system uses a smartphone application as a remote control to project educational content, live code exercises, and data visualizations directly onto the rig's 5-screen panoramic display. The platform integrates multi-modal learning—combining animated visual diagrams, auditory voice narration, and kinesthetic hands-on coding—with a privacy-conscious, on-device Gemini AI Mentor. This enforces core development best practices from day one and significantly reduces the manual onboarding workload for organization mentors.
This project aims to resolve the computational bottleneck in self-collision detection within the OCS2 framework for humanoid robotics. The current implementation in ocs2_self_collision operates on a pair-by-pair basis, iterating through collision pairs and calling PinocchioGeometryInterface::computeDistances() followed by Jacobian and penalty term calculations. This sequential approach is not SIMD-friendly by default and fails to utilize the parallel processing power of modern CPUs. To address this, I propose replacing the current computeDistances()-based distance computation with a high-performance implementation inspired by SIMD-amenable structures. A primary focus will be exploring / integrating SIMD-friendly data structures, such as Collision-Affording Point Trees (CAPT), to represent the storage and computation of collisions. This transition aims to transform the collision pipeline into a vectorized workflow that can be efficiently accelerated using AVX2 intrinsics. The primary deliverables include the clean integration of this accelerated engine into the ocs2_self_collision pipeline, accompanied by rigorous correctness checks against Pinocchio/FCL baselines. Furthermore, I will provide a comprehensive end-to-end latency evaluation using ocs2_mobile_manipulator to demonstrate the reduction in average and maximum compute cycle times. This work will significantly enhance the real-time performance of MPC-based humanoid control in complex environments.
COCONUT-SVSM is a Secure Virtual Machine Service Module running at a privileged level inside Confidential VMs to provide trusted services (e.g., virtual TPM) independent of the host hypervisor. Currently, the SVSM kernel performs full TLB flushes on every context switch, discarding all TLB entries indiscriminately and causing significant runtime TLB miss overhead. This project enhances COCONUT-SVSM to leverage the x86 PCID (Process Context Identifiers) hardware feature to tag TLB entries per task, preserving them across context switches and enabling selective TLB invalidation. The work is structured in three phases: Phase 1 builds a code-generated Rust crate (x86-cpuid) from the authoritative x86-cpuid-db v2.4 XML database, replacing all scattered, magic-bit-position CPUID checks across the codebase with a type-safe cpu_has(leaf_0x1::ecx::Pcid) API unified across SNP, TDX, and native platforms via a CpuidReader trait. Phase 2 designs and implements a PCID assignment strategy for all virtual pages in the COCONUT kernel, enabling the CPU to tag TLB entries per task(same for all threads of task) and preserve them across context switches. Phase 3 converts global TLB flush operations in into selective, PCID-aware invalidations: using AMD's INVLPGB broadcast instruction to flush a specific PCID across all cores without IPIs. Key Deliverables are x86-cpuid Rust crate with code generator consuming x86-cpuid-db XML, refactored COCONUT-SVSM codebase with all open-coded CPUID checks replaced with new code generated by x86-cpuid Rust crate, PCID allocator, applying the PCIDs in the COCONUT page-tables and selective TLB flush functions (flush_tlb_pcid, flush_tlb_range_pcid) with AMD INVLPGB.
This project aims to develop a multi-modal foundation model training pipeline for end-to-end particle reconstruction in the CMS experiment. Building on last year's LorentzParT hybrid architecture (L-GATr + ParT) and its track-level masked autoencoder pretraining, I will design a unified tokenization scheme encoding particle kinematics and interaction features as distinct modality streams, and pretrain the shared encoder using a novel Cross-Modal JEPA objective that predicts masked token embeddings across modalities in latent space — combining, for the first time, JEPA-style self-supervision with Lorentz-equivariant representations. The pretrained encoder will be fine-tuned and benchmarked on multiple downstream tasks including event/jet classification and mass regression, with conditional generation as a stretch goal. Deliverables include the complete CM-JEPA pretraining pipeline, a multi-modal tokenizer, multi-task fine-tuning scripts, systematic ablation studies across pretraining methods and masking strategies, trained model checkpoints, and an open-source repository with documentation and a blog post.
This project will focus on L5: expanding on existing L5 tutorials, documentation, and building integrations with existing editors so that creatives can seamlessly start building in L5. The focus of the documentation updates will include updating community statements (such as principles of permacomputing), adding clarity to first-time start-up and examples, creating and fleshing out new tutorials, ideally helping both those new to Lua or new to coding.
I'm building a VS Code extension that brings the power of CScout’s whole-program C analysis directly into the editor. My goal is simple, let developers understand large C codebases more effectively without ever leaving VS Code. Using this extension, one will be able to browse identifiers, find all references, explore call graphs, check metrics, and even preview refactorings in the IDE itself. We will have to extend CScout by adding a clean REST/JSON API on top of the SWILL web server. This API will be the bridge to let external tools (like my VS Code extension) query the data from CScout in a structured way.
This project aims to expand the Qt Integration Tests by adding tests for Keyboard navigation, playback controls, playlist management, and other UI elements. Improve CI integration in Linux for better stability, and explore running the tests on Windows for VLC 3.
This project aims to add a livepatch subsystem to dynamically update kernel code. Having a way to patch bugs or security vulnerabilities without restarting the whole machine would be very useful, especially on servers, which make up the majority of FreeBSD usage. Patches will be delivered via kernel modules, utilizing ELF headers and CTF/DWARF metadata to accurately resolve internal symbols. The patching mechanism will redirect control flow by inserting trampolines at the prologue of target functions. To ensure system stability, patches will be safely applied using a stop-the-world consistency model via smp_rendezvous, with safeguards to prevent the modification of critical routines like the SYSINIT routines. Stack trace analysis will also be explored to more accurately detect function quiescence.
This project focuses on improving the accuracy, reliability, and observability of the Nixpkgs Security Tracker by addressing key limitations in its current CVE–derivation matching pipeline. At present, the system relies on overly permissive substring-based matching, incorrect string-based version comparisons, and lacks proper monitoring, which leads to noisy results, missed vulnerabilities, and silent failures. The proposed work introduces a structured, test-driven redesign of the matching pipeline. It replaces flawed string comparisons with semantic versioning to ensure correct handling of version boundaries. It also improves matching quality by incorporating multiple signals such as trigram similarity, CPE-based matching, and version constraint filtering, thereby reducing noise and increasing the precision of candidate derivations. In addition, the project strengthens data integrity and consistency by fixing cache update issues, eliminating race conditions in issue generation, and ensuring that the system always reflects the latest state after manual or automated changes. It also introduces observability through metrics and dashboards, making system behavior measurable and exposing previously hidden failure cases. Finally, the proposal removes hardcoded infrastructure by enabling dynamic, database-driven channel selection, improving maintainability and scalability. All improvements are guided by measurable metrics and validated through tests to ensure correctness and prevent regressions. Overall, the project aims to deliver a more accurate, robust, and transparent security tracking system for the NixOS ecosystem.
This project proposes an interactive geospatial storytelling platform that visualizes rice agriculture across india using the liquid galaxy multi-screen visualization system. Rice is one of the most important crops in India, and understanding its geographical distribution, seasonal cycles, irrigation patterns, and production trends can help students, researchers, and the public better understand agricultural systems.
Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.
This proposal addresses the deployment gap in federated learning for genomics, where frameworks like FLAN enable distributed model training but lack standardization, security, and interoperability required for real-world biomedical environments. As a result, federated learning systems remain difficult to deploy across institutions and cannot scale in regulated settings. To solve this, the project transforms FLAN into a GA4GH-aligned, production-ready federated AI system by integrating key standards across the stack. It incorporates DRS for secure and standardized data access, TES/WES for portable and reproducible task and workflow execution, and TRS for containerized tool discovery. Security is strengthened using GA4GH Passports and Attested TLS for zero-trust, identity-aware communication, while Model Context Protocol (MCP) is introduced to enforce privacy constraints and execution policies across federated nodes. The deliverables include a refactored FLAN pipeline with DRS-based data access, modular training workflows executed via TES, end-to-end orchestration using WES (CWL/WDL/Nextflow), containerized environments registered with TRS, integrated Passport-based authentication and Attested TLS communication, a prototype MCP-based policy enforcement layer, and comprehensive documentation with a GA4GH-compliant reference implementation.