Hi all!! I'm Harsh Chauhan currently an Engineering Physics undergrad at IIT Dharwad. I'll be using this space to document my GSoC journey and everything around it. This is my first time writing a blog, so please bear with me :p.
So to start with the good news, my proposal on ML Inference on Heterogeneous Architectures using SOFIE got accepted for Google Summer of Code 2026 with CERN-HSF and as I'm writing this I'm already in Week 3 of the coding phase. I'm currently working under my mentors Dr. Lorenzo Moneta (Senior Applied Physicist at CERN) and Sanjiban Sengupta (Doctoral Student at CERN and previous GSoC'21 contributor with CERN).
Table of Contents
So what's the project about??
GSoC and where does CERN-HSF fit in?
How it started?
Finding my footing at CERN-HSF
Three proposals, one deadline
D-Day: Results
My two cents
What's next?
So what's the project about??
SOFIE (System for Optimized Fast Inference code Emit) is part of CERN's ROOT framework, developed under ML4EP, a CERN SFT group effort focused on building common ML software tools for high-energy physics. It takes trained ML models and generates fast, dependency light C++ code to run inference on them, which is useful when you need to deploy models inside large physics analysis pipelines. So far SOFIE has mostly targeted CPUs and my project is about extending it to run on GPUs using the alpaka framework, which lets the same code run across different hardware backends like NVIDIA and AMD. The goal is to make ML inference in ROOT faster and portable across heterogeneous architectures.
I'll go into the actual technical goals, the operators, their fusion and benchmarking in a later blog once I cover the coding phase in detail.
GSoC and where does CERN-HSF fit in?
If you're reading till here, I'm assuming you probably already know what GSoC is, but for any readers who might be new to this: Google Summer of Code is a program where students contribute to open-source projects over the summer, each paired with mentors from a participating organization. You write a project proposal and if it gets accepted, you spend a few months building it out with guidance from your mentors.
CERN-HSF is one of those organizations, and it's an umbrella org, meaning it brings together a bunch of high-energy physics projects from places like CERN, Fermilab, DESY, MIT and several universities under one roof. And honestly, just the idea of contributing to software used at CERN is kind of exciting for me. Coming from a physics background, I've been hearing and reading about CERN forever (from professors casually mentioning it to watching Veritasium videos about it), so getting to contribute here still feels a little surreal, this is the place where the web was born and the Higgs boson was discovered. ROOT, the framework my project sits under, is one of its biggest sub-projects.
One thing that makes CERN-HSF a bit different from a lot of other orgs is how selection works. It's not just about how many contributions you rack up. The process is more phase-wise: you reach out to mentors, complete an evaluation task they assign and then, if that goes well, you write a proposal. Your prior contributions do play a role, but the eval task and the proposal carry real weight. I'll get into how that actually played out for me further down.
How it started?
I first heard about GSoC at the end of my freshman year, through a friend who had gotten in and was contributing over the summer. It stuck in my head as something I wanted to do.
By sophomore year I had it in mind, but I'll be honest, I never really committed to it. I was into development at the time and had started learning WebRTC, so I set up a few org projects locally like Rocket.Chat, Plone and Jitsi and poked around here and there. But around midsems I couldn't stay consistent and I just let it go. TBH, part of me leaned on the excuse that it was only sophomore year and I had time.
Looking back, that was a bit silly of me. Even just trying and drafting a proposal that might not get accepted is worth a lot, because you learn where you fall short and what to fix. If there's one thing I'd tell anyone reading this, it's that the attempt itself teaches you more than waiting for the "right year" ever will. As cliche as it may sound, you break stuff, learn and figure it out!!
Finding my footing at CERN-HSF
Around January this year, I started seriously researching orgs again. This time I came across the umbrella orgs like CERN-HSF, ML4Sci and NumFOCUS. CERN-HSF stood out to me because of the sheer range of its past projects, everything from webdev, agentic AI, ML to compiler research, with a lot of them coming straight from experiments like ATLAS and CMS.
The 2026 projects started dropping around February 3rd, so I began going through them. There were a lot, around 40 announced initially and I spent the next couple of weeks reading through codebases and the research papers behind the projects that caught my eye. A few stood out were: firstly ofc the one I'm working on now, the Keras and PyTorch parsers project (both under SOFIE), OmniFold and MCFM, which is a Monte Carlo event generator.
The mentor contact window ran from February 19th to March 16th. My timing wasn't ideal because my midsems landed right at the end of February, so I got stuck for a bit and started mailing mentors a little later than I'd have liked. In total I reached out to around 7 to 10 mentors for eval tasks.
Once a mentor responds, they assign you an evaluation task. For my project, this started with a preliminary exercise to get my environment set up and get familiar with SOFIE, followed by a small toy implementation where I implemented a few operators and wrote tests for them on the GPU.
The hardest part wasn't the implementation itself, it was getting everything to build and set up locally. Fixing those build issues by digging through the docs taught me a lot and that same setup and understanding is what made contributing to the ROOT repo afterwards much smoother. The implementation came a bit easier since I'd done deep learning last semester, so if you're aiming for an ML-related project, having built even tiny things and messed around with existing ones beforehand helps more than you'd expect.
Three proposals, one deadline
By this point I had to draft three proposals at once, MCFM, OmniFold and the SOFIE ML Inference one, all while quizzes were going on :/ It was a lot to juggle.
For MCFM, a good chunk of the proposal came directly from my eval task. While doing it I'd found an issue building the project through CMake which I fixed locally and flagged it to the mentor, so I documented that along with my results. That one ended up around 12 pages and got feedback from the mentor.
For the SOFIE ML Inference proposal, my mentor gave guidance on the expected length and content, and I got review feedback on my draft. That came out to about 6 pages. Along with this, I was also contributing in ROOT and interacting with my mentors and other maintainers since March. For OmniFold I didn't get much feedback and mostly submitted what I had.
A few things I took away about writing proposals:
Keep the deliverables clean and the timeline realistic. Better to have clear core deliverables plus some stretch goals than to overscope everything upfront, since the actual scope tends to evolve as the project progresses.
Look at past accepted proposals. They give you a real sense of structure and depth.
Add small code snippets, a rough framework plan, or diagrams where you can. Showing a skeleton of what you're thinking lands better than just saying "I'll do this and that."
There's more to it, but it's not worth stressing over right now, proposal writing really only comes into the picture in the last month or so.
If you'd like to see how they actually turned out, here are my three proposals: SOFIE ML Inference, MCFM and OmniFold.
D-Day: Results
Results came out on April 30th, right at 11:30 PM. My endsems were going on that week and I distinctly remember stressing about it at around 3 AM that morning, because I had my Condensed Matter Physics endsem the same day. Meanwhile, I was also up surfing the GSoC subreddit, discussing with others and basically stressing together with a bunch of strangers.
When the time came, I opened my GSoC profile page and saw my ML Inference on Heterogeneous Architectures project accepted. It happened sooner than I expected and telling my friends and everyone after was overwhelming, to say the least.
My two cents
If there's one thing I'd want you to take away, it's this: don't let the big orgs intimidate you out of trying. CERN-HSF felt way out of my league at first and I think a lot of people talk themselves out of even attempting it because of that fear. But it's worth the shot. Worst case, you learn a ton along the way.
And honestly, that's something I've only started realizing myself. I'm still pretty new to all of this, but even in this short time, I've felt how much getting into open source pushes you to grow as a developer. You learn to read unfamiliar codebases, work with maintainers, take feedback and collaborate with people across the world and that sticks with you regardless of whether you get selected.
I'll probably write a separate, more detailed blog on the contributions and application side of things, so I'll keep this short for now.
What's next?
Right now I'm already into the coding phase, working with my mentors, raising PRs and discussing the plan forward in our weekly syncs as we go. I'm planning to keep blogging through the program and documenting my work along the way, which should also help me when the final evaluation comes around.
For those of you who made it till the end, thank you very much!! If you're considering GSoC, especially with a big org, I hope this was useful.
A few blogs that helped me figure out how to write this one:
Sanjiban Sengupta's GSoC'21 blog (now one of my mentors!)
I'll be covering the project's technical side and how the coding phase is going in upcoming posts, so stay tuned for more. Until next time!! :p
Top comments (0)