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.
<p>The proposal is on implementing the SCIM 2.0 compliance test suite which can be run on both the cloud and on premise by eliminating the limitations that can be seen in SCIM 1.1 compliance test suite. In the proposed test suite, it is expected to validate the supportability of a provided service provider, in terms of the SCIM 2.0 core specification and protocol specification.</p> <p>The test suite should be able to generate a detailed analysis view and comprehensive report upon providing the server’s SCIM endpoint. The report should include the test results indicating the coverage percentage of each specification and a detailed view of the results of each test including requests sent by the test suite, expected response and the server response along with the indication whether a particular test is passed or not.</p> <p>Apart from that the test suite should be run against WSO2 Identity Server to identify any gaps between the SCIM 2.0 specifications and Identity Server and provide improvements to the product.</p>
Multivariate data visualization is useful when grappling with correlated data that naturally arises in a number of scientific fields, such as polarization microscopy, hyperspectral astronomy, various X-ray imaging techniques, geographical data, etc. While specialized and/or commercial tools exist in some of these disciplines, implementing support for multivariate color mapping in matplotlib would provide a unified framework and expand access across the various use cases. This feature has been proposed multiple times, but implementation is non-trivial as it affects the low-level classes that handle data normalization. A discussion on GitHub led me to develop a solution where the class ScalarMappable is replaced by VectorMappable. I have already demonstrated the feasibility of this approach, and developed a working implementation, including a test suite for the new functionality. This project aims to finish this implementation by creating tutorials, examples, and presenting color maps for various use cases. Additionally, tests, docstrings, variable names, and code organization must be updated to conform to the quality standards of matplotlib.
This project comprises two parts: prototyping a real-time Python pipeline for object detection on point cloud data, and integrating it into LivePose. The goal is to build a functional pipeline that reads streaming point cloud data from various sources (e.g., Orbbec Femto Megas, Intel RealSense, stereo cameras), runs deep learning inference using models like PointNet++, applies filters for smoothing and tracking, and streams the results via OSC. During prototyping, the system will be evaluated across multiple models, input types, and hardware configurations to assess real-time performance and reliability. Once validated, the pipeline will be integrated into LivePose, leveraging its modular infrastructure for input handling, filtering, and output. By the end of the project, LivePose will support end-to-end processing of streaming 3D point cloud data in at least one working configuration, with clear documentation and performance benchmarks to guide future development and extension.
<p>Hasktorch has two distinct APIs for tensors: Torch.Tensor and Torch.Tensor.Typed. While the untyped version can initially be easier to use and experiment with, the typed version offers static analysis of tensor’s shape, layout, precision, and compute device. The typed version not only helps with debugging and maintainability but also offers better support for type-driven development via GHC features like type holes. However, it is currently difficult to mix the two approaches, e.g., statically specifying tensor’s embedding size while keeping other dimensions unchecked is not possible. Gradual typing is the proposed solution that fuses the two APIs by adding Torch.GraduallyTyped type. The new API allows for more granular control by letting the user choose which properties of the tensor should be given a static type. The goal of the project is to bring maturity to the gradually typed tensor API, add missing features, and experiment with new ideas.</p>
Create a set of automated tasks to install services on a Raspberry Pi to meet the needs of small community-network with an administration/tech team, e.g. a set of commonly needed monitoring tools, such as Prometheus, Prometheus-node-exporter, Blackbox-exporter, Altermanager, Grafana, VPN and an editing map service. Create a set of tasks to replicate the OpenWrt build-system, to provide a reproducible and automated set of instructions, to speed-up the process of self-building images for OpenWrt and/or LibreMesh for newcomers, and to easily setup a dedicated machine. These Ansible roles would include tasks to build for: different architecture and targets, different Openwrt and Libremesh versions, keeping trace of devices with specific packages or particular needs and related patches; keeping a local list of supported targets. With the possibility to later extend the process of build to other automated tasks, like a pub-keys-exchange needed for configuring a VPN, update documentations, or to update the configurations of monitoring services.
This proposal outlines modernization of Pygoat, focusing on scalability and a future-proof curriculum. The top priority is a complete structural and gamified overhaul, featuring a dynamic scoring system and a lab list updated for OWASP Top 10:2026. This is supported by a new Core API Gateway and a Dynamic Admin Control Center, which together allow for seamless, real-time monitoring of dockerized labs and centralized management of user data and security categories. A key innovation is the Plugin-Based Custom Lab Loader, allowing the community to integrate their own labs via a standardized labs.json format. To ensure long-term accessibility, the project includes a Tailwind CSS UI migration, automated CI/CD pipelines for multi-platform Docker builds, and a comprehensive MkDocs documentation hub. By bridging the gap between exploiting a vulnerability and implementing secure coding practices, these features provide a structured, professional, and engaging learning path for the new security developers.
<p>I aim to improve the existing diff handling capability of coala so that it is possible for bears to offer multiple fixes for an issue. I also plan to implement interactive diff behavior where the user input is used to generate interactive diffs using appropriate placeholders in the code. For achieving this I plan to have a generic approach for bears to pass their own applicable actions which can then be used to write a generic bear which can offer multiple patches. This can be followed by Implementation for templated patches and interactive diff behavior along with writing tests supporting these new functionalities. Finally thorough testing and exception handling should be done to fix bugs and designing alternate approaches if necessary(e.g. resolve conflicts of multiple bears on a single issue by git like conflict markers through IDE). I would be updating the documentation throughout the project. An optional task would be implementing output formats for the enhanced features and their processing functions being implemented in the Linter class if time permits.</p>
BLT University is an interactive security learning platform built on top of OWASP BLT that transforms existing labs into hands-on, code-driven exercises. It migrates the current Django-based labs into a static Jekyll system where content is stored and rendered as Markdown, making it more scalable and easier to maintain. Instead of static, theory-heavy content, users work directly with vulnerable code through a structured Identify → Explain → Fix workflow to understand how vulnerabilities appear and how to fix them in practice. The project also includes GitHub Actions workflows for validation and syncing, along with a security intelligence pipeline that analyzes GitHub issues, pull requests, and review comments to identify recurring vulnerability patterns. These insights power a dashboard and a recommendation system, helping connect real-world security issues with relevant labs and improve hands-on learning for contributors. It aims to help contributors build a practical security mindset while improving the quality of open-source contributions.
The Android build ecosystem includes a robust linting tool designed to detect Android-specific issues that general-purpose linters may overlook. Currently, Android Lint is not integrated into Oppia's Bazel-based build system. This project aims to bridge that gap by introducing a custom linting script that runs Android Lint independently of Gradle, with support for configurable exemptions via textproto files—ensuring alignment with Oppia’s existing scripting infrastructure. The project will proceed in two phases. The first will establish a foundational script that interfaces with Android Lint, handles exemption logic, and integrates with continuous integration workflows. The second will focus on resolving high-priority lint issues to improve overall code quality. The completed project will deliver a scalable and maintainable Android linting workflow tailored to the Bazel environment, enhancing code quality and developer productivity across the Oppia Android codebase.
Rate limiting is a technique used by computer systems to control the rate of traffic sent or received by a particular entity (such as an application or a user). The goal of rate limiting is to prevent a single entity from overwhelming the system with too many requests at once causing resource exhaustion, security vulnerabilities, API abuse, and unpredictable behavior. The objective is to develop a plugin for Coraza WAF which prevents ‘rate-based attacks’ and provides more security and stability to the applications behind the wall. In brief, this is to be accomplished by creating a new directive `SecRateLimitOptions` for specifying the rate limit options(no. of requests allowed per minute, the algorithm used, when to clear rate limit, default action if rate limit exceeds) and a new non-disruptive action `rate limit` which enforces rate-limit on the matching chains of SecRule. A more detailed explanation can be found in the proposal PDF. The set of deliverables, in the end, would be the plugin itself, support for distributed systems, and well-written documentation with examples, benchmarks, and recommended settings.
The project aims to improve the quantum circuit visualization capabilities of QuTiP-QIP by introducing a new framework for circuit rendering that doesn't rely on external dependencies. Presently, circuit visualization relies on LaTeX and ImageMagick, which can be problematic for users. This solution plans to create two rendering modules: one utilizing matplotlib for visually appealing and precise quantum circuit diagrams, and another ASCII text-based rendering. The matplotlib renderer will also support generating circuit visualizations within IPython environments like Jupyter Notebook, while the text-based renderer will cater to command-line interactions. Apart from the rendering modules a Circuit Renderer Selector will also be included in the project deliverables, enabling users to easily choose their preferred rendering method among LaTeX, Matplotlib, or Text-Based options. These tools will enable users to visualize quantum circuits more efficiently and effectively, making it easier to work with QuTiP.
This project aims to ease the transition and implementation of Posits, an alternative numerical representation, for RISC-V systems. By creating a robust hardware abstraction layer (HAL), developers need not know if the target RISC-V platform has a hardware Posits implementation or requires a software implementation. This new POSIX-compliant C++ library (with ports planned eventually) will help make available the option to transition between IEEE Float / Doubles to Posits and should make the machine-specific selection and configuration seamless. The lack of such a HAL is a roadblock in Posit adoption and Posits represent a serious opportunity for free and open source silicon (FOSSi) systems. Initial focus will be directed toward HPC support, where numerical computation efficiency may be best observed. Additionally, we will be conducting benchmarking studies to evaluate the performance of the HAL, identifying bottlenecks, and iterating on the design based on empirical data. The testing framework will also be part of the mentee's deliverables.
Specialization is a compiler transformation that optimizes generic program code such that code using primitive types can execute without significant overhead. The @specialized annotation in the Scala 2 programming language allowed programmers to direct the compiler to create optimized generic data structures for each primitive type. @specialized is used significantly in the implementation of high-performance Scala 2 libraries, allowing for performance without the productivity of generics. This optimization trades performance at the cost of extra space, as generic code must be specialized for each of the primitive types, scaling exponentially on the number of type parameters. Since the Scala 3 programming language has evolved significantly from Scala 2, the @specialized annotation is no longer available. This proposal will prototype a new scheme of specialization for the Scala 3 compiler based on inline traits that avoids the performance pitfalls of the Scala 2 implementation, enabling the evolution of many high-performance Scala 2 libraries into Scala 3.
<p>The VideoLAN organisation has transformed the digital audio and media space since its inception over 10 years ago. The ease of use of its forerunning product, VLC Media Player, has made it the number one choice for millions of users around the world for viewing and interacting with media. Yet, despite this VLC Media Player’s design is relatively outdated. Features should be readily obvious to users, not hidden in multiple menus so that they can be accessed quickly and easily.</p> <p>As an avid VLC Media Player fan, this forms the motivation behind my proposal. I propose to update VLC Media Player by leveraging Qt/QML to design a more modern and elegant interface. Specifically, I plan to redesign and implement a new welcome screen which is visible upon first opening of VLC Media Player. This includes the relevant Privacy and Metadata Consent passages for users as well as the ability to alter some commonly changed settings through an easily accessible modal.</p>
F4PGA is an open-source FPGA toolchain designed as a free alternative to proprietary computer-aided design tools like Xilinx’s Vivado. Currently, mapping designs to DSP blocks and generating DSP block bitstreams are not implemented for the Xilinx 7-series FPGA devices within the toolchain. This project aims to integrate DSP48E hard block in F4PGA. This will enable designs using DSPs to be synthesized, placed, and routed correctly. We need to diagnose and implement required changes throughout the F4PGA toolchain, allowing for DSP design bitstreams to be successfully generated with open-source tools. Deliverables: 1. Support for DSP48E within the F4PGA architecture definitions. 2. Testing flow for designs using Xilinx 7-series DSP hard blocks which include Verilog-to-Bitstream using the F4PGA toolchain, Fasm2bels to re-generate the original netlist from the bitstream output of F4PGA and Proof-test through Vivado to verify the correctness of the netlist.
The IfcOpenShell library lacks a stable C API, which currently limits interoperability with other programming languages and makes its higher-level APIs largely accessible only through Python. Its existing WebAssembly support also depends on Pyodide, resulting in unnecessarily bloated binaries, slow initialization, and reduced runtime performance in browsers. This proposal aims to address these architectural limitations by introducing a first-class C API for IfcOpenShell, enabling more maintainable cross-language bindings and a stronger foundation for native WASM builds. The project will replace the current Pyodide-based approach with a direct C++ to WASM build, and will migrate the Python bindings away from SWIG to generated bindings built on top of the new C API. It will establish autogenerated TypeScript bindings and an ergonomic web-facing API, while incrementally moving important high-level Python APIs into the C++ core so that they become available consistently across Python, WASM, and future language bindings.
This project aims to transform how analysts interact with threat intelligence data in IntelOwl by introducing a conversational AI interface. Currently, analysts must manually navigate dashboards, query APIs, and correlate results across different jobs and investigations. To solve this, I will integrate a privacy-preserving, self-hosted LLM chatbot using Ollama and a LangChain ReAct agent. The agent will be equipped with custom tools to query IntelOwl's internal REST API using natural language. Key deliverables include: 1) A new Django chatbot app handling WebSocket connections via Django Channels for real-time token streaming. 2) Ollama Docker integration with CPU/GPU auto-detection. 3) A native React chat component embedded in the existing frontend. 4) Custom LLM tools for triggering analyses and searching data models. 5) Comprehensive test coverage and detailed documentation for users and future maintainers.
<p>DHIS is one of the most popular open source health management information system/framework used by over 47 countries in the world including Sri Lanka. It has two basic architectures embedded in it, mainly the aggregation and tracking. The main functionality of tracker capture app of DHIS2 is to collect and analyze the patient based (individually identifiable) statistical data.</p> <p>Longitudinal Analysis is an important statistical and public health approach where data gathered over a period of time is visualized for temporal trends. Hence, the gathered data can be analyzed to make conclusions about the behaviour of the tracked subject over a long period, giving accurate picture than a cross sectional visualization. Graphical visualization of analyzed data is widely used technique in longitudinal analysis to make it easier to understand the trends and study the patterns and behaviours of the subject at a single glance.</p> <p>The goal of this project is to add dynamic longitudinal charting support for DHIS - tracker capture app.</p>
<p>The project goal is to establish a test infrastructure which supports unit testing, UI testing and Integration testing. Unit tests and UI tests will be written for the android project to test the new features and code changes done in the project before getting merged in the main repository. The goal is to confirm that no new code gets merged unless it passes all the tests that will be run at build time i.e. the new code works as designed and does not cause any regression issues by breaking other functionality/tests. The test infrastructure will be designed in a way that it will tell the developer what method or function or Which piece of code is causing the error or tests to fail. So It will be easy to find which portion of code is causing an error and the developer can fix that. Proper test automation consists of the generation of test coverage reports as it helps in identifying the areas of missing test coverage. So the generation of test reports using Codecov is also an important goal of this project.</p>
The Human Neocortical Neurosolver (HNN) is an open-source neural modeling tool designed to help researchers and clinicians interpret human brain imaging data. Currently, HNN primarily focuses on simulating neural activity within single neocortical columns. This project aims to extend HNN's capabilities by developing a Python API that facilitates multi-network simulations, enabling the modeling of interactions between multiple neocortical networks. This enhancement will provide neuroscientists with a more comprehensive tool to study complex brain interactions and better understand the neural mechanisms underlying MEG/EEG data. The project will involve designing and implementing the API, developing comprehensive documentation and tutorials, ensuring compatibility with existing HNN functionalities, and conducting validation tests to verify the accuracy and reliability of multi-network simulations. By expanding HNN's capabilities, this project will support a broader range of research applications, fostering innovation and collaboration within the neuroscience community
This project aims to enhance RUXAILAB, an open-source platform for usability evaluation, by integrating three key components: eye tracking, sentiment analysis, and pre/post form tasks. These additions will support real-time, data-rich user testing and improve the understanding of user behavior and emotional responses. We will embed affordable eye tracking to visualize attention (e.g., heatmaps, gaze paths), implement multimodal sentiment analysis using facial expression recognition and NLP, and enable customizable pre/post-test forms to evaluate usability (e.g., SUS, NASA-TLX) and cognitive load. Built with a user-centered, modular, and API-first approach, the project will also define evaluation protocols, publish open datasets, and validate the system with real users. The outcome will be a comprehensive, extensible, and community-driven tool for empirical UX research, bridging qualitative and quantitative insights.
<p>To provide strict serializable isolation among transactions, PostgreSQL needs to track read-write conflicts (rw-conflicts for short in the following context) executed concurrently at runtime. PostgreSQL uses a double-linked list in the shared memory to record all conflicts of each transaction. Based on the list structure, the rw-conflict tracking has a time complexity of O(N^2). The designer assumed that the list is short so that the overhead can be ignored. However, some benchmarks reported that the conflict-tracking took up to half the CPU time at high concurrency levels, where searching the list becomes a bottleneck. There are five static functions existing in the project to manage the rw-conflicts. We intend to rewrite these functions by replacing linked list with other data structures to support faster search. There are two possible replacements. Hash table is the first choice because there is an existing implementation of hash table (HTAB) in shared memory in PostgreSQL. Skip list is the other choice as it is similar to the linked list.</p>
The Zulip community has been actively requesting improvements to video call functionality and Atlassian integrations, and addressing this cluster of features would meaningfully expand Zulip's appeal for organizations that depend on these tools. On the video call side, I will implement a Google Meet provider, help take a native LiveKit integration prototype to a mergeable state, build a cold-call ringing experience and add support for multiple simultaneous video call providers per organisation. On the Atlassian side, I will implement a bidirectional Jira integration extending the existing webhook with richer filterable notifications and outbound actions (comment, assign, change priority) directly from Zulip, and a new Confluence incoming webhook integration covering the full page and blog lifecycle. All deliverables include full test coverage, API documentation, changelog entries, and help center articles. The work builds directly on my existing merged and open PRs in Zulip's video call and Atlassian integration areas.
The opportunity to assist Mifos achieve its goal of "Ending Poverty One Line of Code at a Time," excites me. Working on bank statement analysis (AI) is something I would like to contribute to. I want to join this mission in order to learn more about different financial phenomena, actively participate in interdisciplinary collaboration, and utilize Mifos tools and support. Through my involvement, I hope to solve current difficulties in the rapidly developing financial digital environments and significantly advance the field of financial research. The goal, which I wish to participate in, is to bridge the gap between theory and practice in the financial sector and to optimize implementations using AI. I've always wanted to work in the field of financial technology more thoroughly because I have done a lot of research in the past. I became enthralled with it since I could understand a lot of it. In this project, I'll utilize decision trees and natural language processing (NLP) to classify different expenditures and credits on bank statements. This would be created as a Fineract add-on module that uses data tables to link the analysis of bank statements to the records in Fineract.