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.
Molly.jl is a package in pure Julia for simulating molecules and physical systems in general using method known as Molecular Dynamics (MD). This project implemented a class of molecular dynamics simulations known as replica exchange molecular dynamics (REMD) to this library. REMD methods are very important in the study of complex biomolecules such as proteins, due to their ability to better explore the configurational space of such molecular systems by running many parallel copies of MD simulations with different conditions and sampling states from all these copies. These states are then periodically exchanged which helps in evading local minima. During the complete project phase, variants of REMD known as temperature-REMD and Hamiltonian-REMD were implemented. Along with these a general interface to define custom REMD simulations, improvements to the parallelization, more potentials and many improvements to the whole library in general were introduced.
Blendyn is one of MBdyn post-processing tools based on the Blender platform. It visualizes MBdyn output as a 3D system. However, the current Blendyn version is outdated since its last update is in 2017. In this project, we aim to flexible plotting engines and plotting features, and create a Live animation feature that visualizes MBdyn output in the real-time animation process. In addition to that, we also intend to make stress and strain visible for deformable objects.
Ideation and implementation of the new design patterns and features to be added to the FOSSology system. Fix bugs of the existing APIs which are not operating as intended , exposition and integration of the more APIs for the new features.
Static analysis helps developers to find bugs in their code at compile-time. Shipping a static analysis tool built into the compiler, which can be enabled by just a command line argument, makes the process for developers easier than ever. GCC gained a static analysis pass with version 10 and is constantly improving since then. This project aims to implement several checkers that are already offered by the clang static analyzer in GCC's static analysis pass.
<p>Curves in blender have been subject to a number of user requests for improvement from several different aspects. One such request was a new tool that makes the workflow for dealing with curves much smoother by enabling the editing of curves using simple and intuitive shortcuts instead of taking multiple steps to achieve the same. Another suggestion was the ability to create bevels at bends of a curve. The goal of this project is to address and develop solutions for these suggestions.</p>
<p>GStreamer plugins are written in C and the developers are pursuing in an attempt to convert them to Rust which is more robust and easy to maintain. I will be a part of this conversion and help to fix certain issues related to this. This may require lot of testing and careful implementation of the C written program in Rust.</p>
<p>BioJS is a library of over one hundred JavaScript components enabling users to visualise and process data using current web technologies. BioJS makes it easy for users to integrate their visualisations into their own website or web application.</p> <p>The process of updating the BioJS standard to version 3.0 is going on. The Yeoman generator to upgrade BioJS components by wrapping them in a Web Component has already been created which enables users to embed and use visualisation of various BioJS components.</p> <p>This project involves improving the Yeoman generator by adding new features and tests to make it easier for developers to implement old BioJS components as Web Components and to make new BioJS Web Components. It also involves clearly documenting the whole process of using the generator so as to make the task of working with the generator, making new components easy for developers as well as easily creating visualisations so that even non-technical persons can embed and use the visualisations in their work.</p>
<h3>1. EvalAI Python Package.</h3> <p>Creating a python package for EvalAI which lets the participants to <code>import evalai</code> as a python package and then make submissions through their python script instead of logging in to the website and then doing it.</p> <h3>2. Submission Worker using SQS.</h3> <p>Currently, there are a lot of short-comings in the Submission worker like individual dependencies for Challenges which can be solved by switching to Amazon SQS.</p> <h3>3. Implementing RESTful web services.</h3> <p>Adding analytics, admin dashboard and API versioning to EvalAI.</p> <h3>4. Implement webhooks and data collection.</h3> <p>To retrieve the results of a challenge from some forked version of EvalAI to the main EvalAI server. Also, for adding integrations to external services using Slack, Gitter etc.</p>
<p>Design and partially implement a research operating system that uses WebAssembly to implement software-isolated processes (SIPs) that run in ring 0 in order to allow architecture-agnostic compiled binaries and possibly attain higher performance due to not needing page-table switches and interrupt-based system-calls.</p>
<p>The current implementation of Poisson Surface Reconstruction algorithm in CGAL constructs a continuous, piecewise linear implicit function, i.e. it is only C0-continuous. My work during this summer would primarily have two objectives: to implement a C1-continuous implicit function to yield smooth surfaces, and to generate smooth curves as boundaries, using graph cut optimization and local mesh refinement.</p>
Joplin's offline-first design is one of its best features, but it comes with a real cost when the same note is edited on two devices before either syncs, Joplin has no way to merge the changes. It saves one version as a conflict note and leaves the user to manually figure out what to keep. For long notes on mobile, most people just give up and pick whichever version looks more complete, which means changes get silently lost. This project adds an interactive conflict resolution UI to Joplin desktop and mobile. When a conflict note is opened, instead of seeing a raw copy with no context, the user gets a clear section-by-section view of exactly what each side changed. Non-conflicting changes like additions and deletions can be resolved in one click. Genuine conflicts where both sides changed the same part give the user full context to pick one side or edit manually. A Keep both option preserves both versions for users who want that. The same shared diff module powers both platforms so the behaviour is always identical. The core deliverables are a platform-independent diff module using node-diff3, a minimal addition to the sync pipeline to store a base snapshot for three-way merging, and a conflict resolution React component for desktop and React Native component for mobile. The implementation also handles edge cases including notes synced before the feature was deployed falling back to two-way diff, stale remote data being detected and reset on open, and second conflicts on the same note being handled gracefully. No existing conflict behaviour changes and sync is never blocked at any point.
Checkstyle is widely used to detect code style violations, but many of its formatting-related issues are trivial and time-consuming to fix manually. This project aims to introduce an auto-fix module that can automatically correct formatting violations reported by specific Checks. The work involves evaluating existing auto-fix tools and libraries (e.g., OpenRewrite, CleanThat), selecting or building a reliable code modification engine, and designing an API for triggering code changes. A set of fixable formatting Checks will be selected, and their fix logic will be implemented in a maintainable way. The module will also include logic to prevent conflicting fixes and, if successful, may be proposed for integration into Checkstyle’s core to support plugin reuse.
SciCommons aims to revolutionize academic publishing by providing an open peer review platform. The current system faces challenges such as time constraints and limited reviewer capacity. SciCommons addresses these by allowing any user to review, comment, and rate research articles, enhancing article quality and decreasing review time. Anonymity ensures ethical and unbiased reviews. Building upon its existing functionalities, the project will introduce private communities for exclusive peer review, an immersive discussion/chat sections for each article. Deliverables include modularizing the frontend, enhancing user experience, implementing small feature enhancements, and integrating private communities and discussion channels. The project will prioritize code quality and adhere to open-source standards. By democratizing scholarly discourse, SciCommons fosters collaboration and transparent peer review.
To address the challenges identified with the FOSSology scheduler, particularly the limitations stemming from its programming language (C) and its linear queue design, proposed idea is to refactor current scheduler codebase in python and integrating Rocketry to create a more flexible, maintainable, and feature-rich scheduler. 1. Task Scheduling: Implement task scheduling with rocketry, utilizing its cron-style syntax for defining job frequencies. This allows for precise control over when jobs are executed, aligning with FOSSology's existing scheduling requirements. 2. Mutual Exclusivity and Concurrency: Define tasks with mutual exclusivity constraints directly within Rocketry, ensuring that jobs which should not run concurrently are handled appropriately. Utilize Rocketry's support for asynchronous execution to improve the scheduler's efficiency and responsiveness. 3. Error Handling and Logging: Built-in error handling and logging mechanisms to ensure that job failures are captured accurately, and relevant information is logged for debugging purposes.
The objective of this project is to provide alias support in concerto language . For example import statement like "import {document as d} from Library" to be supported by the end of this project. This would allow us to import two models with same name in a single file by aliasing them to different names which is currently not supported in the language. Doing this would require changes in both the concerto-parser and concerto-runtime . The project requires compiler design and programming language knowledge. The stack used in project is NodeJs and written in typescript. The concerto-parse is written in PEGJS.
shenyu-ingress-controller is an important step for Apache ShenYu to integrate into the cloud native ecosystem. This time gsoc roughly needs to complete the following steps: 1. Implement the divide plugin to support host; 2. Implement the divide plugin to dynamically configure the tls certificate; 3. Develop a controller to implement the native API specification of ingress; 4. Write unit tests and integration tests; 5. Write deployment and usage documentation.
The Eclipse Cargo Tracker project is a key part of the EE4J/Jakarta EE umbrella at the Eclipse Foundation. One of the current challenges the project faces is that it is running on outdated versions of Jakarta EE and Payara. Upgrading to newer versions will bring numerous benefits, such as improved performance, better security, and access to new features. In this project, I propose to upgrade the Eclipse Cargo Tracker application to Jakarta EE 10 and Payara 6. This will involve updating the project's dependencies, making necessary changes to the codebase, and ensuring that the application remains compatible with these newer versions. Additionally, the project's documentation will also need to be updated to reflect these changes.
This project represents the orbit of a satellite orbiting earth on an Arduino-controlled pointer and a Liquid Galaxy rig through a mobile application. The application offers a unique way to visualize satellite orbits using the Liquid Galaxy rig (Google Earth) and a real-world Arduino-controlled pointer. It also provides insights into satellites' movements and access to vital satellite information seamlessly within the app. I plan to develop this by getting all the satellite data from SatNOGS database through API calls. Then, we use SGP-4 model to convert TLE of a satellite to get the state (position and velocity). Then we convert the satellite state to KML format. We segregate the KML data into the various tracks to get a neater visualization of the satellite's orbit data. Then, we write the code to send KML data from our Flutter app to the Liquid Galaxy to visualize this data on the Liquid Galaxy rig. Next, we make Arduino controlled pointer which emits green laser in the direction of satellite, which is controlled by the app. First, we 3D print the STL files of the 3D projector. Then, we assemble all the components of the Arduino-controlled pointer. Then, for the application, we use flutter_bluetooth_serial package to connect and send data to HC-05 module. Then, we use SGP-4 model to get the servo motor angles for the Arduino pointer. Then, we upload code to Arduino to receive data.
The Scraper class in SunPy retrieves solar data from web sources using efficient file organization. The current implementation uses regex for the core functionality which limits the use-cases and has made the class difficult to maintain. The project aims to re-implement the Scraper to use parse instead and make it easier to work with. The goal also involves implementing newer functionality while keeping the same API for the rewritten parts.
This project aims to implement a daemon that serves as a build system manager for modules, providing support for explicitly built modules irrespective of the build system. By simply incorporating a single command line flag, each Clang invocation registers its translation unit with the daemon, which then scans the unit's dependencies. As translation units are registered and analyzed, the daemon constructs a dependency graph for the entire project. Concurrently, it utilizes the emerging graph to schedule and build each module's AST. This approach allows for a single, comprehensive entity to effectively coordinate and manage the build of modules throughout the entire build process.
Zulip Terminal is a TUI which caters to users who use Zulip through their terminal. But, many functionalities in Zulip Web App are not currently implemented in Zulip Terminal. The features/areas this project will focus on are a) Achieving the same level of notification functionality as Web App. b) Add the feature of file upload along with other related issues. c)Support muting/unmuting of users d)Support Alert-Words. Most of the issues need work on multiple areas such as event handling, UI changes/additions, Migrations etc.
1st CLasS framework is an open-source project that deals with the deployment of a custom kernel on AWS EC2 instance cloud FPGAs with fully automated scripts and establishing a connection with Web Applications using web protocols and APIs. The AWS F1 instances are quite costly (around 2 dollars/ hr) so the focus of the project will be to add local FPGA deployment as well and integrate it with a hardware-accelerated web application.
This project contain two parts which are Bb-Config Improvement and GPIO Benchmarking. For bb-config improvement, I will implement some new features on top of it making more user interactive and functionable. For GPIOs benchmark, We needed data to help ourselves and developers to decide which method accessing GPIOs suit them better. We compare the latency performance of different methods to access GPIOs.
<p>The new implementation will consist of a central registry in <code>ProjectState</code><em> instances where all the related fields would be registered for all apps. Then significant changes in <code>ProjectState</code></em>, Schema Editor, and <code>Operations</code><em>' subclasses would be made in order to make all of them adapt ModelStates in spite of fake rendered models in a backward-compatible way. Then the new method mapping in <code>ProjectState</code></em> for all Operation subclasses' <code>state_forwards</code> and <code>state_backwards</code> would be introduced. And after all this, the traditional <code>__fake__</code> model implementation would now be replaced with new <code>ModelState</code> implementation</p>