Explore Projects

<p>As a part of my project, I'll take ownership of object rest spread, transform decorators, optional chaining, private fields, and async-await specifications and keep them updated, spec-compliant, tested and bug-free.</p> <p>I am a JavaScript developer and I'm really excited about what Babel does. Babel allows everyone to have access to future language features which make life easier, code cleaner, and give devs one less thing to worry about upgrading in next few months. As a side-note, I love things that compile to JavaScript, and I'm really excited about what I'll learn (AST manipulation, details of the JavaScript AST, lexing &amp; parsing) as a part of my work on Babel.</p>

<p>GCC has support for built-in functions in C99/C11 standards along with features of IEEE standards. These functions do appropriate calculations according to the requirements of the users taking various types of arguments and returning values as required on supported data types of GCC like int, float. Such inbuilt functions help users, developers and GCC developers to minimize the repetitive calculations and efforts. There are optimization steps carried out to have faster compilation and running time of programs, folding and inlining being one of them. The purpose of this project is to implement more such functions in GCC which are added in ISO/IEC TS 18661 (supporting features of IEEE 754), folding them and expanding them inline wherever appropriate.</p>

FreeCAD currently has several ways of measuring objects, causing confusion for users and making the learning curve steeper. The proposed project aims to implement a generic measurement command that can be extended by workbenches, refactor and port existing commands to use the new system, and polish existing measuring commands for a consistent user experience. Optional deliverables include adding additional measurement modes and settings and communicating with developers of external workbenches to port them to the new system. Benefits: A single method of measuring objects would smooth the workflow and reduce learning time. The user will always be able to invoke one global measure command regardless of the active workbench.

The Multiple Flightpath Docking Widget in MSS is crucial for visualizing atmospheric data but lacks customization options hindering effective comparison of flight paths. This project aims to enhance the widget's functionality by introducing centralized line controls, adjustable transparency, Matplotlib linestyle options, automatic color assignment, regex filtering, select all/deselect all buttons, integrated legend, operation labeling, and saving user preferences using QSettings. (Deliverables): Enhanced UI with centralized controls. Improved backend filtering with regex. Comprehensive legend design with synchronization. Annotation feature for operation labeling. QSettings implementation for saving/loading preferences. Test cases, documentation, and future work suggestions.

PAM (Pharo Automated Mouth) is Pharo's first ever text-to-speech (TTS) system. It will convert English text into phonemes, add basic prosody, and generate speech using a DSP built with Phausto. The project is divided into two main parts: A Reciter that processes text into phonemes and stress markers, and A DSP that generates real-time audio output with multiple voice presets (Male, Female, Child). A simple UI will be developed with pitch, speed, and stress customization. Deliverables include a working TTS engine, voice presets, a customizable UI, and documentation to improve accessibility and support future extensions. The project aims to increase Pharo's accessibility to the community !

The idea here is to provide both runtime support (preferably using the SymEngine library to provide the computation, as it is fast and robust) and compile time support (in ASR) to implement Symbolic Algorithms in LPython. The runtime operation could use the SymEngine library for LLVM, C and C++ backends. For Python backend, we can simply use SymPy itself. The algorithms would be implemented in the ASR code, which would make them independent of any specific frontend. Any frontend that uses the ASR code could then make use of the symbolic algorithms without having to reimplement them. LPython, in this case, would not implement the symbolic algorithms themselves, but would instead parse the syntax used by the SymPy library, which already has a rich set of symbolic algorithms, and use the ASR representation of these expressions to perform various operations. This would allow LPython to have powerful symbolic manipulation capabilities without having to reinvent the wheel.

<p>ASCEND provides support for Conditional modeling, where a model can contain both variant and invariant equations. Invariant equations must be respected by the model at all times while the variant equations only are included in the model if certain conditions are met. For example, a model for fluid flow will have different sets of equations depending on the phase of the flow (laminar, turbulent or sonic flow). Unfortunately, the current syntax for conditional modeling has been considered unintuitive by some of its users and there is demand for a better alternative.</p> <p>In this project, my goal is to precisely identify why the current syntax is considered unintuitive and use this information to design and implement a better alternative. The identification would be based on a review of code examples using the current conditional model syntax and the implementations would be made by modifying the existing Bison-based compiler.</p>

FreeCAD currently lacks a dedicated parametric 3D sketching , forcing engineers to use multiple 2D sketches. like some examples are bicycles,roll cage etc. This project solves this by building a new Sketcher3D Workbench. The solution natively extends the existing planegcs constraint solver to 3D , adding new 3D primitives (Point, Line, Arc, Circle) and 3D spatial constraints (Distance3D, Parallel3D, Angle3D, PointOnPlane etc). Designed specifically to avoid tool duplication, the architecture builds upon the existing 2D data model for a future merger into a unified FreeCAD Sketcher. Deliverables include the extended 3D solver, a functional ViewProvider with a switchable drawing workplane, interactive 3D constraint UI, and native wireframe output consumable by downstream FreeCAD operations.

The Debezium Management Platform currently deploys pipelines only to Kubernetes. This project adds host-based deployment support, enabling users to deploy Debezium Server pipelines to bare-metal servers and cloud VMs via SSH and Docker. The implementation integrates into the platform's existing event-driven architecture by adding a new EnvironmentController for host targets, an SSH-based provisioning service that validates and prepares remote hosts, a lightweight agent deployed on each host for managing the Debezium Server lifecycle via REST APIs, and a status polling mechanism for monitoring deployments. Key deliverables include the host registration API, automated provisioning with remediation, the Debezium Host Agent, Docker-based deployment engine, config drift detection, and comprehensive integration tests using Testcontainers.

<p>The performance issue, or bundle time speed-up, is a common challenge for modern JavaScript/web bundler. As one of the most powerful module bundlers in recent year, Webpack team endeavors to enhance the bundling performance. In the latest version of Webpack 4, several improvements like new plugin system and parallelization with cache with UglifyJs have been implemented and accomplish a considerable performance enhancement. In this project, some cores and dependencies of Webpack are re-implemented in Rust, a low-level language, and WebAssembly binary is generated from them with the corresponding compilers. Some automation tools are used to help to convert existing JavaScript sources as well as future works to other languages. At the same time, backward compatibility of earlier Node.js versions will be maintained. It can be considered to be a significant performance enhancement with this project in the future Webpack release.</p>

Boa is an embeddable JavaScript engine written in Rust. JavaScript is garbage collected by specification, meaning the runtime is responsible for managing memory and reclaiming values once they become unreachable. Boa's current collector (boa_gc) works and is well tested, but it was designed for correctness first, and now carries design debt that holds back performance and maintainability. Experimental redesign work is already underway in the separate Oscars repository. This project focuses on evaluating that work, auditing the current design, improving the GC where needed (tracing strategy, allocation model, rooting) and integrating a production ready collector into Boa's runtime, backed by stress tests, benchmarks and documentation covering the design decisions and tradeoffs. Extensions may include incremental or generational collection, GC aware VM optimizations and heap visualization tooling.

<p>This project aims at updating lua bindings to libgit2 for the lua users to use libgit2 ( pure C implementation of the Git core methods ) API from lua. The new luagit2 covers most of important libgit2 modules. It is developed completely using lua-C api. This provided us with a lot of flexibiltiy to create functions that are very close to lua style in their final implementation. This includes returning multiple values from C to lua, type checking of lua - userdata objects used and error checks if anything goes wrong.</p> <p>The tests for such a case of software development where binding is written completely using c and final usage is in lua was very exciting to write. Luagit2 has been tested using busted as testing library and some examples has also been provided for very general case usages.</p>

The EOS User Story project aims to provide a user-friendly and interactive website where users can log in and request features, report bugs, and so on. Users can keep track of their issues' progress, vote on them, and post comments on them. The project administrators can then examine, resolve, close, or assign a status to the issues. It serves as an effective feedback system for businesses, which is necessary for the development of a variety of products. The purpose of this project is to enhance the user experience in a variety of ways. These are some of my thoughts: • UX/UI improvements in desktop and mobile devices • Making the application a Progressive Web App (PWA) • Polish existing features and increase test coverage • Improving session management for user authentication • OAuth 2.0 and SAML Integration • Report feature for stories • Email notifications • Resolve all existing issues on GitHub and User Story

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

<p>The main goal of this project is to make the APIs more reliable, faster, operational and easy to maintain.</p> <p>Firstly, I will work on determining the aspects that need to be improved or refactored in the current codebase, and then introducing more domain-features like Generating SVG code-snippets, base64 encoded image, tags recommendation and adding the possibility of searching with different languages.</p> <p>Eos-icons is a search-heavy project, which necessitates having a great search process starting from the search-input in the frontend and ending in getting your desired icons in seconds! for this to be achieved, a search-engine layer will be added to manage the process of searching/filtering, also the icons will be added to a MongoDB instance, with a caching layer in front of it, to have a much faster responses.</p> <p>Lastly, I will be working on adding unit tests, to make sure that the APIs work as expected, alongside with creating a Docker Image, to have a solid deployment solution.</p>

<p>MDAnalysis provides a python framework to allow users to analyse Molecular Dynamics (MD) simulations. Umbrella Sampling (US) is an MD technique which involves performing a series of simulations in which a ‘reaction coordinate’ – such as distance between two molecules – is restrained to different values. Simulation data can be combined, usually using the WHAM method, to produce a ‘potential of mean force’ (PMF) profile that shows the energy landscape along the chosen coordinate. Several implementations of WHAM exist, but require input files of specific formats which may differ from that obtained directly from the simulation, dependent on the simulation engine used. Additionally, it would be convenient be able to calculate the PMF alongside analysis of the trajectory such as offered by MDAnalyisis. However, MDAnalysis does not yet have tools specifically for dealing with and analysing US simulations. This project aims to introduce capabilities for loading US simulation sets, including a generalised tool for loading auxiliary data files, and performing WHAM and other basic analysis.</p>

<p>DIPY is a python toolbox for analysis of diffusion magnetic resonance imaging. Its website <a href="http://nipy.org/dipy/" target="_blank">http://nipy.org/dipy/</a> acts as the source of information and hosts all kinds of resources like documentation, examples and guides for getting started and using Dipy for research in diffusion magnetic resonance imaging. However, the current website is based on Sphinx and allows for only one documentation to be online (the development version). Also it lacks many essential features that are required to manage and update the website conveniently. The goal of this proposal is to reconstruct the website from scratch with latest web technologies adding essential features like content management system for creating and managing articles, tutorials, news, etc., admin functionality for maintenance, continuous generation and integration of documentation, social network integration, github integration for visualisation of development metrics, responsive frontend with modern UI elements and search engine optimization.</p>

Gigaflow is an innovative solution to accelerate network processing in large-scale data centers by leveraging flow locality and pipeline-aware caching, offloading processing to SmartNICs. Currently, it supports only Alveo U250 FPGAs, limiting its versatility. This proposal aims to extend Gigaflow’s backend support by developing new APIs for flow integration, enabling compatibility with Pensando DPUs. Additionally, the current implementation of Sub-Treversal Partitioning (STP) incurs high CPU overhead during startup, minimizing the system's performance benefits. This project will optimize STP to reduce CPU usage and improve startup efficiency. Finally, Gigaflow’s newness requires further optimization in the compilation, LTM, and driver pipeline, alongside additional testing for alternative strategies for priority selection and rule deletion. The proposal will address these challenges. By achieving these goals, the project will streamline Gigaflow caches in the OVS backend, facilitating more efficient and flexible solutions for modern data centers.

The recent release of serialport 4.9.0 has provided an opportunity to thoughtfully plan the next major release, catching up on features that have been postponed for years which includes trait-object architecture, internal panics that manifest unexpectedly and an outdated MSRV 1.59(which was being leveled up to 1.75 recently) causing actual dependency resolution problems. This project lays the foundation for the next big release. I will start with a downstream usage audit of public dependents to guarantee that the refactoring decisions have minimal migration difficulties. This will be followed by the implementation of struct unification where backends using Box<dyn SerialPort> will be replaced with concrete structs while maintaining compile time compatibility for typical usage scenarios. Capabilities such as exclusive locking and RS485 settings will be provided using extension traits for platform specific operations. Panicking conversions such as FromRawFd will be replaced with fallible TryFrom variants. The MSRV will be bumped along with CI extension of cargo-minimal-versions.

This project aims to make Tölvera more accessible to artists and researchers by adding a Natural Language Interface (NLI). Currently, Tölvera's reliance on Python coding presents a barrier for those without programming expertise. This project will refine and substantially extend tv.llm, a functional proof-of-concept NLI module, enabling users to generate and modify Tölvera sketches using natural language commands. The core work of this project involves expanding the NLI's architecture, which utilizes Pydantic for configuration validation and Jinja2 for reliable code generation, to encompass a broader range of Tölvera modules (tv.vera, tv.osc, tv.cv, tv.mp, tv.iml), refining prompt engineering strategies, and improving the command-line interface. Deliverables will include the full release of the tv.llm module integrated as a core Tölvera feature, detailed documentation, and an evaluation report. The goal is to help empower a broader community of users to integrate Tölvera into their creative workflows.

<p>RISC-V is an open ISA freely available for all types of use. The RISC-V ISA has been designed with small, fast, and low-power real-world implementations in mind, but without "over-architecting" for a particular microarchitecture style.</p> <p>The RISC-V being a base ISA is carefully restricted to a minimal set of instructions sufficient to provide a reasonable target for compilers, assemblers, linkers, and operating systems (with additional supervisor level operations), and so provides a convenient ISA and software toolchain skeleton around which more customized processor ISAs can be built. This project thus aims to leverage and demonstrate the advantages of myHDL and python in general in the field of CPU design by implementing a RISC-V CPU (in myHDL) and other CPU design utilities. Since RISC-V is a base ISA, having a myHDL based implementation becomes a essential and would enable a lot of Computer Architecture researchers to design and test RISC-V based derivatives using myHDL and python based utilities.</p>

<p>Users can design a custom iconic font on the <code>eos-icons</code> landing page by choosing from a wide variety of EOS icons. These can be used in any open source project by following the guides in the documentation page. Currently people can suggest and request new icons and features by opening an issue on Gitlab. The problem here is that most people do not want to sign in to Gitlab to send an issue and want something faster within the same interface of EOS. The aim of this project is to design a scalable backend infrastructure that delivers a web interface allowing users to request new icons in an easy and intuitive way. Users can attach files with the request to explain what they want. The admins or EOS maintainers can then resolve, close and revise these requests. Even users can comment and vote for the existing requests. This can also serve as an efficient feedback and response mechanism which is critical for any organization to improve and make progress. Thus, it potentially becomes another reusable open source project for EOS.</p>

This project proposes the development of faust2clap, a tool that integrates the Faust programming language with the CLAP (CLever Audio Plugin) standard. Faust is a high-level functional language for real-time DSP, while CLAP is a modern open-source plugin format gaining traction as an alternative to VST and AudioUnit. Currently, Faust does not officially support CLAP as a target architecture. The goal is to extend the existing faust2xx framework by implementing a CLAP architecture file and a new command-line utility, faust2clap. This will allow developers to compile Faust DSP code into fully functional CLAP plugins, supporting advanced features such as per-note modulation and sample-accurate automation. Deliverables include the tool itself, a reusable architecture backend, a suite of test plugins, and comprehensive documentation. The project has been developed in close collaboration with the Faust team and aims to be merged upstream as an official component of the Faust toolchain. By bridging Faust and CLAP, this project supports open plugin standards, expands deployment options for DSP developers, and modernises the Faust ecosystem.