Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters
13453 Projects Found
Sort by

New Meshery Nighthawk Adapter

advanced
Meshery•2026Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
350h (Large)

Meshery stands as the canonical cloud-native management plane, rigorously managing the lifecycle, performance, and topologies of multicloud infrastructure. Currently, Meshery manages multiple load generators (Nighthawk, Fortio, Wrk2) to execute Service Mesh Performance (SMP) benchmarks. However, the heavyweight C++ Nighthawk binaries are bundled directly inside the meshery/meshery Go backend container. This statically couples the data plane execution to the control plane, bloating the core image size and preventing independent scaling. This project resolves this architectural flaw by cleanly severing Nighthawk from the core server and wrapping it into an autonomous, standalone gRPC adapter (meshery-nighthawk). To achieve this, I will evolve the existing meshkit/meshes/meshops.proto into a generalized adapters.proto capable of routing both traditional service mesh commands and raw load-generation requests. By the end of this project, Meshery Server will dynamically discover and orchestrate Nighthawk as a first-class out-of-tree component, supported by fully overhauled CLI commands (mesheryctl perf), Helm chart deployments, and a dedicated Meshery UI Adapter chip.

javascriptgolangkubernetes+2
Student: Yash Vilas Mahakal
Code
Proposal

HugeGraph Query Engine Dependency Modernization

advanced
Apache Software Foundation•2026Varies350h (Large)

Apache HugeGraph's query engine relies on Java 11, TinkerPop 3.5.1, and Groovy 2.5.x, facing critical issues: the security sandbox depends on Java's deprecated SecurityManager and a blacklist already bypassed in CVE-2024-27348, while TinkerPop 3.5.x lacks 26 new Gremlin steps, GraphBinary, and JDK 17 support. This project will execute a phased upgrade to Java 17 + TinkerPop 3.7.x + Groovy 4, covering full TinkerPop API migration with custom Steps/Strategies adaptation, a security sandbox redesign from runtime blacklist to a three-layer compile-time whitelist defense using Groovy 4's @CompileStatic and AST Customizers with configurable enforcement modes (strict/warn/off), extension to PD/Store distributed modules, and performance benchmarking on the Twitter-2010 dataset. Deliverables include the upgraded codebase (PR), the new compile-time security sandbox, PD/Store module upgrade, a quantified performance benchmark report, full regression test reports, and a complete documentation set.

pythonjavascriptjava+7
Student: contrueCT
Code
Proposal

1.2. Learner assessments

intermediate
Oppia Foundation•2026Varies175h (Medium)

Learners are currently recognized for progress at the individual lesson (exploration) level, but there is no structured way to celebrate or assess their understanding across multiple lessons. This limits motivation and fails to capture long-term learning achievements. To address this, the project introduces multi-lesson assessments that evaluate a learner's mastery of a group of related skills. Learners will be able to take these assessments at any time to measure their overall progress. Upon completion, they will receive a passing score page that can be showcase their achievement, helping to boost motivation and engagement. This system also lays the foundation for future enhancements such as certificate generation. Deliverables: Milestone 1: Assessment Creation & Management (Lessons Team) Frontend interface for creating, editing, viewing, and deleting certificate assessment offerings Validation mechanisms to prevent invalid configurations (e.g., insufficient questions per skill, missing descriptions) User feedback system for successful or failed save actions Backend infrastructure to store and manage assessment offerings Milestone 2: Learner Assessment Experience Frontend interface for learners to discover, attempt, and view assessment results Display of assessment attempt history for learners Backend systems for generating assessments dynamically Storage and management of learner responses and assessment results

pythonjavascriptangularjs+10
Student: Mosin Shaikh
Code
Proposal

Modernizing the EGI MFF Reader for MNE Python via mffpy Integration

intermediate
Python Software Foundation•2026$3k–$6.6k175h (Medium)

The EGI-MFF reader in MNE-Python uses an old internal parser that’s pretty hard to maintain and often runs into timing drifts or memory issues. My plan for GSoC is to completely modernize this by switching the backend over to the 'mffpy' library. I’m going to build a wrapper that keeps everything backward-compatible while fixing those annoying 1-sample errors and array mismatches that have been blocking users for years. By the end of the summer, I’ll have delivered a refactored read_raw_egi module that supports O(1) memory mapping, so researchers can stream huge files without crashing. I'm also making sure we get proper support for PNS channel mapping and automated bad-channel detection. Most importantly, I’ll be building a solid regression test suite to make sure the event timing stays microsecond-accurate, which is crucial for the neuroscience work this library supports.

pythonmercurialjavascript+3
Student: Pragnya Khandelwal
Code

BreathState: A Cross Platform App for HRV Biofeedback and Resonance Breathing Protocols

intermediate
INCF•2026Varies175h (Medium)

Problem: Currently, resonance frequency-based HRV training is backed by robust scientific evidence, but it remains inaccessible to the masses due to the high costs of proprietary hardware and software tools. There is a need to bridge the gap between basic consumer wearables and professional open-source psychophysiological research. Solution: BreathState 2.0 solves this by evolving the existing mobile application into an active, multi-modal, clinical-grade biofeedback platform. This will be achieved by introducing cross-platform architecture (Mobile/Web/VR), integrating research-grade hardware (Vernier respiration belts), and porting Python-based professional analytics natively to the application. Deliverables: A multi-patient database architecture using Drift with CSV export capabilities. Cross-platform application builds supporting Android, iOS, and Web. Integration of Vernier GDX-RB respiration belts via BLE with Polar H10 synchronization. A full on-device NeuroKit2-to-Dart analytics engine (computing time-domain HRV, frequency-domain HRV, RSA, and Baevsky Stress Index). A real-time biofeedback dashboard featuring dual-axis waveforms and adaptive guided breathing. An immersive WebXR HRV visualization scene (breathing sphere) accessible via Meta Quest headsets.

pythonjavac+++7
Student: Faraz S
Code

BI connector and demonstration

intermediate
Apache Software Foundation•2026$3k–$6.6k175h (Medium)

Fineract is largely used as a system of record for lending in many institutions globally. As such, most of the analysis is about portfolio health — how well are people paying back, and what are the key risks around repayments. This includes PAR, loan loss provisioning, write-offs, and trend lines for the same, along with basic stats like number of customers, the loan cycle they are on, aging of customer cycles, exceptions tracking, and correlation to any characteristic in the data. Currently Fineract does not have a analytics pipeline where vendors, users, institution can see these analytics. This project solves this problem. My plan is to build a complete ELT analytics platform. A python extractor will pull data from read replica of Fineract DB incrementally using a read only database user. It will push the data the PostgreSQL analytics warehouse. From there a dbt project will handle all the data transformation (delinquency calculations, PAR ratios, repayment behavior, portfolio health). I will show interactive dashboards with different type of charts, graphs, stats and analytics using Apache Superset. By the end of GSoC, the deliverables are: a working Python ELT extractor with both backfill and incremental modes, a fully tested 4-layer dbt warehouse model covering the Fineract lending domain, five production-oriented Superset dashboards (Portfolio Health, Delinquency and PAR, Repayment Behavior, Risk and Finance, Customer Lifecycle), Docker Compose setup so anyone can run the full stack locally, and complete documentation including a runbook and data dictionary. The whole stack is Apache 2.0 licensed, self-hostable, and designed so future contributors can add new analytics modules without changing what's already there.

pythonjavascriptjava+7
Student: Aira Jena
Code
Proposal

Switch to Playwright tests for integration testing

intermediate
Django Software Foundation•2026Varies175h (Medium)

This proposal explains my plan to update Django's browser integration testing by moving from Selenium to Playwright. The main idea is to smoothly plug Playwright testing (using playwright.sync_api) into Django's current LiveServerTestCase setup. The project involves writing new Playwright test classes, converting the old Selenium tests, setting up CI/CD workflows, and finally deleting all the old Selenium code.

pythondjango
Student: Varun Kasyap Pentamaraju
Code
Proposal

Fine grained storage for the DUNE experiment

advanced
CERN-HSF•2026Varies350h (Large)

DUNE’s fine-grained Phlex/FORM I/O model stores data products across many independent RNTuple containers, which can increase read-side overhead during full event reassembly. The project addresses this by creating a reproducible benchmark baseline, running systematic studies across container count, data size, and cache conditions, and quantifying dominant bottlenecks such as metadata cost, file-open overhead, cache pressure, and cluster traversal. Deliverables include a reproducible benchmark suite, analysis plots and reports, before/after results for optimization prototypes (container caching, prefetching, and read-side consolidation), and a final recommendation report for production-oriented FORM storage decisions.

pythonc/c++machine learning+6
Student: Ahmed Idani
Code
Proposal

Create the watchOS app for VLC

intermediate
VideoLAN•2026Varies175h (Medium)

Develop a standalone VLC app that any user would benefit from it on its Apple Watch. With this app, they could listen to their audio files anywhere, in the gym, running or commuting, just using their Apple Watch. The app will have its own media library and will be powered by the VLCKit for playing the audio files. It will leverage the functionalities offered by the iPhone companion app for transferring the files, playlists and URLs.

copenglc+++10
Student: DavidNeacsu
Code
Proposal

EduAI - Move Your Body - Vaibhav Aryan

intermediate
AOSSIE•2026Varies175h (Medium)

This project focuses on building an on device fitness application that provides short and personalized micro-workout sessions (5–7 minutes) based on user goals, preferences, and health conditions. The main aim is to help users stay consistent by reducing repetition and adapting workouts based on their feedback over time. The system uses a combination of rule-based filtering and lightweight semantic matching to generate safe and relevant workout sessions. It is designed to work fully offline, making it more accessible and privacy-friendly for users. By the end of the project, I aim to deliver a complete mobile application that supports personalized session generation, progress tracking, feedback-based adaptation, and custom workout creation.

pythonjavascriptswift+8
Student: Vaibhav Aryan
Code
Proposal

Fate Protocol: Bull/Bear Coins as Native Oracles

intermediate
AOSSIE•2026Varies175h (Medium)

I’m proposing to build Fate’s oracle system by turning bull and bear prediction pools into Chainlink-compatible price feeds that other DeFi protocols can use. This covers all five AOSSIE-defined tasks, along with a few practical improvements I identified while working with the codebase. For the core, I’ll implement IFateOracle with round-based price history and a sentiment-based price mechanism using multiple strategies like DIRECT, WEIGHTED, and EWMA. A FateOracleAdapter will provide Chainlink compatibility through AggregatorV3Interface. Since pools rebalance on every trade, each buy or sell naturally produces a new oracle data point. Alongside this, I’ll address some real issues I came across, like the hardcoded 18-decimal assumption that breaks certain pools, high RPC usage on the portfolio page, and fee accumulation that can’t currently be withdrawn. I’ll also add a subgraph for historical data, price impact estimation, and improvements to the explorer and creator dashboard, based on actual gaps in the current system.

pythonjavascriptswift+8
Student: Rohann
Code
Proposal

Long Context Coding Evaluation Dataset for Gemini CLI

advanced
Gemini CLI•2026Varies350h (Large)

This project builds a long context and complex reasoning coding evaluation dataset for Gemini CLI. It focuses on multi file, multi language software engineering tasks, difficulty certification, agentic evaluation, and structured failure analysis to better measure real coding agent performance on large repositories.

typescriptGenAIMCP+2
Student: Letian Li
Code
Proposal

lwIP TCP/IP Network Stack Improvements

intermediate
RTEMS Project•2026Varies175h (Medium)

This project brings up lwIP on the TI TMS570LC43x under RTEMS. The TMS570 is a high-reliability MCU most recently used as the flight controller on the Ingenuity helicopter. A secondary contribution reintegrates the lwIP stack at the netconn API layer, which eliminates BSD socket indirection, reduces memory footprint, and enables zero-copy tx/rx in RTEMS applications.

cpythonembedded systems+5
Student: Armaan_Chowfin
Code
Proposal

Characterizing I/O Performance for ML Data Loaders at Scale using Darshan

advanced
CERN-HSF•2026Varies350h (Large)

Modern machine learning workflows in High Energy Physics increasingly rely on large-scale datasets, where the data-loading stage can become a primary bottleneck for performance and scalability, particularly due to the lack of visibility into the I/O behavior of data-loading pipelines. While model performance is extensively studied, data ingestion remains comparatively under-characterized and often limits scalability due to inefficient access patterns, filesystem contention, and poor interaction between data formats and loading strategies. This project addresses this gap by developing a reproducible benchmarking and analysis framework for characterizing data-loading performance in ML pipelines. The system will integrate the Darshan I/O characterization tool to capture system-level access patterns and combine them with application-level metrics such as throughput and runtime. It will support multiple data formats and compare different loading approaches, including the native PyTorch DataLoader and a ROOT-based loader. The methodology consists of controlled experiments that vary data formats, loader configurations, and execution parameters. Results will be processed through an analysis layer to identify recurring patterns and bottlenecks, and a diagnostic component will detect inefficiencies and provide actionable recommendations. The main deliverables of the project are: - A modular CLI-based benchmarking system for dataset generation and ingestion, configurable experiment execution, and structured result collection. It will enable reproducible experiments across data formats (NumPy .npz, HDF5, CSV, ROOT RNTuple), loader implementations, and execution configurations. - Integration of Darshan for automated I/O profiling and trace collection - A curated set of benchmark experiments covering representative combinations of data formats, loader implementations, and configuration parameters - Documentation and a final report summarizing findings and best practices

pythonc/c++machine learning+6
Student: AtikSantellan
Code

GSoC 2026 Fine-tuning AI Transcription for Greek Municipal Councils

intermediate
Open Technologies Alliance - GFOSS•2026$3k–$6.6k175h (Medium)

This project fine-tunes a Whisper ASR model using LoRA to enhance the first stage of OpenCouncil's transcription pipeline. Greek municipal speech breaks standard Whisper in predictable ways: council-specific idioms, proper names it has never encountered, and morphological errors that accumulate fast in a heavily inflected language. The goal is a 15–20% drop in domain-specific Word Error Rate (DS-WER). The expected result is that human reviewers spend less time correcting transcripts and more time on work that actually requires judgment.

pythonmysqljava+7
Student: Angelos Papamichail
Code
Proposal

Multilingual documentation of R packages

intermediate
R project for statistical computing•2026Varies175h (Medium)

This project implements a new R package that brings multilingual documentation to R help pages with correct support for dynamic content generated by Rd macros. The package intercepts utils:::.getHelpFile() applies section-level translations from installable modules and renders a per-section toggle so users can switch between translated and original text without changing environment variables.

cc++r+4
Student: adi018
Code
Proposal

CIR Combine: Cross-Boundary Analysis for Heterogeneous CUDA/HIP Compilation

advanced
LLVM Compiler Infrastructure•2026Varies350h (Large)

Today, LLVM's offload compilation keeps host and device code strictly separate; they only reunite late in the pipeline when the device binary is embedded into the host object. By that point, cross-boundary reasoning is largely out of reach. CIR Combine introduces a merge-optimize-split stage into ClangIR's compilation pipeline. After both host and device modules are compiled to CIR, a new driver action merges them into a single heterogeneous translation unit, an offload container holding both modules as nested regions. With both sides visible simultaneously, cross-boundary analysis passes can propagate constants from host launch sites into device kernels, eliminate kernels that are never launched, and infer launch dimensionalities that inform device-side optimization. A subsequent split action extracts the transformed modules and feeds them back into their respective backend pipelines. Deliverables: - Working merge/split skeleton integrated into the new offload driver - Cross-boundary constant propagation pass validated on real CUDA/HIP kernels - Compile-time overhead measurements, and the infrastructure that makes further host-device optimizations possible in the future.

cllvmc+++3
Student: David Rivera
Code

Telehealth Effectiveness and Necessity Tracker for Alaska (TENeT)

advanced
Alaska•2026Varies350h (Large)

Alaska's unique geography and infrastructure challenges severely impact equitable healthcare access. Currently, there is a lack of centralised, intersecting data to help identify "healthcare deserts" based on broadband connectivity, transportation routes, existing medical facilities as well as affordability. This makes it incredibly difficult for policymakers and healthcare networks to make data-driven decisions on where to expand telehealth services or prioritize physical infrastructure. Here, this project introduces TENeT (Telehealth Effectiveness and Necessity Tracker). TENeT is an open-source geospatial dashboard that layers real-world broadband performance data over socioeconomic and healthcare infrastructure maps. By calculating both the technical capacity and economic affordability of internet access, TENeT provides policymakers with a dynamic, multi-layered visualization to precisely target telehealth funding and infrastructure deployment in rural Alaska."

pythonmysqljava+2
Student: Daksh Pathak
Code
Proposal

Reduced Order Modelling with Neural Operators in Gridap.jl

advanced
NumFOCUS•2026Varies350h (Large)

THE PROBLEM: Solving partial differential equations (PDEs) for parametrical studies is a fundamental part of scientific research, but traditional many-query Finite Element simulations are highly computationally expensive and suffer from performance bottlenecks. THE SOLUTION: This project aims to drastically reduce simulation times by integrating modern machine learning into the Gridap.jl ecosystem. The plan is to augment GridapROMs.jl with nonlinear neural operators. The work plan is split into three phases: 1. Benchmarking: Generating high-fidelity training data from 1D test cases to evaluate and compare external neural operators (via NeuralOperators.jl) against standard linear Reduced Order Models (ROMs). 2. Implementation: Integrating the best-performing neural architectures to solve more complex, real-world physics problems, such as heat equations with nonlinear coefficients and turbulent fluid dynamics. 3. API Extension: Extending the GridapROMs.jl API to unify traditional linear models and the new nonlinear neural operators under a single interface. DELIVERABLES: - A public repository containing data generation scripts, training loops, and a comparative performance report of the tested models. - Validation scripts showing the core implementation works on complex physics problems. - A final Pull Request to GridapROMs.jl containing the extended API, unit tests, documentation, and user tutorials demonstrating the end-to-end workflow.

pythonjavascriptr+3
Student: Isaia Zollo
Code
Proposal

Adding a Pressure-Based Solver

advanced
Stichting SU2•2026Varies350h (Large)

The proposed project involves the addition of a pressure-based solver to the SU2 code base. The pressure-based solver is an important algorithm in the Computational Fluid Dynamics (CFD) landscape due to its great performance for low Mach and incompressible flow applications. As of right now, SU2's primary solvers are density-based algorithms which excel in compressible flow simulations. Density-based algorithms can be adapted for low Mach and incompressible flows using for example artificial compressibility or preconditioning. However, these approaches effectively modify a formulation that is not inherently aligned with incompressible flow physics, and therefore remain less efficient than pressure-based algorithms for these applications. The goal of the project is to investigate the current attempts on the addition of pressure-based algorithms to SU2, and to identify what is needed to subsequently work on integrating the pressure-based algorithm into the main SU2 branch. The final result is expected to be a successful merge of a pressure-based algorithm into the main SU2 branch.

pythonc++
Student: Thijs Aalbers
Code
Proposal

Add New Integrations of Talks and Speakers component with eventyay Video

intermediate
FOSSASIA•2026Varies175h (Medium)

The eventyay platform consolidated its talk and video components into a single codebase, but the integration between them remains manually wired and fragmented. Organizers must manually keep talk rooms and video rooms in sync, there is no system for assigning MCs to video rooms, and the video interface shows no speaker or session context — all four gaps confirmed through direct codebase audit and live instance testing. I will build the missing integration layer and deliver: an event-driven room sync system using Django signals and the existing Channels broadcast infrastructure, a full MC assignment system with model, API, admin UI, and email notifications, and a speaker metadata pipeline that pushes TalkSlot data into the Vue.js video interface in real time. Having worked in this codebase, I noticed these gaps firsthand while testing my own PRs — creating a room in the talk component and switching to video still requires manual coordination. I've worked with the exact role-assignment and notification architecture this project replicates for video rooms.

pythonjavascriptandroid+7
Student: Mukund Chavan
Code

Tail call support in the Kotlin/Wasm backend

beginner
Kotlin Foundation•2026Varies90h (Small)

WebAssembly's call stack limit is unspecified by the spec and varies across host environments. As a result, any Kotlin/Wasm program that uses mutual recursion or deep tail calls is vulnerable to stack overflow at runtime, with no way to guarantee safe execution across browsers and runtimes. Kotlin's existing tailrec modifier mitigates this for simple self-recursion by rewriting functions as loops, but it cannot handle mutual recursion or indirect calls, and requires an explicit annotation that many developers will not add. The WebAssembly Tail Call proposal (standardized and part of the Baseline target since 2024) addresses this at the instruction level with return_call and return_call_ref, which discard the current stack frame before transferring control and reduce stack consumption from O(n) to O(1) regardless of recursion structure. This project integrates that proposal into the Kotlin/Wasm compiler backend. The work covers adding the missing RETURN_CALL opcode to the Wasm IR layer, detecting tail call positions in the code generation pipeline and emitting return_call and return_call_ref in place of the current call + return two-instruction sequence, writing a test suite covering mutual recursion and virtual dispatch across multiple host environments, and benchmarking return_call against the existing loop transformation to evaluate the tradeoffs.

gradlekotlinjvm+3
Student: Ayako Hayasaka
Code
Proposal

Publication & Reproducibility Suite for Visdom: From Experiment Tracking to Paper-Ready Outputs

beginner
FOSSASIA•2026Varies90h (Small)

This project focuses on solving a real gap in the current research workflow that is the disconnect between running experiments and turning those results into clean, publication-ready outputs. Right now, tools like Visdom are great for live experiment visualization, but the moment a researcher wants to use those results in a paper, everything becomes manual. Plots are exported as screenshots or loosely formatted images, experiment configurations are tracked separately (often in notes or notebooks), and comparisons across differnent runs are done by hand. This makes the process slow, error-prone, and difficult to reproduce. The proposed solution is to extend Visdom into a complete “experiment-to-publication” pipeline. Instead of stopping at visualization, the system will allow researchers to directly generate structured, reproducible, and publication-quality outputs from Visdom itself. The project introduces four tightly connected components: A publication-quality export engine that allows plots to be exported in formats like SVG, PNG, and PDF with proper resolution and formatting suitable for academic journals. An experiment metadata tracker that automatically records configurations, parameters, environment details, and results for every run, ensuring full reproducibility. A LaTeX generation system that converts plots into ready-to-use LaTeX figure blocks, eliminating the need for manual formatting in Overleaf or similar tools. A multi-experiment comparison suite that enables researchers to compare different runs with statistical summaries and generate both plots and tables for inclusion in papers. By building this system, Visdom evolves from a visualization tool into a full research workflow assistant. The end result is simple: what currently takes days of manual effort can be reduced to minutes, while also improving the reproducibility and consistency across various experiments.

pythonjavascriptandroid+7
Student: rajnisht7
Code

DeepForest P_2: Recovering Historical Image Data Using Automated OrthoRegistration and ImageMatching

advanced
NumFOCUS•2026$6k–$13.2k350h (Large)

The U.S. Forest Service's Aerial Detection Survey (ADS) program has produced tens of thousands of hand-drawn polygons marking forest health damage from aircraft. Due to GPS imprecision and flight geometry, these polygons have systematic spatial offsets of 50–500 meters from their true locations in NAIP satellite imagery. This project builds an automated pipeline to align ADS polygons with NAIP data, recovering historical annotations as a training dataset for forest health computer vision models. The GSoC work focuses on three objectives: (1) improve alignment accuracy through a learned refinement layer using self-supervised displacement estimation techniques from the mentor-provided references, (2) scale the pipeline to all ~48,000 Oregon ADS polygons to generate a weak training dataset, and (3) fine-tune a DeepForest model on the aligned annotations for NAIP-based forest health outbreak detection. Deliverables: an optimized alignment pipeline with quantitative evaluation, aligned polygon GeoPackage for Oregon ADS data, a computer vision model for forest health detection on NAIP imagery, and a blog post documenting the methodology for others to apply to their own datasets.

pythonjavascriptr+3
Student: Saqlain01
Code
Showing 937 - 960 of 13453 Projects
3839404142
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal