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

Automated Compilation Verification Across All Concerto Code Generation Languages

intermediate
Accord Project•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 →
175h (Medium)

Concerto is the modeling language of the Accord Project. It supports code generation for 16 target languages and schema formats such as Java, TypeScript, Go, Rust, C#, GraphQL, and Protobuf. At present, CI only checks that the generator runs without crashing. It does not verify that the generated code compiles or validates in its target environment. This allows broken code to reach users without detection. This project adds full compilation and validation checks across all 16 targets through three deliverables. The first deliverable is a set of Docker images, one for each target. Each image includes the Concerto CLI and the required language toolchain. These images are published to the GitHub Container Registry with layer caching enabled. The second deliverable is a GitHub Actions matrix workflow. It generates code from a test corpus, runs it inside the correct image, and executes the compiler or validator for every pull request. The workflow fails immediately if the output is invalid. The third deliverable is a versioned test corpus of .cto model files. These files cover all Concerto language constructs such as primitives, optionals, arrays, inheritance, enumerations, and relationships. This ensures full coverage of code generation features.

javascriptreactcompiler+5
Student: Apoorv Gadiya
Code
Proposal

Add ensembling methods for tiling to Anomalib

advanced
OpenVINO Toolkit•2023Varies350h (Large)

When tackling the challenge of detecting defects in high-resolution images, we encounter many challenges. One significant problem is the difficulty in training models effectively, primarily due to memory limitations. The process of down-sampling these images to fit within memory capacities leads to the loss of crucial information, which can result in the oversight of small yet significant defects. To overcome these issues, we can employ a strategy involving a tiled ensemble mechanism. In this case, images are split into smaller, manageable tiles. Each of these tiles is then processed using a separate model, specifically trained for that tile position. This strategy enhances localization and improves the detection of small anomalies, while also satisfying memory limitations. Anomalib currently has a basic tiler. However, the advantages of locally-aware models, like Padim, are diminished without the support of a tiled ensemble. To address this problem, we introduce a tiled ensemble implementation that preserves the advantages of local awareness while also enhancing overall performance. This approach aims to incorporate Anomalib's existing features, while simultaneously providing users the flexibility to tailor specific steps within our pipeline. All the while, we ensure that our approach remains memory-efficient.

pythonc++x86+1
Student: Blaž Rolih
Code
Proposal

[DaCe-Debug] Retaining Semantic Source Information in Dataflow Representations

advanced
Scalable Parallel Computing Laboratory•2024Varies350h (Large)

The DaCe framework uses the Stateful DataFlow multiGraph (SDFG) data-centric intermediate representation. This graph maps to a variety of high-performance architectues and performance engineers can manipulate this graph for achieving state-of-the-art representations. When dealing with large projects with hundreds of thousands lines of codes the state graph can become extremely unreadable due multiple nested cycles, function’s calls, and conditional branching: it becomes nearly impossible to understand smaller parts of the graph and it also makes relating it to the original source code very hard. To mitigate this problem the concept of ControlFlowRegion was introduced. A ControlFlowRegion is a region of the SDFG which represents a control flow construct just like a traditional programming language. An example can be the LoopRegion, developed on a separate feature branch (loop_architecture_pt_3), which represents the classic C-like for loop for ( init-clause ; cond-expression ; iteration-expression ). The project goal is to - Implement all the other control flow constructs like if … elif … else and match - Implement regions for function calls and with statements - Implement user defined regions - Add support for all these new regions in the DaCe VSCode extension

pythonc++mpi+2
Student: luca-patrignani
Code

Robust OpenCL Operations

intermediate
GNU Image Manipulation Program•2024Varies175h (Medium)

The massively parallel nature of many real-world computations has led to the development of specialized massively parallel hardware such as GPUs, TPUs and FPGAs. Many closely-related programming models exist such as CUDA and OpenCL. OpenCL is a popular framework for writing massively parallel code given its broader ecosystem and supported platforms. GIMP is a popular free open-source image manipulation tool often shipped as the default tool in many Unix-based distributions. GIMP uses GEGL internally for accelerating various image processing tasks. GEGL comes with OpenCL implementations for many operations. However, the OpenCL backend in GEGL was often slower than the baselines and resulted in incorrect outputs (and crashed sometimes). The goal of this project is to enumerate all the existing OpenCL implementations in GEGL, write a thorough suite of tests for them, and fix as many implementations as possible. If time permits and once correctness is established via tests, the project adds new faster implementations for popular operations. A successful completion of the project would allow the OpenCL backend to be enabled by default and allow the end-users to take advantage of hardware acceleration on their devices automatically.

cGEGL
Student: Varun Samaga B L
Code
Proposal

OrgExplorer: GitHub Organization Analytics and Visualization System

beginner
AOSSIE•2026Varies90h (Small)

As GitHub organizations grow, it becomes difficult to understand overall activity across multiple repositories and contributors using the default interface. Important insights such as contributor involvement, repository activity, and development trends are often scattered across many pages, which makes analysis slow and inconvenient. This proposal introduces OrgExplorer, a web-based platform designed to provide a clearer view of activity within GitHub organizations. The project will collect data from the GitHub REST and GraphQL APIs, process it, and present it through an interactive and easy-to-understand interface. The system will include features such as repository and contributor insights, activity visualizations, calculated metrics, and browser-based caching to reduce repeated API requests. Support for GitHub Personal Access Tokens will also be included to enable richer data access. By the end of the project, OrgExplorer will provide an interactive dashboard with organization-level insights, repository and contributor visualizations, metrics and rankings, exportable reports (CSV and PDF), and proper documentation. The goal is to make it easier for users, maintainers, and community members to explore and understand how GitHub organizations are evolving over time.

pythonjavascriptswift+8
Student: Rahul_Vyas
Code

Large-scale computing backend for Jupyter notebooks - HTCondor batch job submission and monitoring using the Ganga toolkit

intermediate
CERN-HSF•2018Varies175h (Medium)

<p>Jupyter Notebook is an interactive computing environment that creates notebooks which contains computer code as well as rich text elements like equations, figures, plots, widgets and theory. Ganga is an open source iPython based interface tool to the computing grid which leverage the power of distributed computing grid and provide scientists an interface supported by a powerful backend where they can submit their computation intensive programs to Ganga as a batch job. HTCondor is a workload management system created by University of Wisconsin-Madison. It is based on High-Throughput Computing which effectively utilizes the computing power of idle computers on a network or on a computing grid and offload computing intensive tasks on the idle machines available on a network or computing grid. This project aims to create a plugin for Jupyter Notebook and also integrate it to SWAN Notebook service which is a cloud data analysis service developed and powered by CERN. This plugin will easily submit and monitor batch computation jobs to HTCondor using Ganga toolkit. The plugin will display status of ongoing job in Notebook itself and will also allow termination of ongoing jobs.</p>

pythonc/c++machine learning+6
Student: Aman Pratap Singh
Code

New releases for atleast 25 Sugar Activities

intermediate
Sugar Labs•2020Varies175h (Medium)

<p>Sugar has a lot of activities, with 250+ on GitHub, and more elsewhere. These have scope for improvement; bugs, features, updated human translations, and release. There are many activities which have not been maintained or updated for over a decade. It is important to port such activities from python 2 to python 3 along with porting them to Gtk+3. The support for python 2 is being withdrawn and the port to Gtk +3 to have a fully functional activity is important. Inaddition to that, the activity might require porting</p> <ul> <li>from GObject to GLib</li> <li>from GConf to Gio.settings</li> <li>from GStreamer Gst.Message.structure to get_structure()</li> <li>and porting to TelepathyGLib</li> </ul> <p>My project also includes adding feature improvements or fixing the features of the activity which are not working and fix display resolution issues. I will be collaborating with others to prepare activities for release and also test debian packages if needed. It is important to identify if the tracebacks are due to activity code, changes in versions of packages or due to difference in the test environment.</p> <p>So this project aims at making necessary changes to sugar activities to have at least 25 release ready activities.</p>

pythonjavascriptgtk++10
Student: Jui Pradhan
Code
Proposal

Folksonomy Engine: a one size fit all for any product data

beginner
Open Food Facts•2025Varies90h (Small)

The Folksonomy Engine does not support intuitive property suggestions and reusable web components. In order to enhance usability and scalability, the system requires improved property suggestion mechanisms, more effective handling of nested values, and an easier-to-use interface for data contribution and analysis.\n \n To address the challenges in data contribution, consistency, and exploration, the project will develop new API features and create a reusable web interface. The proposed solution includes developing new API features and a reusable web interface. The main goal is to get as many contributors as possible to use this, making it easy and accessible for everyone to contribute.\n \n New API Features:\n - Suggestions based on popularity and categories\n - Adding User roles\n - Improved handling of nested property values\n - Adding moderation for bulk property, value management\n - Tools for exploring and merging values\n \n Improved Reusable JavaScript-based Web Interface:\n - For display and editing of data\n - Integrating folksonomy-editor to main project\n - Potential formalization of property definitions

androidmachine learningmongodb+6
Student: Kirtan Chandak
Code

Expand genome metadata in Ensembl with AI tools

advanced
Genome Assembly and Annotation•2026Varies350h (Large)

The Ensembl Plants and Metazoa platforms face a significant metadata gap where critical biological context, such as ploidy, strain, and sex, is often documented in peer-reviewed literature but missing from formal INSDC sequence archives. This lack of structured metadata, particularly ploidy, creates technical bottlenecks in downstream comparative genomics and requires labor-intensive manual curation. To address this, I propose developing a standalone, Python-based "Retrieve-Extract-Verify" module that leverages Large Language Models (LLMs) and Retrieval-Augmented Generation (RAG) to automate metadata extraction from scientific papers. This tool will utilize literature APIs like Europe PMC, employing section-aware parsing and confidence scoring to ensure high data integrity with minimal human intervention. My previous experience in building Transformer-based bioprocess optimization models and genome-level embeddings directly informs my approach to handling complex biological datasets. The final outcome will be a ready-to-deploy Nextflow module designed for seamless integration into Ensembl’s production pipeline and provide the global research community with richer, more reliable genomic metadata.

pythonmysqljavascript+4
Student: Soomin Lee
Code

Implement JS filesystem bridge layer for Emscripten

advanced
Chromium•2023Varies350h (Large)

Emscripten is an open-source tool used to translate C/C++ code to WebAssembly, allowing web apps to run with near-native performance. WebAssembly is especially popular for web games and other performance-oriented applications. As of March 2023, Emscripten uses an emulated file system written in JavaScript to support C/C++ file system operations in compiled WebAssembly code. Currently, the mentors are working on WasmFS, an emulated file system built in C++/WebAssembly, for Emscripten. However, WasmFS lacks the JavaScript required to connect the existing JS API to the new C++/WebAssembly file system operations. The central goal of this project is to build a new JavaScript library modeled after Emscripten’s existing file system library that will call WasmFS functions instead of JavaScript routines. This approach aims to speed up filesystem operations and lay the foundation to add multithreading in the future. That being said, this project does not aim to redesign the filesystem implementation for Emscripten. This project also will not add new functionality to the Emscripten file system. Finally, this project will not attempt to add full multithreading functionality yet.

pythonjavascriptjava+2
Student: James Hu
Code
Proposal

Rucio WebUI Revamp

advanced
CERN-HSF•2025Varies350h (Large)

As a final-year Software Engineering student at Kyiv Polytechnic Institute, I propose transforming Rucio WebUI into a more powerful, intuitive, and sustainable platform. Drawing from my previous contributions and technical expertise, I've developed a comprehensive strategy that addresses current limitations while setting the foundation for future growth. My plan focuses on migrating to modern technologies (Next.js 15, React 19, TailwindCSS 4.x), implementing server-side rendering for improved performance, enhancing the authentication system with NextAuth.js and RBAC, and fixing critical bugs like DID slash-handling issues and non-functional replicas loading. I'll also optimize performance through advanced streaming mechanisms for large data volumes, improve architecture with a transition to NX monorepo, enhance entity management functionalities, and implement comprehensive UI/UX refinements. With substantial experience in the Rucio WebUI codebase from my previous internship and 30+ contributions to the project, I've demonstrated my commitment and technical ability to execute this comprehensive modernization plan. My current work with Next.js and NX at a startup provides me with cutting-edge expertise that I can directly apply to enhance the project's development and implementation.

pythonc/c++machine learning+6
Student: MytsV
Code
Proposal

Hyperledger - Cacti - Ledger Data Sharing with Proof in Besu and Ethereum Mentorship Project

Intermediate
•Varies175h (Medium)

Cacti provides a protocol and trigger mechanism for the sharing of ledger data or data derived from smart contracts (called "view", and identified by a "view address") deployed in a network with another network using relays for communication and consensus-driven proof generation and verification in the end networks. Some parts of the protocol are generic and DLT-agnostic but others, specifically protocol drivers or connectors and core ledger operators (typically built as smart contracts) are DLT-specific. Presently, Cacti provides DLT-specific data sharing mechanisms for Hyperldger Fabric and Corda. The goal of this project is to add similar support, i.e., build modules, plugins, and API for permissioned networks built on Hyperledger Besu. As an optional extension, these mechanisms will then be extrapolated to share data to and from public Ethereum. This will involve designing and basic building blocks or capabilities for view proof generation, proof verification, and access control of remote data requests, in the form of smart contracts. Higher up the stack, the Cacti SDK for Besu must then be augmented to enable network apps to trigger data sharing requests and submitting the responses for validation to local smart contracts.

TBA
Proposal

Re-optimization using JITLink

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

In Just-In-Time compilers we often choose a low optimization level to minimize compile time and improve launch times and latencies, however some functions (which we call hot functions) are used very frequently and for these functions it is worth optimizing more heavily. In general hot functions can only be identified at runtime (different inputs will cause different functions to become hot), so the aim of the reoptimization project is to build infrastructure to (1) detect hot functions at runtime and (2) compile them a second time at a higher optimization level, hence the name "re-optimization". There are many possible approaches to both parts of this problem. E.g. hot functions could be identified by sampling, or using existing profiling infrastructure, or by implementing custom instrumentation. Reoptimization could be applied to whole functions, or outlining could be used to enable optimization of portions of functions. Re-entry into the JIT infrastructure from JIT’d code might be implemented on top of existing lazy compilation, or via a custom path. Whatever design is adopted, the goal is that the infrastructure should be generic so that it can be used by other LLVM API clients, and should support out-of-process JIT-compilation (so some of the solution will be implemented in the ORC runtime).

cllvmc+++3
Student: Sunho Kim
Code
Proposal

Router Factory for Design Driven Web API Development

intermediate
Eclipse Vert.x•2017$3k–$6.6k175h (Medium)

<p>The main objective of my project is to expose functions that generate a Router from an API specification (based on an API specification standard like Swagger or RAML), to help dev teams building its services starting from a Web API specification. This method is called Design Driven Development.</p> <p>The main idea is to implement an interface inside vertx-web like this:</p> <pre><code>DesignDrivenRouterFactory routerFactory = new SwaggerDesignDrivenRouterFactory("swagger.json"); routerFactory.addHandler(HttpMethod.POST, "/product", routingContext -&gt; { // do stuffs with JsonObject routingContext.getBodyAsJson() ! }); Router router = routerFactory.router(); vertx.createHttpServer().requestHandler(router::accept).listen(8080); </code></pre> <p>This interface enables developers to create a router based on his API specification without caring about request validation and parameters parsing and other things described in API specification. Also a base interface <code>DesignDrivenRouterFactory</code> will be created to enable Vert.X framework to support multiple specifications standards</p> <p>Here is <a href="https://github.com/slinkydeveloper/twitter-wall-GSOC" target="_blank">my Twitter wall project</a></p>

javakotlinreactive extensions+2
Student: Francesco Guardiani
Code
Proposal

Webpack: New Documentation Website

intermediate
webpack•2026Varies175h (Medium)

Webpack currently lacks a modern, automated documentation site. Existing documentation is manually maintained, lacks API reference generation, and has no automated pipeline to stay in sync with webpack's source code. This project aims to build a fully automated documentation system for webpack using TypeDoc and @node-core/doc-kit. The pipeline extracts API documentation directly from webpack's types.d.ts, generates structured markdown, and renders a complete website - including API reference, guides, loaders, plugins, and core pages like Home and Download. Key deliverables: • A complete TypeDoc theme producing doc-kit-compatible markdown. • Webpack-branded site using doc-kit's theming system (#theme/* components) that aligns webpack's documentation with the OpenJS Foundation's design standards. • Multi-version documentation support (v5, v6 and beyond). • Fully automated CI/CD pipeline that syncs with webpack releases. The overarching goal is zero manual documentation maintenance - every webpack release automatically triggers doc regeneration and deployment, keeping the documentation accurate and fresh without human intervention.

javascriptnode.jsweb development+6
Student: __tushar
Code
Proposal

Modeling Wayfinding

intermediate
Red Hen Lab•2024Varies175h (Medium)

Stentor roeselii is a free-living ciliate species of the genus Stentor. It is a unicellular organism but shows remarkable hierarchy of decisions when faced with a stimulus leading us to question whether there is some level of cognition involved and whether the line between metabolism and cognition is fuzzy implying mitochondria may be the cognitive centre For the last 200 years research into human cognition and decision-making has revolved around rational choice theory, which assumes that actors are utility maximizers capable of searching and finding rational and optimal decisions. However human behavioral data doesn’t support the assumptions that we have infinite time nor infinite cognitive energy to search the full space of candidate choices to produce optimal decisions. Take for example a hiker, who has an infinite number of paths to choose from. It's irrational to assume that the hiker is capable of fully evaluating each of the infinite paths available to them to then choose the most rational/ optimal path. And yet that is the operating assumption for most modern cognitive models. To remedy this, we have the Wayfinding theory which along with an optimal-control based model can be used by researchers in private and academic settings to develop more accurate computational models of cognition in various life species

machine learningopencvhigh performance computing+15
Student: Mayank Palan
Code
Proposal

Improve the Open Event Organizer Server and implement missing features

beginner
FOSSASIA•2016Varies90h (Small)

<p>Organizing an event like a Conference or a technical festival is not an easy task. Here’s where the need for a software platform to assist the team in managing the various aspects of the event arises.</p> <p>And I believe Open-Event could be the answer to that. Open-Event Organizer server shouldn’t just be for adding/editing and accessing the sessions, speakers, tracks, etc. It should also be able to assist the organizers in planning the event, managing it, and post-event documentation.</p> <h5>Deliverables</h5> <ol> <li><strong>OAuth 2.0</strong> authentication for the API</li> <li>Proper <strong>tests</strong> for the API</li> <li>Proper <strong>documentation</strong></li> <li>API page will be loading all available endpoints automatically</li> <li>Ticketing and sales.</li> <li>Support for organizers to link their Stripe/PayPal account to receive payments when tickets are sold</li> <li>Graphical interactive scheduler for scheduling sessions into their respective rooms and timings</li> <li>Invoicing generation and emailing</li> <li>Sales statistics, Fees and tax management</li> </ol>

pythonjavascriptandroid+7
Student: Niranjan R
Code

Integrating Multitaper Periodogram into Stingray

intermediate
OpenAstronomy•2021Varies175h (Medium)

<p>Time series analysis has become a fundamental ingredient in modern-day astronomical studies. A common approach for characterizing the properties of time-series data is to estimate the power spectrum of the data using the periodogram. But the periodogram as an estimate suffers from being:</p> <ul> <li>Statistically inconsistent (does not converge to zero with infinite data)</li> <li>Biased for finite samples</li> <li>Suffers from spectral leakage</li> </ul> <p>This project aims to implement and integrate a superior spectral estimation technique, known as the Multitaper Periodogram, into Stingray. It, as an estimate, is attractive because it directly trades off bias and variance for frequency resolution; it is consistent; and is fast to compute.</p> <p>This integration would follow the library’s existing design principles so its current users can use this technique to better interpret their time-series data.</p> <p>The tapers, or data windows, applied to the data in the time domain before Fourier transforming are characterized as being the most nearly band-limited functions possible among functions defined on a finite time domain. These are the discrete prolate spheroidal sequences (DPSS), or the Selpians, and help reduce spectral leakage.</p>

cpythonjulia+7
Student: Dhruv Vats
Code
Proposal

Enhancing Apache DolphinScheduler with Generalized OIDC Authentication

intermediate
Apache Software Foundation•2025Varies175h (Medium)

To address Apache DolphinScheduler's lack of generalized OIDC support which limited its adoption in enterprises that rely on a variety of identity providers like Keycloak, Okta, or Azure AD, this project introduces a new, pluggable, and configuration-driven authentication module. Built with Java and Spring Security, the backend handles the complete OIDC Authorization Code Flow, including automated user provisioning and role mapping based on IdP groups, all without requiring any database schema changes. The Vue.js frontend was enhanced to dynamically render login buttons for each configured identity provider. To ensure smooth onboarding and adoption, the project also delivers production-ready documentation with detailed setup guides for administrators and developers. The feature's quality is ensured by a robust testing strategy, featuring comprehensive unit tests and a full end-to-end API test suite using Testcontainers, which automatically orchestrates a Docker environment with DolphinScheduler and a Keycloak IdP to validate the entire login flow in a production-like environment. This project successfully delivers a production-ready Single Sign-On (SSO) solution that significantly enhances DolphinScheduler's security, usability, and enterprise-readiness.

pythonjavascriptjava+7
Student: tusaryan
Code

Browser-Based Graphical Interface for JuliaBUGS

advanced
The Julia Language•2025$6k–$13.2k350h (Large)

JuliaBUGS is a modern Julia implementation of the classic Bayesian Inference using Gibbs Sampling — BUGS language for Bayesian modeling, combining BUGS’s intuitive model specification with Julia’s high-performance sampling methods like Hamiltonian Monte Carlo. This project proposes a browser-based graphical model editor for JuliaBUGS, enabling users to visually construct probabilistic graphical models by adding nodes and drawing arrows, instead of writing code. Built using React with TypeScript and React Flow, the web interface will support adding, connecting, grouping, and editing random variables and deterministic nodes via an interactive canvas. Users can specify probability distributions and hyperparameters through intuitive forms. The editor will export model structures to JSON and generate valid JuliaBUGS (or BUGS) code. The GSoC project will focus entirely on delivering a polished, user-friendly frontend with clear usage examples and tutorials. Inspired by tools like DoodleBUGS (for WinBUGS or MultiBUGS), shinystan, and the R Package causact, this editor aims to make model specification more accessible and streamline the Bayesian modeling workflow.

cjavascriptc+++12
Student: Shravanpuri Goswami
Code
Proposal

A Library for In-Memory Data Analysis in Haskell

intermediate
Haskell.org•2018Varies175h (Medium)

<p>A typical workflow in interactive data analysis consists of :</p> <ul> <li>Loading data (e.g. a CSV on disk)</li> <li>Transforming the data</li> <li>Various data processing stages</li> <li>Storing the result in some form (e.g. in a database). </li> </ul> <p>The goal of this project is to provide a unified and idiomatic Haskell way of carrying out these tasks. Informally, you can think of “dplyr”/“tidyr” from the R ecosystem, but type safe. This project aims to provide a library with the following features:</p> <ol> <li>An efficient data structure for possibly larger-than-memory tabular data. The <code>Frames</code> library is notable prior work, and this project may build on top of it (namely, by extending its functionality for generating types from stored data).</li> <li>A set of functions to “tidy”/clean the data to bring it to a form fit for further analysis, e.g. splitting one column to multiple columns (“spread”) or vice versa (“gather”).</li> <li>A DSL for performing a representative set of relational operations e.g. filtering/aggregation.</li> </ol>

haskellghccabal+3
Student: Gagandeep Bhatia
Code
Proposal

Fixing Bugs in BoneScript and Improve BeagleBone UI

beginner
BeagleBoard.org Foundation•2018$1.5k–$3.3k90h (Small)

<p>BoneScript is an existing Node.js library specifically optimized for the Beagle family and featuring familiar Arduino function calls, exported to the browser.The BoneScript library provides several functions for easy interaction with hardware which otherwise would have required the users to manipulate the SysFs files directly(assuming use of no other libraries),which is obviously confusing for a beginner-level user.</p> <p>BoneScript library even though being widely used by BeagleBone users has compatibility issues across boards,some bugs and unfinished features.The primary aim of my project is to solve most of the open issues reported and add some more features which will be of benefit to the users.</p> <p>A secondary objective of my project is to add Improvements to the BeagleBone User Interface to provide a similar interface for PocketBeagle that can also support the BaconBits cape examples, so as to provide PocketBeagle beginners a Graphical User Interface from which they can try out the example codes easily(similar to BBUI).</p> <p>Detailed Proposal at :<a href="https://elinux.org/BeagleBoard/GSoC/fix-bugs-bonescript" target="_blank">https://elinux.org/BeagleBoard/GSoC/fix-bugs-bonescript</a></p>

cpythonlinux+10
Student: VAISHNAV M.A
Code

Integration of CircuitVerse with LMS Platforms

intermediate
CircuitVerse.org•2021$3k–$6.6k175h (Medium)

<p>CircuitVerse is an online circuit simulator that can be used as an online classroom companion for circuit simulation related needs of teachers and students.</p> <p>The aim of the project is to integrate CircuitVerse with as many Learning Management Systems such that teachers and students of different educational institutions can use CircuitVerse without leaving their favourite Learning Management Systems (Like Moodle, Canvas, Sakai etc.)</p> <p>A novel method has been developed to integrate <a href="https://www.imsglobal.org/activity/learning-tools-interoperability" target="_blank">Learning tools Interoperability</a> specifications with the existing Ruby on Rails codebase of CircuitVerse such that the platform can be used seamlessly with LTI supported Learning Management Systems (Like Moodle, Canvas, Sakai etc.)</p> <h4>Read More</h4> <p><a href="https://github.com/CircuitVerse/CircuitVerse/pull/2382" target="_blank">Final Pull Request</a> | <a href="https://blog.circuitverse.org/posts/ayan_phase_1_report/" target="_blank">First phase report</a> | <a href="https://www.ayanbiswas.in/tag/gsoc21/" target="_blank">See all blogs</a></p>

postgresqljavascriptbootstrap+8
Student: AYAN BISWAS
Code

Porting Chebfun to GNU Octave

intermediate
GNU Octave•2025$3k–$6.6k175h (Medium)

I propose to work on the following project: porting the Chebfun package to GNU Octave. Chebfun is a numerical computation package for MATLAB that provides a framework for representing functions in a symbolic manner using ”Chebyshev technology”, a term coined by the package authors to describe the use of Chebyshev polynomials to represent functions up to machine precision. GNU Octave is supposed to be mostly compatible with MATLAB, so Chebfun should ideally work without change on the former, but there are some slight differences and unimplemented features in Octave that make this difficult. Primarily, the main issue is that Octave’s support for object-oriented programming (classdef) is not as feature complete and as stable as MATLAB’s, which is a major problem since Chebfun is written in classdef. The goal of this project is to port Chebfun to GNU Octave, and to make it work as a dropin replacement for the MATLAB version. Since fixing classdef is not a feasible/recommended goal for a GSoC project, I will instead focus primarily on making the necessary changes to the Chebfun codebase to make it work in Octave. Along the way, I will compile new information about the status of classdef in Octave, and I will share my findings with the Octave developers, and perhaps aid in some changes to the Octave codebase itself.

c++hg
Student: Thomas Kolman
Code
Proposal
Showing 4417 - 4440 of 4718 Projects
183184185186187
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal