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 proposal addresses the outdated support for Braille embossers in printing systems, which currently relies on shell scripts and PPD files. To modernize this support and ensure long-term sustainability, the plan is to transition to the newer CUPS infrastructure using Printer Applications. The project involves converting shell scripts into filter functions in libcupsfilters and developing a Printer Application for easy configuration of Braille embossers. The deliverables include a software solution for Braille embosser support within the CUPS ecosystem, enhancing accessibility and usability for users.
The project aims to refactor the Brain's unit system into a standalone package. Additionally, it aims to incorporate additional functionalities from other unit packages such as astropi (for type annotations), pint (for integration with matplotlib’s unit system), Quantiphy (for string formatting), and pint-pandas (for integration with pandas). To achieve the desired outcome, I propose structuring the standalone package into multiple submodules, each well-documented with READMEs and examples. Moreover, the package will include new units, constants, and potentially implementation of tests for other projects. This approach will enable other organizations and developers to easily utilize the resulting Brain unit package in their projects. The integration into other projects will be seamless and effortless due to the well-structured documentation and package stability. This will ensure widespread adoption of the Brain unit package in scientific research projects, thereby making a significant impact on the computational and development communities.
My proposal aims to improve existing integrations of third-party services. Currently, some services only provide object ID in their webhook payload, not human-readable data. Some integrations also require users to download a script to be integrated, which is not ideal for non-technical users. To address these issues, I propose adding a proper callback system by extending the bot model and providing an additional UI for configuring the integration details. I also plan to improve several integrations by implementing newer features such as the proposed callback system and provide maintenance for ones with outdated payloads.
This proposal aims to enhance user experience on Drupal.org by integrating AI-powered chatbots. The project will focus on solving the problem of providing users with a more interactive and user-friendly experience while navigating the Drupal website. By integrating chatbots, users will have access to instant support, guidance, and information retrieval, improving overall engagement and satisfaction. The project will involve researching and selecting suitable AI frameworks, designing and implementing chatbot functionality, testing for compatibility and usability, and documenting the integration process. The deliverables will include the integration of AI-powered chatbots on Drupal.org, documentation for installation and customization, demonstration of chatbot functionality, and regular blog posts or articles highlighting the benefits and usage of chatbots.
Ray tracing involves computationally expensive calculations and geometry with varying degrees of complexity. According to Fujieda et. al[1], a novel Neural Intersection Function can be used for ray intersection queries. This method has better efficiency while ensuring image quality. The objective of this project is to implement and rigorously evaluate this Neural Intersection Function against the industry-standard bounding volume hierarchy (BVH) algorithm, providing a comprehensive comparative analysis of their respective performance characteristics.
DevoGraph is an open-source GNN framework designed specifically for analyzing embryogenetic data. It utilizes Graph Neural Networks (GNNs) as a powerful method for revealing connectivity patterns within complex geometric datasets. My contribution to this project involves (i) implementing the Mapper algorithm for topological data analysis, (ii) implementing an Evolutionary-based Neural Developmental Program to mirror the embryogenetic growth of C. elegans, and (iii) code integration in DevoLearn. Through this project, I aim to create informative and interactive visualizations for better interpretation and analysis of the data.
In hardware compilers, scalability issues often arise due to inefficient tree data structures. To tackle this challenge, the proposed project aims to optimize these structures by creating an efficient hhds::tree<> class with a novel tree flattening policy. This initiative targets improved runtime performance, especially for common operations like sibling and parent queries. The deliverables include the fully implemented hhds::tree<> class, benchmarking results, documentation, unit tests, usage examples, and a future plan for a hhds::graph<> class. The implementation plan is divided into two phases with specific targets and timelines for each phase.
Python's evolution to support static type hinting since Python 3.5 marks a significant milestone in developing robust programs. This project aims to upgrade the Invesalius3 project by incorporating static type checking using Mypy, augmenting functions, methods, and classes with type information. The project also includes implementing a GitHub CI workflow to detect type errors in pull requests. Additionally, I plan to integrate swift linting support with Ruff, upgrade the packaging system using a "pyproject.toml" file, and automate hook management using pre-commit.
This project aims to enhance query efficiency through two main optimizations. Firstly, it will focus on improving stream filtering and sorting queries by reducing unnecessary I/O operations. Secondly, the project will leverage the Bluge API to optimize inverted index queries of measure through reducing the number of query executions. These optimizations will significantly improve the system's overall query performance.
This project aims to implement wasm-coredump, to enhance the debugging capabilities of WebAssembly by implementing a coredump feature for post-mortem analysis for the wasmedge runtime. When WebAssembly encounters a runtime error, it will start unwinding and initiate a process to collect debugging information, including stack frames, local variable values, and a snapshot of the linear memory. For each stack frame, it will collect the values in locals (includes function parameters) and on the stack. Along with binary offsets to resolve to source file locations. This data is saved in a coredump file, which can be analysed post-mortem to debug the error using tools like wasmgdb
This proposal aims to enhance the MCnet projects, Rivet and YODA, by automating the generation and deployment of Docker images across multiple architectures, thus ensuring broad accessibility and ease of use. For Rivet, we focus on Docker automation and web documentation migration into CI builds for seamless new website deployments. YODA enhancements will concentrate on bolstering unit testing and coverage analysis frameworks through the integration of gcov for comprehensive coverage insights, utilizing lcov for accessible reporting, and developing web-based visualizations for coverage reports. This initiative promises to significantly elevate the clarity, reliability, and functionality of both projects, making them more robust and user-friendly for the high-energy physics research community.
Currently, when new users open the app, a registration/signup page opens. Ideally there should be a onboarding process where users are introduced to most important factors of XMPP/Monal and as well as most important privacy settings / privacy policies. As of now when tapping on image in the chat, a SwiftUI based image viewer appears showing the image in full screen. I will enhance it to support multiple media formats and additional features - Users will be able to swipe through all received and sent media sent from or to their contacts. Clicking on the contact details users will see the SwiftUI based gallery of all received and sent media. After tapping on a gallery item they will be led to this SwiftUI based image/video viewer. Deliverables: 1 - Working Swiftui based media viewer with support of multiple formats 2 - Ability to see received/sent media when clicked on contact details button 3 - Modern onboarding process for new users.
Port the remaining demos in Workbench to Vala, the plan of action; port demos, get reviews from maintainers, and fix any issues. Build a new and enhanced library for demos. The new layout would make it easier to navigate for new and experienced users. This involves changing the library content containers and implementing category and language-based filtering. Replace the current code search with a faster, more optimized search. Requires using software that allows full-text search (Eg: Xapian, FTS5 in SQLite).
CCExtractor, though widely utilized, has not seen a stable release since 2022. This initiative seeks to ensure stability by consolidating existing pull requests, enhancing the GUI application, implementing Continuous Integration via Github Actions, rectifying regression tests, and ultimately transitioning most of the code from C to Rust. By undertaking these steps, CCExtractor will attain robustness akin to Crust, thereby undergoing a significant utility overhaul.
The objective of this proposal is to design and implement an in-context AI assistant, named Co-Pilot, tailored for assisting users in creating Concerto models. This AI assistant will be seamlessly integrated into the existing VSCode web-extension, Playground, or other chatbot marketplaces, providing users with intuitive access to AI-driven suggestions and guidance during model creation. Co-Pilot will support multiple foundational AI models, such as OpenAI, Bard, Anthropic, among others, and allow users to configure API keys for their preferred models. Additionally, the proposal aims to engineer LLM prompts effectively to aid users in editing Concerto models and measure the effectiveness of these prompts.
Beacon is a cross platform mobile application made with Flutter for the frontend and supported by Node.js and GraphQL for the backend. It's a handy tool for planning and managing group hikes, offering features like tracking leaders location in real-time, showing routes dynamically, sending emergency alerts, and easily sharing locations. Using Flutter makes Beacon easy to use on different devices. By connecting with Node.js and GraphQL, it ensures quick updates and smooth navigation during hikes, making outdoor adventures safer and more enjoyable for everyone involved.
Project synopsis / summary: This project is dedicated to developing a set of automated tools and processes for extracting useful neuronal experimental data from datasets provided by the Allen Brain Institute, and converting these data into parameters that can be used for neuronal modeling on the NetPyNE platform, for comparison with cortical regions already validated by NetPyNE. The project flow is divided into the following steps: Data Collection: Automatically extracts data from the Allen Cell Type Database for specific cell types in the visual cortex, including electrophysiological properties, morphological characteristics, and gene expression patterns. The Allen Institute provides a powerful API that allows users to programmatically access and retrieve data. First through data cleaning, and then through data crawling to obtain data that is difficult to access in the API. In addition, domain-specific language models will be fine-tuned or trained using Google's Gemini model for subsequent data acquisition. Parameter Conversion: Develop tools(scripts) or design large language model prompts to automatically convert extracted data into a parameter format understood by the NetPyNE, such as .hoc or .swc format. Identify how to set reasonable default values for missing data. Model construction: Use the converted parameters to construct neural network models of relevant brain regions in NetPyNE. This includes defining neuron types, neuron connectivity, and synaptic interactions between neurons. Run Simulation: Run a simulation of the model in NetPyNE to simulate the brain's response to a specific input stimulus. Compare Results: Compare the simulation results with actual biological experimental data to verify the accuracy of the model. Intended set of deliverables: Automated Data Collection Tool. Parameter Conversion Script. Simulation Run Framework. Result Validation Report. Documentation and User Guide.
Agora is a high performance vote counting library written in Scala. The library currently supports several vote counting algorithms, however it is quite outdated and doesn't have support for Scala 3. Rewrite library using Scala 2.13 and provide support for Scala 3.x Make Candidate and Ballot generic Implement tie resolution algorithms and add possibility for users to include theirs
A common feature that most build tools supports common source code generator such as Protobuf or Smithy. The idea of supporting code generator has been existed for a while, with some of the features such as the execution of the source generator already been implemented in Bloop. The goals of this project is to improve upon the already existing feature for Scala CLI.
It’s Urgent Project is a notification app, with the twist that allows the user trying to reach out decide how urgent it is (i.e. if they want to disrupt or not). It is not a messaging app or a phone app. Intuition behind the project: Have you ever had to get in touch with someone at all costs even if that meant disrupting whatever they were doing? Of course they can make you a priority contact that always rings, but then you would be disrupting every time. So that doesn't work. Deliverables: User Authentication and Management: Account creation, sign-in, and sign-out functionality. Adding other users who are currently on the app. SMS invite functionality for user referrals & Account deletion option. Notification System: Implement the Notification system with Do-Not-Disturb Mode & other checks along with Challenge mechanism. User Interface (UI) Implementation: Intuitive UI design adhering to material design guidelines. Consistent design elements and smooth navigation between app sections. Good Documentation: Technical articles explaining the app's functionality and implementation details. Updated README with project details, setup guide, and contribution guidelines. Testing (Unit, Widget & Integration): Comprehensive testing for different scenarios to ensure app reliability. Unit tests for individual components, widget tests for UI elements, and integration tests for overall functionality. Timeline & Plan of Action: Phase 0 (May 1 - 26): Community Bonding Period, UI Design, Repository Setup. Phase 1 (May 27 - Jun 16): User Authentication Implementation. Phase 2 (Jun 17 - Jul 7): Notification System Development. Midterm Evaluation (Jul 8 - 14): Mid Evaluation. Phase 3 (Jul 15 - Aug 4): UI Enhancement, Testing, and Documentation. Phase 4 (Aug 5 - 25): Refactoring, Final Testing, and Evaluation.
This proposal aims to create a client library in rust and command line interface (CLI) for interacting with GA4GH environments in python. It will be easy to upgrade and maintain different versions of API’s with the CLI, which will be done by generating code using openapi-generator automatically. It also involves cross language bindings to access the functions in other languages like C, Python, Go and JavaScript. It will make it easier for organisations and users to access GA4GH standards, increasing the usability of GA4GH standards worldwide
Modbat is a model-based testing framework that utilizes finite state machines (FSMs) to generate tests systematically, exploring various execution paths based on predefined models. Java PathFinder (JPF) is a powerful model checking tool that verifies Java programs by exhaustively exploring their state space.The primary objective of this project is to integrate Modbat with JPF to improve the effectiveness and efficiency of test generation for Java applications. By combining the model-based approach of Modbat with the exhaustive verification capabilities of JPF, we aim to achieve comprehensive test coverage while minimizing redundant test cases.
The project aims to develop a robust pipeline for assessing the performance of foundation models, specifically focusing on scGPT, in generating embeddings suitable for inferring gene regulatory networks (GRNs) from single-cell RNA-sequencing (scRNA-seq) data. Leveraging the BEELINE benchmark and algorithms like GENIE3, GRNBoost2 and PIDC the pipeline will systematically evaluate scGPT's ability to capture gene regulatory relationships. Key steps include data preprocessing, embedding generation with scGPT, and GRN inference using GENIE3. Evaluation metrics such as precision, recall, F1-score, and area under the precision-recall curve (AUPR) will be employed, comparing inferred networks against simulated ground truth or expert-curated GRNs from BEELINE. The modular design of the pipeline allows for future integration of additional foundation models, enhancing its versatility and extendibility. This research will deepen our understanding of foundation models, particularly scGPT, in GRN inference, guiding the development of improved algorithms and methodologies for deciphering gene regulatory mechanisms from scRNA-seq data. Ultimately, this work will advance biological knowledge by shedding light on gene regulatory processes and their implications across various biological contexts.
My proposal aims to increase the level of context that Pwndbg provides when stepping through a binary by “annotating” the results of instructions. Alongside the disassembled machine instructions in the dashboard, there would be text to indicate the action that each instruction takes, such as moving values between CPU registers, writing data to memory, or doing a mathematical operation. We would resolve the concrete values that memory and CPU registers take on after each instruction, providing relevant information that the user would otherwise have to fish out manually using a GDB command that varies depending on the context. Pwndbg is starting to support this annotation feature for the x86 architecture. My project would add these annotations to other architectures supported by Pwndbg, namely 32-bit Arm, 64-bit Arm, RISC-V, and MIPS. This not only aids in debugging and reverse engineering, as you would gain much-needed context as to the results of instructions, but there is also an educational benefit in that you can visually see what each instruction is doing while stepping through a binary. We would additionally create annotations for future instructions in the disassembly view using emulation. By combining the Unicorn Engine, a CPU emulator framework, with the Capstone Engine, a disassembly framework, we can provide the user with insight into the next handful of instructions, providing more context and increasing debugging efficiency. Deliverable - A series of pull requests which add annotations for instructions for Arm, AArch64, RISC-V, and MIPS inside the “disassembly” view of the Pwndbg dashboard - A rewrite of the parent class API to make adding annotations to new architectures more simple - Add the ability for the recursive printing of pointers inside the annotations to provide enhanced information on pointers inside heap memory, such as internal heap manager metadata - Documentation and tests to aid future contributors and reduce chance of regressions