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.
DigiKam’s Advanced Search is powerful, but translating a natural-language request into the right combination of structured filters can be difficult for many users. This project will add a natural-language input to digiKam’s Advanced Search so users can describe queries such as “landscape photos with red labels taken in Paris last summer,” which will then be converted into editable search criteria such as tags, labels, dates, and locations. The implementation will use a lightweight local language model, structured intent parsing, capability-based resolution into supported digiKam search fields, ambiguity handling for unclear terms, and caching for repeated queries, while reusing digiKam’s existing model-management infrastructure. The deliverables include the Advanced Search UI integration, the local inference and parsing pipeline, criteria resolution and validation, safe clarification behavior, and end-to-end integration with digiKam’s existing Advanced Search workflow.
This project aims to extend API Dash by adding support for WebSocket, MQTT, and gRPC, enabling developers to work with multiple modern communication protocols within a single tool. It will introduce a modular, protocol-agnostic architecture along with intuitive UI components for real-time and streaming workflows. Additionally, a CLI will be developed to support headless usage . The focus will be on performance, usability, and seamless integration with the existing API Dash ecosystem.
This project aims to improve the handling of transposed diffuse irradiance and optical loss modeling in the pvlib-python package. Currently, pvlib’s transposition models provide inconsistent output, with some providing only total sky diffuse radiation (e.g. isotropic), while others allow for outputting the isotropic, circumsolar, and horizon components. Due to this, the ModelChain workflow only allows users to define a single angle of incidence (AOI) model, and then applies the resulting incident angle modifier (IAM) to total irradiance, limiting physical accuracy. The proposed GSoC project will start by standardizing the outputs of diffuse transposition models already implemented in pvlib, introducing a consistent interface to return circumsolar, isotropic, and horizon components. Building on this, the project will extend ModelChain to support component-specific IAM calculations, enabling more accurate modeling of optical losses by distinguishing between direct and diffuse contributions. These enhancements will improve both the flexibility and accuracy of pvlib simulations while maintaining full backward compatibility. The project will include comprehensive testing and documentation to ensure reliability and ease of use.
Hundreds of BSM Lagrangians have been proposed in the literature, but translating them into validated FeynRules .fr model files is still a manual, time-consuming process. This project builds an agentic system inside the HEPTAPOD framework that automates this workflow. Given a BSM scenario description, the agent searches INSPIRE and arXiv, extracts Lagrangian terms into a typed schema, generates a syntactically correct .fr file using deterministic Jinja2 templates, and validates the output through HEPTAPOD’s FeynRulesToUFOTool and a downstream MadGraph smoke test. Every literature source, extraction decision, and validation outcome is recorded in an audit trail.
This project makes the ENTS (DirtViz) dashboard easier to grow with real field use. A lot of the UI is still wired together by hand in React, which gets painful when new sensors show up or when people want different views of the same data. The plan is to expose what can actually be plotted using live database information, mainly from the sensor table, so the app lists available sensor names, measurements, and units per cell instead of maintaining long static lists in the frontend. Power and TEROS data may still live on older storage paths for a while, so the catalog will need a clear, documented way to bridge those sources until everything lines up on one model. The headline user feature is a drag and drop dashboard: reorder panels, add or remove them, and keep layout in the URL so someone can share a view with a link. Saving layouts on the server can come later, once the client side layout behavior is solid and easy to reason about. For people comparing multiple cells, the work should also make loads feel snappier by avoiding strictly one after another requests where batching or parallel loads make sense, and by ignoring out of date responses when the selection or date range changes mid flight. After that foundation, there is room for equations for derived metrics with tight server side validation, plus CSV export of what is already on screen. Fancy per panel styling is a lower priority and might stay minimal. Overall this is steady refactoring of the existing Flask and React stack, not a from scratch rewrite, so current APIs stay stable unless an extension is clearly worth it.
B0Bot is currently a monolithic Flask application relying on synchronous, manual data ingestion and a single-pass LLM pipeline to retrieve cybersecurity articles. This current architecture creates significant bottlenecks: it requires manual scripts to update knowledge bases, scales poorly under heavy loads, lacks advanced reasoning capabilities, and delivers a generic "one-size-fits-all" news feed that ignores individual user preferences and behaviors.
The OWASP Web Application Honeypot is the only open community project focused on the HTTP application layer, but it currently sits as a dormant proof-of-concept with an outdated logging format, no fingerprint detection, and no path to push threat data into community platforms like MISP. This proposal evolves it into a production-ready, adaptive, and intelligence-grade platform. The solution is built around 8 interconnected deliverables: 1. Versioned JSON logging schema (v1.0) with GeoIP2 and MITRE ATT&CK enrichment 2. Automated CRS version management via nightly GitHub Actions 3. CRS 4.x honeytrap plugin with hot-reload daemon (no container restart required) 4. Shodan Honeyscore-triggered chameleon engine for automatic persona rotation 5. Vulnerable application fingerprint library with 4 personas (Apache, IIS, phpMyAdmin, WordPress) 6. Multi-region AWS deployment framework using Terraform with centralised Kibana 7. MISP and STIX 2.1 threat intelligence exporters with optional TAXII push 8. Industry segment profiles for education, financial, and general deployments switchable via a single environment variable Each deliverable has measurable success criteria and risk mitigation. Built on prior production work in DICOMHawk, GreedyBear, and IntelOwl where identical problems were already solved. Total effort is 350 hours across 13 weeks.
OmegaUp has around 40 MySQL queries that do full table scans making pages slow for students and teachers. The CI pipeline detects them but never fails the build so they go unnoticed. I will optimize these queries by adding indexes and rewriting them in the DAO layer, make CI block new inefficient queries using an allowlist system, and add a performance benchmark to catch slow queries before they reach production. The goal is to make omegaUp faster today and prevent regressions in the future.
The ATLAS Tile Calorimeter (TileCal) currently reconstructs energy using a linear signal-processing method. For the Phase-II HL-LHC upgrade, readout will move to a 9-sample sliding window, where this approach becomes less reliable because many proton-proton collisions overlap in time. This project develops compact neural networks (MLPs and 1D-CNNs) that improve energy reconstruction while remaining small enough for real-time FPGA deployment. The approach combines a floating-point teacher CNN trained offline, knowledge distillation into a compact student model, quantization-aware training with 1-8 bit mixed precision, and magnitude pruning, targeting a strict 225 ns algorithmic latency within the 1.7 μs TilePPr budget. Deliverables include reproduced linear baselines on Phase-II simulation data, a trained teacher CNN with benchmarked energy resolution, a distilled and quantized student model, a prototype offline reconstruction integration, and a full FPGA synthesis report with latency and resource usage on a Xilinx Ultrascale+ target device.
I am C Innocent Pious, a final-year B.Tech Computer Science student from Chennai with hands-on experience in the colcon mixin codebase. Prior to this proposal, I identified and fixed a multi-year bug in multi-mixin argument merging (Issue #40, PR #59), adding six regression tests with all tests passing. This project introduces mixin composition to colcon mixin, allowing a mixin to declare dependencies on other mixins via a "mixin" key. These dependencies will be resolved automatically using a dependency graph, topological ordering, and cycle detection, eliminating the need for users to manually specify transitive dependencies in every colcon invocation. The deliverables include a dependency resolution system, cycle-safe ordering mechanism, well-defined argument merge semantics, comprehensive test coverage, and updated documentation integrated into the upstream repository.
PSLab Mini is a compact, open source instrumentation platform built around the STM32H563 as its primary microcontroller and the ESP32-C3 as its wireless co-processor. While the board already supports oscilloscope and multimeter functionality over USB using an SCPI based interface, key features such as the logic analyzer, waveform generator and wireless connectivity remain unimplemented. This project aims to complete these missing components. A logic analyzer will be implemented using STM32 timer input capture combined with DMA driven circular buffering to enable efficient, high speed signal acquisition. Digital waveform generation will be developed using STM32 timers configured in PWM and output compare modes, supporting configurable frequency and duty cycle outputs. To enable wireless communication, a reliable STM32 to ESP32 bridge will be implemented using SPI as the primary data channel and UART as a secondary interface. A lightweight framed binary protocol will be developed to ensure robust communication between the microcontrollers. On the ESP32 side, MQTT based communication will be implemented to publish instrument data over Wi-Fi, with support for Home Assistant discovery.
Checkstyle plays an important role in maintaining code quality in Java projects, but many of its reported violations are small, repetitive issues that developers tend to overlook. Although these problems are easy to fix, the effort required to manually locate and resolve each one discourages developers from addressing them, resulting in inconsistent code quality and growing technical debt. This project focuses on reducing that manual overhead by extending Checkstyle’s auto-fix capabilities using OpenRewrite. The main objective is to develop auto-fix recipes targeting frequently occurring Checkstyle violations. These recipes will automatically apply safe and consistent transformations to the codebase, allowing developers to resolve issues quickly and at scale. Beyond adding new recipes, the project will improve the internal design of the auto-fix system by transitioning from a position-based approach to a marker-based approach. The current method relies heavily on fixed code positions, which can become unreliable when the code structure changes. A marker-based strategy, on the other hand, enables more stable and context-aware transformations, making the system easier to maintain and extend. All implemented recipes will follow consistent design principles, include proper test coverage, and be validated on real-world open-source projects to ensure their correctness and effectiveness in practical scenarios. Overall, this project aims to streamline the process of fixing style violations, improve developer efficiency, and strengthen Checkstyle’s ecosystem by making automated code corrections more reliable and scalable.
KFP and Katib users deploying via Helm currently have no upstream-supported path — charts exist but drift from Kustomize baselines silently, with no parity validation or explicit support boundaries. I've spent the last few months contributing to kubeflow/manifests (12 merged PRs) and reading through the maintainer feedback on PR #3237 closely enough to understand exactly what the constraints are. Before writing this proposal I built a PoC branch that gets all 9 scenarios (2 KFP + 7 Katib) to 0% parity diff against the upstream Kustomize baselines, traced and fixed each failure class, and ran runtime smoke tests on Kind. The goal is to upstream that work properly — charts, CI, documentation, and a support matrix that makes the supported/deferred boundary explicit. I also added two things that came out of building the PoC: a scheduled drift detection workflow and a schema validation gate using helm lint + kubeconform, both already implemented and validated.
Users who want to understand how the AFS cache manager resolves each element of a path (plain directory, mount point, or symlink) must manually run fs examine and fs lsmount on each component separately, or write wrapper scripts. This project implements a new fs pathinfo subcommand in C that walks a given path, iteratively resolves each prefix using the existing pioctl interface (VIOC_AFS_STAT_MT_PT, VIOC_FILE_CELL_INFO, lstat), and reports the type of each component in a human-readable format consistent with existing fs output. Deliverables include: the subcommand implementation integrated into src/venus/fs.c, support for both relative and absolute paths, a -verbose flag, a fs_pathinfo(1) man page in POD format, and a regression test suite covering all major path resolution scenarios.
MUIOGO is an existing Flask and JavaScript application that provides a browser-based interface for running CLEWS energy-environment models. This project extends it in four directions. 1) Cross-platform hardening: fixing path assumptions, making configuration runtime-configurable, and setting up CI on macOS, Ubuntu, and Windows. 2) Building a full OG-Core UI module with parameter input forms, scenario management, run execution, and interactive Plotly results visualization, so that OG-Core has the same level of browser-based support that CLEWS currently has. 3) A coupled mode interface providing a guided workflow where one model's outputs feed into the other, with validation, multi-stage progress tracking, and combined results display. 4) A converging mode interface enabling iterative execution of both models until results stabilize, with live convergence charts, configurable tolerance, and early stopping. The project concludes with PyInstaller packaging for all three platforms, an automated GitHub Actions release pipeline, and user and developer documentation. Deliverables include a CI pipeline on three operating systems, working OG-Core standalone workflows, coupled and converging execution UIs, downloadable platform-specific installers, and complete documentation.
The objective of this project is to significantly enhance the reliability, user experience, and maintainability of the Badge Magic application. To achieve this, I will systematically resolve core Bluetooth transfer errors and animation rendering bugs, ensuring stable communication between the app and the LED hardware. Furthermore, I will streamline the user workflow by upgrading the animation preview and introducing intuitive features for managing, loading, and sharing custom designs. Finally, to secure the project's long-term health, I will integrate structured logging and error tracking for rapid debugging, alongside a fully automated CI/CD pipeline to guarantee reliable app store releases.
The sbi (Simulation-Based Inference) library currently constructs neural density estimators via opaque factory functions that accept loose keyword arguments. This design leads to delayed validation errors crashing deep inside PyTorch rather than at configuration, tangles data preprocessing (Z-scoring) with model architecture, and prevents experiment configurations from being serialized, making reproducibility difficult for researchers. This project will refactor the neural network builder infrastructure into a modular, three-tier Layered API. By transitioning to strongly-typed Python dataclasses, the new API will introduce DensityEstimatorBuilder for fail-fast validation and a fully decoupled ZScoreConfig to isolate data standardization. This object-oriented approach ensures that invalid configurations are caught immediately and allows architectures to be easily inspected and saved.
Problem: gprMax's devel branch GPU solver (cuda_opencl/ directory) supports CUDA, OpenCL, and Metal via shared kernel templates. But the Plane Wave (TF/SF) source from GSoC 2023 remains CPU-only Cython, forcing CPU-GPU transfers every timestep that negate GPU speedup. solution: I will create new kernel templates in cuda_opencl/ following the existing multi-backend pattern: 1) Create knl_planewave_updates.py: batched kernel updating all six 1D DPW auxiliary arrays in one launch. 2) Create knl_tfsf_injection.py: TF/SF correction injection at six boundary faces, coalescing optimized per-face with shared memory buffers. 3) Optimize boundary storage: SoA layout, 128-byte padding, precomputed index maps. 4) Testing suite: GPU vs Cython comparison across free-space, slab, oblique, and polarization cases. Why me : I built a PyCUDA heat diffusion solver with shared memory tiling, vectorized loads, and occupancy tuning, the same techniques this project needs. I have raised 8+ issues and multiple PRs to gprMax and studied all 13 files in cuda_opencl/ in depth. Deliverables: multi-backend GPU kernels for DPW update and TF/SF injection, optimized memory layout, and automated testing suite. Outcome: TF/SF runs entirely on GPU, zero CPU fallback.
Music Blocks v4 has a modular architecture with a block editor, compiler, and execution engine built separately but not yet connected. This project integrates the Masonry visual block editor into the main application, implements block snapping and connection logic so users can build structured programs, and wires the full execution pipeline (blocks to AST to IR to output) so programs produce real music and graphics. Core deliverables: (1) Masonry module integration with palette and workspace (2) snap-based block connections with visual feedback enforcing programming semantics (3) end-to-end execution connecting blocks to the Painter and Singer modules via a real function registry. Stretch goals include inline block editing and workspace zoom/pan/undo.
This project focuses on improving the CircuitVerse simulator experience by targeting four major tasks: - Having a separate simulator-<version>.js and simulator-embed-<version>.js as separate output files. - Integrating simulator session with rails session - Implementing authentication mechanism for desktop version which is built using Tauri - Addition of the new circuit debugging suite
LFortran's MLIR(Multi-Level Intermediate Representation) backend executes fortran code via LLVM dialect of MLIR, but requires major refactoring with every new MLIR version. This is because it calls unstable MLIR C++ APIs directly, which gets changed with MLIR version changes. This project focuses on finding the right design to solve this problem. Multiple approaches will be studied and compared including studying projects which support MLIR to identify the most stable and maintainable architecture. The best design will then be implemented and validated. The deliverable is a redesigned MLIR backend that is stable across MLIR versions, requiring minimal refactoring for adding support for newer versions in future.
OWTF's proxy silently drops every HTTPS transaction, blocks the entire event loop during live interception, and is written in deprecated Tornado coroutine syntax that prevents proper asyncio integration. I plan to fix this by rewriting the proxy core to use async/await throughout, replacing the threading-based CONNECT tunnel with a proper asyncio-native forwarding pipeline, and routing decrypted HTTPS traffic through the same CacheHandler and TransactionLogger chain that HTTP already uses. The result will be a proxy that records all traffic (HTTP and HTTPS), supports request and response modification hooks for both protocols, and does not freeze under concurrent load. Deliverables: async/await rewrite of proxy.py and main.py, working HTTPS transaction recording with PostgreSQL entries, fixed interceptor hook pipeline applying to both protocols, binary response handling using a bytes buffer instead of string accumulation, in-memory LRU cert caching, upstream cert CN/SAN mirroring, and functional tests covering each of these.
CircuitVerse provides a powerful digital logic simulator, but its classroom workflow lacks critical features required for effective teaching at scale. Currently, instructors cannot organize students into structured teams, assign collaborative work, reuse pre-built circuit templates, or rely on modern LMS integrations due to outdated LTI 1.1 support. These limitations lead to inefficient grading, repeated manual setup, and poor integration with platforms like Canvas. This project aims to enhance CircuitVerse’s classroom ecosystem by introducing four key improvements. First, a subgroup system will enable instructors to divide students into teams with defined roles, supporting structured collaboration. Second, group-based assignment workflows will allow submissions on behalf of a team, ensuring consistent grading and reducing redundancy. Third, a circuit template library with integrated test cases will enable reusable, pre-configured assignments and automated grading using a simulation-based evaluation pipeline. Finally, the project will upgrade LMS integration by implementing LTI 1.3 using OpenID Connect and OAuth 2.0, enabling secure authentication, deep linking, and modern grade passback via Assignment and Grade Services (AGS). The deliverables include: A fully functional subgroup and team management system with API support Group assignment workflows with submit-on-behalf functionality A template library with auto-grading using simulation-based test cases Complete LTI 1.3 integration including OIDC login, deep linking, AGS score submission, and NRPS roster access Comprehensive RSpec test coverage and documentation By addressing these gaps, this project will transform CircuitVerse into a scalable, LMS-integrated teaching platform capable of supporting modern classroom workflows and institutional requirements
According to the Google Summer of Code (GSoC) project ideas listed for One proposed DeepChem project involves adding support for the OLMo Large Language Model (LLM) family to the DeepChem repository using the Hugging Face Model wrapper. The goal of this project is to enable DeepChem users to perform tasks such as text generation, classification, and continued pretraining with large language models, including Open Language Model (OLMo). I have already contributed several improvements to DeepChem’s HuggingFaceModel integration, including improving typing and validation for the fill mask method and implementing a new generate() function that wraps HuggingFace’s text generation API. I have also already demonstrated partial compatibility with OLMo models through recent contributions to the generate() function and example scripts using allenai/OLMo-1B-hf. I have also added support for causal language modeling in the HuggingFaceModel wrapper, including integration with AutoModelForCausalLM and end-to-end validation through unit tests. My contributions demonstrate familiarity with the DeepChem codebase and provide the foundation for extending DeepChem to support large language models such as OLMo.