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.
<p>The Open Event project has SIX components:</p> <ul> <li>The Open Event Format Definition</li> <li>The Open Event Server</li> <li>The Open Event Generic Android App and It's Generator</li> <li>The Open Event Web App Generator</li> <li>The Open Event Organiser App</li> <li>The Open Event Frontend</li> </ul> <p>All the components support organizers in all stages from event planning to publishing, marketing and ticket sales for all kinds of events including concerts, conferences, summits and regular meetups.. Automated web and mobile apps help organizers in creating event web pages and apps without any investment or knowledge of development. This also helps attendees to get information easily.</p> <p>This proposal focuses on the <strong>Open Event Server, the Organizer App, and the Frontend</strong> for the summer.</p> <p>For the Open Event Server, remaining important features will be added in order to make it feature complete. These features would then be implemented in the Frontend and the Organizer App.</p> <p>The Organizer App's architecture will be revamped from MVP to MVVM. And new features from the server will be implemented while using reactive programming, dependency injection, and other modern standard libraries.</p>
Virtio is an open standard designed to enhance I/O performance between virtual machines (VMs) and host systems in virtualized environments. VirtioFS is an extension of the Virtio standard specifically crafted for file system sharing between VMs and the host. This is particularly beneficial in scenarios where seamless access to shared files and data between VMs and the host is essential. VirtioFS has been widely adopted in virtualization technologies such as QEMU and Kata Container. Apache OpenDAL is a data access layer that allows users to easily and efficiently retrieve data from various storage services in a unified manner. In this project, our goal is to reference virtiofsd (a standard vhost-user backend, a pure Rust implementation of VirtioFS based on the local file system) and implement VirtioFS based on OpenDAL. Through this project, VMs can access numerous data services through the file system interface with the assistance of the OpenDAL service daemon deployed on the host, all without their awareness. It ensures the efficiency of file system reading and writing in VMs through VirtioFS support. This storage-system-as-a-service approach conceals the details of the distributed storage system from VMs. This ensures the security of storage services, as VMs do not need to be aware of the information, configuration and permission credentials of the accessed storage service. Additionally, it enables the utilization of a new backend storage system without reconfiguring all VMs.
This project aims to add brain imaging data structure (BIDS) provenance to a workflow engine written in Python called ‘Pydra’. The brain imaging data structure format is a widely-adopted framework for disseminating clean datasets for use in the reproducibility of neuroimaging data analyses (https://bids.neuroimaging.io/). This project would aid in this pursuit by establishing built-in support for the BIDS format within the Pydra software package. Pydra is a library that allows complete control of the command line through Python (e.g., within a Jupyter Notebook). The majority of brain imaging data is analyzed using many commands that operate in a serial manner for cleaning, aligning, and applying statistical models to the data often in batches. Rather than relying on shell scripting and manual documentation of software versions, commands used, and outputs that are generated, Pydra can do so automatically. Pydra not only allows commands to be run through Python that would normally be run within the command line, but also unlocks the ability to interface with any CLI binaries a user might have installed as third party tools. Beyond this, Pydra allows the development of ‘workflows’ or stepwise processing pipelines with traceable software and command provenance, allowing an individual to essentially run an exact analysis in a “frozen” environment that the original publisher/researcher/scientist used themselves.
Meshery is the open-source cloud native manager that empowers platform engineers to design and operate infrastructure. As infrastructure complexity grows, the need for intelligent assistance becomes critical. This project focuses on developing and enhancing a dedicated AI Adapter and AI Connections for Meshery. This adapter serves as the bridge between Meshery’s core orchestration engine and various Large Language Models (LLMs). The goal is to enable "Natural Language to Infrastructure" capabilities, allowing users to describe their architectural intent (e.g., "Deploy a highly available Kubernetes cluster on AWS with Prometheus monitoring") and have Meshery auto-generate the visual topology and configuration manifests. The intern will work on decoupling the AI logic from the core platform, allowing users to "Bring Your Own Model" (BYOM)—supporting both cloud-based providers (OpenAI, Anthropic) and local inference runners (Ollama, LocalAI). Expected Outcome: 1. A fully functional AI Adapter (or Connection) integrated into the Meshery ecosystem. 2. Demonstrable capability for users to swap between at least two different LLM providers (e.g., OpenAI vs. a local Llama 3 model). 3. Implementation of a feature where natural language queries result in a rendered design. 4. Merged pull requests (PRs) including code, tests, and documentation.
This proposal aims to describe how to add inlay hints support to the Haskell language server. Inlay hints can provide a more fancy, intuitive, and convenient ui view of the current state of the code, such as the fixity of operators, the type of bound symbols in `let`, the type of holes, etc. Some basic work already exists in the current HLS that makes it feasible to implement inlay hints, such as the basic type library already in use: https://github.com/haskell/lsp; and the hls plugin system. Prior to submitting this proposal, I had already started working on trying to make some implementation work, and had made some progress. I submitted a draft pull request (https://github.com/haskell/haskell-language-server/pull/4131) to hls's github repository, which lists some todo's, but it should be noted that there is more to this proposal than just the pr's, and any suitable information that can be presented with the help of inlay hints will be included in the work. Since the ability to configure inlay hints is already in the todo, even if inlay hints that are too informative are implemented, they will not be a bother to the user: the user has the ability to configure the information that inlay hints will display. In the body of the proposal, I detailed the timeline and details for implementing the idea. I'll continue to build on the progress of this pull request, gradually implementing more inlay hints usages and important configuration capabilities.
<p>The proposal is inspired by the idea G on RedHen's GSoC 2016 idea page. The main purpose is to develop models and code helping domain experts to research on art history. It includes five main tasks:</p> <ol> <li>Training a classifier for recognizing a limited number of known visual symbols in images of religious artworks. VGG-net based fully convolutional network models will be trained for this task. Multi-scale detection, non-maximum suppression and bounding box regression will be implemented. </li> <li>Training a detector for localizing person heads and hands in images of art with various styles. CNN models will be trained based on a state-of-art head detection method.</li> <li>Building a module identifying a few certain hand gestures in images of artworks based on task 2. With the cropped detection result of task 2, a classifier based on VGG-net will be built.</li> <li>Developing a tool generating a frontal view of a face given a artistic portrait with a side view of the face based on existing face frontalization code. </li> <li>Developing initial research code for analysis of color style changes over time of Christian paintings by machine learning.</li> </ol>
Standards Working Group (Standards WG) of Hyperledger's Climate Action and Accounting Special Interest Group (CA2-SIG) has been working on developing an Anthropogenic Impact Accounting Ontology (AIAO). Climate accounting is currently the primary use case for AIAO. The ontology aims to enable interoperability between the plethora of impact accounting standards and methodologies in the market, allowing further development of systems such as a global climate impact accounting ledger. The WG has formulated an ontology comprising a current total of 46 classes and 11 primary axioms with several more axioms on the secondary and tertiary level. The core concepts are explicated on the Standards WG's wiki and encoded in an OWL file. During the 2022/2023 southern hemisphere's summer break the Nova Institute sponsored and hosted a mentorship programme that recruited three second-year ICT university students from South Africa to refine the OWL file, develop a Turtle parser and set up an MVP triple store for the ontology. The next steps towards operationalization of the ontology are aimed at developing the tools for interoperability between the AIA ontology and existing vocabularies in the field of impact accounting, starting with those from the climate accounting space. This will involve mapping the existing vocabularies and standards to the ontology, improving on the examples produced by the students; annotating existing climate impact data from selected case studies.
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.
This project addresses the issue of translating complex marine biodiversity data into actionable knowledge for ecosystem management in Florida. It makes use of existing biodiversity datasets (OBIS, GBIF) and ecosystem variables (e.g., temperature) to develop a collection of reproducible Jupyter Notebooks powered by Python packages like pyOBIS, GeoPandas, and machine learning packages. These notebooks are dedicated to showcasing the top environmental inquiries in areas like the Florida Keys, Rookery Bay, Tampa Bay, and the Gulf of Mexico covering trends in Rice's Whale, birds, and seagrasses. The solution combines species occurrence records and ecosystem information to generate visualizations, spatial models, and biodiversity metrics. Interactive maps, temporal trend plots, and model-based habitat predictions are products. Constructed with reproducibility and open science principles in mind, the tools will assist resource managers, researchers, and decision-makers in conservation planning. Deliverables include: 5 modular Jupyter Notebooks (e.g., habitat models, trend predictions), Reusable data pipeline functions (data ingestion, cleaning, analysis), Public Docker-supported GitHub repository, Easy-to-read documentation and automated testing framework. The project facilitates environmental decision-making through data science and encourages collaboration through open, reproducible tools.
The goal of this project is to make the Rust language available on the GNU/Hurd operating system. Currently, there is no official Rust support for GNU/Hurd, which limits developers' ability to build high-performance, safe, and concurrent software on this platform. The Rust language is increasingly being used in fundamental libraries such as librsvg and python-cryptography, so it is crucial to have a compiler for Rust on GNU/Hurd. The Rust compiler is portable, but its runtime library, libstd, needs to be ported to GNU/Hurd. This involves telling Rust how to call standard C library functions, which can be generated from libc C headers using the bindgen tool. The proposed solution involves creating a new Rust target for GNU/Hurd by investigating the system calls and interfaces available in GNU/Hurd and adapting Rust's code generator to generate code that uses these interfaces. The project aims to optimize Rust's performance on the GNU/Hurd platform by identifying performance bottlenecks and implementing improvements where necessary. The deliverables of the project include the Rust-GNU/Hurd toolchain, which comprises the Rust compiler and libraries, documentation, and optimized performance of Rust on the GNU/Hurd platform. The project also includes researching the GNU/Hurd system, identifying the system calls and interfaces that Rust will need to use, and creating documentation for the Rust-GNU/Hurd toolchain.
Deep learning is now used to solve many different CV problems. A typical approach is to train a separate network for each specific task. However, there is a need for models that are closer to the human brain and can solve multiple tasks. Multi-task learning (MTL) is a branch of machine learning, in which multiple tasks learn simultaneously through a shared model. It has the following advantages: improving data efficiency, reducing overfitting through shared representation, and using auxiliary information to learn quickly. The project has four objectives: 1. One or more multi-task CV models trained (or borrowed, if the license is appropriate), and submitted to OpenCV model zoo. Specifically, at least MCN or networks with similar functions should be successfully transplanted or improved for OpenCV, and the accuracy and less computation should be provided, which is not lower than that of the existing single OpenCV model. 2. quantize the model on the condition that the accuracy does not decrease too much. At least try to quantize the model and make a trade-off between performance and effectiveness at the end. 3. Necessary patches, if any, for OpenCV DNN to support the provided multi-task models. Ideally, there should be an API introduced to optionally disable some parts of the multi-task CV model and save time by not computing unnecessary parts/heads of the model. 4. Using at least one example will demonstrate how to use this multi-task model.
<p>R provides two types of regular expressions in <code>base</code> package, extended regular expressions (the default) with TRE and Perl-like regular expressions used by <code>perl = TRUE</code> with PCRE.</p> <p>PCRE includes useful features, such as named capture, but it uses a backtracking algorithm, so it is easy to take exponential time or arbitrary stack depth for certain regular expressions. Using PCRE in the service backend would have left it open to easy denial of service attacks.</p> <p>TRE has a polynomial time complexity but does not include named capture.</p> <p><code>stringi</code> is a R package use the regular expression engine from the ICU library, which has an exponential time complexity. The <code>stringi</code> package does not support named capture yet because it is still considered as experimental in ICU.</p> <p>RE2 is a primarily DFA based regular expression engine from Google that is fast at matching large amounts of text with named capture. Users can build fast and scalable service backend with RE2 library.</p> <p>This project will create an R package interface to the RE2 library, providing the R community with the first regular expression package with both named capture and polynomial time complexity.</p>
OpenTRIM is a C++ Monte Carlo simulation framework that models the interaction of ions with matter, tracking energy deposition and defect creation. Currently, it includes a fixed tallying system for recording standard outputs, such as energy lost to ionization or defects. This project aims to extend OpenTRIM's capabilities by implementing a flexible, user-customizable tally system. The new tally system will allow users to define, via JSON configuration, what simulation events to track (e.g., ion stopping, vacancy creation), how to bin data (e.g., in cylindrical or Cartesian coordinates), and what physical quantities to record (e.g., ion depth, deposited energy). It will be implemented as a new class hierarchy in C++, inheriting from the existing tally class, and will make use of the ArrayND data structure for multidimensional data storage. Deliverables include: a) A customizable tally class with support for user-defined event handling b)JSON-configurable tally setup (geometry, energy bins, spatial bins, etc.) c) Sample tally implementations (e.g., ion range profiling) d) Unit tests, documentation, and tutorials for extending the system This work will empower researchers and developers to tailor OpenTRIM output to their specific simulation needs, improving its usability and scientific value.
<p>This mobile app will be used to tell user about CO2 emission during user’s activity . This app will find the type of activity and distance travelled . Based on activity type and distance travelled by user , CO2 emission will be measured by using same formula used in existing browser extensions . This measurement will be real time , i.e. , user will be notified about CO2 emission at same time while he/she is travelling . This app will also contain Google Map to show user about his/her source and destination which will help user in navigating the path ( Having less CO2 emission) along with current information about CO2 emission .</p> <p>Platform Used - This mobile app will be developed as a Hybrid app . For Hybrid app development , React Native framework will be used along with Scala.js to make it cross-platform and easy to develop and maintain .</p> <p>Functionalities provided by Mobile app -</p> <ol> <li>Google account authentication </li> <li>Google Map showing path (having less CO2 emission) between source and destination</li> <li>Details about CO2 emission and its calculation</li> <li>Other features like 'learn more about Carbon Footprint' , 'set CO2 emission rate of user’s vehicle' , 'logout' etc.</li> </ol>
Background: Current flows from RISC-V Sail specification to downstream implementations have manual steps which are time-consuming and can introduce errors.A lack of familiarity with Sail and OCaml presents a barrier to adoption of Sail as the basis for automated downstream implementations: emulators, simulators, compilers, assemblers, disassemblers, instruction stream tools, documentation, etc. Proposal: - Create an accessible Sail backend. - Extract salient information. - Transform it into an accessible database (JSON). - Survey projects dependent on RISC-V ISA for how that dependency is realized. - Utilize JSON to directly and automatically generate downstream source that is currently generated by hand. - Create a React-based interactive RISC-V ISA reference by directly importing the JSON database. Benefits: The backend can serve as a model for creation of additional Sail backends. The JSON database itself may be sufficient for many downstream uses. Creating downstream source shows feasibility, and a process for a fully-automated downstream flow. Additional collaboration with the effort to transform Sail into documentation is warranted. Much of the effort to transform Sail into JSON is complete, but there is still significant effort ahead: - enhanced parsing - enhancing the RISC-V Sail specification itself with more required content Much of the effort in creating an interactive web site is complete, but there is work to support the incorporation, display, and filtering.
Currently, the Cytoscape App Store only supports plugins for the Cytoscape Desktop App. Since a web version of Cytoscape is available, web plugins and service apps can add functionality, similar to the desktop plugins. With multiple platforms, a unified app registry would be ideal in organizing plugins and extensions, with layered filtering capabilities (e.g. platform type, app type). To solve this problem, the proposal includes an implementation plan on frontend UI changes and filtering, database migrations, an updated submission and approval flow for both web apps and service apps, and health monitoring for all apps. The first 3-4 weeks will be spent discussing final changes with mentors, with database migrations to accomodate the new platform types. The frontend will also receive changes including filtering, new tags and categories. Weeks 5 and 6 will follow a similar process for web service apps. Weeks 7-10 will consist of adjusting the submission workflow, including frontend UI changes for developers and database migrations. Health checks will also be implemented, with certain criteria to determine the health status of an app. Weeks 11-12 will consist of unit testing, including health check testing, testing new uploads, latency checks and documentation.
Kgateway can be used as an “AI Gateway” that allows applying traditional traffic management, security, and resiliency policies when reaching out to LLM providers. It also allows sending a request to another server for processing things like prompt guards or enrichment before we send it off to the LLM providers. An important aspect in any system that has lots of moving parts is observability: the collection of metrics and other information that allow you to identify issues and troubleshoot a live system. This project aims to enable OpenTelemetry support in kgateway’s AI extensions by allowing users to configure a gRPC tracing collector. This feature enables span propagation from the AI extensions extproc server and exporting traces to an OpenTelemetry-compatible backend (e.g., OpenTelemetry Collector, Jaeger, Zipkin, or Datadog). This feature will build on Envoy’s native tracing capabilities and aligns with industry-standard observability practices. This will make it easier to debug, monitor, and optimize traffic flowing to LLM Providers through kgateway. Expected Outcome: 1. Design and implement an API to enable tracing for the kgateway’s AI extproc extension. 2. Extend the AI extensions extproc server with OpenTelemetry tracing. 3. Create end-to-end (e2e) tests to validate configuration and trace propagation. 4. Write documentation for plugin developers and end users.....
This project studies the development of a tiny worm called Caenorhabditis elegans, focusing on how its cells divide, grow, and interact during its early embryonic stages. To map out and understand these complex interactions, the project upgrades the OpenWorm DevoGraph library using an advanced deep learning tool called the Explainable Spatio-Temporal Graph Evolution Learning (ESTGEL) model. This model tracks two critical dimensions of growth simultaneously: the 3D spatial arrangement of cells (how they physically touch and communicate in space) and the directed cell lineage (the family tree detailing how cells evolve to form different tissues). By combining these spatial and lineage pathways with an "edge attention" mechanism, the tool highlights the most critical cell-to-cell connections at various stages of growth. Ultimately, the project aims to get a complete, computationally explainable picture of the worm's development, from a single cell to a fully formed organism, and to successfully classify between healthy and mutant embryos. This work will help us learn more about basic life processes, track how early cell interactions influence neural wiring, and improve fields reliant on understanding cellular growth. The project is supported by the OpenWorm community, an international organization dedicated to using advanced dynamic graph neural networks to model and study the brain and nervous system development of the first virtual organism in a computer.
After the 2010 Deepwater Horizon oil spill, airborne surveys produced 18,304 images with 2.6 million birds individually marked using a point-counting tool. The tool baked colored annotation dots directly into screenshot pixels no coordinates were ever saved. I built a six-stage recovery pipeline that extracts dot positions from corrupted screenshots, maps them to original high-resolution photographs via SIFT homography, and exports DeepForest-compatible training annotations. Tested on 34 images spanning 7 years and 10 annotators with zero failures: 70.8% detection accuracy, 98.3% position precision, 3,915 annotations recovered across 21 species. Training experiments confirmed that position accuracy of recovered coordinates not data volume drives downstream detector performance. GSoC deliverables: (1) Scale recovery to all 18,304 images with an optimized feature matching cascade targeting 80%+ geometric precision, (2) a quality-tiered dataset of 250,000–340,000 recovered annotations, (3) a fine-tuned airborne bird detector evaluated per-species on held-out colonies, (4) a tested DeepForest module with documentation, and (5) a blog post documenting the full recovery process including approaches that failed and why.
<p>There are shell scripts for creating X.509 certificates, revoking certificates and signing CRLs and scripts for the creation of Profile certificate files for certain devices such as Linux, Apple OS X, Windows, iOS, etc., these require careful specification of various certificate attributes so that these certificates work on a variety of devices: Android, Windows, iOS/OSX, Linux, etc. The goal of this project is to gather all that knowledge into a simple interface which should support the following:</p> <ul> <li>Generating the proper ipsec.conf configuration based on web admin interface including DNS/split-DNS configurations.</li> <li>Allow Administrator to invite new users using email id.</li> <li>A new user after account validation can download the generated certificate/profile (over TLS) for different platforms.</li> <li>The generated certificates/profiles can only be downloaded once, through the portal.</li> <li>Admin can list, revoke/disable (temporary revocation) user certificates/profiles.</li> <li>Generate PKCS#12 certificates for users.</li> <li>Generate iOS/OSX .mobileconfig profiles for automatic installation on iOS/OSX.</li> <li>Ipsilon user authentication to web application.</li> <li>Configure munin-node to work with libreswan plugin.</li> </ul>
Beam's Python SDK is increasingly the first choice for ML and data-intensive pipelines, making robust native streaming APIs more important than ever. However, two essential streaming primitives, UnboundedSource (Issue #19137) and Watch (Issue #21521), remain unavailable in Python despite being long established in the Java SDK. Today, Python developers who need these capabilities either pull in cross-language transforms that add Java dependencies and gRPC overhead, or wrestle with low-level RestrictionTracker internals. This project solves the problem by porting both primitives natively to Python on top of Beam's existing SDF framework. The UnboundedSource wrapper adapts the legacy reader API into a Splittable DoFn that handles checkpointing, watermark progression, deduplication, and splitting. The Watch transform adds periodic polling with composable termination conditions and stable dedup behavior. Porting both primitives natively abstracts away that complexity behind clean and Pythonic interfaces. It also unlocks native enhancements, such as updating fileio.MatchContinuously, without leaving the Python ecosystem. The planned deliverables are: (D1) a Python UnboundedSource API with its SDF-based wrapper, (D2) a native Watch transform with PollFn and TerminationConditions, (D3) a test suite spanning DirectRunner and Dataflow, and (D4) supporting documentation including docstrings, programming-guide updates, and migration notes.
Currently, in OpenYurt, the core component YurtHub—which acts as a transparent proxy between edge node system components (e.g., kubelet, CNI, CoreDNS, kube-proxy) and the Kubernetes API server—is deployed as a systemd service on each edge node. The installation is performed exclusively via the community-provided tool YurtAdm during node joining. This approach imposes a significant limitation: users must use YurtAdm to onboard nodes, making it impossible to install YurtHub on existing Kubernetes nodes that were not initially provisioned with YurtAdm. To improve flexibility and user experience, the community aims to support a label-driven, declarative installation mechanism: 1. When a specific label (e.g., openyurt.io/is-edge-worker=true) is added to a node, YurtHub should be automatically installed and started on that node. 2. Conversely, when the label is removed, YurtHub should be gracefully uninstalled and its resources cleaned up. This enhancement will enable seamless integration of OpenYurt into existing Kubernetes clusters without requiring re-onboarding of nodes. Expected Outcome: 1. Design and implement a controller/operator that watches for node labels and triggers YurtHub lifecycle operations. 2. Develop an installation/uninstallation mechanism that: a. Installs YurtHub as a systemd service. b. Ensures idempotency and handles failures gracefully. c. Cleans up all YurtHub-related files, configurations, and services
In this project, we aim to build a Rust-based log processing framework. Applications built on this framework will be compiled into WebAssembly and run in WasmEdge containers side by side with Linux containers and apps. The WasmEdge app collects logs from other containerized apps and then sends them to a streaming database or processing pipeline. - Expected outcome: * Create a Rust framework with 3 traits similar to the [`Transformer`](https://github.com/second-state/MEGA/blob/main/mega_etl/src/lib.rs#L99) trait in the [MEGA framework](https://github.com/second-state/MEGA). * The `Collector` trait abstracts operations needed for a log collector. * The `Transformer` trait abstracts the transformation algorithms that can be applied to the logs. * The `Destination` trait abstracts operations needed to send transformed to a streaming data pipeline or database. * Implement at least two `Collector`s. One for MySQL database binlog and the other for a generic log file in a Linux container in the same Kubernetes pod. * Implement at least two `Transformer` algorithms supported by [FileBeat](https://www.elastic.co/guide/en/beats/filebeat/current/filebeat-overview.html). * Implement at least three `Destination`s. One for a Kafka queue, one for a Redis database, and the other for ElasticSearch. * Provide CI and demo test cases. * Provide documentation and tutorials.
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.