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

Faster Matrix Algebra for ATLAS

advanced
CERN-HSF•2018Varies

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)

<p>Eigen is a C++ template library for linear algebra that aims for high performance in combination of high reliablity and good compiler support. A lot of remarkable projects rely on it, including Google's Tensorflow. Another successful project using Eigen is the high-energy physics experiment ATLAS at the LHC.</p> <p>At the LHC, millions of particles collide every second and each collision creates a huge amount of data that has to be classified and analyzed by software. Most algorithms in ATLAS software use symmetric matrices, i.e., matrices where the upper triangular part is equal to the lower triangular part. Unfortunalty Eigen currently misses support for symmetric matrices.</p> <p>This Google Summer of Code 2018 project aims to implement a class for handling symmetric matrices in Eigen. The goal is to provide a working implementation that can be submitted as a patch for Eigen.</p> <p>This project proposal contains implementaions ideas and plans, a detailed implementation timeline, consisting of 13 weekly tasks and some short biographical information about me.</p>

pythonc/c++machine learning+6
Student: David Tellenbach
Code
Proposal

Replace FreeType's tracing and debugging facilities with an external logging library

advanced
FreeType•2020Varies350h (Large)

<p>FreeType is an open-source library used to render fonts​. FreeType is packed with a lot of complex font-related features, therefore, logging is an important aspect for this library. Freetype uses a home-brewed tracing and debugging facility which is well thought and designed but there is a limitation of this facility to write logs only on platforms that have inbuilt support for standard error. Therefore, this facility fails on platforms lacking standard error. Since FreeType is used on a variety of platforms, there is a strong need to enhance the current logging facility beyond a standard error in order to ease the development and debugging. The idea under this project is to enhance the existing design of writing logs to standard error to writing logs to the file system considering almost all platforms support input/output to files. There are multiple logging libraries that are freely available in the market and are stable, which will do the job of printing logs to a file. Hence, this project involves exploring the existing logging libraries, selecting one of them, integrating the same in FreeType and finally touching upon the testing part.</p>

cpythongnu make+4
Student: Priyesh Kumar
Code

Improving Clang-Doc

intermediate
LLVM Compiler Infrastructure•2026$3k–$6.6k175h (Medium)

Clang-Doc is LLVM's modern C/C++ documentation generator built on the compiler AST rather than heuristic text parsing. A key blocker to its adoption is the absence of Markdown support inside documentation comments. Fenced code blocks, pipe tables, and lists currently pass through to output generators as raw text, making generated documentation unreadable for any project that uses Markdown in its comment workflow, which includes LLVM itself. This project implements a standalone Markdown parsing library that takes text and returns typed data structures, with no knowledge of comments or Clang internals. Clang-Doc is the immediate consumer, but the library is usable by any LLVM tool. It follows the same pattern as the Mustache library from GSoC 2024, with no third-party dependencies. Deliverables include the full library, Clang-Doc integration, updated HTML and Markdown generators, end-to-end lit/FileCheck tests, a libFuzzer harness, and an LLVM blog post. Stretch goal: Clang AST support for Doxygen group comments, flagged by mentors as particularly valuable.

cllvmc+++3
Student: NeilN
Code
Proposal

AI-Powered Chatbot for Quick Access to Jenkins Resources

beginner
Jenkins•2025Varies90h (Small)

Many Jenkins beginners often struggle with setup issues, plugin compatibility, and troubleshooting pipeline configurations. This project proposes the development of an AI-powered chatbot integrated into Jenkins inside a plugin. This AI tool is designed to assist users by providing context-aware support based con Jenkins documentation and community resources. The assistant will be delivered as a Jenkins plugin, combining a modern React frontend, a Java backend, and a local lightweight AI model exposed via a FastAPI service. Instead of relying on fine-tuned models, the project exploits Retrieval-Augmented-Generation(RAG) approach, fetching relevant context from a vector index built from Jenkins docs and community forums, Deliverables include: a complete indexing pipeline, a functioning RAG-based LLM assistant, a modern UI, a Jenkins plugin that integrates the AI service, a robust testing coverage and a clear documentation. The final goal is to reduce the learning curve of the Jenkins users, allowing them access to a smart, embedded support tool.

javascriptjavago+2
Student: Giovanni Vaccarino
Code
Proposal

Enhancement of Statistics Module

beginner
SymPy•2019$1.5k–$3.3k90h (Small)

<p>Currently the stats module lacks some useful features as suggested on the ideas page, like Random Walks, Random Matrices, etc. There is also a scope of completing the work of GSoC 2018 by Akash Vaish like, exporting expressions of random variables to external libraries. There are also certain issues with results being produced by various functions and methods, like, sometimes unwanted complex results are produced for simple probability expressions or, unevaluated results are given as output. I would divide my project into the following broad categories:</p> <ol> <li>Implementing additional multivariate distributions.</li> <li>Implementing Markov Chains, Random Walks, Bernoulli Process(extending PR #15058), and Poisson Process.</li> <li>Implementing Random Matrices.</li> <li>Implementing mechanism to export random variables to PyStan, PyMC3, NumPy, etc. </li> <li>Adding support for assumptions of dependence among random variables.</li> <li>Adding support to enhance result generation by statistics module.</li> </ol>

pythonc++numpy+1
Student: Gagandeep Singh-1
Code
Proposal

Evaluating Cloud-Native Storage: Performance Benchmarking for Uyuni on RKE2

advanced
openSUSE Project•2026Varies350h (Large)

I propose to build a reproducible benchmark framework for evaluating cloud-native storage options for Uyuni on RKE2. The problem is that different Kubernetes storage backends can behave very differently for the kinds of operations Uyuni depends on, especially PostgreSQL transactions, repository metadata handling, and package distribution. The project will address this by starting from a storage-only control baseline and then extending the evaluation into PostgreSQL benchmarking and Uyuni-specific workload benchmarking, while collecting synchronized observability data for each run. The same benchmark method will be reused across selected storage backends so that results remain comparable and can support a practical recommendation for which StorageClass Uyuni should support on RKE2. The main deliverables will be a reusable benchmark harness, benchmark results for the tested storage backends, PostgreSQL and Uyuni workload comparison data, observability-backed summaries, and a final report that explains the benchmark method, compares the backends, and recommends the most suitable StorageClass. The project will also produce the configuration artifacts and scripts needed to rerun the benchmark process and reproduce the tested setup.

pythonlinuxjavascript+11
Student: AkashKumar
Code

Matplotlib: Revisiting Text/Font Handling

intermediate
NumFOCUS•2021Varies175h (Medium)

<p>Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations, which has become a de-facto Python plotting library. It allows user text to be rendered on the canvas, includes extensive support for mathematical expressions, raster and vector outputs, arbitrary rotations, and supports Unicode. Much of the inspiration behind its font manager is inspired from W3C compliant algorithms, allowing users to interact with font properties like font-size, font-weight, font-family, etc.</p> <p>However, the current way Matplotlib handles fonts and general text layout is not ideal, which is what this proposal aims to tackle.</p> <p>It is divided into three subgoals, such that by the end of the project completion, TeX exporting mechanisms would use the same structural layout for most backends, and every exported PS/PDF would contain embedded glyphs which are subsetted from the whole font. This would be done with an implementation of a redesigned text-first font interface, essentially enabling a font-fallback mechanism, such that all font-family members will be parsed before rendering a “tofu”.</p>

pythonjavascriptr+3
Student: Aitik Gupta
Code
Proposal

MNE-Python: Time-Frequency Volumetric Source Space Viewer

advanced
Python Software Foundation•2022Varies350h (Large)

Transforming electrophysiology signals from sensors into their frequency representations has been shown to be a way to increase the power for application of this data; for one example of very many see Swann et al., 2015. This Fourier-transformed sensor data can be used to infer data within the brain in a very similar way as the time-series data but with an added, fifth dimension for frequency. MNE-Python has all the components necessary for time-frequency source estimate viewing and would be greatly improved by integrating them to allow for exploration of this complex data. A graphical user interface (GUI) that allows users to look at regions of high power spectral density, while letting the user dynamically adjust the range of frequencies, would be incredibly helpful for allowing this kind of data to be explored and analyzed. The ability to browse slices has already been implemented in `mne.gui.ieeg_locate` and could be abstracted to be used in this case. Time-frequency plotting of spectrograms, with appropriate units and baseline correction already exists in MNE-Python as well. Putting these elements together into a GUI would be a great improvement for the MNE-Python tool and community.

pythonmercurialjavascript+3
Student: Alex Rockhill
Code

CVE Binary Tool : Vex Tooling

intermediate
Python Software Foundation•2025Varies175h (Medium)

Currently, the CVE-BIN-TOOL supports basic VEX triage functionality but lacks user-friendly tools for editing, validating, and managing VEX data. VEX’s JSON-based structure, while machine-readable, it is error-prone for manual human interaction, which often leads to invalid files or incomplete triage information. This project aims to bridge this gap by working on cve-bin-tool’s VEX capabilities through these three key pillars: 1. Interactive HTML Reports: Embedding JavaScript-based editing interfaces to enable offline-compatible VEX triage with real-time validation. 2. CLI Automation: Developing tools for validation, guided generation, and archival of VEX files to minimize manual effort. 3. Standardized Maintenance: Integrating the lib4vex library to unify support for CSAF, OpenVEX, and CycloneDX formats while ensuring schema compliance. By simplifying VEX workflows, the project will allow developers to manage vulnerability context effectively, reduce their errors, and align with evolving security standards.

pythonmercurialjavascript+3
Student: Jigyasu Rajput
Code
Proposal

FLINT-Backed Multivariate Polynomials in SymPy

advanced
SymPy•2025Varies350h (Large)

SymPy currently lacks an efficient backend for dense and sparse multivariate polynomials over ℤ and ℚ, leading to performance bottlenecks in many core functions such as solve, linsolve, simplify, cancel, and polynomial GCD computations. This project aims to address this by integrating FLINT’s highly optimized multivariate polynomial arithmetic into SymPy via python-flint. To achieve this, we will implement: FLINT-backed Sparse Polynomial Support – FlintPolyRing (FLINT-backed equivalent of PolyRing), FlintPolyElement (FLINT-backed equivalent of PolyElement), comprehensive tests and documentation. FLINT-backed Dense Polynomial Support – DMP_Flint (FLINT-backed dense multivariate polynomial class), comprehensive tests and documentation. Performance Analysis and Optimization – Benchmarking against SymPy’s existing implementations, optimizing operations. This is a high-priority task in SymPy's development roadmap, and achieving this can make SymPy reach "state-of-the-art" levels of speed and performance. Since multivariate polynomial operations are involved across various modules in SymPy, this project significantly strengthens the library.

pythonc++numpy+1
Student: Aasim Ali
Code
Proposal

Airavata Research Catalog Local Agent

beginner
Apache Software Foundation•2025Varies90h (Small)

The Airavata Cybershuttle Research Catalog is a web platform that enables researchers to share and run Jupyter Notebooks, GitHub repositories, datasets, and scientific models. It supports project creation by combining resources for collaborative, reproducible research, with direct cloud execution of notebooks and models. To enhance flexibility and performance, a desktop application is being developed: Web Research Catalog - Audience: General users - Pros: No installation required; easy access to shared resources - Cons: Limited by cloud compute resources Local Research Catalog (Desktop App) - Audience: Power users needing high performance - Pros: - Utilizes local machine resources (GPU, RAM) for better performance - Offline access to notebooks, datasets, and models - Integration with local tools and file systems - Seamless synchronization with the web catalog when online - Runs JupyterLab and VSCode sessions locally without needing Docker or external dependencies The local agent is designed to be lightweight, extensible, and user-friendly, with built-in support for running scientific workflows entirely from a desktop environment.

pythonjavascriptjava+7
Student: Ganning Xu
Code
Proposal

Developing Image Sequencer as a library

advanced
Public Lab•2017Varies350h (Large)

<h5>Introduction to Image Sequencer</h5> <p>Image Sequencer is a non-destructive image processing library built with JavaScript which creates a new image at each step in a sequence of steps. Image Sequencer is in early-development phase. The core functionality is being implemented. There are a few modules present. Calculations aren’t GPU accelerated. As a result, there is a lag when images larger than 700KB are handled. Also, Image Sequencer works only for browsers currently as it uses a browser dependency (the JavaScript Image Class). Image Sequencer currently supports only one image at a time.</p> <h5>Aim of my project</h5> <p>The aim of my Project is to expand the module library by implementing powerful processing modules (As listed at the end of this proposal) followed by enabling GPU-backed calculations for browser based clients and hence enhance performance, reliability and speed. And, ultimately, to develop Image Sequencer as an importable library for image manipulation and publish it on NPM. Also, support for Node.js based clients and JSON input/output will be generated.</p>

javascriptruby on railswebrtc+5
Student: Chinmay Pandhare
Code
Proposal

A New Package for Empirical Asset Pricing Research, or EAPR

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

<p>A major effort in empirical asset pricing research is the initial stage of gathering the data, cleaning and filtering it, and then formatting it in a way that simplifies further statistical analysis. This process, when done properly, takes a large portion of a researcher’s time when it would be better spent on doing the actual analysis. By developing a package that automates much of the data import, cleaning, filtering and standardization process, a substantial fraction of the researcher’s time will be saved, while automating a significant portion of the data gathering and management aspect of asset pricing research. We expect this last aspect to support the reproducibility of research by academics and financial professionals. Our over-arching goal is to make the EAPR package an ideal support tool for the wide range of asset pricing research as described in Ball, Engle, and Murray (2016), and for quantitative portfolio construction research. The initial version of the package will work very effectively with asset prices, returns and factors (exposures) data delivered by Wharton Research Data Services, a major source of empirical data for academic asset pricing researchers.</p>

cc++r+4
Student: Gregory S Brownson
Code

Polling-based I/O in FS2

advanced
Typelevel•2025Varies350h (Large)

FS2, a functional streaming library for Scala, currently utilizes blocking I/O operations, resulting in performance bottlenecks such as context switching and resource contention, particularly in high I/O-bound workloads. To overcome this, the project proposes reimplementing I/O APIs specifically Unix sockets, datagram sockets, and processes by leveraging polling-based mechanisms introduced in Cats Effect v3.6.0, which will remove the reliance on dedicated dispatcher threads and eliminate inefficiencies tied to blocking calls. This reimplementation will support JVM selector-based polling and Native file descriptor polling, while keeping existing implementations as fallbacks for runtimes that do not support the new approach therefore ensuring backward compatibility. The project will deliver these reimplemented APIs alongside comprehensive test suites to verify correctness, performance benchmarks to quantify improvements, and updated API documentation to ensure usability. By improving FS2’s efficiency and scalability, this enhancement will strengthen the Typelevel ecosystem and provide high-performance streaming library tailored for modern applications.

linuxnode.jsjvm+2
Student: Purmani Rahul Reddy
Code
Proposal

Capsule Networks for 3D Medical Imaging Segmentation in Julia

advanced
The Julia Language•2026Varies350h (Large)

Julia's medical imaging stack currently relies on 3D U-Net variants for segmentation, which lose spatial relationships through max-pooling. This project implements 3D capsule network architectures in Lux.jl that preserve part-whole spatial hierarchies through dynamic routing-by-agreement. I will build reusable capsule layer primitives (PrimaryCapsule3D, ConvCapsule3D, routing modules), two full architectures (3D SegCaps and a SegCaps-UNet hybrid), and custom GPU-accelerated routing kernels using KernelAbstractions.jl. The full pipeline integrates with MedPipe3D.jl for data loading, training, and evaluation. Deliverables: (1) Capsule layer primitives as Lux.jl modules, (2) 3D SegCaps architecture, (3) SegCaps-UNet hybrid, (4) GPU routing kernels, (5) training pipeline with MedPipe3D.jl, (6) benchmarks across all 10 Medical Segmentation Decathlon tasks (Dice, HD95, cross-task transfer vs 3D U-Net), (7) documentation and pretrained weights, (8) PRs to JuliaHealth.

cjavascriptc+++12
Student: Bhavya-QuantDeveloper
Code

Expanding the receiver to BEIDOU B1C

intermediate
GNSS-SDR•2019Varies175h (Medium)

<p>The current version of GNSS-SDR supports GPS, GALILEO, GLONASS and BeiDou Global Navigation Satellite System signals. Right now in BeiDou signals, GNSS-SDR fully supports BeiDou B1l and BeiDou B3I. The primary goal of this project is to make the software receiver compatible with the BEIDOU B1C signals. This project will enhance the software receiver to aid acquisition and tracking of BEIDOU B1C signals that would further expand the receiver's capabilities and would facilitate research on multi-constellation, multi-frequency receiver working with real signals. The demodulation of the B-CNAV1 navigation message of BEIDOU B1C will open the door to innovation in multi-constellation receivers. Along with the fully functional implementation of a GNSS receiver working with BEIDOU B1C signals, this project will help to address topics such as integrity, reliability, robustness, enhanced coverage, and high-accuracy positioning. Additionally, the integration of BEIDOU B1C observables into the position, velocity, time (PVT) solutions will allow the achievement in a diverse range of applications and components.</p>

c/c++c++11c++14+7
Student: Andrew Kamble
Code
Proposal

Beginner-friendly ML Library for Processing

beginner
Processing Foundation•2022Varies90h (Small)

This project aims to develop a new beginner-friendly Machine Learning Library for Processing by (1) using the diverse model pool supported by Deep Java Library and (2) providing a user-friendly, step-by-step reference & tutorial page. A powerful Machine Learning library can expand the possibility of Processing by enabling the users to create cool AI-powered art, games, and interactive applications. Furthermore, a well-implemented ML library in Processing can be an effective tool to lower the barrier of AI/ML and teach ML to beginners in a friendly way. Though there are some ML libraries such as OpenCV for Processing and Deep Vision for Processing, there is no one universal ready-to-use ML library that is friendly for beginners. Additionally, the speech/audio models and text models are not supported by any of the existing libraries. By using Deep Java Library's extendable high-level API, this library resolves the aforementioned issues by enabling powerful pre-trained models from Deep Java Library's model zoo, including speech/audio and text models.

pythonjavascriptandroid+6
Student: Jeongin Lee
Code
Proposal

Project 5: Implementation of parallel analysis in MDAnalysis

advanced
MDAnalysis•2023Varies350h (Large)

The proposal introduces parallel backend based on `dask` for MDAnalysis package. Potentially, it will allow researchers to run analysis of the molecular dynamics trajectories much faster, depending on their access to HPC facilities, hence increasing the speed of obtaining valuable insights from large-scale molecular simulations. Briefly, the proposal aims to re-write protocol for `MDAnalysis.AnalysisBase.run()` method to use a scheduler-based approach. This is supposed to be done with gradually increasing complexity, covering each steps with respective tests to ensure backward compatibility: - simply re-write the protocol without adding additional complexity such as multiple processes - add multiple cores for a single node At this point, a mid-project checkpoint is set. - introduce cluster support that allows user to run analysis in an HPC environment with a `dask` backend - (optional) add tests for subclasses of the base class, and mark those that don't support such parallelization - (optional) add example jupyter notebook showing that a large-scale molecular dynamics trajectory can be analyzed in a parallel fashion much faster than before

pythoncythonc/c+++1
Student: Egor Marin
Code
Proposal

A Pandas Experience

intermediate
Scala Center•2025Varies175h (Medium)

This project aims to improve the way Scautable handles CSV files by making structured data parsing in Scala more robust, flexible, and user-friendly — especially for data exploration and quick scripting tasks. Key problems being addressed include poor handling of row/column mismatches, limited support for malformed or missing headers and lack of custom delimiter options. Inspired by the usability of Pandas, this proposal introduces enhancements such as configurable error-handling modes (e.g., skip or autofill bad lines), support for automatic or custom headers, smarter handling of duplicate or malformed columns, and flexible delimiter parsing. For large files, methods to access specific columns will be distributed across implicit classes to avoid JVM method count limitations, improving scalability. Additionally, clear error messages and diagnostics will guide users through common issues and edge cases. By addressing these aspects, the project will significantly improve Scautable’s reliability and make it a more powerful tool for developers working with structured data in Scala.

#scala#scala_lang#jvm+7
Student: Lidiia Zaparenko
Code
Proposal

Automate dependency updates with Renovate (2025 Term 2)

Intermediate
•Varies175h (Medium)

Antrea currently relies on Github's Dependabot to automatically updated dependencies (Go modules / Github Actions) on the main branch. There is a key limitation with Dependabot, which is that it doesn't support automatically updating dependencies with security vulnerabilities in "active" release branches (for Antrea minor versions which are currently actively supported). This limitation means that maintainers have to manually backport Dependabot patches when they address security vulnerabilities, which has become a burden. Renovate (https://docs.renovatebot.com/) is an alternative tool for dependency management, and it seems that it offers richer configuration options and may not suffer from the same limitation as Dependabot. Expected Outcome: Migrate the Dependabot config to a Renovate config for the main Antrea repository (antrea-io/antrea), as well as for all other repositories (under the antrea-io organization) which currently use Dependabot. Dependencies that are currently updated as a group (e.g., golang.org/x modules) should remain that way. The Renovate config should include provisions to automatically perform security updates in active release branches. The change should not impact developer workflows and the Antrea release cycle; all experiments should be performed in a fork.

TBA
Proposal

New Documentation Site Engine

advanced
Keptn•2022$6k–$13.2k350h (Large)

My project will be Making a New Documentation Site Engine for Keptn which can handle a large number of documentations projects of Keptn. Currently, the Keptn documentation site is based on Hugo based theme called hugo-serif-theme. For tutorials, Codelabs is also used. While extremely handy for smaller projects and initial versions of Keptn, this toolchain has serious deficiencies for larger-scale projects like Keptn. I am going to propose a New Documentation Site Engine that will be based on Docusaurus. Docusaurus is an optimized site generator in React. Docusaurus helps you to move fast and write content. Build documentation websites, blogs, marketing pages, and more. The main focus of Keptn New Documentation Site Engine will be managing large-scale documentation and complex documentation projects. So two major things which are needed in the documentation engine are Multiple repository docs support and Versioning of Docs support. Find my detailed GSoC 2022 Project Proposal at https://github.com/iamrajiv/GSoC-2022/blob/main/GSoC_2022_Project_Proposal.md.

golangkubernetesangular+1
Student: Rajiv Ranjan Singh
Code
Proposal

Making research more accessible with Origami

intermediate
CloudCV•2017Varies175h (Medium)

<p>Origami aims to provide Artificial Intelligence as a Service. Presently, deep learning is a very interesting field. However, the issue arises when someone has to setup someone else's code on their machine. Origami aims at solving that problem by allowing researchers to quickly create a demo of their implementation for the world to see. This serves a twofold purpose. It lets other users see if a particular implementation solves their purpose while also serving as a 'portfolio' for the researchers.</p> <p>By the end of the summer, users will be able to search for various demos published by various researchers and thus be able to find an implementation that suits their needs the best. Additionally, Origami will also support REST APIs. This will allow Origami to be used to provide some infrastructure for chat bots which can then be integrated with Slack, Facebook, etc. Origami will also be integrated with EvalAI to allow users to compare their implementation with that of their competitors. Finally, Origami will support other features such as allowing users to upload to/from Dropbox, releasing anonymous demos, a better CMS and predefined templates to create apps to name a few.</p>

pythonjavascriptlua+14
Student: Avais Pagarkar
Code
Proposal

From UDB to Implementations

Intermediate
•Varies175h (Medium)

The RISC-V movement has massive potential to unify a fragmented industry behind a single instruction set architecture (ISA). If technology providers focus their efforts on a single processor architecture, rather than duplicating efforts among incompatible architectures, the entire computing ecosystem benefits. Inefficiency in critical base components of the ecosystem hampers this consolidation. There are numerous projects which directly serve as the base components of the software ecosystem, including assemblers, disassemblers, compilers, linkers, loaders, simulators, emulators. In most of those projects today, the human-readable documentation is consulted, and the necessary implementations are performed manually. Needless to say, these processes are time-consuming, inefficient, and error-prone. A new foundation which can serve as a base for automatically generating large swaths of the processor-dependent ecosystem is available, but is not yet effectively use. The “RISC-V Unified Database” project has transformed the salient content from within the RISC-V specifications into an accessible format, YAML, from which content for downstream projects can easily and automatically be further transformed into the content necessary to their project which is currently produced by manual effort.

TBA
Proposal

Improvements to GHC's handling of conditionals.

intermediate
Haskell.org•2018Varies175h (Medium)

<h3>Improvements to GHC's Code Generator</h3> <h4>Improved code layout</h4> <p>In the current approach there is no way to incorporate additional control flow information</p> <p>We improve on that by constructing a CFG, assigning weights to its edges via static analysis and finally using these weights for code layout.</p> <p>A more detailed description is available on the wiki page of the GHC project. At the time of writing the write up is <a href="https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/CodeLayout" target="_blank">here</a>.</p> <p>Initially not viewed as a major task evaluating this change took up most of this Project.</p> <h4>Support for conditional move instructions</h4> <p>This has been partially implemented but requires further work before it can be used.</p> <h4>Add support for lookup tables</h4> <p>Dropped in favour of code layout work.</p> <h4>Invert FP comparisons such that the parity check can be eliminated</h4> <p>By selectively inverting comparisons we avoid an explicit parity check.</p>

haskellghccabal+3
Student: Andreas Klebinger
Code
Proposal
Showing 2593 - 2616 of 4718 Projects
107108109110111
Proposal
Proposal
Proposal
Proposal
Proposal