Fetching the latest programs, projects, and workspace data.
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.
The function of the list configuration tool is to export the list and configuration of the administrator and generate a JSON file to store them. At the same time, you can also use these JSON files to import the list and configuration in the file into other users. This is a process of converting the server's online data into files for storage, backup and data migration.
<p>The main goal of the proposed project is to create the frontend part of a JPEG encoder which will be implemented in MyHDL. The frontend part consists of the color-space converter, the 2D DCT, the top-level FSM, and the input buffer. Based on a reference design, the final implementation in MyHDL will provide a more modular and scalable design. Throughout the project, will be developed all the required unit tests to prove the correct functionality of each block of the frontend part of the encoder while keeping in mind not only to verify the correct behavior of the design but also to produce synthesizable VHDL/Verilog code. The ideal goal would be to create a fully working JPEG encoder by combining the frontend and the backend part of the encoder written in MyHDL and implement the converted code in a FPGA board in order to measure some metrics like resource utilization and performance.</p>
In this proposal, I outline three projects. The following is a brief outline of each project problem, solution, and set of deliverables: Project 1) Improving Test Coverage Problem: Vorta has a current test code coverage of 72%, and we would like to get this in the 80% - 85% range. Additionally, current testing files need more a consistent file structure and organization. Solution: Work with organization mentors to prioritize test code coverage. Create unit and integration tests to reach our target code coverage. Reorganize and restructure testing file. Deliverables: At least 80% code coverage, with a stretch goal of 85%. Test files separated into unit tests vs integration tests. Consistency in file naming and structure across all test files. Project 2) Implement Profile Sidebar Problem: The current profile selector and setting tab implementation mixes global setting with profile specific settings. Solution: Move the profile selector and settings button to a collapsible sidebar. The settings button opens a new interface with options relating to global settings and profile management, while the individual profile buttons open to profile specific settings. Deliverables: A new sidebar with profile selector and setting button, as well as a new setting interface. Unit and integration testing accompanying all new features. Project 3: Test on Live Borg Binary Problem: Currently we test on static mock files of Borg JSON output. This task would improve testing to run on actual Borg versions/binaries. Solution: Test multiple versions of Borg using Tox to simplify testing. Implement these changes in setup.cfg Deliverables: CICD running tests on live Borg binaries with > 99% success rate. Include the option to run existing integration tests locally. Include thorough documentation of this process.
<p>I have started doing the initial work on the EOS Adobe XD plugin and I found the community extremely supportive. For the summer, my goal would be to increase the capabilities of the Adobe XD plugin, and develop the Angular package for EOS. This might touch the sister packages for React library and the original NPM package and I would ensure there are no frictions during development and we are on the same page while moving forward.</p>
<p>Scrapy uses a signaling mechanism, as documented here: <a href="http://doc.scrapy.org/en/latest/topics/signals.html#topics-signals" target="_blank">http://doc.scrapy.org/en/latest/topics/signals.html#topics-signals</a> to notify various entities when something of interest happens, so callbacks can be triggered accordingly and deferred calls can be processed. Signaling is also exposed via the core API of Scrapy for use in extensions/middleware. The current signaling mechanism is based on the <code>pydispatcher</code> library which although does serve the purpose well often tends to be slower than the actual HTML parsing and tends to bottleneck spiders(see: <a href="https://github.com/scrapy/scrapy/issues/8#issuecomment-112029296" target="_blank">https://github.com/scrapy/scrapy/issues/8#issuecomment-112029296</a>). Django, in its 1.0 release refactored the <code>pydispatcher</code> code which they claim resulted in a speed improvement of up to 90%, and also simplified the API for better. The task at hand is to introduce the same efficiency in Scrapy while also trying to retain as much backward API compatibility as possible and not breaking any user code.</p>
pocketpy is a lightweight Python interpreter that can be embedded in C++ applications. Though pocketpy has provided low-level APIs for creating Python bindings, it requires a lot of boilerplate wrapper code to bind complex C++ classes. The community has long expected a high-level solution for creating bindings. pybind11 is a header-only library that exposes C++ types in Python and vice versa, which has been widely used to create Python bindings of existing C++ code. Inspired by pybind11, this project aims to implement a compatible binding solution for pocketpy. By utilizing the template metaprogramming technique in C++17, we can extract metadata from C++ classes and functions and generate wrapper code automatically. By the end of this summer, header files compatible with pybind11 will be implemented for pocketpy. Existing pybind11 users can seamlessly migrate their bindings into pocketpy. New users can also benefit from this high-level binding solution. Additionally, we will test and verify the deliverables of the project in Cave Engine, a real-world product built on top of standard pybind11 header files.
The Multiple Flightpath Docking Widget in MSS is crucial for visualizing atmospheric data but lacks customization options hindering effective comparison of flight paths. This project aims to enhance the widget's functionality by introducing centralized line controls, adjustable transparency, Matplotlib linestyle options, automatic color assignment, regex filtering, select all/deselect all buttons, integrated legend, operation labeling, and saving user preferences using QSettings. (Deliverables): Enhanced UI with centralized controls. Improved backend filtering with regex. Comprehensive legend design with synchronization. Annotation feature for operation labeling. QSettings implementation for saving/loading preferences. Test cases, documentation, and future work suggestions.
<p>Radiation is the transmission of energy in the form of waves or sub-atomic particles.In space missions the major concern is the particle radiation.Energetic particle radiation passing through human body could damage the cells or DNA causing an increased risk for cancer. Especially when out of Earth's magnetic field protection, astronaut's are exposed to ionizing radiation with doses in the range from 50 to 2,000 mSv(milli Sievert). The evidence of cancer risk from ionizing radiation is extensive for radiation doses that are above about 50 mSv. Hence it is important to forecast the radiation events and train crew members to tackle the issue of radiation effectively in simulated environments(Mars city project).</p> <p>The aim of the project is to build a reliable system(Tango server) to :</p> <p>1) Alert crew about the incoming SEP event if the radiation level is above the SWPC set threshold.</p> <p>2) Issue the “all - clear” signal once the event has passed Mars.</p>
d-SEAMS currently uses an embedded Lua interpreter to provide user interactivity in tandem with YAML inputs for selecting workflows. The project seeks to replace this interface with a Python interface. This is expected to take place in two stages: - Replacing the Lua Interpreter with Python - Binding to C++ classes and functions directly With both of these milestones completed, feature parity will be kept with the existing code while also providing much more flexibility due to the Python library formed in the second deliverable.
Memory safety is critical to delivering reliable and secure software. This is even more evident with projects like CPython, which is integral to innumerable applications across the world and unfortunately a prime target for attackers. Based on recent guidance by the OpenSSF an effort has been made to look into implementing hardened compiler options for CPython. The phases of this project include establishing benchmarks for existing performance with current compiler options as well as the counts and types of errors. Some work has been done so far to evaluate warnings when compiling with the TL;DR compiler options provided by OpenSSF, but more research should be done to establish candidate flags. Secondly performance analysis should be generated for candidate compiler flags. Warnings should be combed for false positives since this can impact if the work should be undertaken to fix these warnings or not use the compiler flag. Once compiler options have been selected in accordance with desired safety goals, performance analysis, and additional work needed to address warnings then tooling should be implemented to track new violations relative to an existing baseline.
<p>Since the Blender 2.8 update, that introduced the Grease Pencil object type, there are a couple of primitives that can be added in the Grease Pencil draw mode. The user can draw a shape (e.g. a circle, arc, rectangle, etc.) using the respective tool, edit it and confirm the creation of the stroke. After this step, the shape can no longer be manipulated as a curve. I propose to add an interactive edit mode tool, that allows the user to manipulate any Grease Pencil stroke using curve handles.</p>
PyZombis is a community course to teach Python to the Spanish-speaking community. It is based on a Brazilian MOOC Python para Zumbis. The idea is to make an improved version of the course in Spanish, with an interactive environment for the students, that allows them to visualize and try active code on the site. I'm going to add the browser's local storage functionality which helps when in downtime/remote network connections. This will allow students to work in the course offline or with a bad internet connection. Along with this improvement in Pygame lectures and other improvements in project lectures
<p>This project aims to implement a feature-rich code analysis plugin for the Eclipse IDE using <code>coala</code>. This plugin will perform the analysis by running the given code through <code>coala</code> and present the results to the user to take further action. The user can then view the diff or apply the patch with a single click.</p>
<p>The project goal is to add an editor menu for the quick favourites in the preferences and to give the possibilities to create more personal menu and to be able to display them on screen like the editors menu (3D viewports, properties, ...).</p>
<p>Scrapy currently uses Python's inbuilt RobotFileParser which is not fully compliant, but the more compliant alternatives are difficult to package and use within Scrapy’s pure-python development tree. This project is about introducing a new interface for robots.txt parsers in scrapy, allowing users of scrapy to substitute a different robots.txt parser. The stretch goal of the project is to create a pure python parser for robots.txt files.</p>
<p>The aim of the project is to ease the process of creating a new Lint Bear, addressing the issue of linting files having embedded source code and provide command line interface improvements to existing coala application.</p> <p><a href="http://mr-karan.github.io/2016/08/13/coala-GSoC-2016-Summary.html" target="_blank">http://mr-karan.github.io/2016/08/13/coala-GSoC-2016-Summary.html</a></p>
<p>The GTK client (Tryton) already has CSV Import/Export feature. This project would implement the same feature in web client (SAO) keeping the behavior similar.</p>
This project aims at bridging the gap between popular DataFrames and the Pharo DataFrame. This can be done by adding more functionality to the Pharo DataFrame. The DataFrame API in Pharo will be improved by fixing existing features and adding new ones. This project also aims to make the Pharo AI DataFrame Inspector interactive. This will be achieved by enabling users to perform operations such as editing, searching, sorting, etc., directly from within the DataFrame Inspector itself.
Features 1. Per-brush opt-in for scene-level brush settings (“use unified xxx”). 2. Brush tip roundness (currently available in limited brushes). 3. Customizable pressure curves for all pressure-sensitive parameters. 4. Customizable brush toggling and improved toggle display. 5. Improved first-stroke responsiveness across relevant brushes. 6. Pressure handling improvements in anchored mode. Deliverables 1. Tip roundness and tilt support across all relevant brushes. 2. Per-brush “use unified xxx” support. 3. Custom curve controls for all pressure-sensitive parameters, including auto-smooth and hardness. 4. Improved brush toggle UI and behavior. 5. Improved first-stroke responsiveness for relevant brushes. 6. Improved anchored-mode pressure handling. 7. End-user documentation for new features.
<p>As someone who uses Blender as his main tool on a daily basis I know just how cabale Blenders UV Editor is ...But I also know about its shortcomings and areas for improvement regarding the current tool-set. In this project I aim to improve the UV Editing workflow by improving the current tools as well as adding new ones. Improvements to a UV tool could mean enhancing its features, working on usability or both of course.</p>
This proposal aims to enhance the visualization system of Mesa, an agent-based modeling (ABM) framework in python, to make it more modular, user-friendly, and feature-rich. The project addresses two key issues in the current visualization system: clumped API design and difficulties in model sharing. The implementation plan is divided into two phases: 1) Phase 1 focuses on creating a more modular API for space drawing by developing AgentPortrayalStyle and PropertyLayerStyle components, separating agent drawing from grid drawing with a CoordinateMapper, and creating a unified SpaceRenderer class. 2) Phase 2 implements model sharing through links, upgrades the Altair visualization backend to match matplotlib capabilities and improves documentation. Deliverables include: a separate and intuitive visualization API, easy model sharing functionality, an improved Altair backend and comprehensive documentation. This upgrade will significantly improve the user experience for Mesa users.
This project will aim to create an LLM module within Mesa that enables the use of large language models as autonomous agents, via mesa.llm. This module will extend Mesa by providing tools to define, simulate, and analyze agents powered by large language models.