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.
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
IPUMS is the “world’s largest available individual database of census microdata”, providing survey data and census records from across the world. IPUMS houses several projects, to furnish a wide variety of datasets that are applicable in a variety of domains. The primary objective of this proposal is to develop a native Julia package to interact with the APIs built around IPUMS datasets, provide useful utilities in this package to manipulate IPUMS data sources, and compose this package with the broader Julia ecosystem to enable novel research in health, economics, and more. Additionally, a long term goal will be to situate IPUMS.jl as another viable IPUMS SDK alternative in the official IPUMS project and to interoperate with these other SDK offerings.
One of Fossology's primary features is extracting licenses and license text from files. Traditional methods like text comparison, regular expressions, and SPDX identifiers can result in false positives, often requiring human review. This project aims to leverage recent advancements in Large Language Models (LLMs). LLMs can process text at a near-human level or beyond. In the domain of copyrights and licenses, models like Gemini-Pro, ChatGPT-3.5, and GPT4 have demonstrated exceptional accuracy in recognizing and converting licenses into formats like SPDX. Research across various fields, including medicine and coding, indicates that smaller, domain specific LLMs can outperform larger, general-purpose models in their respective areas. For this project, we'll fine-tune a relatively small LLM with parameters in the 2-7 billion range for optimal performance in license identification and other applications. Potential models include gemma (2B or 7B), Mistral (7B variant), LLaMA-2 (7B), phi-2 (2.7B) and others. This project involves selecting the best-suited model, utilizing existing datasets for fine-tuning, experimenting with different fine-tuning techniques based on data and computational resources, and finally, deploying the refined model.
Accounting for spectral effects in photovoltaic (PV) performance models is critical for accurate and reliable performance forecasts. Variation in the solar spectral distribution changes the useful fraction of irradiance incident on a PV device, and thus can increase or decrease its performance. The relationship between the performance of a PV module and the solar spectrum is captured by a “spectral correction function” (SCF), a plethora of which have been published in the literature over the last quarter of a century. However, only a fraction of these published models are available in pvlib. The aim of this project is to implement new SCFs in pvlib and develop examples to guide users in applying these models. The implementation of these new models will strengthen pvlib through enhancing its flexibility, accuracy, and reliability for different modelling scenarios. Furthermore, the additions to the example gallery will increase the accessibility and usability of these models and pvlib as a whole, in particular for new users.
The proposal for the GSOC project focuses on the "Optimization of CUDA and OpenCL performance" within the gprMAX software, a tool utilizing the Finite-Difference Time-Domain (FDTD) method for detecting anti-personnel landmines and addressing practical challenges. Problem Being Solved: The primary challenge this proposal aims to address is the optimization of CUDA and OpenCL performance within gprMAX to enhance its computational efficiency. This is critical for the application's ability to perform tasks such as detecting anti-personnel landmines more effectively. Solution Approach: The project will be tackled through a series of analytical and optimization stages, focusing on CPU/GPU computing stage segmentation, system-level analysis using Nsight System, and GPU-level analysis with Nsight Compute. These stages are designed to identify and alleviate bottlenecks in the system, with particular attention to Streaming Multiprocessors (SMs), Video Memory, and the Instruction Set Architecture (ISA). Based on the above analysis, the deliverables should contain several parallel branches. Each component will be thoroughly tested to verify its effectiveness and reliability before integrating these optimizations into the main project branch.
My interest in AsyncAPI was sparked by my admiration for the technical ingenuity behind Netflix's ability to provide flawless video streaming services globally. As a Master's student studying Data Science and Computer Science at the University of Pennsylvania, I am eager to explore the intricacies of event-driven architectures further, particularly by deepening my contributions to the AsyncAPI community. My ambition is to transition from a role of simply contributing code to assuming the responsibilities of a project maintainer for the AsyncAPI Generator, a key instrument for facilitating documentation and code generation based on the AsyncAPI specification. This commitment aims to not just contribute technically but also to foster community engagement and ensure the longevity of the project. In this new role as a maintainer, I plan to review and improve documentation, handle incoming requests, engage in community discourse, assist new contributors, and spearhead the implementation of innovative features, complete with testing. Additionally, I will document my path to becoming a maintainer, the challenges faced, and the insights gained, culminating in a roadmap for future maintainers. This endeavor is not only a testament to my commitment to enhancing the AsyncAPI project but also an opportunity to contribute to the sustainability and enrichment of the broader open-source community. Leveraging my technical skills, demonstrated in a recent project that achieved a 20% performance increase using React.js and Redux, and my proactive participation in AsyncAPI discussions and enhancements, I am prepared to undertake this significant shift.
With the advent of machine learning, statistical learning and modelling becoming more prevalent in today’s world, we can estimate values for an unknown data given a trained model i.e. finding value of data(D) given parameter (Θ) .Now what about the reverse? What if we want to find optimal parameter value, given a particular set of dataset. Why is this even required? The very simple answer to this can be found in every modelling and computation textbook. We cannot necessarily measure the other parameters. Let us take an example: There are several parameters while defining a neuron whose measurement is difficult to make, for example the axial resistance, the capacitance of the soma etc. Thus to achieve this process we make use of 2 tools, the first is the neuron library which is used for designing your neuron model and setting your parameters ,secondly is a statistical measurement tool used for the parameter estimation .This is done by checking for the voltage value generated by the neuron model and what might the parameter values be for that particular value. The reason to utilize Bayesian inference for parameter estimation is due to the specification of the prior data ,which will help us to increase the accuracy of our model which predicts approximate parameter values. Now the user could specify the prior data on the basis of any previous study or research material. Neuroptimus is an open source tool created for the same purpose. It is an interactive tool where the user can drop a dataset file. Train it and use it for parameter estimation . I have been tasked to utilize the prior ,the noise (for the calculation of likelihood),and the evidence to find the posterior distribution of the parameter I want to estimate. This is the main gist of the project, but there are various hurdles such as what if it is difficult to find the likelihood ,type of noise, computational costs for multiple parameters etc. These are some other things I believe I will be working on.
The goal of this project is to refresh the Uyuni website, make it responsive and accessible for everyone that visits it. The approach will involve using a simple and straightforward method without introducing complicated dependencies or frameworks, for easy and continuous maintenance.
A Flutter tool made to be able to control agronomical robots from a distance, with a database with data on different plants' ideal cycle: planting dates, transplanting dates, harvesting dates...
Guided by theories of expected returns by Ilmanen (2011), we will test models to understand how various factors drive returns on stocks and commodities portfolios. Through a series of replication projects, we will build vignettes to analyze the effects of factors such as inflation, liquidity and economic cycles on portfolio performances. The project pertains to the quantitative analysis of active portfolio management and the three broad areas under which implementations fall are: (i) approaches to dynamic asset weighting, (ii) return factors and their risk premia and (iii) time-varying expected returns. The ultimate goal of the project is to provide an accessible framework for factor and portfolio analysis that adds to existing literature on portfolio management, contributes to open source research and replications, and identifies areas for future research.
SymPy's physics/mechanics and physics/vector modules are powerful tools for modeling and analyzing the dynamics of multi-body systems. These modules allow users to set up models of physical systems and automatically generate the corresponding equations of motion. In SymPy, these equations can be derived using two primary methods: Lagrange's Method and Kane’s Method. This automation greatly simplifies the process of deriving these equations. However, as models grow more complex, the computational cost of generating the equations of motion can increase significantly, highlighting several opportunities to improve the performance of SymPy’s routines. My goal during this project was to identify these performance bottlenecks through benchmarking and community feedback, and to develop solutions that ensure SymPy remains efficient even with large and complex systems. A significant portion of the work involved developing a function to more quickly compute Jacobian matrices, thereby speeding up system linearization.
This project aims to enhance the course copying feature present for copying courses across the servers. Currently, when courses are copied between these platforms, crucial elements such as Timeline content are not included, posing challenges in reusing assignment plans. The proposed improvements will streamline the transfer process, enabling seamless migration of Timelines and other essential content across servers utilising pre-defined classes and methods. It would also allow non-admins to copy courses from Wiki Education Dashboard to Program and Events Dashboard. The current Dashboard mobile view presents challenges such as overflowing pages, non-responsiveness and design flaws, significantly limiting its functionality on small screens and hampering the overall user experience. This project also aims to resolve them.
This project intends to extend the system identification capabilities of Ardupilot to include all UAV types supported by Ardupilot, along with a dedicated library for processing, analysing and extracting the vehicle’s dynamic model from flight data. This will hopefully allow researchers to develop better model based guidance and control algorithms. The project would involve creation of lua scripts for Arduplane, which enables actuating all the control actuators in either a close loop or open loop mode. The flight logs will then be processed via a separate dedicated codebase to analyse and validate the data, and identify transfer functions and state space models. Finally, the custom control library can be extended for ArduPlane to allow researchers to experiment with multiple control algorithms.