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 Clear
11996 Projects Found
Sort by

Convert eventyay tickets VueJS Implementation to Single Page Application

advanced
FOSSASIA•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)

The eventyay presale and ticketing flow is currently built with Django templates and jQuery, resulting in full page reloads between every step of the ticket purchase journey. This project will migrate that flow into a Vue 3 Single Page Application using Vue Router for client-side navigation, centralized state management for cart and checkout state, and a unified API layer interfacing with the existing Django REST Framework endpoints. The migration follows an incremental approach where Django templates remain active throughout, keeping each phase independently reversible. Deliverables include a fully functional SPA covering event discovery, product selection, cart management, voucher handling, and checkout, along with route guards, performance optimization through lazy loading, frontend tests, and contributor documentation.

pythonjavascriptandroid+7
Student: aqil
Code
Proposal

Data Representation Optimization for ML-based calorimeter simulation

advanced
CERN-HSF•2026Varies350h (Large)

This project aims to develop a pipeline for producing calorimeter shower datasets in point-cloud form for a given detector and various types of particles. Its central goal is not only to compress detailed Geant4 shower information into a compact point-cloud representation, but to do so while preserving the physics content needed for the downstream. The work will proceed in two major stages. First, electromagnetic (EM) showers will be used to establish the pipeline, optimize point-cloud construction, and define a robust validation protocol. Second, the same framework will be extended to hadronic showers, which are more challenging due to larger fluctuations, invisible energy, delayed components, and a stronger dependence on material and interaction modeling.

pythonc/c++machine learning+6
Student: Siyu (Rain) Chen
Code

Updating Application Libraries (Redis and Nginx)

advanced
Unikraft•2026Varies350h (Large)

The Unikraft ports for popular applications like Redis and Nginx are currently outdated and fail to compile with the latest kernel core. This project solves this problem by updating the application glue code and implementing missing system calls in the ukposix compatibility layer. The main deliverables are fully working, stable, and benchmarked unikernel versions of Redis and Nginx. This work will also improve the overall POSIX support in Unikraft, making it easier to port other applications in the future.

cpythonxen+3
Student: Radu Andrei
Code
Proposal

HTCondor Live Tools with Solution Memory

advanced
CERN-HSF•2026Varies350h (Large)

This project enhances the Archi framework by enabling real-time interaction with HTCondor job scheduling infrastructure and introducing a persistent memory system to enhance conclusions drawn on live data with previously encountered similar situations. Currently, Archi operates without access to live system state, limiting it to generic, non-actionable responses when diagnosing job failures. Additionally, solutions discovered during user interactions are not retained, leading to repeated effort and inefficient troubleshooting. To address these limitations, the project introduces a read-only HTCondor tooling layer that allows Archi to query live job data (e.g., via condor_q and condor_history) and provide precise, evidence-based diagnostics. In parallel, a "solution memory" system will be implemented to store validated fixes from past interactions in a vector storage. These solutions will be indexed, embedded, and retrieved through a hybrid search mechanism, enabling Archi to reuse proven resolutions for similar future issues. The main deliverables include: (1) a secure, read-only HTCondor integration layer with structured outputs and error handling, (2) a suite of agent tools for live job inspection and failure diagnosis, (3) a solution memory database with indexing and retrieval capabilities, and (4) full integration into the Archi agent workflow via tools, supported by comprehensive testing, benchmarking, and documentation. By combining live diagnostics with reusable knowledge, this project transforms Archi from a passive assistant into an active, context-aware agent that improves troubleshooting efficiency, reduces computational overhead, and continuously learns from past incidents.

pythonc/c++machine learning+6
Student: Antonio Battaglia
Code
Proposal

Automated Agent System for Adding New Model Support to Optimum-Intel

intermediate
OpenVINO Toolkit•2026Varies175h (Medium)

Develop an autonomous multi-agent system using LangGraph to automatically analyze Hugging Face model architectures and generate the necessary code, tests, and documentation to add support for new models in the Optimum-Intel repository

pythonc++x86+1
Student: Mohamed Ashraf Ibrahim
Code
Proposal

Finalize and Release Desktop & Web Versions of the PSLab App

intermediate
FOSSASIA•2026Varies175h (Medium)

The PSLab Flutter application currently has limited testing and optimization for desktop and web platforms, as most development has focused on mobile devices. This results in issues such as inconsistent UI behaviour, limited mouse and keyboard support, unreliable data export, and the absence of a proper build and release workflow. This project focuses on improving usability, compatibility, and stability of the PSLab app on desktop and web platforms. It includes testing across platforms, fixing UI responsiveness issues, enhancing support for non-touch interactions, and improving the reliability of data export functionality. Hardware communication on the web will be analyzed based on available support and further tested when access to the PSLab device is available. A consistent build and release workflow will be defined, including CI support for generating web builds and preparing desktop releases. The project will also include packaging, distribution through GitHub releases, and improved documentation with clear setup guides and demo videos.

pythonjavascriptandroid+7
Student: Bhavini Joshi
Code

Inspect native memory in Dart DevTools

intermediate
Dart•2026Varies175h (Medium)

When debugging Dart applications that use dart:ffi (Foreign Function Interface), developers encounter a frustrating limitation: Pointer objects appear as opaque memory addresses. For a Pointer<MyStruct> containing fields a = 42 and b = 3.14, the debugger shows only 0x7f8a4b3c2d10, not the actual data. This forces developers to rely on print statements or risky manual memory inspection, creating a significant blind spot when working with native code. This project aims to make native memory inspection a first-class debugging feature in Dart DevTools. By extending the VM Service Protocol, implementing safe pointer dereferencing, and enhancing DevTools' UI, developers will be able to inspect struct fields directly in the debugger without crashing on invalid pointers. The goal is to display Pointer<MyStruct> contents as intuitively as regular Dart objects. The outcome: seamless, crash-free inspection of native memory during development

flutterdartprogramming-language
Student: Nourhan H.
Code
Proposal

DIT: Decentralized Identity Platform

intermediate
AOSSIE•2026Varies175h (Medium)

My proposal aims to build the smart contracts of DIT which is a blockchain based identity system that gives users ownership of their digital identity. DIT lets users mint on-chain identity (ERC-721 NFT tokens) tied to unique username. Tokens can be educational qualifications, work history, healthcare records etc. Others can endorse these credentials, recovery and flagging keeps trust honest and up to date. private information is stored as cryptographic hashes, so no personal data is exposed on-chain. It lets users mint self-sovereign identity tokens.

pythonjavascriptswift+8
Student: khushalagarwal
Code
Proposal

Wagtail Starter Kit Upgrade Stabilization Modernization Developer Experience

beginner
Wagtail•2026Varies90h (Small)

The current Wagtail news starter template presents significant onboarding challenges for new developers, including dependency conflicts, Python version incompatibilities, lack of cross-platform setup support, and incomplete features such as a non-functional newsletter and missing RSS feed. This project aims to transform the starter template into a reliable, modern, and beginner-friendly entry point into the Wagtail ecosystem. The approach is structured across three pillars: 1. Stabilization: Introduce CI targeting the latest stable versions, resolve dependency conflicts, enforce reproducible installations, and implement a cross-platform setup system using a single Python entry point validated via CI on both Linux and Windows. 2. Modernization: Replace broken or missing features with Wagtail-native implementations, including a working newsletter (FormPage), RSS feed, improved admin interfaces (PageListingViewSet, SnippetViewSet), SEO fixes, modular StreamField block architecture, and GDPR-compliant asset handling. 3. Developer Experience: Improve onboarding through interactive admin guidance, simplified frontend tooling, better inline documentation, and demo content that works out-of-the-box. Deliverables include a fully functional, CI-validated starter template, modular and reusable architecture, improved documentation, and a setup experience that reduces time from clone to running project to under five minutes. Initial validation experiments show a 100% setup success rate in controlled environments with zero dependency conflicts, demonstrating feasibility.

pythonjavascriptdjango
Student: Aryan Khandhadiya
Code
Proposal

Create a Comprehensive FHIR facade Layer For OpenELIS Global

advanced
OpenELIS Global•2026Varies350h (Large)

Executive Summary: Create a Comprehensive FHIR facade Layer For OpenELIS Global. The Challenge: The Synchronization Gap The current architecture utilizes a HAPI FHIR JPA "Sidecar" which functions as a secondary, disconnected data store. This results in: Data Latency: Clinical data is trapped in a "sync queue," delaying real-time care coordination. State Drift: Risks of "Split-Brain" where the LIS database and FHIR store disagree on patient records. Resource Waste: Redundant storage of the same data in two different PostgreSQL schemas, increasing infrastructure costs by ~40%. The Solution: Real-Time Native Facade I propose a Native FHIR Facade embedded directly within the OpenELIS Spring context. This transforms OpenELIS into a FHIR-native server without the need for a secondary database. Core Innovations: HAPI Plain Server Integration: Swapping the heavy JPA engine for a lightweight RESTful controller. Live Resource Mapping: A FhirTransformService that maps OpenELIS Domain Objects (Java 21 Records) to FHIR Resources on-the-fly. Atomic Transactions: FHIR writes (POST/PUT) share the same @Transactional context as the LIS, ensuring 100% data integrity. Technical Implementation Stack Language: Java 21 (leveraging Pattern Matching for cleaner transformation logic). Engine: HAPI FHIR (Plain Server Library). Mapping: Manual POJO transformation or MapStruct for high-performance throughput. Validation: Native HAPI FhirValidator to ensure compliance with regional Implementation Guides (IGs).

postgresqljavascriptjava+2
Student: Isabirye
Code
Proposal

Building the Amharic DBpedia Language Chapter with Large Language Models (LLMs)

advanced
DBpedia•2026Varies350h (Large)

The Amharic DBpedia chapter's past implementation was largely manual, relying on tedious template mapping that has proven impossible to scale given the complexity of the Amharic language and the messy Wikipedia markup. My project's goal is to transition the chapter away from this bottleneck and fully automate the entire Semantic Web pipeline. I'll build an Agentic Orchestration Pipeline (using LangGraph/Mastra) that fixes the problem in three core areas: AI-Powered Mapping: The pipeline will integrate the fine-tuned Afro-XLM-R model to automatically predict and align Amharic properties to the DBpedia Ontology, completely replacing the manual mapping effort. This process is preceded by a Python preprocessor that cleans the raw Wikipedia XML dumps to prevent parser crashes. Human-in-the-Loop Safety (HITL): I will wrap the entire system in a Human-in-the-Loop (HITL) interface, allowing community experts to verify low-confidence predictions to ensure data quality and continuously improve the AI model. Visualization and Accessibility: Finally, I will refactor the current am.dbpedia.org website into a dynamic dashboard that hooks into our deployed SPARQL endpoint, letting users actually query and visualize the live Knowledge Graph. Key deliverables will include the fully functional, automated extraction framework, the publication of the generated Amharic RDF triples to the DBpedia Databus, the deployment of a public-facing SPARQL endpoint (Tentris/Fuseki) for live querying, and the refactoring of the am.dbpedia.org website into a dynamic dashboard for visualizing the new Knowledge Graph.

javascalardf+7
Student: Natnael Yohanes
Code

Integrating 5G NR module with ns-3-ai

advanced
The ns-3 Network Simulator Project•2026Varies350h (Large)

The Integrating 5G NR module with ns-3-ai project aims to create a high-performance, zero-serialization bridge between the 5G-LENA NR MAC scheduler and Python ML frameworks using the ns-3-ai Message Interface, enabling richer observations, lower latency, and framework-independent ML integration beyond what the current OpenGym-based approach supports. While the NR scheduler is the target use case, the integration patterns, bindings, and agent framework built here serve as a reusable reference for any ns-3 module looking to adopt ML.

pythonc++c/c+++2
Student: Anuka Hettiarachchi
Code
Proposal

Modernize search storage format for the MusicBrainz database

advanced
MetaBrainz Foundation Inc•2026Varies350h (Large)

The MusicBrainz database has a Solr search engine used for both website search and search API. MB Search architecture for reference. After solr was upgraded to version 9, the schemas in configsets weren’t updated and still use version 1.5. They need to be upgraded to version 1.7. Solr currently keeps data in index fields for search and also uses _store field to store the index field data + other non index field’s data for response writer, causing redundancy. To eliminate this redundancy, we need to store all the required data in the fields themselves. Solr response writer currently reads all the data from _store field of a document and returns it in a valid MB XML/ MB JSON format. After modifying the configsets and indexer to store data in the fields, we need to create response writers that read from these fields and return data in a valid MB XML/ MB JSON format, along with validation tests for these writers. Since storing data in individual fields rather than a single _store blob will lead to change in performance,we will start with the artist core and benchmark it before rolling out to all remaining entities.

pythonjavascriptperl+8
Student: junaid_
Code

6LoWPAN Mesh Under Routing Enhancements with Trickle Suppression in ns3

intermediate
The ns-3 Network Simulator Project•2026$3k–$6.6k175h (Medium)

This project enhances 6LoWPAN mesh under routing in ns3 by replacing unconditional flooding with a smarter Trickle based suppression strategy following RFC 6206. Each node listens before forwarding and stays silent if neighbors are already spreading the packet. Adaptive forwarding jitter adjusts timing based on local density. A pre GSoC patch already implements the strategy framework with abstract base class and default flooding. The proposed work adds per packet Trickle timers with counter based suppression and interval doubling. Medium 175 hours.

pythonc++c/c+++2
Student: Usham Roy
Code
Proposal

GPU Accelerated Motion Compensation-based Video Frame Interpolation in libplacebo

beginner
VideoLAN•2026Varies90h (Small)

Video frame interpolation (VFI) refers to the process of increasing the framerate or frames-per-second (FPS) of digital media beyond the initial framerate that is explicitly available (e.g., interpolating 24fps video to 60fps video), and is desirable to be done in real-time using GPU-accelerated algorithms to allow for use in media players such as VLC Media Player. This technique is not available to a broad audience through open source software, with implementations either being proprietary, unsuitable for real-time use, or unsuitable for use in a media player setting. We will solve this problem in libplacebo, VideoLAN's GPU-accelerated video processing library, by implementing a motion compensation-based VFI algorithm, a class of VFI algorithms well suited for real-time performance. This algorithm will require two stages: motion estimation (predicting the motion of pixels from one frame to the next), and motion interpolation (using motion estimates to estimate an intermediate frame between the two). This algorithm will be robust to common VFI challenges, using an image pyramid for large motion handling, and bidirectional motion estimation for occlusion handling. We will clearly document VFI in libplacebo to enable easy integration into software projects, such as media players. We will document the performance, the speed and accuracy of our VFI implementation, using common benchmarks from literature such as Adobe240FPS, or the Xiph dataset, using metrics such as SSIM as well as visually identifying artifacts, to better understand the computational efficiency of our algorithm (performance on 1080p vs 4k resolution, performance when interpolating multiple frames 24->120fps) and accuracy under varying input (large motion caused by high resolution).

copenglc+++10
Student: John Tyler
Code

Improve Getting Started Documentation

advanced
dora-rs•2026Varies350h (Large)

This plan aims to improve dora-rs's getting-started documentation by creating a comprehensive learning system—including written tutorials, video guides, and runnable code examples—that enables new users to complete their first project within 2-3 hours. Leveraging prior contributions to the dora-rs ecosystem and experience producing AI-assisted programming tutorials, the applicant plans to deliver 8 milestones across 12 weeks: basic setup and rerun simulation before midterm (July 10), followed by multimodal model integration, LLM-based action planning, and adora+octos advanced features before the final deadline (August 24). All outputs will be published as open-source documentation and bilingual video tutorials on GitHub, Bilibili, and YouTube.

pythonrosc+++2
Student: Ace20260322
Code
Proposal

CCExtractor: TaskWarrior Mobile App

intermediate
CCExtractor Development•2026Varies175h (Medium)

This project focuses on improving the TaskWarrior Flutter mobile application by reducing technical debt, improving the Rust–Flutter integration, and expanding core TaskWarrior functionality on mobile platforms. The current codebase contains legacy synchronization components, incomplete Rust FFI features, and an unstructured project layout that makes maintenance and feature development difficult. The project will remove the deprecated CCSync synchronization layer and unify synchronization through the TaskChampion Rust backend. The tc_helper Rust library will be refactored to improve build configuration, modular structure, cross-compilation, and to expose missing task attributes to the Flutter application. The Flutter project will also be reorganized into clear modules separating legacy Taskwarrior 2.x code from the TaskChampion implementation. Additionally, a mobile reporting engine will be implemented to support Taskwarrior-style filtered reports and user-defined configurations. A GitHub Pages website with automated nightly build tracking will also be created, along with targeted UI and UX improvements based on community feedback. Deliverables include synchronization refactoring, Rust library improvements, Flutter project restructuring, a reporting engine, project website, and UI/UX enhancements.

clinuxvideo+14
Student: Chinmay Chaudhari
Code
Proposal

AI/ML Models for Agricultural Analytics on the National Research Platform

intermediate
UC OSPO•2026Varies175h (Medium)

The VINE project at Iron Horse Vineyards collects continuous agricultural data through LoRaWAN sensors (soil moisture, temperature, CO2, weather) and multispectral drone imagery, but lacks the ML models to turn this data into actionable predictions. This project builds three interconnected model tracks for the VINE precision agriculture platform, all trained on NRP's GPU clusters. First, predictive irrigation scheduling: time-series forecasting models (ARIMA, Prophet, LSTM) that predict soil moisture at multiple horizons and recommend when to irrigate before crop stress occurs. Second, plant health computer vision: CNN-based models (fine-tuned ResNet/EfficientNet) that analyze multispectral drone imagery to classify plant stress, detect pest damage, and estimate yield, producing spatial health maps per vineyard block. Third, harvest timing prediction: forecasting models (XGBoost, LSTM) that predict optimal harvest windows from sensor data, weather, and historical records. Deliverables: (D1) data ingestion and feature pipeline for sensors, imagery, and historical records, (D2) irrigation scheduling models with decision layer, (D3) plant health CV models with spatial health maps, (D4) harvest timing models, (D5) systematic model evaluation report with ablation studies, (D6) Dockerized inference services deployed on NRP Kubernetes with REST API, (D7) documentation and bi-weekly blog posts.

pythonc/c++visualization+5
Student: Sohan Shingade
Code

BRL-CAD Agentic MCP Interface

intermediate
BRL-CAD•2026Varies175h (Medium)

BRL-CAD is a battle-tested Constructive Solid Geometry (CSG) engine, but it currently lacks a native, bidirectional interface for headless command execution, creating a massive barrier for modern web integrations and AI agents. This project proposes building BRL-CAD’s first native, extension-agnostic C++ Local IPC (Inter-Process Communication) API. By securely binding a stdio-based pipe listener to the main event loop and leveraging native libbu utilities for memory-safe string parsing, this infrastructure will allow users to safely pipe commands directly into the libged database engine. Designed with a "generic passthrough" architecture, it avoids hardcoding 400+ command schemas and ensures frictionless portability to BRL-CAD’s upcoming MOOSE/Qt interface. Alongside this foundational API, the project delivers a robust Model Context Protocol (MCP) server to establish BRL-CAD's first native Agentic AI integration. Operating externally as decoupled Python-based FastMCP middleware, this daemon bridges the legacy C-engine with modern Large Language Models. Rather than embedding a bulky AI chatbot inside MGED, the user interacts through their preferred external MCP client (like Cursor IDE or Claude Desktop), which routes commands directly into BRL-CAD's new background IPC pipeline. This empowers users to seamlessly query native documentation, automate batch database tasks, and debug spatial relationships using conversational commands, drastically lowering BRL-CAD's onboarding friction.

pythonc/c++opengl+6
Student: RaghavSharma0125
Code
Proposal

Improving performance using sparse linear algebra

advanced
The Julia Language•2026Varies350h (Large)

Graph Neural Networks (GNNs) rely on message passing, traditionally implemented via a gather/scatter mechanism. In GraphNeuralNetworks.jl, this approach materializes dense feature matrices on graph edges, leading to severe memory bottlenecks and reduced performance as graph sizes scale. This project addresses this limitation by redefining message passing as non-materializing Sparse Matrix-Matrix Multiplications (SpMM). By treating the graph as a sparse mathematical operator, this project will unlock significant computational efficiency and memory savings on CUDA GPUs. The core objectives include integrating COO storage, upstreaming patches to CUDA.jl, and refactoring the GNNlib API. To ensure continuous momentum during upstream review cycles, the project features a secondary track focused on upgrading the Automatic Differentiation (AD) pipeline by fully integrating Mooncake.jl and Enzyme.jl, alongside expanding the ecosystem with new datasets and new tutorials / improved documentation.

cjavascriptc+++12
Student: Parv Mittal
Code
Proposal

Coverage of Documentation Comments Style Guide

intermediate
checkstyle•2026$3k–$6.6k175h (Medium)

Description: Project will mainly be focusing on automation of Documentation Comments (javadoc) guidelines by Checkstyle Checks. Reliable comments parsing was a major improvement in Checkstyle during GSoC 2014 and 2025, archived results need to be reused to reliably implement automation of Javadoc best practices. Separate configuration file with newly created Checks need to be created. Best practices in documentation make sense not for all projects. Javadoc validation matters only for library projects that need to expose online documentation in web publicly. Deliverables: The result of this project will be a configuration file with the maximum possible coverage of Comment style guide. Report should look like Google's Java Style Checkstyle Coverage. If there will be time left we can focus on coverage of guidelines from https://blog.joda.org/2012/11/javadoc-coding-standards.html

javaantlrxpath+1
Student: Gianmarco Schifone
Code
Proposal

Generalise the Qubes PDF Converter to Other Types of Files

intermediate
Qubes OS•2026Varies175h (Medium)

The Qubes PDF converter safely sanitises untrusted PDFs by rendering them inside a disposable VM. However, other risky file types (documents, spreadsheets, images) lack equivalent protection. This project generalises the converter into a plugin-based architecture with per-format qrexec services and minimal DispVM templates. Key features: • New qvm-convert-file entry point with MIME-based routing • Document & spreadsheet conversion via LibreOffice → existing bitmap pipeline • Image sanitisation via decode + re-encode (metadata stripped) • Audio/video conversion via ffmpeg (stretch goal) • Full backward compatibility with qvm-convert-pdf Deliverables: D1: Plugin architecture + MIME dispatch D2–D3: Document & spreadsheet converters D4: Image sanitiser D5: Media converter (stretch)

cpythonxen+3
Student: Jayant Saxena
Code
Proposal

Enhanced Reuse Agent for Intelligent License Reuse

intermediate
FOSSology•2026Varies175h (Medium)

The current reuse workflow in FOSSology provides a powerful mechanism to copy license clearing decisions from a previously analyzed upload to a newer version. However, this process remains largely mechanical and opaque, offering little insight into what has changed between versions after reuse is applied. As a result, users must manually inspect differences to understand the impact of reuse, which becomes increasingly difficult for large codebases and frequent updates. To address this limitation, this project proposes the development of an Enhanced Reuser Agent that adds an intelligent analysis layer on top of the existing reuse workflow. The agent runs automatically after scanners complete and reuse decisions are applied, comparing the previously cleared upload (v1) with the new upload (v2). It generates insights such as a diff-aware file tree, license comparison, aggregated statistics, and a risk-level summary. In addition, a Smart Reuse (Suggested Matches) mechanism automatically identifies and recommends similar previously-cleared uploads, reducing the manual effort required to search for suitable reuse candidates. By providing a clear and interactive view of structural and license-level changes, along with proactive reuse suggestions, the system enables users to better understand the outcome of reuse and efficiently refine decisions where needed. This transforms reuse into a more transparent and insight-driven process, reducing manual effort and improving overall usability while remaining fully compatible with the existing FOSSology workflow.

linuxpostgresqlc/c+++7
Student: Saksham Mishra
Code
Proposal

Add anova Classdef Object to the GNU Octave Statistics Package

advanced
GNU Octave•2026Varies350h (Large)

This project implements an anova classdef for the GNU Octave statistics package, providing a unified object-oriented interface for one-way, two-way, and N-way analysis of variance. The anova class delegates core computation to the existing anova1, anova2, and anovan functions, preserving their tested logic while exposing a clean, MATLAB-compatible OOP API with properties (Coefficients, anova table, fitted values, residuals, diagnostics) and methods (summary, multcompare, plotDiagnostics, predict, getEffectSizes). The class stores model state, enabling interactive post-hoc workflows without refitting. Beyond the classdef, the project delivers targeted performance improvements to the underlying functions: vectorizing loop-heavy group statistics in anova1 with accumarray, vectorizing anova2 SSE computation, reducing memory in anovan interaction column construction, and adding NaN handling to anova2. Deliverables: (1) anova classdef with constructor, properties, and core methods, (2) summary and display methods with formatted ANOVA table output, (3) multcompare method for post-hoc pairwise comparisons, (4) plotDiagnostics method for residual and leverage plots, (5) performance optimizations to anova1, anova2, anovan internals, (6) NaN handling for anova2, (7) comprehensive BISTs and Texinfo documentation, (8) benchmark suite. All computation reuses existing functions with no architectural rewrites.

c++hg
Student: beingamanforever
Code
Proposal
Showing 25 - 48 of 11996 Projects
12345
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal