[RFC]: Implement ndarray APIs to achieve compliance with the Array API specification

[LoayAhmed304]

Full name

Loay Ahmed

University status

Yes

University name

Cairo University

University program

Engineering, Computer Engineering

Expected graduation

2027

Short biography

I am a Computer Engineering student at Cairo University with a strong focus on networks engineering, systems programming, and backend engineering. I started programming at an early age and have since explored multiple domains including web development & networking, machine learning, and DevOps, with an emphasis on understanding how systems work internally.

I have completed structured coursework in JavaScript, Node.js, and backend development, and further expanded into networking, system design, and machine learning (including Andrew Ng’s specialization). I have also gained industry experience through internships as a FastAPI and .NET backend engineer, and most recently as a C/C++ and Tcl intern at Siemens DISW.

Technically, I am comfortable with C/C++, JavaScript/TypeScript, and backend systems, along with experience in CI/CD, Docker, and deployment workflows. My primary interests lie in high-performance computing, ndarray-based numerical systems, and building reliable, scalable architectures. I am particularly motivated by contributing to open-source projects where I can work on foundational systems and grow into a long-term contributor.

Timezone

GMT +02:00

Contact details

email:loayahmed304@gmail.com

Platform

Linux

Editor

VS Code. I prefer it for its flexibility, strong ecosystem, and efficient debugging tools. I customize it extensively depending on the project (e.g., C/C++ vs JavaScript workflows), and I often integrate it with terminal-based workflows for better control and efficiency.

Programming experience

I have worked across multiple domains including backend systems, networking, machine learning, and DevOps. Some of my key projects include:
Note that deployments are currently down for most projects as I haven't had the time to update the AWS billing details just yet.

• Digit Recognition: A simple digit recognition web app built as my first project in the field of Machine Learning. [Python & Numpy]
• Yappuccino: A text, voice, and video chatting app, all in one. Implemented using WebSockets and WebRTC. Deployed and containerized. [Node.js]
• Mark It: A real-time, live-collaboration, cross-platform Markdown editor. Implemented using WebSockets. Deployed and containerized. [Node.js]
• C Sockets: Implementing a TCP and UDP client and server protocols in plain C, using sockets.c library.
• Raven (X clone): A large-scale team project where I handled DevOps, CI/CD pipelines, versioning, and automated deployments across multiple teams. [DevOps & CI/CD]
• GO Rate Limiter: A fully customizable standalone rate limiting service in Go. Define per-route rate limits with a chosen algorithm. [Golang]
• In addition to courses projects.

JavaScript experience

I have a strong foundation in JavaScript, built through an intensive 80-hour course and multiple full-stack projects using both JavaScript and TypeScript.

Favorite feature: The flexibility and accessibility of JavaScript. The ability to quickly prototype and execute code directly in the browser or runtime environment makes it extremely powerful for both development and experimentation.

Least favorite feature: JavaScript’s dynamic typing and implicit coercion, which can sometimes lead to unintended behavior and make large-scale systems harder to reason about without strict patterns or TypeScript.

Node.js experience

Node.js has been my primary backend environment. I have used it extensively in projects such as Yappuccino, Mark It, and other full-stack applications.

I have experience building real-time systems (WebSockets, WebRTC), REST APIs, and working with Node.js beyond frameworks, including filesystem operations and core modules. I have also completed both university and external courses covering Node.js in depth.

C/Fortran experience

C/C++ were my first programming languages, and they remain central to my interest in systems programming.

I have implemented low-level networking using C (TCP/UDP sockets), and I have experience with memory management and performance-oriented programming. Additionally, my internship at Siemens DISW involved working with C/C++ and Tcl in a production environment.

I also regularly use C++ for problem solving and strengthening my understanding of algorithms and data structures.

Interest in stdlib

I've always been driven by how things behind the scenes work and how taken-for-granted behaviors are made. That was the first thing that got me interested in libraries implementations and architecture in general. I liked stdlib's vision and I see it's very promising and would love to be part of it one day, as a core contributor guiding the others and helping in development in my own way.

Version control

Yes

Contributions to stdlib

For all and always updated PRs: https://github.com/stdlib-js/stdlib/issues?q=sort%3Aupdated-desc%20is%3Apr%20author%3A%40LoayAhmed304

• I've started with using dynamic memory allocation in C benchmarks as a good first issue.
• I've created several C implementations adding to stats/base/ndarray namespace. They got me exposed more to the ndarray world. [1] [2] [3]
• I've started implementing functions from the Array API already: where, full, eye and currently working on others.
• I've also created an issue to improve the C benchmarks random arrays generations.

stdlib showcase

Bayesian Classifier, Live demo: https://stdlib.loayahmed.me
This isn't as simple project as it looks. This was a college assignment of mine few weeks ago in Python, and I transferred it into stdlib implementation. This what makes this project unique for me, because since this project focuses on Array API compliance, it would hep a little to see how the current transferring works.
I used the following for ndarrays (strided base implementations since ndarray versions were not merged in latest release):

• ndarrays
• mean
• variance
• max, min

Goals

This project aims to advance @stdlib/ndarray toward compliance with the Array API standard by mapping required API functions to existing stdlib primitives and identifying gaps where new implementations are needed.

A key focus will be minimizing redundant implementations by reusing existing strided and ndarray kernels wherever possible, and designing new kernels only when necessary. The project will involve analyzing the Array API specification, auditing current stdlib capabilities, and proposing efficient implementations for missing functionality.

By the end of the project, @stdlib/ndarray will achieve significantly improved compliance with the Array API standard, enhancing interoperability and making stdlib more accessible for numerical computing, data science, and machine learning workflows in JavaScript.

Why this project?

I am particularly excited about this project because it sits at the intersection of systems programming, numerical computing, and API design.

While exploring stdlib, I found working with ndarrays, BLAS, and strided operations especially engaging, as they reveal how high-level numerical operations are built on efficient low-level implementations. This project gives me the opportunity to deepen my understanding of these concepts while contributing meaningful improvements to a real-world library.

I am especially motivated by the impact of ndarrays as a foundational abstraction in scientific computing and machine learning, and I would like to contribute to strengthening this foundation within the JavaScript ecosystem.

Qualifications

I have already spent more than a month working with the stdlib codebase and contributing to ndarray-related functionality, which has given me a solid understanding of its architecture, including strided kernels, ndarray interfaces, and the C-to-JavaScript bridging model.

In addition, my experience with C/C++, backend systems, and numerical computing (via NumPy and ML projects) provides a strong foundation for working on ndarray internals and Array API alignment.

This combination of practical contributions and relevant background makes me well-prepared to execute this project effectively.

I also am a fan of documenting my work and new topics that I get exposed to, this may be a good addition as I would love to help in documentation issues if needed, whether it be ndarray-related or for stdlib in general.
Small examples:

• Debugging and Memory Profiling in C++
• Semantic Searching Introduction
• Nginx’s Master-Worker Model: How It Handles Requests Efficiently

Prior art

This project in general is very close to stdlib's JavaScript built-in arrays ndarray compliance.

Similar external works include Numpy, MATLAB, and Julia, which in my proposal I reference them for some implementation details.

Commitment

I plan to dedicate full-time effort to this project during the GSoC period (approximately 40 hours per week). I have almost no conflicting commitments during the summer and intend to prioritize this project fully.

Before the program, I will continue familiarizing myself with the stdlib codebase and contributing where possible. After GSoC, I aim to remain involved as an active contributor and continue working on ndarray-related improvements.

Schedule

Here's the GSoC proposal, where it'll include the updated implementation details, with commentor access.

Assuming a 12 week schedule,

• Community Bonding Period:

• Week 1 & 2: Priority 1 functions. Should not be hard but it may take more time since I'm still starting and getting used to the work.

  • matrixTranspose, full(Like), ones(Like), astype, eye, where, isdtype

• Week 3 & 4 & 5: Priority 2 functions and blocking or essential kernels for priority 3.

  • arange, squeeze, canCast, sort, argsort, cumProd. (and std, var, matmul if we'll exact match the specs behavior).
  • Blocking functions: Open PR(s) for unary-strided2d*, and more if discovered.

• Week 6: This week may be merged to the coming weeks or may act as a stop to finalize and refactor what is done so far.

• Week 7 & 8 & 9 & 10: Priority 3 functions. This period may vary according to implementation details, some functions I may over or underestimate their work since this area is the most challenging.

  • tril, triu, permuteDims, repeat, argmax, argmin, countNonzero, prod, tensordot, isin, unique functions, take, takeAlongAxis & moveAxis (or their equivalent), roll, stack.

• Week 11 & 12: Focus on missing tests and/or documentations. For extra time, I can add C implementations and/or add extra ndarray kernels outside the Array API specs.

• Final Week: My stdlib and GSoC journey project submission, post and review of everything that has been done, add any additional work after the review if needed.

Notes:

• The community bonding period is a 3 week period built into GSoC to help you get to know the project community and participate in project discussion. This is an opportunity for you to setup your local development environment, learn how the project's source control works, refine your project plan, read any necessary documentation, and otherwise prepare to execute on your project project proposal.
• Usually, even week 1 deliverables include some code.
• By week 6, you need enough done at this point for your mentor to evaluate your progress and pass you. Usually, you want to be a bit more than halfway done.
• By week 11, you may want to "code freeze" and focus on completing any tests and/or documentation.
• During the final week, you'll be submitting your project.

Related issues

#176

Checklist

• I have read and understood the Code of Conduct.
• I have read and understood the application materials found in this repository.
• I understand that plagiarism will not be tolerated, and I have authored this application in my own words.
• I have read and understood the patch requirement which is necessary for my application to be considered for acceptance.
• I have read and understood the stdlib showcase requirement which is necessary for my application to be considered for acceptance.
• The issue name begins with [RFC]: and succinctly describes your proposal.
• I understand that, in order to apply to be a GSoC contributor, I must submit my final application to https://summerofcode.withgoogle.com/ before the submission deadline.

[batpigandme]

Quick thing: The link to the Bayesian Classifier/showcase isn’t working for me. Is it possible you still have it set to private?

Thanks! 😊

[LoayAhmed304]

Quick thing: The link to the Bayesian Classifier/showcase isn’t working for me. Is it possible you still have it set to private?

Thanks! 😊

Yes it was private. It's public now, thank you for the note.

[headlessNode]

@LoayAhmed304 A couple comments:

• What’s your plan for the 3-week Community Bonding period? You could use this time to clear any blockers you think might come up later, or get a head start on the parts that seem straightforward so you can focus more on the tougher ones down the line.
• If your GSoC proposal already includes implementation details for each function, consider sharing them here as well. That way, you can get early feedback and make improvements before the final submission.

[LoayAhmed304]

@LoayAhmed304 A couple comments:

• What’s your plan for the 3-week Community Bonding period? You could use this time to clear any blockers you think might come up later, or get a head start on the parts that seem straightforward so you can focus more on the tougher ones down the line.

Yes I'm planning to implement the straightforward packages, it'll help me get to know the basic conventions and review notes apart from implementations details (since they're fairly straightforward), I take notes aside of any review I receive.

I believe I'll continue most (if not all) the first priority packages in that period. Knowing that the first week in the Community Bonding period I would still be in college final exams, but I'll have the summer for the rest so I can put more effort in the latter 2 weeks. I try to compensate that week by creating packages starting from now.

• If your GSoC proposal already includes implementation details for each function, consider sharing them here as well. That way, you can get early feedback and make improvements before the final submission.

Good point, I wasn't planning to post it but I'll update this RFC with the implementation details and ping you then 👍.

[LoayAhmed304]

I have added a commenter link to my proposal with implementation details for each function at the very end. I have questions and guidance on some functions there, excited and looking forward to hearing everyone's feedbacks to discuss!

Anyone feel free to comment either here or on the document itself since it's a commenter link, I'll consider both.

[kgryte]

@LoayAhmed304 Thank you for opening this draft proposal. A few comments:

1. Why is tri blocking for tril and triu? Quote: "Blocking for tril and triu: tri, add more if discovered." The former is a creation routine, while the others extract the triangle from an existing array.
2. Based on your Google document, it would be good for you to think a bit more about when/why an underlying strided implementation is needed (e.g., stdev) versus writing a separate set of nested loop kernels (e.g., where). Hint: reductions involving specialized algorithms (think variance, stdev, mean, summation, etc) are prime targets for strided operations. Similarly, sorting algorithms make sense on one-dimensional arrays. Similarly, resolving a specific index. Etc.
3. Make sure you are taking a bigger picture view and doing research on how other ecosystems beyond Python (NumPy) do various numerical operations. As mentioned elsewhere, we don't want to copy everything in NumPy. There are good ideas and design principles found outside of the Python world, including Julia, so it is good to ensure we are doing our homework.

[LoayAhmed304]

@LoayAhmed304 Thank you for opening this draft proposal. A few comments:

1. Why is tri blocking for tril and triu? Quote: "Blocking for tril and triu: tri, add more if discovered." The former is a creation routine, while the others extract the triangle from an existing array.

I updated the implementation details Google document and forgot to update the issue. We discussed about this already and said it'll be related more to unary-strided2d*.

3. Based on your Google document, it would be good for you to think a bit more about when/why an underlying strided implementation is needed (e.g., stdev) versus writing a separate set of nested loop kernels (e.g., where). Hint: reductions involving specialized algorithms (think variance, stdev, mean, summation, etc) are prime targets for strided operations. Similarly, sorting algorithms make sense on one-dimensional arrays. Similarly, resolving a specific index. Etc.

Noted. On it. I though when referencing a strided kernel it would infer that the function base will also be a strided kernel, and same for otherwise. I'm in the middle of my college midterm exams so I may not be able to update all, but I'll show that I got the overall idea of what needs and whatnot.

3. Make sure you are taking a bigger picture view and doing research on how other ecosystems beyond Python (NumPy) do various numerical operations. As mentioned elsewhere, we don't want to copy everything in NumPy. There are good ideas and design principles found outside of the Python world, including Julia, so it is good to ensure we are doing our homework.

Yes I've started doing so with Julia, I'll try to update as much as possible as I got more familiar with Julia's codebase and took me a while to understand their structure and language syntax and symantics. As stated above, I may not update all approaches but I'll certainly do as much as I can and will be doing my homework prior to your selection process.

[LoayAhmed304]

I have kind of updated the Google document and hence the submitted GSoC application. I got even more excited to learn more while diving into these implementations and more. I'm open to discussions for the updated document.