Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
This project aims to implement a daemon that serves as a build system manager for modules, providing support for explicitly built modules irrespective of the build system. By simply incorporating a single command line flag, each Clang invocation registers its translation unit with the daemon, which then scans the unit's dependencies. As translation units are registered and analyzed, the daemon constructs a dependency graph for the entire project. Concurrently, it utilizes the emerging graph to schedule and build each module's AST. This approach allows for a single, comprehensive entity to effectively coordinate and manage the build of modules throughout the entire build process.
<p>Enzyme performs automatic differentiation (in the calculus sense) of LLVM programs. This enables users to use Enzyme to perform various algorithms such as back-propagation in ML or scientific simulation on existing code for any language that lowers to LLVM. Enzyme does so by applying the chain rule to every instruction in every function called by the original function to be differentiated. While functional, this is not necessarily optimal for high-level matrix operations which may have algebraic properties for faster derivative computation. Many programs use BLAS libraries to efficiently compute matrix and tensor operations. This project would enable high-performance automatic differentiation of BLAS and similar libraries (such as Eigen) by specifying custom derivative rules for their operations.</p> <p>At the end of this Google Summer of Code project, Enzyme should be able to automatically calculate the optimal derivatives of several common linear algebra functions, thereby implicitly allowing easier integration of Enzyme in several mathematical computing libraries.</p>
<p>The performance of the code generated for the GPU heavily depends on runtime parameters such as the number of thread blocks and threads per thread block. For this reason, a proper choice of such parameters based on both the IR information and runtime information can give a tangible improvement of the performance of the generated code. In this project, we will explore the ML-based approach to this problem which uses machine learning models for making a decision on the runtime parameter values given the IR and runtime features.</p>
<p>The aim of this project is to complete all remaining typescript and webpack tasks in order to ensure a smooth development workflow. In particular:</p> <ul> <li>Remove all custom typings for typescript</li> <li>Remove "any" types for third-party libraries</li> <li>Remove all "any" types from the codebase</li> <li>Replace third_party and remaining imports with webpack</li> <li>Reduce the overall time for webpack compilation.</li> <li>Add documentation on all typescript and webpack errors and solutions on how to fix them.</li> </ul>
<p>Oppia uses Angular as the frontend framework with typescript as the primary language, hence this codebase is fully typed which implies that variable assignment, procedure arguments and function return values will all be associated explicitly with a type. <code>strict</code> is a typescript compiler option which turns on a set of stricter type rules which, when enabled, helps reduce the chances of getting unpredictable results and makes the code more robust but currently, Oppia’s code base does not pass these strict rules. This makes the code prone to unexpected actions and errors.</p> <p>To avoid this, the following actions need to be taken:</p> <ul> <li>All the new files to be added should have typescript strict mode enabled</li> <li>Strict typing should be introduced to the files already present in the code base</li> </ul> <p>This project aims to change the config files to ensure that any new file added to the Oppia’s code base will, by default, have typescript <strong>strict mode</strong> enabled. Also, strict typing will be introduced to 240 files (120 files and their test file) already present in the code base and listed down in <code>UpgradedServices.ts</code>.</p>
In order to streamline releases, we are planning to ensure that all critical user journeys (CUJs) on the Oppia web application are covered by acceptance tests. This is important because it will provide assurance that, on the merge of every PR, these critical user journeys still function correctly, which means that no major breakages will result if the develop branch gets deployed to production. Additionally, having a complete set of acceptance tests that are organized by CUJ makes it easier to audit whether or not a particular CUJ has been included, and it also helps developers add tests for new CUJs while still keeping the tests well-organized. This project includes: Writing acceptance tests for the as-yet-uncovered CUJs in a way that keeps the tests organized and maintainable. This might also include small updates to the acceptance test framework, e.g. extracting utility functions to enable code reuse or providing relevant functionality for a group of tests. Tightening all page utility functions to have pre/post checks (in the form of "wait" statements) and proper error messaging, so that it is easier to debug flakes. The pre-check wait ensures that the conditions are good for performing the action, and the post-check wait ensures that the action has fully completed. Deleting e2e tests whose functionality has been fully replaced by the acceptance tests.
<p>This project aims to introduce a system to introduce a suggestion-review system which would allow the community to contribute to the content on Oppia. It also aims to add a review system to allow easy management of the proposed suggestions and accept or reject them as appropriate. In order to maintain quality of reviews, we allow reviews from users who have made above a certain number of contributions in similar kind of suggestions. For each exploration the creator of the exploration can appoint some trusted reviewers who will be able to accept (merge) content related suggestions for that exploration. At a site-wide level, translation reviewers can be selected for each language and they can accept translations for that particular language.</p>
<p>As seen on Bazel’s <a href="https://github.com/bazelbuild/bazel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+NullPointerException+" target="_blank">Issue Page</a>, Bazel suffers from numerous <code>NullPointerException</code>( NPE ). These NPEs come out at runtime as <code>RuntimeException</code> causing a crash at runtime this leads to a large number of Issues being generated. This could be a result of not handling possible <code>null</code> values not being handled in many cases or outright poor design choices(as seen in many issues due to not handling <code>null</code> OR empty string as arguments while using certain flags).</p> <p><strong>Checker Framework's Nullness Checker</strong> runs as a compiler plug-in, and it issues a warning at every possible null pointer dereference. If it issues no warnings, the code is guaranteed not to throw a <code>NullPointerException</code> at run time.</p> <p>My project will ensure the significant reduction of these NullPointerException(s) before they happen (by checking them at compile time) rather than relying on users to report them and fixing them.</p>
This project aims to enhance the Checker Framework by introducing a Mutable Index Checker, which provides compile-time guarantees of index safety for dynamically sized data structures such as ArrayList, LinkedList, and Deque. Unlike the current Index Checker, which focuses on fixed-length structures like arrays and strings, this checker will track collection size changes across mutations, enabling flow-sensitive reasoning and validation of index accesses. The checker will support annotations like @IndexFor, @LengthOf, @SameLen, and custom subtyping rules to enforce both lower and upper bounds on index values. It will also provide support for aliasing-aware length consistency, post-mutation invalidation, and integration with purity annotations. Deliverables include: - A new pluggable type checker integrated into the Checker Framework. - Support for standard mutable collections with annotated APIs. - Type qualifiers and subtyping rules for index tracking. - Flow-sensitive analysis and invalidation logic on mutations. - Real-world examples, documentation, and a case study on annotating existing codebases. This tool will help developers prevent IndexOutOfBoundsException in mutable structures by enforcing correctness at compile-time—making Java applications safer and more robust.
Blendyn is one of MBdyn post-processing tools based on the Blender platform. It visualizes MBdyn output as a 3D system. However, the current Blendyn version is outdated since its last update is in 2017. In this project, we aim to flexible plotting engines and plotting features, and create a Live animation feature that visualizes MBdyn output in the real-time animation process. In addition to that, we also intend to make stress and strain visible for deformable objects.
<p>KIOSlaves are a powerful feature within the KIO framework, allowing KIO-aware applications such as Dolphin to interact with services out of the local filesystem over URLs such as fish:// and gdrive:/. However, KIO-unaware applications are unable to interact seamlessly with KIO Slaves. For example, editing a file in gdrive:/ in LibreOffice will not save changes to your Google Drive. One potential solution is to make use of FUSE, which is an interface provided by the Linux kernel, which allows userspace processes to provide a filesystem which can be mounted and accessed by regular applications. KIOFuse is a project by Fabian Vogt that allows the possibility to mount KIO filesystems in the local system; therefore exposing them to POSIX-compliant applications such as Firefox and LibreOffice. This project intends to polish KIOFuse such that it is ready to be a KDE project.</p>
Throughout this project, I hope to gain a firmer understanding of TCL scripting and the backend working of parameterized devices and hopefully make some new ones too these devices are used many times while using magic to makes our work easier. this project will help me in a deeper understanding of how each command in the command line works in magic and how we can make some changes in its scripts to make it to improve user inference. In terms of the project, the goal is to work in scripts to draw devices like LDNMOS, LDPMOS, bipolar transistors, photodiodes, Avalanche Diode, etc as well as fixing a few devices that are known to draw incorrectly for some parameter values.as far as working on this project is concerned as per my own rough timeline following is the methodology i would use while working on the project : The magic VLSI tool uses TCL scripts for the parameterized design layouts so we should start by going through some of the scripts to get a better understanding of what we are working with then we will be going through each of the mentioned devices and study its CMOS design and draw it on the magic tool using the magic command line TCL scripts, we will also be looking at the pre-existing devices to check if we were getting the required drawings of them or not if the drawings are not as required then we will be making changes to those scripts as well, in the meantime, we will be looking for improvements we could make on the user inference of magic tool too. to get a better understanding of how I would work on this project please go through the proposal I have attached below. thankyou soo much for your time, looking forward to working with you soon.
I will be developing a native Swift Memcached client using SwiftNIO to address the need for an efficient and user-friendly caching solution in Swift based applications. The goal is to provide a high performance client that integrates seamlessly with existing Swift ecosystems, simplifying the process of sending commands and receiving responses from memcached servers. Our focus is on implementing the Memcached meta protocol, request encoding, response decoding, and request pipelining, while the non-goals is to cover every memcached feature or command. This project aims to benefit developers by offering an asynchronous-first Swift API for essential memcached operations, ultimately enhancing the caching capabilities of their applications.
This project aims to shrink BlackParrot multicore to have a minimal variant called TinyParrot multicore. The main goal of this project is to get very low resource ASIC tapeouts. The deliverables of this project are: **Provide Minimal ISA support: This will be done by parameterizing the FPU logic (all the FP pipes, register file, and bypass paths). **Shrink the size of caches: The cache size will be reduced to 1kb of data. **Logic saving optimizations: The optimizations are planned to be done through Yosys. Yosys supports optimization passes and runs them while synthesis.
Considering the performance, instead of reparsing the entire file every time, we could speed up the parsing procedure with the information provided by old AST, which is an ability provided by the old parser. In the old implementation, this feature was only applied to CodeBlockList and MemberDeclList. In the new implementation, It would be nice to apply node reusing to other syntax collections e.g. exprList, functionParameterList, etc. Also, It would be good to allow more fine-grained reusable nodes via expanding the definition of nodeAtCursorCanBeReused to allow reusing nodes such as FunctionDeclSyntax where only identifier is changed.
<p>Block-Based Circuit Design is a solution to counter the complexity of Circuit Design. We aim to develop and deploy a Block-Based TL-Verilog solution for developers and new entrants to the sphere. Powered by Blockly from Google, it will deliver a simple, concise, and intuitive gateway to Circuit Design.</p>
<p>Property Wrappers are responsible for wrapping common getting and setting boilerplate and also for storing any auxiliary helpers. Often, these helpers are the same across different instances of the wrapper. Thus, having to store it in each individual wrapper instance is a waste that should be avoided. We can solve this by introducing a static storage that is shared across instances, within the scope of where they are declared. Thus, providing a tool for property wrapper authors to optimize their wrapper abstractions.</p> <pre><code>@propertyWrapper(shared: Storage) struct Clamped { private var value: Value struct Storage { let range: ClosedRange<Value> init(_ range: ClosedRange<Value>) { // ... } } // wrappedValue would be accessed through a subscript subscript(shared storage: Storage) -> Value { get { value } set { value = storage.range.clamping(newValue) } } } </code></pre>
<p>This project aims to design and integrate the integer “Multiplication and Division Unit (MDU)” with SERV core as a co-processor. The MDU will support all of the instructions that are provided in <code>The RISC-V Instruction Set Manual. Volume I: Unprivileged ISA</code> chapter 7, M-Standard Extension for Integer Multiplication and Division, Version 2.0”. This MDU is to be designed in a way that it would use most of the DSP resources on the targeted FPGA board and it would be generic and parameterize so that it can easily be integrated with any of the RISC-V core.</p>
The semiconductor industry, driven by Moore's Law, continuously pushes the boundaries of integrated circuit (IC) technology, leading to ever-shrinking transistor feature sizes. Recent research by the U.S. Department of Energy (U.S. DOE) shows promising endeavors of reducing feature sizes to record sizes as small as 1 nanometer. However, the growing complexity of ICs raises the likelihood of manufacturing defects, consequently, sustaining reliability within this zero-failure tolerance domain poses an increasingly daunting task. In this landscape, Design-for-Testability (DFT) features play a paramount role in guaranteeing the quality and reliability of integrated circuits (ICs) amidst evolving complexities. This proposal aims to enhance the Fault DFT toolchain through the Google Summer of Code (GSoC) program. “Fault” is a premier open-source DFT toolchain that provides a comprehensive solution including automatic test pattern generation (ATPG), scan insertion, and scan chain testing. The project focuses on improving Automatic Test Pattern Generation (ATPG) fault coverage within the Fault framework by integrating algorithmic ATPG methodologies and implementing techniques for enhancing controllability and observability in digital designs. By addressing these challenges, the project seeks to advance open-source EDA tools and meet the evolving demands of the semiconductor industry.
Concerto, the core modeling language of the ACCORD PROJECT, is critical for smart legal contracts and domain modeling. This project aims to migrate from the current testing framework mocha to vitest which will enhance the performance, execution time and debugging capabilities. This process can be automated by the combination of vitest-codemod, regex transformations, ai assistance and some manual scripts required for handling complex test cases which cannot be automated. Here are the deliverables: 1. Migration from Mocha, Chai, Sinon to Vitest for all Concerto implementation. 2. A new Concerto conformance package which will be a standalone validation test package for all Concerto implementations.
Deploying AWS Lambda functions using AWS SAM (Serverless Application Model) requires manual creation of a deployment descriptor, posing challenges for Swift developers due to learning a new DSL and adopting new tools like SAM CLI and Docker. To simplify this process, the community proposed a Swift-based DSL and a Swift package plugin. However, these solutions rely heavily on accurately mimicking the evolving SAM AWS deployment descriptor. To address this, this project proposes to automatically generate the AWSLambdaDeploymentDescriptor library based on the SAM template definition. That generated code is used by the Swift-based DSL to create SAM YAML templates required to deploy Lambda functions and their dependencies to AWS.
The goal of this project is to enhance the usability of Decorator Command Set (DCS) data by developing a utility/method to convert verbose, complex JSON formats into a more human readable YAML representation and back again. Currently, it is highly verbose to read, write, and edit DCS JSON files. The plan is to implement a converter that turns DCS JSON objects into a simple YAML format and back again. The new YAML will be less verbose and more readable, helping people work with DCS better. By the end, a fully integrated converter will be delivered, complete with tests and proper documentation.
<p>The project aims at developing a feature wherein the template developers can sign the templates (to authenticate the source) they developed. The contracts derived from the templates can be then signed by the parties involved in the agreement (to authenticate the signatories).</p>
circt-bmc can already prove when an assertion is falsifiable, but it does not yet produce the counterexample trace format hardware developers rely on for debugging. Today, users get a SAT/UNSAT result without a practical cycle-by-cycle waveform showing how the design reached failure. This project adds that missing debugging path. I will preserve meaningful signal identities before lowering, track the corresponding solver expressions across BMC timesteps, and evaluate those expressions against the first satisfying Z3 model. The implementation is intentionally staged: first a readable text counterexample for the failing prefix, then VCD waveform generation from the same trace data. The focus is the first-failure prefix (cycle 0 to the violating step), which delivers high user value with low integration risk and clean upstreamability. Deliverables: 1. Signal tracking and naming pipeline for user-relevant values (ports, externalized registers, selected internals where remapping is reliable). 2. A BMC trace runtime component that records per-step solver ASTs and supports model-driven trace emission. 3. Midterm milestone: first-failure text counterexample dump. 4. Final milestone: VCD waveform output for the same counterexample path, exposed through circt-bmc CLI flags. 5. Upstream-quality tests and documentation (IR-level + end-to-end regressions, including failing and no-violation cases).