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.
I work on Gitcord, a tool that connects a GitHub organization with a Discord server to help track and manage open-source contributions. The system will collect GitHub events such as issues, pull requests, reviews, and merges, store them locally, and calculate contributor scores based on configurable rules. The automation will follow a simple pipeline (Read → Plan → Report → Apply) so that every action can be reviewed before it is applied. To keep the system safe, it will run in dry-run mode by default and generate audit reports for maintainers. The project will also include a Discord bot that allows contributors to interact with the system directly from Discord. Contributors will link their GitHub and Discord accounts using a verification step instead of OAuth. Through bot commands, users will be able to check contribution summaries, view pull request information, request issues, and receive notifications about reviews, assignments, and merged pull requests. Gitcord will follow a local-first approach, storing data in a SQLite database rather than relying on external services. It will maintain records such as contribution history, identity mappings, audit logs, and notification history. The project will also include documentation, YAML-based configuration, Docker support, and automated tests so that organizations can deploy and maintain the system more easily.
HPX already has partial Tracy support and stronger integrations with tools like VTune and APEX, but tracing is still fragmented and largely thread-centric. This makes it difficult to understand how tasks actually behave, especially across suspension, resumption, and asynchronous dependencies. This project focuses on strengthening and extending Tracy integration in HPX by building on the existing hpx::tracing abstraction and expanding task-level instrumentation across key runtime paths. The goal is to make task execution easier to follow by improving lifecycle visibility, especially around suspend/resume behavior, and by adding initial causal signals (for example, future fulfillment and other synchronization events) to help explain why tasks resume. The work will also extend tracing to execution paths that currently lack visibility, such as fork_join_executor and continuation execution, and introduce scalable controls like filtering and sampling to keep tracing usable in fine-grained workloads. As a stretch goal, I will explore optional trace-context propagation across parcel paths to enable cross-locality correlation in distributed runs. The expected deliverables include integrated tracing hooks across core runtime components, improved suspend/resume tracing, better coverage of executor and continuation paths, benchmark-validated low-overhead operation, and clear documentation for both maintainers and users.
<p>Open Event Organizer is an Android Application for Event Organizers and Entry Managers. It is a client side application for another project under FOSSASIA named Open Event Organizer Server.</p> <p>The core features implemented in the app are:</p> <ul> <li>Scan a QR code to validate an attendee's check-in</li> <li>Overview of Sales</li> <li>Ticket Management</li> <li>Edit Basic Event Details</li> <li>Offline Support to the above-mentioned features</li> </ul> <p>The app is designed on the Model View Presenter Architecture which enables robust unit testing. Each feature implemented in the app has a complete coverage of unit tests. The app uses most of the modern open source technologies like ReactiveX API for multithreading, Dagger for dependency injection, OkHttp+Retrofit for handling network requests, Evernote's android-job for handling jobs in the background, JSON API-converter to handle JSON API schema responses, Google Vision API for scanning QR code, Glide for image loading/caching, Jackson to parse JSON data, Leakcanary to detect memory leaks, Lombok for logs, Mockito Framework for unit tests, DbFlow ORM database library, Data Binding etc. Material Design Guideline is followed for the UI in the app.</p>
Bio-Block is an open-source healthcare data marketplace on Ethereum and IPFS that handles the full upload → anonymize → encrypt → sell → download lifecycle. However, the pipeline stops at download — once a buyer purchases and decrypts a dataset, there is no way to analyze it inside Bio-Block. This project adds a data analytics layer by introducing a dedicated FastAPI Analytics API (port 3003), a lightweight AnalyticsRegistry smart contract for on-chain result tracking, and a React dashboard for visualizations. The system supports three levels of analysis: graphical (distribution plots, heatmaps, scatter plots via matplotlib/plotly), descriptive (summary statistics, correlation matrices via pandas), and inferential (t-tests, chi-square, ANOVA via scipy/statsmodels). Results are stored on IPFS and linked to their source datasets on-chain via the AnalyticsRegistry contract, maintaining an unbroken chain of custody from data purchase through analysis. Deliverables include: (1) Analytics API microservice with EIP-712 authentication, (2) AnalyticsRegistry.sol smart contract deployed on Sepolia, (3) IPFS result storage and on-chain attestation pipeline, (4) Interactive React analytics dashboard integrated into the existing frontend, (5) Comprehensive test suite (80%+ coverage) and documentation. An optional differential privacy layer using OpenDP is planned as a stretch goal.
<p>Improve the performance and scalability of TEAMMATES.</p> <ol> <li>Migrate Storage component to Objectify API<ul> <li>Rewrite entire Storage layer to use Objectify instead of JDO</li> <li>Deploy change and divert small amount of live traffic to new version for testing</li> <li>Turn on Objectify global cache (uses memcached); do similar isolated testing</li> <li>Fix issues surfaced during live testing (if any), then fully deploy new version</li> </ul> </li> <li>Write performance profiling tests for Storage and Logic components<ul> <li>All methods in Storage and Logic API to be profiled for cost and performance</li> <li>Use remote API client for client-driven testing</li> <li>Use task queues for app-driven testing</li> <li>Results to be used as a benchmark when making changes to the architecture</li> </ul> </li> <li>Redesign schema<ul> <li>Determine entity groups based on GAE transaction limits and our usage</li> <li>Use conceptual relationships as much as possible while keeping within limits</li> <li>Plan for extensibility: should be able to support new features like LTI compliance without too much effort</li> </ul> </li> </ol>
Help us fight climate change through nature-based solutions! The Full Lands INtegration Tool (FLINT) is a platform for estimating greenhouse gas emissions at local, national and global scales. This project aims to build a cloud deployment framework for rapid deployment of FLINT implementations. This framework will be used in a continuous deployment pipeline (CD) for integration testing and the delivery of FLINT as a service (FLINTcloud) for demonstration purposes. We hope to offer an easy entry point for new users to evaluate the FLINT platform and provide a blueprint for new users to roll their own FLINTcloud deployments. This is critical to help drive the adoption of FLINT and help scale up the monitoring, reporting and validation of carbon emissions and sequestration from land use and land use change around the world. This will involve: 1. Publishing a design for the complete FLINTcloud solution, detailing the required components, technologies and endpoints to be exposed. 2. Exposing the core FLINT routines by wrapping the existing command line interface in a REST API. 3. Creating a simple script to install the prerequisite libraries, FLINT and its modules as a standalone microservice. 4. Creating the deployment framework and setting up a CD pipeline on commodity cloud hardware, favouring automation wherever possible (e.g. infrastructure-as-code). 5. Providing new documentation for the cloud deployment procedure.
The healthcare system in Pakistan, particularly in rural areas, faces significant challenges due to limited access to medical facilities and high costs of conventional diagnostic equipment. These constraints leave a large portion of the population underserved, with limited access to timely and reliable healthcare. This project aims to address these gaps by providing a low-cost, portable healthcare solution powered by energy-efficient Edge-AI. By leveraging advancements in RISC-V technology, the proposed solution can revolutionize healthcare delivery in underprivileged areas, ensuring affordable and accessible diagnostics for all. The project, Healthcare-Centric Edge-AI Development on RVMCU Architecture, builds upon the RVMCU, a RISC-V microcontroller designed during the Linux Foundation's Spring 2024 LFX Mentorship Program. The RVMCU, which is compliant with the RV32IMC_Zba_Zbb_Zicsr_Zifencei specifications, was developed as an ultra-low-power, versatile SoC. This proposal seeks to extend that foundational work to enable healthcare-centric applications, specifically targeting wearable and portable devices. The enhanced RVMCU architecture will support diverse healthcare sensors (e.g., cough monitors, heartbeat detectors, ECG sensors) and provide real-time AI-powered analytics. The emphasis will be on achieving energy efficiency, modularity in hardware and firmware design, and seamless integration with AI frameworks optimized for edge computing.
This project aims to create a tool that automatically generates Python typing stubs for the Device Under Test (DUT) in cocotb-based hardware verification testbenches. By leveraging cocotb’s existing introspection capabilities, the tool will produce .pyi stub files describing the DUT’s interface – its hierarchy of modules and signals – in a statically typed fashion. These stubs will enable IDE features like auto-completion via VS Code’s Pylance and allow static type checkers such as mypy to catch errors in testbench code, significantly improving the hardware verification development experience. The generated stubs will mirror the HDL design’s structure (with considerations for hierarchical vs. flat representations) and provide a structured abstraction of the DUT interface that can even be used for mocking or unit-testing components of the testbench. Initially, the stub generator will rely on runtime cocotb introspection only, but it will be designed with extensibility in mind, so that future enhancements (e.g., integrating a SystemVerilog language server like slang for richer type info) can be incorporated. Over a 175-hour Google Summer of Code timeline, the project will deliver a working stub-generation utility, along with documentation, tests, and integration into the cocotb ecosystem, providing a concrete benefit to the open-source hardware verification community.
This proposal aims to implement HTTP/3 communication for Dubbo Triple in the Go language environment, enhancing the connection management capabilities of the Triple protocol in dubbo-go. The proposal will address the compatibility issues between Triple communication in dubbo-go and dubbo-java by implementing keep-alive functionality at the Triple protocol layer. Additionally, the proposal plans to organize and standardize the error codes of the Triple protocol and output necessary log information. By developing a Triple HTTP/3 server and client, seamless and high-performance communication between Dubbo Java and Dubbo Go over the HTTP/3 protocol will be achieved. We will design a connection pool to effectively manage Triple connections and ensure the validity of connections through a PING-PONG mechanism between the server and client, thus realizing keep-alive functionality. Furthermore, the error codes of the Triple protocol will be standardized according to Dubbo Java's standards to facilitate developers in obtaining detailed log information during the debugging process. The final deliverable of the proposal is to achieve high-performance, barrier-free communication between Dubbo Go and Dubbo Java through the Triple protocol, ensuring perfect compatibility and support for interaction via the HTTP/3 protocol. Users will be able to enjoy flexible keep-alive functionality and improve debugging efficiency through standardized error codes.
<p>Systems biology researchers study the network of molecular interactions within a biological system and publish the deduced models in a diagram format. Many XML variants were developed to represent diagrams, including SBML and SBGN. However, SBML can represent much more complex models than SBGN. For example, the SBML qual extension package can mechanistically describe events in its models, such as the relationship that A activates C, B activates C, but A and B cannot activate C at the same time. The SBGN Activity Flow language can describe a similar relationship, but the relationship is represented visually only, and therefore is not stored in its model. The incompatibilities between SBML and SBGN prevent direct comparison between the models.</p> <p>In this project, I will build tools to support bidirectional conversion between SBML and SBGN, which acts as a machinery to map between SBGN-specific and SBML-specific information. SBML Layout package will be used to represent SBML diagrams, and the SBML qual package used to store the logic model.</p> <p>Blog: <a href="http://haleyyew-gsoc.blogspot.ca/" target="_blank">http://haleyyew-gsoc.blogspot.ca/</a></p> <p>Repository: <a href="https://github.com/NRNB-GSoC2017-SBML2SBGNML-Converters/SBML2SBGNML" target="_blank">https://github.com/NRNB-GSoC2017-SBML2SBGNML-Converters/SBML2SBGNML</a></p>
The project aims to complete the development of the Tauri Desktop Application. This project will finally mark the completion of the Vue-simulator and replace the legacy simulator with the Vue-simulator. This project has been divided into 7 parts - 1. Fixing the current bugs in the simulator and Desktop App - Fix the bugs, refactor the user Authentication for the Desktop Application, fix the broken Verilog module and Test bench enhancements. 2. Type script integration and Vue frontend updates - Ts integration, replacing Options API with Composition API, replacing JQuery with Vue's reactivity and increasing the use of Vue lifecycle hooks. 3. Testing for Web and Desktop simulator - Fix the current test failures, Mock APIs for desktop application testing, writing additional tests for Tauri app for the Verilog, Testbench fixes and the additional features added to Tauri App. 4. Integration of Vue simulator with the primary codebase - Replace the legacy simulator with the vue-simulator for development and production. 5. Versioning of App and Release for the Desktop Application and Update Mechanism for Tauri App - Deploying a seamless release pipeline for versioned releases with the artifacts mentioned, optimizing those built artifacts, and implementing a reliable update mechanism to deliver the future improvements seamlessly. 6. Implementing Verion switch (backend). 7. Documentation for the Vue-simulator and the Desktop Application.
This proposal aims to implement intelligent event classification, natural language search, and EXIF metadata read-write capabilities for image metadata portability. Key backend upgrades include implementing image metadata based image clustering with SigLIP2 for visual similarity-driven clustering. It introduces application optimization techniques like modular AI model management, allowing users to extend functionality on demand without bloating the base install, to keep the core application lightweight. It improves face clustering accuracy by addressing confirmed gaps in the current DBSCAN pipeline, including adaptive eps estimation and a face quality gate. On the frontend side, a new Memories UI will be introduced with advanced sorting features, user notifications, video support, along with a new landing page for the product launch. A major addition is shareable album links: users will be able to generate secure, token-based links to share selected photos over the network while the PictoPy backend is running, with new API endpoints serving image data directly to a lightweight web-based receiver. Additionally, comprehensive documentation—including contributing guides, API references, and setup videos—will encourage new developers to contribute. These improvements will make PictoPy more user-friendly, scalable, and ready for widespread adoption.
The Inspektor Gadget gadgets are heavily coupled to the kernel version as they need to access internal kernel data and use different eBPF features. One key feature for Inspektor Gadget is to hide all this complexity from its users: the gadgets should work the same regardless the kernel version they’re running in. To be sure our gadgets (and Inspektor Gadget too) are working fine, we need to run tests on different kernel versions we want to support. The purpose of this mentorship is to develop a framework that allows gadget developers to (1) implement unit tests for their gadgets (2) and run them on different kernel versions. A previous mentorship successfully implemented a framework for running integration tests (https://github.com/inspektor-gadget/inspektor-gadget/pull/2607), now it’s time to extend that framework to allow running unit tests as well. Some preliminary investigation done in (https://github.com/inspektor-gadget/inspektor-gadget/pull/2638) explored the possibility to use https://github.com/lmb/vimto, it seems it’s the right tool for the job. Expected Outcome: Gadget developers have a way to run unit tests in different kernel versions for their gadgets in their CI platform Upstream Issues: - https://github.com/inspektor-gadget/inspektor-gadget/issues/3195 - https://github.com/inspektor-gadget/inspektor-gadget/issues/1343
The multibeam sonar is a ray-based plugin designed to simulate the physics of acoustic signal propagation, including phase and reverberation effects. Originally developed for ROS 1 Noetic and Gazebo Harmonic as part of the DAVE project, it is currently being migrated to Gazebo Harmonic and ROS 2 Jazzy. This project aims to complete the migration and enhancement of the multibeam sonar plugin, with three main deliverables. The first is an enhanced plugin with improved performance through the introduction of half-precision calculations in CUDA. It is expected that this modification will greatly improve frame refresh rates. Numerical accuracy must be carefully taken into account when implementing it, however, and this should involve thorough testing and evaluation using quantitative metrics in comparison to the performance of the single-precision code. The second deliverable is the extension of simulation capabilities to support additional sonar types. Building on the existing multibeam sonar, it should be feasible to implement a side-scan sonar with for seafloor imaging, taking into account shadow analysis and directivity patterns like side lobes, for example. Finally, benchmark integration is essential to make the simulation more practical and accessible. This involves incorporating hardware that is often used in maritime robotics, like the BlueROV, and not only efficiently modeling the vehicle and its sensors, but also offering examples that are effortless to use. These benchmarks will enable the simulation to be validated and more available and beneficial for the general community, researchers, and developers.
This project implements a D-CAN driver for the AM335x controller on the BeagleBone Black and integrates it into the RTEMS CAN stack, addressing the current lack of CAN support for this widely used embedded platform. This enables RTEMS applications to access CAN communication through standard interfaces such as /dev/canX. The main challenge lies in bridging the mismatch between the mailbox-based D-CAN hardware architecture and the queue-based abstraction used in RTEMS. To address this, the driver will introduce a mapping layer that emulates FIFO-based reception using hardware message objects and implements a software-managed, priority-aware transmission mechanism. Synchronization will be carefully handled through IFx register access and interrupt management to ensure correctness and real-time behavior. The implementation will follow an incremental approach, starting with a minimal working driver (initialization, polling-based TX, FIFO RX), and then extending to interrupt-driven operation, improved mailbox utilization, and priority-aware scheduling. Validation will be performed on real hardware using loopback and cross-platform communication tests (RTEMS ↔ Linux). Deliverables include a fully functional and maintainable D-CAN driver integrated into RTEMS, along with documentation, test demonstrations, and validation results. This work will also serve as a reference for future CAN driver development within the RTEMS ecosystem.
XRefer is a binary analysis tool built by Mandiant FLARE that uses cross-reference correlation, capa integration, and LLM-powered cluster analysis to help malware analysts navigate complex binaries faster. Today it requires IDA Pro, Binary Ninja, or a configured Ghidra environment to run, locking out students and researchers who lack commercial licenses or heavyweight setups. This project implements a fully functional Radare2 backend for XRefer via the r2pipe Python bindings, paired with a standalone CLI that auto-detects the best available disassembler and falls back to Radare2 when none are found. Radare2 is free, open-source, cross-platform, and pip-installable, making it the right foundation for democratizing XRefer access. The backend maps every method of the BackEnd abstract base class to verified r2pipe commands, handles known r2 edge cases including the aflj NaN-value bug and pdfj integer overflow, and includes targeted refinements to the base abstraction layer. Deliverables are: a complete Radare2 backend module passing integration tests against the Ghidra backend on a three-binary reference corpus; a standalone CLI installable with pip; a test suite with pre-recorded JSON fixtures enabling CI without a live r2 installation; and full documentation covering setup, architecture, and guidance for adding future backends.
Antrea provides [Network Policy APIs](https://github.com/antrea-io/antrea/blob/main/docs/antrea-network-policy.md) (in the form of K8s CRDs) for K8s cluster administrators and application developers to declare security rules in order to protect workloads. These APIs complement the [Network Policies supported natively in K8s](https://kubernetes.io/docs/concepts/services-networking/network-policies/). When using the Antrea-specific Network Policy APIs, it is possible to use Fully Qualified Domain Names (FQDNs) in order to select the list of external domains with which a K8s application is allowed to communicate, or forbidden from communicating. The current implementation of this feature is not compatible with applications which directly cache the result of DNS queries. We have found that this type of caching is frequent for Java applications, which greatly impacts the usability of FQDN-based security rules. We believe that by defining a new configuration parameter for the Antrea implementation, we can bypass the issue and ensure that the feature can be used even with such applications, providing of course that the parameter is set correctly by users. Expected Outcome: Definition and implementation of a new configuration parameter (`minTLS`) for the Antrea Agent, which will ensure that FQDN-based security rules can be used even with application that cache DNS results. The implementation should come with a sufficient amount of tests (both unit tests and e2e tests).
The RISC-V Certification Steering Committee is developing certification tests to prove that RISC-V processors conform to the ratified specifications. The goal of this mentorship project is to run the tests on as many open-source RISC-V cores as possible, and improve the usability of the tests, debug any issues found in the tests, and report any real bugs that might be found in the cores. This work will involve: * Identifying multiple open-source cores to test * For each core: - Develop a Unified Database (UDB) file specifying the extensions and parameters supported by the core - Implement trick box macros to trigger interrupts, print characters to a console, and terminate a simulation in a core- specific manner - Create a linker script appropriate to the memory map of the core - Compile the tests with the core-specific trick box and linker scripts - Run the relevant tests on the core * Identify and fix any problems in the tests that make them hard to run on a core * Identify and fix any problems with the flow or documentation * Identify and report any bugs found in the cores The work will start with Phase 0 tests of the RVI20 profile with the RV{32/64}IMACDF extensions in machine mode. As time permits, it will continue to the Phase 1 MC100 microcontroller profile with machine mode, traps, Zicsr, and Zicntr, and then to the Phase 2 RVA23 application processor profile with all privilege modes, vector and hypervisor.
AMD chips, with their powerful x86 architecture, exceptional computing performance, and advanced NPUs, demonstrate significant potential in fields such as industrial automation, in-vehicle systems, and high-performance edge computing. Introducing AMD's robust general-purpose and heterogeneous computing capabilities into the KubeEdge ecosystem is crucial for handling increasingly complex and latency-sensitive edge AI applications.However, the deep integration, performance optimization, and best practices between KubeEdge and AMD's high-performance edge platforms—particularly their built-in NPUs and other hardware acceleration units—still require systematic exploration and validation. This project aims to establish a complete link between KubeEdge and AMD edge nodes, building a comprehensive edge computing solution from hardware deployment to NPU acceleration, thereby greatly enriching KubeEdge's hardware ecosystem. Expected Outcome: 1. Debug and support KubeEdge edge nodes running on AMD chips 2. Successfully deploying and managing edge application Pods on AMD-based edge nodes 3. Scheduling and managing AMD NPU resources through KubeEdge to achieve performance acceleration for edge AI inference applications. 4. Implement monitoring and metric collection for nodes, applications, and NPUs 5. Using KubeEdge to achieve the complete platform setup, configuration, and management from the cloud to AMD edge nodes 6. Complete hardware compatib.....
<p>A long-standing issue with Haskell’s documentation tool Haddock is that it needs to effectively re-perform a large part of the parse/template-haskell/typecheck compilation pipeline in order to extract the necessary information from Haskell source for generating rendered Haddock documentation. This makes Haddock generation a costly operation, and makes for a poor developer experience.</p> <p>An equally long-standing suggestion to address this issue is to have GHC include enough information in the generated <code>.hi</code> interface files in order to avoid Haddock having to duplicate that work. This would pave the way for following use-cases and/or have the following benefits:</p> <p>1) Significantly speed up Haddock generation by avoiding redundant work.</p> <p>2) On-the-fly/lazy after-the-fact Haddock generation in cabal new-haddock and stack haddock for already built/installed Cabal library packages.</p> <p>3) Add native support for a <code>:doc</code> command in GHCi’s REPL and editor tooling (ghc-mod/HIE) similar to the one available in other languages (c.f. the Idris REPL or the Python REPL)</p> <p>4) Allow downstream tooling like Hoogle or Hayoo! to index documentation right from interface files.</p> <p>5) Simplify Haddock’s code base.</p>
Kai is a tool designed to leverage AI for application modernization by analyzing code, identifying issues, and suggesting fixes. We aim to enhance Kai by developing a robust data querying mechanism to facilitate fine-tuning processes. This enhancement will lay the groundwork for potential future integration with InstructLab, an open-source AI project enabling community contributions to Large Language Models (LLMs) by adding new skills or knowledge. The primary focus will be on creating mechanisms to query and utilize data effectively, with a stretch goal of integrating static analysis tools and implementing an agent-based workflow. - This project will significantly enhance Kai’s backend, making it more scalable and capable of providing deeper code insights while also contributing to the enrichment of LLMs through InstructLab. It will offer a rich learning experience for participating students, covering backend development, workflow management, and contributing to open-source AI projects. - Expected Outcome: - Successfully develop and implement a data querying mechanism in Kai to facilitate fine-tuning processes. - Demonstrate the enhanced backend with improved data querying capabilities. - Participate actively in community meetings, presenting progress and insights. - Create a detailed blog post documenting the project, its outcomes, and potential future directions, including the possible integration with InstructLab. - (Stretch Goal) Develop a reusable module fo
The current KubeEdge platform represents device states using three statuses: Desired, ObservedDesired, and Reported. The device states displayed on the platform are entirely reliant on the Mapper, which collects and reports data from the device side. However, due to limitations in the Mapper implementation, physical device malfunctions, network delays, and potential network attacks, the device states shown on the platform may not accurately reflect the actual state of the devices. In the KubeEdge platform, if applications depend on device states for decision-making, such inconsistencies in state representation may lead to undesirable outcomes. Therefore, this project aims to design a device state anomaly detection framework for KubeEdge. By exploring the causal relationships among device states, the framework will establish lightweight anomaly detection capabilities and provide a comprehensive toolchain encompassing data collection, model training, real-time anomaly detection, and results visualization. Expected Outcome: 1. A general-purpose device anomaly detection framework that supports user-defined detection algorithms 2. A complete technical design document including model selection, training procedures, and detailed architecture diagrams for both training and online detection components 3. A machine learning model and corresponding anomaly detection algorithm capable of capturing causal relationships among device states, trained and tested using standard frameworks...
<p>JuliaAstro organization provides astronomers with the tools to work with the Julia language. One of the latest packages is AstroImages.jl, which aims to allow researchers to visualize astronomical images coming from FITS files. It is meant as an interface to popular Julia packages like Images.jl and Plots.jl This package is now in its infancy stage. The goal of this project will be to introduce new features and make it useful.</p> <p>GOALS</p> <ol> <li>Allow users to Reproject and co-align different ImageHDU into one using their WCS header info</li> <li>Support 3 channel/band astronomical images (i.e different extensions like RGB, HSV, XYZ, Lab etc.) and handle interconversions while minimizing losses</li> <li>Integrate different plotting feature like zooming, grids, overlays, markers, labels etc. with AstroImage type.</li> <li>Allow interactive GUI based or script based plotting of astronomical images</li> <li>Designing interface and integration with Images.jl for operations like contour plotting, filtering, histograms, segmentation etc</li> <li>(optional) Some miscellaneous features like blending of images from different fits files, custom colourmap visualization</li> <li>Design distributable format (metadata specific) of these custom visualization</li> </ol>
P4 empowers developers to program the data plane of network devices—switches, routers, and NICs—at a level of detail previously only accessible to hardware designers. P4 software/simulated switches like BMv2 make the development even easier by having the programs and control plane run on developers' computers and give instant feedback. This project aims to further improve the capability of BMv2 and enable a potentially broader insight for developers to analyze their P4 program. While traditionally one packet only goes through one path within the switch and thus obtains only one result, there are many situations where it is more useful to have all possible outputs from a P4 simulation. For example, we use this for diff testing, to determine whether the switch is doing something correct or something incorrect. Multiple allowed behaviors and results usually arise from various multi-path constructs (e.g. ECMP, WCMP, or perhaps LAGs) which are often modeled as action profiles/selector in P4. BMv2 currently allows users to set a mode determining action profile/selector behavior, like `round robin` where every time one sends in the same packet, it would invoke the next possible forwarding action (eventually wrapping around). The goal of this project is to provide a new mode for BMv2 to output all possible behaviors. This will both require extending the action profile modes, and extending the notion of output from a set of packets to a set of sets of packets.