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.
ASSR refers to the cortical entrainment to frequency and phase of an auditory signal that is presented in a fixed “train of clicks”, in a gamma range rhythm (40 Hz). A hallmark of schizophrenia is a reduction in ASSR; this project aims at reproducing this phenomenon using an auditory cortex (A1) model with thalamocortical connectivity. The latter simulates a cortical column with a depth of 2000 μm and 200 μm diameter, containing over 12k neurons and 30M synapses. Specifically, we aim at reproducing results from an experiment looking at the effects of increased CB1 receptor availability and GABA receptor deficits, as these have been linked to the EEG abnormalities that characterize schizophrenia. We will start by running batch simulation tasks to pull out connectivity rules from the A1 model, modifying GABA and CB1 Receptors. This step will be run on a scaled version of the A1, so that I will be able to use a personal computer, but I may employ cloud resources as well.Then, we will analyze parameter sweeps for local field potentials, using the LFPy toolbox. Afterwards, we will move to parameter optimization of the A1 model so that it reproduces the ASSR, using the Optuna HPO toolkit. Our ultimate goal is to reproduce the ASSR phenomenon in the A1 model. For every step of the process, documentation will be made available on a deployed site.
This project aims to enhance EvalAI's functionalities by automating large worker deployments in AWS, adding relevant features for efficient challenge management and also writing a robust and efficient test suite. The focus of the project is: To automate large worker deployment processes on EvalAI using AWS EC2 instances, reducing infrastructure running costs. Make challenge management seamless and less reliant on the admins reducing the dependency of challenge hosts on EvalAI admins. To make EvalAI more reliable and error-free by incorporating tests for different frontend and backend components. Having robust tests prevents making code-breaking changes to the codebase. This task will include adding unit tests for the API suite, prediction upload evaluation workers, code upload evaluation workers (on EKS), and integration tests for end-to-end testing of all components.
Currently, the static analyzer offers little dedicated support for C++. Even when projecting the most straightforward valid C test cases to C++, the checkers output incorrect diagnostics, either by their absence or imprecision. The issues this project aims to tackle are all prerequisites to further extensions of C++ support. The aim of this project is to enable the analyzer to self-analyze itself.
Simulating quantum physics in QuTiP provides an excellent educational tool. However, using QuTiP requires writing Python code, which may present an obstacle in some teaching contexts. Programming is, of course, a very valuable skill to master. Attempting to master it while simultaneously coming to grips with quantum mechanics is perhaps less advisable. We would like to create a graphical virtual laboratory powered by QuTiP which allows users to explore quantum systems without being distracted by the need to write software. The virtual lab would allow building up experiments from components (e.g. sub-spaces such as qubits, Hamiltonians for those subspaces, interaction Hamiltonians, environment baths), evolving the system over time, applying measurements, and attaching monitoring of quantum states or measurement outcomes (e.g. Hinton plots, Bloch sphere plots). Deliverables - A graphical interface that acts as a virtual laboratory - Allows the construction of simple quantum systems (e.g. placing four neutral atoms) - Allows defining the evolution of each system component - Allows defining the interactions between system components - Allows coupling the system to an environment bath - Allows simulating the system dynamics and visualizing their evolution over time - Allows visualizing the steady state of the defined system - Can be run on both desktop and tablets
This project involves creating a VS Code extension that provides enhanced support for the Brian2 neural simulator. The extension aims to improve the user experience and productivity of those working with Brian2 by offering syntax highlighting, syntax checking, auto-completion, and language server protocol (LSP) support. These features will be implemented using various programming languages and tools, including Javascript, Python, and the LSP protocol. The deliverables for this project include a fully functional extension that can be installed and used with VS Code, as well as documentation on how to install and use the extension. The extension will be designed to work seamlessly with Brian 2 and will provide a user-friendly interface that is easy to use and navigate.
Approximately 15 million premature infants are delivered each year, who face a higher risk of neonatal mortality, particularly in low and middle-income countries. One common complication of prematurity is neonatal hypothermia, which can be effectively treated with Kangaroo Mother Care/Skin-to-Skin care (KMC/STS). However, the implementation of KMC/STS is limited by various barriers such as inadequate healthcare workforce and the labor-intensive nature of neonatal care, leading to inconsistent scale-up of KMC/STS. The goal of this project is to developed to automate vital sign monitoring, facilitate multi-patient tracking, and enable shared goal setting for education, KMC, and discharge. The primary aim of this application is to provide timely alerts to parents and caregivers upon detecting any abnormality in vital signs, thus preventing adverse outcomes. The feasibility and acceptability of this device in US health facilities are being evaluated.
BookBrainz still has a relatively small community and contains less entities than other comparable databases. Therefore we want to provide a way to import available collections of library records into the database while still ensuring that they meet BookBrainz' high data quality standards. From a previous GSoC project, the database schema already contains additional tables set up for that purpose, where the imports will await a user's approval before becoming a fully accepted entity in the database. The project will require processing very large data dumps (e.g. MARC records or JSON files) in a robust way and transforming entities from one database schema to the BookBrainz schema. Additionally the whole process should be repeatable without creating duplicate entries.
Carsus generates an HDF file by combining data from various sources. This HDF file can be used by Tardis to generate Atomic Spectra. However, when a new version of the atomic source rolls out, there is no way of determining the changes in the datasets. The goal of this project is to create a repository integrated with CI pipelines to periodically check for changes in the upstream data sources and maintain a repository of semantic versioned datasets along with a report on the changes in each version update. The Carsus project will be updated to use the latest data source by default by checking for updates in the data repository. Additionally, a utility function will be implemented in the Carsus to support using the older version of the datasets available on the data repository by passing the dataset version number.
The project proposes further extending multi model database support in Apache Gora with ArangoDB datastore and upgrade Hive and HBase datastore dependencies to become fully compatible with latest available API versions.
Accurate gene annotation in eukaryotes solely based on genomic data has been a significant obstacle in biology since the introduction of next-generation sequencing technologies and thus the rapid increase of available data. Traditional methods either rely on homology searches to map the open reading frames to previously identified protein-coding genes or utilize additional experimental data, e.g., transcriptomics data. The first approach produces potentially inaccurate results if the genome of interest is not at least somewhat related to an already annotated genome. The second approach is hindered because gathering transcriptomic data is labor-intensive and expensive. For that reason, there is a high demand for models that predict the location of protein-coding genes solely from inherent features of the DNA sequence of the gene. Although theoretically possible, methods that use, for instance, Hidden Markov models to detect protein-coding genes based on known gene features are often inaccurate. In this project, we will train a Deep Learning Transformer model to extract features of protein-coding genes to gain deeper insight into their exact properties that lead to translation. The whole workflow will include first training a Conditional Random Field model to recognize candidate gene regions and then using these as input for a more fine-grained Transformer - Convolutional Neural Network hybrid model. The final pipeline will be tested against a benchmark of gold standard annotations as well as various test sets to evaluate the influence of different parameters like genome sequence quality, protein length or gene structure complexity.
The project aims to implement pgr_withPointsKSP and all its overloads. Yen's algorithm computes single-source K-shortest loopless paths for a graph with non-negative edge cost. It employs any shortest path algorithm to find the best path, then proceeds to find K − 1 deviations of the best path. Sometimes the applications work “on the fly” starting from a location that is not a vertex in the graph. Those locations, in pgRouting, are called points of interest. So this function will modify the graph to include these points of interest and, using Yen’s Algorithm finds K shortest paths.
This proposal aims to implement a location privacy toolkit in the enviroCar app, a mobile platform for handling personal location information. The toolkit will enable users to make informed decisions about the location data they share by replacing the native Android location API and creating additional settings for fine-grained data selection. The expected result is the successful implementation of the location privacy toolkit in the enviroCar app. The project duration is estimated at 175 hours, and the mentor is Benjamin Pross from 52°North. The project will use the enviroCar code license, and the preparation will involve checking out the toolkit and discussing development with the mentor.
The LibreHealth Radiology AI Model service aids radiologists with AI to produce fast and accurate medical diagnoses. It communicates with LibreHealth RIS module to output labels on DICOM viewer. Currently, CheXnet model is integrated to the AI Model service, but the proposal expands to apply other models to imaging modalities like Mammo, Head CT, Abdomen CT. The project aims to understand what radiologists need in terms of AI and implement it. The goal is to help radiologists perform better by implementing algorithms for new imaging modalities. To tackle the problem we start by looking at research that have looked deep into model architectures and methods that work well with imaging modalities, for example Alexnet have proven to work on modalities like Head CT. We then collect the imaging data necessary to train out models and also decide on the method of training like transfer learning on pretrained models or do we go ahead with training a model from scratch. Appropriate feature engineering and tuning will be part of the problem solving process. Once we establish a model to perform well on a modality we proceed to integrate the model to the AI Model service application. The deliverables will include - Collate information on data sources, methods and models that will be used for implementation and review with mentor(s) - For any modality, start with data preparation, feature engineering, training and evaluation until satisfactory performance is achieved. Here we will trial different augmentation techniques and hyperparameter tuning methods. - Integrate the model inferencing code and retraining code to the application for all modalities - Add methods to the Flask API to appropriately call the specific AI model for a modality. Modify existing methods as necessary so as to include the new AI models - Perform unit tests, integration tests, functional tests and end to end tests for the implementations. Necessary coding standards will be used.
This project aims to implement the necessary infrastructure for the Discontinuous Galerkin method in the finite element toolbox Ferrite.jl. This will include writing examples, documentation, and tests. DG method is a FEM like the continuous Galerkin (CG) method where the test functions are chosen to be the same as the trial functions. However, DG elements do not share degrees of freedom (DoF) at common nodes, introducing extra DoF and adding the process of choosing coupling between elements through numerical fluxes. The main deliverables are: • Methods to integrate on inner faces. • Extend the methods to integrate over subfaces. • Sparsity pattern methods for DG. • Implement infrastructure for handling boundary conditions for DG approximations. • 1-D, 2-D, and 3-D steady heat equation using DG example. • Testing and documentation for all implemented methods.
This project aims to port the remaining tree elements to the new object-oriented design of the Outliner codebase. The project will involve creating new subclasses, modifying existing code, thoroughly testing changes, and documenting the modifications made. The deliverables for this project include a detailed report and updated code of new AbstractTreeElement sub-classes representing the remaining tree elements. The project will contribute to the ongoing development efforts of the Outliner by providing a necessary refactoring that will make future development work easier and more efficient, and the Outliner module's documentation will be improved.
LibAFL, a library written by Rust, helps people develop a fuzzer tailored to specific needs, but due to the lack of the running status information of LibAFL, we are difficult to grasp some key metrics in a fuzzing campaign. so I propose adding AFL-style UI to the TUI monitor. LibAFL will have an AFL-style UI encompassing some key status metrics such as the status bar, process timing, and so on.
The Whiteboard Integration project enhances collaborative experiences in Rocket.Chat by introducing a powerful Whiteboard App. This integration facilitates real-time visual communication, making it easy for users to create and share diagrams, drawings, and more. With a user-friendly interface and features like slash commands and action buttons, users can effortlessly create and collaborate on whiteboards. The project also offers a convenient local setup guide, allowing users to deploy the app locally for testing. This integration adds a new dimension to communication within Rocket.Chat, fostering creativity and efficient collaboration.
This project focuses on migrating JavaScript codebase to Typescript. Zulip is in the process of porting the main web app JavaScript codebase to TypeScrip. Zulip’s 8% of lines have been migrated while the goal for this summer will be to get that to ~75%. The challenges for migrating JS to TS include circular imports, a large number of interdependent modules, tracking down complex cycles, multiple cycles in one module, order of conversion, and understanding types and their relationships. The proposed solutions include classifying circular imports, passing callback workaround, extracting common functionality into a third module, and writing unit and integration tests to ensure the migrated codebase functions properly.
The idea is to add thumbnail preview on the UI while seeking. Tasks to be accomplished include: extend the preparser to take snapshot of a video every few minutes/seconds, and adding qt and/or macOS support: display the snapshot taken by the prepaser while seeking.
This project proposes novel evaluation metrics for anomaly segmentation in computer vision, taking into account pixel-level and spatial information. The aim is to provide a more comprehensive evaluation of anomaly segmentation algorithms, aiding researchers and practitioners in selecting and fine-tuning models. The first proposed metric is the False Positive Blob Relative Volume (FP-BRV), which accounts for the visual nuisance of false positive pixels, complementing the Per-Region Overlap (PRO). The proposed metric will be evaluated on popular anomaly segmentation public datasets and visually validated. Milestones: prototype implementation, testing and validation on public datasets, production implementation, optimization/unit testing/documentation, and research paper writing. See "Section 5 Detailed project proposal" in the PDF for details and a timeline.
Mathesar is an open-source, web-based database management tool that is easy to use, flexible, and scalable. It provides users a simple, intuitive interface for managing their databases, including creating and editing tables, defining relationships between tables, and querying data. Mathesar UI allows users to import data from CSV and TSV files. We aim to expand this functionality into importing JSON and Excel files too. The project will allow users to import JSON and Excel files and create a table from the imported data. The user can preview the table, remove/rename columns, change data types, and more. If the imported file is not in a suitable format for creating a table, we will develop algorithms to convert the file into a suitable format. If the algorithm doesn’t work, the system will refuse to import the file and give the user a readable error.
The Airavata Django Portal is a web interface to the Apache Airavata API implemented using the Django web framework. Gateway admins need period reports on user count, running experiments, resource usage, and other relevant information to aid in their reporting and planning activities. The primary task is development of dashboards where admins can get quick statistics. Data to be displayed on the dashboard is to be taken from Airavata databases making use of Airavata APIs. Apache Superset along with other libraries can be employed to create the required dashboards using Vue.js.
The C++ Standard Template Library (STL) provides many algorithms to sort, search, and perform a variety of operations on numerous data structures in its algorithms library. However, a major issue with the STL is that it is not optimized for parallel programming. Despite the fact that nearly all processors ship today with multithreading available, the STL is currently single threaded, leaving its algorithms library running at suboptimal efficiency. Taskflow is a C++ parallel programming library that organizes functions into tasks that it then can run concurrently or consecutively, depending on the user’s goal. My project will reimplement the STL’s algorithm library using Taskflow so that it can take advantage of multithreading.
This project aims to improve the scale and navigation inside the Phoenix application which is basically an Angular-based web application written in the ThreeJS library to visualize high-energy physics events in 3D. The application renders a detector that detects the collisions of particles that have been accelerated up to speeds comparable to that of light, along with the event data that consists of tracks, jets, missing energy, etc. after the collision. The problem statement is to improve the visualization of the event, for example, by developing a customizable and interactive cartesian grid functionality, so as to better give the idea of the locations and distances of the particles to the researchers. Also, the user should be able to view the dimensions of the individual detector parts. Apart from this, the users should be able to navigate to the individual detector parts. My plan for the first problem is to introduce a 3D cartesian grid with multiple equally spaced XY, YZ, and ZX planes, as well as, to be able to display the 3D coordinates of a point on clicking. For this, I will make use of the ThreeJS raycaster intersects. Also, I am planning to render the Euclidean distance between any two points clicked. To view the dimensions of the detector, I am planning to render the dimensions of the bounding box of the component. The solution for the second problem would be to list the detector parts and let the user select any one of them, after which it will be highlighted using a ThreeJS outline pass.