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.
ScummVM includes a global fully configurable keymapper, but this requires engines to be adapted to use it. Hence the goal of this project is to integrate the customised ScummVM keymapper into the engine's input handling system. This involves modifying the engine-driven input handling code for mapping user input to in-game actions.
This proposal was titled Enhancements for Flexbench: OpenAPI Integration and Anonymization using Machine Learning (ML). I am leveraging my skills to enhance the HTTP request generator app Flexbench by integrating AI solutions into the codebase. As a computer science student with a focus on full-stack Web/Software Engineering and up-to-date AI trending technologies, I have garnered extensive work and personal experiences in NodeJS, machine learning, and GPT API integration with very strong interests and backgrounds. My skills are directly applicable to the Flexbench project. My history includes the successful deployment of AI-driven applications and microservices with React, which aligns with Flexbench's development for the Google Summer of Code this year.
This proposal involves creating a visually appealing and intuitive website made specifically for C2SI. Essential features include displaying detailed project information such as tech stack, issue count, contributors, forks, and stars, as well as showcasing individual contributor contributions. User authentication will enable personalized views, allowing users to see their own contributions upon logging in. Admin functionality will be provided for managing project visibility settings. Backend development will employ APIs to facilitate communication between frontend and backend systems, utilizing the GitHub API for project details and integrating databases for efficient storage and retrieval of project and contributor data. Comprehensive documentation will be generated to guide future contributors, ensuring clarity and ease of understanding for newcomers to the project.
The ticket-32159 (https://code.djangoproject.com/ticket/32519) originally requested a new feature to make Django provide generic database functions for manipulating JSON data on the database. Currently, in order to make partial updates to a JSONField, developers need tol oad model instance to the memory, modify JSONField data as objects, then call save() on the model instance, or write custom mapping for JSON functions as Func subclasses, and use them in update(). It would be better if Django has built-in support for doing partial JSONField updates more efficiently and more idiomatic to how developers can currently query JSONFields (i.e. with key transforms). In order to achieve that, this proposal intends to create an implementation for all databases supported that developers can use in order to update partial values of JSONField. This project aims to accomplish the problem by dividing it into two big parts: first, implement JSONSet and JSONRemove functions to allow partial updates to JSONField. Second, add support for key transforms in update() for JSONField to make it easier to use for developers. The project will be executed on creating JSONSet for SQLite, MySQL, PostgreSQL, Oracle first, then, create JSONRemove on same databases. After that, support for key transform on update() will be implemented.
In a single Knative Functions command, we aim to abstract the entire process of building serverless functions using WebAssembly (WASM)—from compiling the source code into WASM and containerizing it, to deploying it in Knative. This approach allows developers to focus solely on their source code, while Knative Functions handles all underlying transformations, ensuring seamless execution across various platforms. WebAssembly (WASM) significantly enhances performance, security, and flexibility. By compiling code written in languages such as C, C++, Rust, and Go into a bytecode format, WebAssembly ensures consistent execution across different processor architectures (x86, ARM, RISC-V). WASM’s fast execution and platform-independent bytecode format could expand the capabilities of Knative Functions, supporting a broader range of programming languages and processor architectures. Currently, there is no support for WASM in Knative Functions, which is why our project focused on pushing the boundaries of what’s possible by exploring WebAssembly support in Knative. During this project, we identified some limitations in fully integrating WASM into Knative Functions. However, by successfully implementing WASM support in Knative Serving, we were able to explore the potential of WASM within Knative and lay the groundwork for future improvements once these limitations are addressed.
"RobotCraft" is an immersive 2D game where players construct and program to build robots that will tackle various tasks. The objective is that the player will answer prompts about fundamental programming concepts and for every correct answer the robot will perform a task or build itself! With endless possibilities for creativity, players can customize their robots and learn about logical operators, variable manipulation, and debugging techniques to troubleshoot robot behaviors.
Currently, Mautic lacks a comprehensive end-to-end test suite, which poses challenges in ensuring the reliability and stability of new changes introduced through pull requests (PRs). Relying solely on user testing for quality assurance often results in bugs being discovered post-release, impacting user experience and trust in the platform. This project aims to address these issues by developing a comprehensive end-to-end test suite for Mautic. The suite will cover core functionalities and selected bundles, and it will be run through GitHub Actions as well as locally. This approach enables developers to run the suite locally before making their PRs, ensuring thorough testing and higher code quality.
The Human Neocortical Neurosolver (HNN) is a computational tool that enables scientists to study brain responses at the cellular and circuit levels. However, the current version of HNN-core has a limitation in that it cannot simulate large batches of simulations. This hinders the efficient optimization of parameters, which is crucial for accurate modeling. To address this issue, I am working on improving HNN-core by adding batch simulation functionality. I am also developing a user-guide on advanced optimization techniques, specifically focusing on simulation-based inference (SBI), a deep learning-based Bayesian inference method. These enhancements will significantly contribute to the HNN's codebase, enabling researchers to extract crucial insights for developing theories about human brain response origins.
MusicBrainz database sees a lot of edits made on a daily basis. Tens of thousands of edits. That’s a large number. With each edit, there’s associated an edit note which provides additional information about the edit. Often, these edit notes, as well as some edits, contain external links, which we want to archive in the Internet Archive. This project idea aims at creating a Rust application that can archive the external URLs using Wayback Machine APIs.
Instructors face significant challenges when configuring autograding systems for their courses due to limited examples, insufficient documentation, and a lack of coverage for various features. To address these issues, I propose a comprehensive solution aimed at reducing the learning curve for instructors and enhancing the functionality of autograding systems. The project focuses on three primary areas: Firstly, I aim to improve autograding examples by creating tailored solutions for specific use cases, such as evaluating compilation speed and handling distributed/networked applications. These examples will feature detailed configurations in config.json, accompanied by comprehensive documentation. Additionally, existing examples will be revamped to meet current standards and encompass a broader range of programming languages and features. Secondly, I will enhance documentation and provide illustrative examples for new autograding features that lack proper guidance. Through thorough research and collaboration with mentors, I will develop demonstrations for features like generating random input/output and utilizing customized Docker containers. The aim is to facilitate understanding and usage of these features by instructors. Lastly, to provide instructors with a user-friendly platform for configuring autograding across various educational levels, I will establish a structured repository. This repository will house a diverse array of autograding examples organized by educational level, ranging from introductory to advanced courses. Furthermore, I will encourage crowd-sourced contributions to create a comprehensive collection of programming assignments and exercises, complete with their autograding configurations. To streamline the contribution process and ensure consistency in configurations, I will implement GitHub Workflow Actions. The repository will include detailed documentation and guidelines to facilitate contribution and usage.
The goal of the project is to port the SIMD optimized routines written for amd64 to riscv64. This will be accomplished using SWAR techniques. Because the code will only depend on the base integer ISA, the optimizations will result in a performance increase on all riscv64 systems.
The project focuses on creating 3-4 Low carbon footprint templates incorporating the sustainability factor, accessibility as well as SEO & Performance. I am going to try multiple tech stacks and then compare them on the basis of the above 3 factors to find the best sustainability templates with the lowest carbon footprint using multiple Benchmarking tools. The technology stack or stacks used to achieve this are to-be-determined, with an inclination towards static site hosting, scale-to-zero backends, and hybrid client/server rendering.
The JupyterLab application relies heavily on plugins sourced from the Lumino project. Currently, all plugins load at startup, significantly increasing load time. The proposed solution is to enhance the extension configuration to incorporate entrypoints, akin to how VS Code manages extensions. This configuration will dictate when to load an extension based on various triggers, ultimately improving performance. Introducing main and side panel changes without manual coding will further optimize performance.
The proposal aims to develop a package manager for the Faust programming language, consisting of several components to enhance the development and sharing of Faust libraries. The proposed system encompasses: Central Repository on GitHub: Establishing a central repository on GitHub to store metadata for Faust libraries. This repository will serve as a centralized hub for developers to publish. GitHub App for Publishing Automation: Developing a GitHub application to automate the publishing process of Faust libraries to the central repository. The GitHub app will automate the submission of libraries, manage versioning, and generate documentation automatically to enhance accessibility and ease of use. Package Manager Application: Creating a package manager application designed to manage dependencies for Faust projects locally. The package manager will enable developers to efficiently integrate and manage dependencies within their projects, ensuring seamless integration of Faust libraries. Faust-hub Website: It will contain comprehensive information about Faust libraries available in the central repository. Faust-hub will provide a user-friendly interface for browsing, searching, and accessing Faust libraries, enhancing collaboration and community engagement within the Faust ecosystem.
While Unikraft may have the bare minimum implementation required to receive and process the information passed from Firecracker under the form of the Linux Boot Protocol structures, it is not able to boot through this protocol from more strict and proper environments such as QEMU, GRUB, U-Boot or any of the many open source bootloaders that speak this protocol. The main reason this does not happen is because the Unikraft bootable images are missing the Linux header. The first step will be reading documentation and familiarizing myself with the project. I would estimate that this step will take about two weeks. The Linux x86 Boot Protocol will be studied and questions will be asked towards the community and the mentor. Secondly, a step for planning ahead the workflow that will dictate the way I will work on the project (two weeks). By doing this, a schedule will be set in place that will help me always be on time. Design the structure of the external program to parse bootloader metadata and generate the Linux Boot Protocol header. Comparing the x86 header to the ARM64 one could highlight certain common traits that can be used to minimize the existent code. Finally, the coding period will start that will be summed up by taking feedback, discussing unforeseen problems, striving to meet deadlines. This will take approximately twelve weeks. At this time, the best course of action is to respect the planning done before and focus on integrating everything that can be picked from the UEFI script. The rest can be done after thorough testing and reviews from the community.
Apache Beam through its unified model for batch and streaming data-parallel processing pipelines, runners for executing them on a variety of distributed processing backends and ML specialized transforms within MLTransform (such as EmbeddingManager and other MLTransformProvider) make it uniquely positioned for building out RAG (Retrieval Augmented Generation) based applications. These applications are one of the most useful and commonly being built applications on LLMs (Large Language Models). For this project we will focus on building a knowledge base on a vector database for a text corpus, and enriching user's questions with matching text chunks using semantic search. This is a crucial part of any RAG applications and helps us in building the right prompt context for LLMs. We will implement the following deliverables to achieve this: 1. Build a Beam pipeline that takes in a batch text corpus from a public dataset as parameter to pipeline and uses MLTransform to generate and save Embeddings in batch mode to a vector database. - Initial scope: Wikipedia dataset with JinaAI Embeddings read from object storage and written to RedisIO to publish to known vector DB. 2. Build a Beam pipeline that takes in stream of text questions from clients and enriches it with related texts from the vector DB. - Initial scope: KafkaIO based reading of queries which is populated by producers independently and published in a different topic for results. 3. New enrichment handlers for vector database queries over Redis based Vector DB Stretch goals: 1. Implement enrichment handlers for OpenSearch (AWS supported)[4] 2. Implement enrichment handlers for Vertex AI Vector Search (GCP Supported)[5] The goal is to demonstrate semantic search building capabilities trivially using Beam and hence evaluation of search results is not tied to a broad benchmark (such as MTEB) for this project's scope.
The project aims to adapt the LuaSQL drivers, which provide an interface between Lua and various database management systems (DBMS), to work seamlessly with the latest version of Lua, 5.4. LuaSQL offers a common API for interacting with different DBMS, including ODBC, ADO, Oracle, MySQL, SQLite, Firebird, and PostgreSQL. However, the last version of LuaSQL was tested only against Lua 5.3, and it's essential to ensure compatibility with Lua 5.4 and potentially leverage new features introduced in this version. The primary focus will be on revising the Lua C API part of the code while ensuring minimal disruption to the existing functionality. Project Objectives - Compatibility Update: Ensure LuaSQL drivers are compatible with Lua 5.4. Code Revision: Review and revise existing Lua C API code for each driver to incorporate any necessary changes considering the new features and changes introduced in Lua 5.4. Potential Enhancements: Taking Advantage of any new features that could enhance performance, readability, or maintainability of the codebase. Documentation Update: Update documentation to reflect changes made to adapt Lua 5.4 and provide clear guidance for users. Testing: Conduct comprehensive testing to verify functionality across different DBMS. Distribution: Package the updated LuaSQL drivers for distribution to users.
In the proposed contributions to Haiku, I plan to revamp the Tracker Query Window's user interface, incorporating a Next Generation Find Panel to enhance search functionality. This involves rebuilding the UI from scratch, integrating features such as query submenus for saving, loading, and editing queries, along with options for selecting attributes and drive/folder locations for searching. Additionally, I aim to introduce real-time query result updates and improve the selection of search parameters for a more intuitive experience. Apart from this, I also intend to work on bugs and enhancements to the Tracker Windows and associated tickets.
This proposal seeks to investigate gender disparities in career trajectories and the impact of gender-minority status on career changes during emerging adulthood. Leveraging longitudinal data from the Baccalaureate and Beyond study, I will analyze how gender influences majors, occupations, and career outcomes over time. By applying advanced statistical techniques and theoretical frameworks, I aim to uncover factors driving career choices and trajectories, providing insights for promoting gender diversity and inclusion in education and the workforce. Through rigorous analysis and interpretation, I will deliver actionable findings and disseminate them to stakeholders and policymakers through academic publications, conference presentations, and policy briefs.
This project aims to develop a unified system for sentiment and stance detection in televised news content. Leveraging text, audio, and video modalities, the research seeks to understand the interplay between emotional tone and the position taken on specific issues in news narratives. The goal is to create an integrated tool for comprehensive analysis, contributing to a deeper comprehension of the overall narrative in news broadcasts. The methods include implementing sentiment analysis models for news transcripts, developing stance detection models for specific topics, and building a unified system that combines sentiment and stance information. The project’s potential impact lies in providing researchers and analysts with a valuable tool for nuanced news content analysis.
Optimize Sugar for Raspberry Pi to engage the Maker community effectively. This entails seamless integration, packaging for inclusion in RPi OS images, and enhancing Sugar activities like Turtle Blocks, Measure, and Pippy to leverage RPi sensors efficiently.
VC-2 is a relatively recent codec for high definition video in high bitrate applications. While hardware encoders for it exist, they come with many limitations. Given the codec is suitable for being implemented purely as a GPU shader, the goal of this project is to implement a GPU encoder using the Vulkan API for the FFmpeg project.
Submitty's autograding is complex for instructors. This project will revamp the Notebook Builder interface to be more user-friendly. Instructors will be able to create autograding configurations more easily through as new interface, improved documentation, and tutorials. The project will also add features to support compiled languages and complex grading.
My proposal for the project "StablePay" is on a mission to redefine how we approach crypto payments. It recognizes the common pain points experienced by both merchants and customers, such as hefty fees and limited stablecoin options. StablePay aims to provide a solution that's not only decentralized and cost-effective but also incredibly user-friendly. At its core, StablePay offers a user-friendly widget that enables customers to connect their wallets, select an EVM-compatible network (initially Milkomeda, with future expansions planned), and conduct transactions effortlessly in either the native currency or Djed stablecoins. This intuitive payment experience is designed to empower users and streamline the adoption of stablecoins in everyday transactions. These include the creation of the StablePay widget which can be easily integrated to websites, aimed at facilitating seamless transactions, a feature-rich dashboard specifically designed to meet the needs of merchants, and a client-side interface optimized for user convenience.