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.
This project aims to improve and evaluate symbolic regression methods for discovering interpretable mathematical models of biological network dynamics. A key challenge in this area is that, when working with real biological data, the true underlying equations are unknown, making it difficult to assess whether equation-discovery algorithms are accurate or biologically meaningful. To address this, I will generate synthetic time-series datasets from curated mechanistic models available in the BioModels database (e.g., SBML models), where the ground-truth equations are known. These datasets will be used to systematically evaluate and benchmark symbolic regression approaches, including PySR and neural-symbolic methods such as the Learning Law of Changes (LLC) framework. The project will also explore strategies to improve model identifiability and interpretability, including constrained search spaces and incorporation of biologically informed functional priors. The expected deliverables include: (1) a reproducible pipeline to generate simulation data from SBML models, (2) an evaluation framework to benchmark symbolic regression methods on equation recovery tasks, (3) implementation and comparison of PySR and LLC-based approaches, (4) strategies to address identifiability challenges in biological data, and (5) well-documented, open-source code integrated with existing SBML compatible tools.
Agentic AI is commonly used to predict and resolve problems before they occur, requiring access to data in near real-time. However, traditional patterns for reacting to data changes come with major disadvantages, exacerbating the challenge of building resilient, near real-time distributed systems. These patterns include polling, which is simple to implement but has a fundamental tradeoff between minimizing load on data sources and minimizing data staleness. Change data capture (CDC) avoids the aforementioned issues, but requires teams to build and maintain custom infrastructure. Using Drasi’s ability to track derived entities (via Continuous Queries) and Dapr Agents’ out-of-the-box durability for agents and agentic workflows, this proposed integration would help developers build scalable, event-driven AI systems in products and internal platforms. To accomplish this, Drasi would need a new ”proxy” service that routes events to multiple publish-subscribe (pub/sub) topics. Dapr workflows and agents would consume from these topics via workflow decorator functions and agent middleware, supporting Drasi and providing the groundwork to integrate other backends.
The goal of this project (Enext) is to unify and modernize the eventyay-tickets architecture, with a next-generation modular system that integrates ticketing, talk management, and video services under a single, maintainable Django framework. The project focuses on refactoring components, introducing containerized workflows, and improving developer efficiency with consistent configurations and plugin capabilities. Key objectives include: - Unified Event Models and Architecture Refactor - Integration of Tickets, Talks, and Video Components - Plugin Standardization (Badge, Exhibitors, OutputPDF, etc.) - Enhanced CORS, Middleware, and Static File Handling - Docker and Gunicorn Deployment Setup - Performance, Logging, and Celery Worker Integration - Testing, Documentation, and Developer Experience Improvements
This project introduces a new Git sub-command (currently intended to be called git repo-info) that will centralize data currently retrieved by git rev-parse in a JSON format.
The project aims to design and implement advanced interactive visualizations for ListenBrainz using Nivo for data visualization and integrating with the existing Flask API. Apache Spark will handle efficient data processing and aggregation. These visualizations will offer granular insights into genre trends, artist diversity, and temporal listening patterns, enhancing user experience and engagement. The project will result in the development and integration of the following four interactive charts into ListenBrainz: 1. Generate Artist Listening Activity Statistics: A function to calculate the number of listens for each artist over a specified time range, mapping the data into an interactive visualization that shows the evolution of artists a user listens to over time. 2. Generate Listens by Era Statistics: A function to calculate the number of listens grouped by the year of release of each track, producing a chart that displays listens by era, enabling users to explore the distribution of their music preferences across different periods. 3. Genre-Based Listening Patterns: A dynamic visualization that tracks a user’s engagement with different genres over time, highlighting how their music preferences evolve. It will also analyze trends in genres listened to at different times of day, revealing how mood or activity influences music choices. 4. Top Listeners: A leaderboard-style visualization that tracks and highlights the top listeners sitewide. This chart will showcase the most active users and display who listens the most within their social circles, encouraging community engagement and fostering a sense of connection among users. These interactive charts will enhance the ListenBrainz user experience by providing deeper insights into listening habits and fostering a stronger sense of community.
GCC Rust (gccrs) is an alternative Rust compiler frontend based on GCC, aiming for full integration into the GNU toolchain. This project focuses on improving the HIR (High-Level Intermediate Representation) visitor pattern and migrating lint checks from the middle-end to HIR. These improvements will enhance gccrs's overall code quality.
This project aims to implement a Near-to-Far Field Transformation (NFFT) feature in gprMax. This will enable users to compute the far-field radiation patterns and radar crosssections(RCS) from the near-field data. It will expand gprMax’s capabilities for antenna design, scattering analysis, etc. I propose to implement the Near-to-Far Field Transformation (NFFT) module and its integration at several key points in the existing workflow: - Adding the NFFT command - Module for Field Sampling during FDTD - Post-Processing & Far-Field Calculation - Integration with the API - Validation and Testing - Documentation and Review
This project focuses on porting the PyCUDA-based FDTD method solver of gprMax to HIP API. The final target is to run gprMax on AMD ROCm GPUs. HIP Python and HIPIFY+Pybind are considered to be used to do the porting work. The final deliverables consist of the ported kernels and the adaption to the original gprMax code, the setup script, benchmarks, and documents.
The project aims to develop a comprehensive Chrome extension to combat online threats such as abusive language, misinformation, clickbait, and malicious websites. It will leverage artificial intelligence, natural language processing, and machine learning techniques to provide multilingual support, automated fact-checking, claim verification, and credibility scoring. The extension will incorporate Bloom filters for efficient URL checking and content filtering, user feedback mechanisms for continuous learning, and educational resources to promote internet safety. The deliverables include a robust, scalable, and user-friendly extension that enhances online safety and productivity
The goal of this project is to reintroduce a tree view functionality into Chrome's bookmarks side panel, addressing user feedback and enhancing usability. The current flat list view lacks the ability to view all bookmarks at once, leading to user dissatisfaction. To solve this, we will transform the compact view into a tree view while retaining all new features introduced in the recent UI overhaul. This will involve retaining drag-and-drop functionality for bookmark organization within the tree view, ensuring compatibility with screen readers, and conducting comprehensive testing for usability and accessibility. Key Deliverables: 1. Implement tree view functionality in the bookmarks side panel, allowing users to view all bookmarks at once. 2. Update existing drag and drop functionality for organizing bookmarks within the tree view. 3. Ensure accessibility standards are met, focusing on tab traversal and screen reader support. 4. Conduct thorough testing to ensure the usability, accessibility, and functionality of the tree view. 5. Prepare comprehensive documentation detailing the implementation, usage, and features of the new tree view in Chrome's bookmarks side panel.
Currently the Graphspace code repository has a lot of mismatched dependency issues & consist no automating techniques in their repository to release or test graphspace image while deploying to production. The Project aims to stabilise & setup the CI/CD pipeline for Graphspace project. The project involves creating a Production ready Dokcerfile setup to install graphspace locally. The project also focuses on automating the release workflow of Docker image to Docker-registry services like AWS ECR or Dockerhub, automating the releasing, testing PR , labelling (PR's & Issues), performing necessary security checks & image vulnerability scans by creating multiple workflows with Github Actions
In today's digital era, where users access applications on a variety of devices with varying screen sizes, ensuring a consistent and user-friendly experience across platforms is crucial. Openrms, a cutting-edge project, presents an array of designs that demonstrate how the frontend user experience (UX) should adapt dynamically based on the screen size or device. We have a ton of designs that show how the frontend UX should change based on screen size or device (e.g. large desktop, small laptop, or tablet). This project aims to implement this responsiveness consistently throughout the application.
This project aims to enable many authentication frameworks and add support for an authentication layer to Glee. This will give developers the ability to use Glee to create secure online applications with a variety of authentication choices. To accommodate future additions of new authentication frameworks, the authentication layer will be created to be modular and adaptable. After this project, when using Glee to build a server, the developer should be able to specify the authentication strategy they wish to support. Token-based authentication: This could be done using the jsonwebtoken npm package, provision will be made for both refresh and access tokens. Access tokens will be short-lived tokens, while refresh tokens will have longer life spans and allow for renewal of the access tokens. Basic authentication: This authentication strategy would be implemented from scratch. Certificate-based authentication: certificate-based authentication will be implemented from scratch. OAuth 2.0 authentication: OAuth 2.0 authentication will be achieved using the node-oauth2-server npm package. Session-based authentication: The viable option here will be to build the session-based authentication from scratch, as many of the options available such as passport-session, express-session, and fastify/session are all framework dependent.
The project aims to fill the current gap in the creation of a baseline urban grid that allows for network analysis of the morphology of street networks. The idea of the project is to develop a set of tools within the current momepy.preprocessing module that combined with the current integration of NetworkX can output a solid, consistent and repeatable analysis of the urban form. Given that other libraries have also approached this issue (namely osmnx.simplification and citiyseer.tools.graphs), the idea is to contribute from the persisting issues of such libraries to then continue with a solution that is much more independent. Issues like multiple Points on LineStrings, snapping ends, and curving segments have already been addressed by such tools, but parallel LineStrings, and enclosed Linestrings (eg. round-abouts) still need to be resolved, to name a few. It seems that a categorization of the different topological issues (likely similar to the ones just mentioned) could create a framework from which to approach a final pipeline. However, it is proposed that early tests of different potential avenues be performed to sketch a planning route going forward (one of such tests is exemplified under the Approach section). The ideal solution is expected to be source-agnostic, but also leverage the current efforts already done by the community. Overall, the idea is to prioritize work alongside the mentors and the community to focus on increasing the short-term benefits of all PySAL/GeoPandas users (some of whom might already be familiar with some of the other corrections). As the project progresses over different iterative approaches, it is expected to incorporate more performance tests to counterbalance the feasibility of each approach as well as to build the desired autonomy of the tools to be reliant exclusively on input geometries.
vedicdatetime() package for R will add the functionality to use the Vedic calendar system instead of the Gregorian calendars system, especially for time-sequence based analysis and forecasting while providing a conclusive view on divergences of using lunisolar based calendar systems for time-series analysis and forecasting.
<p><em>The primary goal of my idea is to implement a WAF which uses Machine Learning to detect anomalies in web traffic.</em></p> <h7>The proposed idea</h7> <p>Since the Securtea is a software that is used on the server-side of an application. In order to implement a WAF we need to monitor the traffic that is being sent to the Web Server. This could be done by utilizing the Ngnix 's and Apache's reverse Proxy. Where we configure the reverse proxy to proxy pass every request to a listening server that is capable of analyzing the traffic. Once the analysis is done it can be passed back to the required server and the response is sent back to the proxy and the proxy would send it back to the client.</p> <p>The analysis part includes , ML model that has been trained with various simulation of web traffic .The simulation includes both good and bad traffic . The traffic is then feature engineered to get additional features , that help us to identify the nature of a traffic.</p>
<p>Nettacker is tool which can scan and find vulnerability from the target. This have numerous modules, like recent Microsoft Exchange vulnerability module that helps to detect this vulnerability from our target. In this project proposal I have mentioned that how i want to utilize nuclei-templates and add workflow for improving user experience and performance of the tool.</p>
<p>Graphs are a ubiquitous and versatile data structure, which allow the representation of problems and systems across a vast array of domains like infrastructure networks, molecular models, language, and social interaction. Recent community work on graph computations has culminated in a standard API which casts graph computations as generalized linear algebra on sparse matrices. This enables performant, standardized graph algorithms which are easily differentiable by modern auto-diff tools. In this JSOC 2021 project I aim to provide automatic differentiation rules for all of the operations in the GraphBLAS C API which admit such rules. The SuiteSparse GraphBLAS (SS:GrB) implementation will be the primary target, and support for the several extensions to the specification in SS:GrB is also a goal. The primary application I am pursuing is an efficient implementation of graph machine learning in Julia, but it should be noted that graph computation and generalized sparse linear algebra have incredibly broad use cases including graph algorithms like breadth first search, and faster neural networks by taking advantage of sparsity and operators faster than typical multiplication.</p>
<p>Currently, mypy and mypyc are unable to recognize uses of the singledispatch decorator, making mypy generate false positives and mypyc generate incorrect or slow code when it is used. This project would improve both of these problems by adding special support for singledispatch in mypy and mypyc.</p>
<p>Mifos Mobile CN is a reference mobile banking app on top of the Apache Fineract CN architecture, which allows a client to securely authenticate against the microservices architecture and interact with his/her accounts. This GSoC primarily aims at integrating with the Open Banking API layer built on top of the WS02 API Gateway, which provides a secure authentication and integration layer for first-party applications as currently the app only is consuming a mock layer of data. Additional use cases would include better support for transactions via external payment systems, improving the workflow for sign-up and account creation, and implementing new UI designs.</p>
<p>Versioned key-value data management interface for TiKV</p>
<p>The project assumes implementaion of integration of Databus with IPFS. Databus (<a href="https://databus.dbpedia.org" target="_blank">https://databus.dbpedia.org</a>) is a service which allows people (or systems) to search for or publish data (knowledge graphs) for further processing. In current version, Databus does not store the data itself, but keeps links to the data. The data itself must be stored by the publishers themselves. Not all the publishers would like to keep the data themselves as well as to support the infrastructure for that, and it is where IPFS (<a href="https://ipfs.io/#why" target="_blank">https://ipfs.io/#why</a>) can help.<br> Integration of Databus with IPFS will allow publishers to publish the data in the IPFS, sparing the publishers from the need to maintain the infrastructure. On top of that, IPFS supports versioning of files, which makes it easier to publish new versions. For consumer that would also mean more reliability, because IPFS stores data in a distributed fashion without single point of failure.</p>
<p>Currently, the package candidates are not using the templating system and their UI can be improved. To improve the candidates publishing process, we need to add certain functionality to smooth the process. The final goal is to implement a fixed workflow for package candidates and have the docbuilder and docuploads worked with them.</p>
<p>Building hardware requires access to costly tools and hardware, furthermore complexity in hardware design remains a deterrent force. FPGAs in the cloud solved the high upfront cost of the hardware, and some aspects of tool availability, but not the complexity and scale yet. Moreover, reuse of the already existing IPs is extremely difficult.</p> <p>For this Summer of Code project, an extension to the FPGA-Webserver project (<a href="https://github.com/alessandrocomodi/fpga-webserver" target="_blank">https://github.com/alessandrocomodi/fpga-webserver</a>) is proposed to provide an end-to-end solution for accelerating web applications and developing hardware using cloud FPGAs.</p> <p>A ready-to-use environment like this could potentially accelerate compute-intensive tasks in web applications and could appear in online HW design tools as backend.</p>