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.
Project focused on improving the user experience of editing Gradle Kotlin Scripts (KTS) in Eclipse. With contributions to the Gradle Eclipse plugin, users will benefit from improved code error highlighting, code completion, and Ctrl-Click to definition functionality. By improving support for editing KTS in Eclipse, developers will be able to work more efficiently, resulting in faster and higher quality software development.
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.
Modern printers usually are driverless IPP printers, and those get discovered fully automatically by CUPS; no CUPS queue needs to be explicitly created. Same for remote CUPS printers and also Printer Applications . They are all discovered as IPP print services. And listings of IPP print services have different requirements: One server can have more than one individual print service and these should get listed together. This could be a print queue and a fax out queue of the same multi-function printer, or two physical legacy printers supported by one Printer Application. Also the user interaction coupled to each listing is different. We do not need to configure PPD option settings, but instead, we need access to the IPP service's web administration interface and also to an IPP System Service configuration panel by a simple mouse click. Several parts of this were already coded in previous GSoCs, but we need to get everything smoothly integrated in the “Printers” part of the GNOME Control Center. I will work together with the upstream maintainer of the “Printers” module, Marek Kasik and also with the UI/UX design teams of GNOME and of Canonical.
The major objectives of the project are: 1. Refactoring the Python code to increase efficiency and readability and increase the overall code quality of the entire codebase of the software. 2. To enhance user engagement and support by creating a comprehensive FAQ dataset which is used to train a custom Chatbot. 3. Investigate and discuss different possibilities for multi-GPU model execution, i.e. allow a model to execute (and share memory) across multiple GPUs.
We are trying to solve the difficulty of collaboration among multiple users working on large datasets, particularly in analyzing datasets with many parameters and essential features that need to be filtered, measured, and analyzed. The solution is AnalySim, a data-sharing platform that simplifies collaboration by providing easy sharing, analysis, visualization, and collaboration capabilities on datasets. The first deliverable is the ability to embed Jupyter notebooks, Observablehq notebooks, and Google Collab notebooks on the website using an interactive panel. The second deliverable is an interactive panel or interface that displays a dataset's different types of features, including minimum, maximum, mean, number of non-zero, and the number of invalid values. The interface should show other visualization options like histograms, pie charts, multi-series line charts, pie charts, graphs, and visualizations representing data with more than two dimensions, e.g., 3D Scatter plots, 3D Mesh Plots, 3D line plots, box plots, and bubble charts. The third deliverable is the ability for users to add publications related to the datasets in a project. We will achieve this by creating a text editor page where users can add content, edit content, remove content, add tables, and add images. The text editor should allow users to add latex code so that users can publish mathematical analyses of the findings. We will also implement a page that gets the list of publications, which should contain clickable items that redirect to another page that details the publication. Finally, we will refactor some of the code to maintain a better project structure, encapsulate numerous fragments of the same code in another method to improve the readability of the code and remove deprecated methods.
DocArray is a library for representing, sending, and storing multi-modal data, with a focus on applications in ML and Neural Search. It currently supports several deep learning frameworks, including PyTorch and TensorFlow. Jax is becoming increasingly popular for deep learning, so we want to integrate it into DocArray. The project we propose is to add Jax as a backend for DocArray, alongside PyTorch and TensorFlow. The first part would involve rewriting and translating all of the computational backend functions of DocArray with the Jax framework. Then, we would battle-test the implementation against a real Jax use case, such as integrating DocArray with Jax support for model training and serving.
I am planning to build the app using flutter for frontend and calling APIs using dart package called “retrofit” for collecting data of rocket launches from APIs such as “https://www.rocketlaunch.live/api” and “https://docs.spacexdata.com/” and “https://spaceflightnewsapi.net/” this API to access different news articles and related information about the launch to show on the app also Celestrak API “https://celestrak.org/” for satellite data. We use “google_maps_flutter” for the live location of the user, “google_directions_api” for finding routes to the nearest launch site and “geocoding” to convert the named launch site location to coordinates. After calling the API it will return data in JSON format which we will convert to KML format file and store it locally using “shared_preferences” and then will send it to Liquid Galaxy for visualisation. There will be a map screen as well in the app to visualise the launch in the app itself if it is not connected to Liquid Galaxy. I will use embedded code sent to LG Rig using the KML format of placemarkers of the launch site with a YouTube live video link pasted by users (of which instructions will be mentioned) in the input text field which will telecast live launch video on LG alongside visualisation.
Currently, FOSSology generates SBOM in SPDX format, which allows for integration with various tools. However, CycloneDX is another popular format for generating SBOMs. By integrating CycloneDX report generation in FOSSology, it will be possible to work with other tools that use CycloneDX. Although a PHP library exists for generating CycloneDX reports, it cannot be used because it is licensed under Apache-2.0, while FOSSology is under GPL-2.0. Therefore, a custom implementation of CycloneDX report generation in FOSSology is necessary. So the main goal of this project focuses on the implementation of CycloneDX report generation in FOSSology.
This GSoC project aims to significantly enhance the user experience of Zulip, an open-source team chat app, by implementing several features that will improve the user interface and usability of the application. The project will specifically focus on redesigning crucial areas of the application, including the top bar, sidebars, Compose box, and Topics, to make them more intuitive, user-friendly, and visually appealing.
Vespucci, the Android editor for OpenStreetMap, uses the JOSM-compatible presets for tagging. Vespucci, however, has evolved to support far greater functionalities than those supported in JOSM. These functionalities include attributes like 'deprecated', which indicates a deprecated preset item, 'regions', and 'exclude_regions' for localisation, and 'value_type' to indicate the type of value, among many others. The project aims at adding these additional attributes to JOSM. Incorporating these attributes will provide a better user experience across the editors, improving the usability and functionality of JOSM.
It provides a convenient and effective way for organizations to manage their use of open-source licenses. With the growing popularity of open-source software, organizations are finding it more difficult to keep track of the various licenses and terms under which they are permitted to use open-source components. Open-source licenses can be complicated, making it difficult to understand how they apply to a specific piece of software or interact with other licenses. It can be used for various purposes by organizations like FOSSology and SW360 like license identification, filtering, and managing licenses.
As of now, Kanidm doesn't provide a way to allow two users to mutually authenticate each other. I would like to design and implement such feature, building upon and further polishing the design already discussed between the maintainers and me (see pull request #1416). The idea is to use ECDH to compute a unique TOTP for each user, make the users exchange said TOTPs with an out of band channel and then verify if they are correct, with no online communication required between the involved kanidm servers. To begin with I'll have to implement a feature that allows kanidm to store ECDH keys for its users, as they are required for the Identity verification system to authenticate subjects. Afterwards I will work on the core server-side logic of the system, and finally, if time will allow it, I am going to implement a frontend interface in the kanidm client for the identity verification system. I also plan on writing a journal of my experience with this project.
The main goal of this year's contribution is to make the TensorMap application bug free with clearly documented steps for setup. That will be the initial task I will be attempting. Then, I will add some features to the app to make it more user friendly for beginners. Finally, the code base will be simplified, and documentation will be updated.
Zulip has a huge codebase for it's web app but it's currently written in JavaScript, this project is aimed at migrating at least ~80% of the zulip's codebase to TypeScript. TypeScript is an awesome language migrating to it will improve the quality, maintainability, and scalability of Zulip's frontend codebase. Also by using TypeScript we will be able to enforce consistent coding standards, document the code better, and leverage powerful IDE features.
The aim of this project is to improve Mail Integration in Kalendar by implementing the following goals: 1) Adding email composition 2) Implementing advanced search functionality 3) Adding signature management [Optional]
This project optimized the GROUP BY operator in MariaDB ColumnStore for workloads requiring disk-based aggregation. To achieve this a) unnecessary I/O operations in the aggregation algorithm were reduced, b) bugs in the previous implementation of disk-based aggregation were fixed and c) vectorized access to the internal hash map used for aggregation was tested. Additionally, Theresa fixed other bugs and improved documentation and the development setup, especially for new developers.
In this proposal, I outline three projects. The following is a brief outline of each project problem, solution, and set of deliverables: Project 1) Improving Test Coverage Problem: Vorta has a current test code coverage of 72%, and we would like to get this in the 80% - 85% range. Additionally, current testing files need more a consistent file structure and organization. Solution: Work with organization mentors to prioritize test code coverage. Create unit and integration tests to reach our target code coverage. Reorganize and restructure testing file. Deliverables: At least 80% code coverage, with a stretch goal of 85%. Test files separated into unit tests vs integration tests. Consistency in file naming and structure across all test files. Project 2) Implement Profile Sidebar Problem: The current profile selector and setting tab implementation mixes global setting with profile specific settings. Solution: Move the profile selector and settings button to a collapsible sidebar. The settings button opens a new interface with options relating to global settings and profile management, while the individual profile buttons open to profile specific settings. Deliverables: A new sidebar with profile selector and setting button, as well as a new setting interface. Unit and integration testing accompanying all new features. Project 3: Test on Live Borg Binary Problem: Currently we test on static mock files of Borg JSON output. This task would improve testing to run on actual Borg versions/binaries. Solution: Test multiple versions of Borg using Tox to simplify testing. Implement these changes in setup.cfg Deliverables: CICD running tests on live Borg binaries with > 99% success rate. Include the option to run existing integration tests locally. Include thorough documentation of this process.
DBpedia proves to be a way of ”Bringing Order to the Web” with structured information as Open Knowledge Graph, contributing towards making quality data more accessible. The main goal of this project is to explore DBpedia’s potential at enriching the data provided to Recommender Systems (RS) on different standard datasets, such as MovieLens and LastFM. A framework, for running reproducible experiments with only the model implementation and a simple .yaml configuration file, will be implemented. Through the framework, this project allows practitioners to easily evaluate and compare their proposed RS algorithms with existing approaches, enabling future benchmarks on enriched and non-enriched datasets. With access to enriched standard RS datasets sourced primarily from DBpedia, this project aims to demonstrate DBpedia’s applicability to RS area and other areas of ML, potentially promoting the adoption of DBpedia and increasing its active community. The main steps of the project are: • Entity linking: between DBpedia and standard RS datasets. • Data Enriching: Build SPARQL queries to enrich RS datasets with useful DBpedia‘s properties. • Framework Implementation: for reproducible experiments.
My project proposal for GSoC in Ivy is to work on building Vision Models using Ivy and creating demos and tutorials to showcase the implementation of these models. These models include PSMNet and MLP-Mixer.
The "Turn All References Blue" (TARB) project at the Internet Archive aims to tackle the issue of content drift in Wikipedia hyperlinks. Content drift refers to the phenomenon where the content behind a URL changes over time, leading to a discrepancy between the original cited information and the current content. The project leverages machine learning models like BERT and BART to identify and flag such instances of content drift. It then suggests replacements for the content drifted URLs with stable references from the Wayback Machine, ensuring the reliability and integrity of Wikipedia citations.
pgagroal is a high-performance protocol-native connection pool for PostgreSQL. It also manages authentication for users who try to access the database. Application software does a terrible job of keeping secrets. For example, the password to the database might be hard coded in their source code or written as plain text in the configuration file. Or it might accidentally log the secret to a file or print out as debug info. By implementing a simple vault, we can have the ability to issue a dynamically generated time-limited secret that map to the actual secret (password of the database in our case), and this will prevent leaking the actual secret to users.
Most of the day to day tests in LLVM are regression tests executed by Lit, structured as source code or IR to be passed to some binary, rather than test code directly calling the code to be tested. This has many advantages but can make it difficult to predict which code path is executed when the compiler is invoked with a certain test input, especially for edge cases where error handling is involved. The goal of this project is to help developers create good test coverage for their patch and enable reviewers to verify that they have done so. To accomplish this we would like to introduce a tool that can be fed a patch as input, add coverage instrumentation for the affected source files, runs Lit tests, and records which test cases cause each counter to be executed. For each counter we can then report the number of test cases executing the counter, but perhaps more importantly we can also report the number of test cases executing the counter that are also changed in some way by the patch, since a modified line that results in the same test results isn’t properly tested, unless it’s intended to be a non-functional change.
The goal of the project is to apply and develop “end-to-end” vision transformer (ViT)-based networks for jet-flavor identification with the CMS open data and to benchmark their accuracy performance. This is expected to improve both the accuracy and computational cost of convolutional neural networks (CNN) developed previously for similar tasks. The networks developed would also expand previous works from a binary "light quark vs gluon jets" tagger to multi-class "b quark vs c quark vs light quark vs gluon jets" tagger. The “end-to-end” here refers to a direct use of images recorded by the particle sub-detectors at the CMS for classification. It strips away the complex reconstruction algorithms and object definitions used by the CMS and paths a way to invite ideas outside of the particle physics community to tackle the difficult task of particle identification at the Large Hadron Collider.
Problem Statement:- Plone is a robust and secure Content Management System that is used by a wide range of organizations worldwide. However, given the growing amount of information available on Plone websites, it can be challenging to locate the appropriate information fast given the state of Plone. Solution:- The objective of this proposal is to develop a Nuclia Plugin that will scrape websites, extract pertinent data, and index it in the Nuclia Knowledge Box. The Plugin will then be deployed to Plone websites after being merged with the current Plone knowledge Box. Set Of Deliverabilities that will be delivered:- Easy Search without multiple navigations. This will save time and increase productivity. Centralized location for all Plone-related information. Enable developers to explore new techniques, features, and solutions more easily, leading to better results and more efficient development processes. Increase the visibility of Plone and help to attract new users and contributors. Make Plone more user-friendly and increase adoption. Help to build a stronger community by encouraging collaboration.