DEV Community: Harkeerat Singh

GSoC 2026 - Week 7

Harkeerat Singh — Sat, 11 Jul 2026 19:34:50 +0000

Week 7 of my Google Summer of Code journey with CircuitVerse (July 6th to July 12th) is officially done.

🔌 Building the End-to-End Pipeline

The first order of business was updating importCanonical.ts to stay perfectly in sync with our finalized canonical.ts. Once the core code layers matched up, the simulator was officially able to take our deterministic JSON and completely rebuild the digital circuits from scratch.

✨ The Ultimate Developer Satisfaction: There is genuinely nothing quite like exporting a complex circuit layout, deleting it, and watching the import engine reconstruct it onto the canvas flawlessly.

🖥️ Wireframing the New Export & Import UI

Because my official GSoC Midterm Evaluation lands next week, I wanted to get the remaining features pushed early so my mentors had plenty of time to review it. My main task became hooking up the engine to the real CircuitVerse frontend.

On the import side, I configured the workflow to accept the new deterministic canonical structure, dropping support for the legacy layout parsing. I also added a safety transaction backup: if a canvas import crashes or fails for any reason, the system automatically rolls back, preserving the user's existing work instead of wiping the canvas clean.

On the export side, I tied the "Export as File" actions directly to canonical.ts to output perfect .cv files. To make the feature developer-friendly, I added:

📜 A live JSON preview panel powered by CodeMirror.
📋 A Copy to Clipboard utility button.
💾 A Download Circuit action trigger.

🚀 Pushing the Pull Requests & Demo Time

Once the UI layers were polished, I opened up two new Pull Requests—one for the import pipeline and another covering the newly minted UI views.

🧠 Brainstorming Determinism with Aboo

During the sync meeting, my mentor Aboo and I had an interesting design discussion regarding a potential edge case that could break component determinism.

We discussed an alternative strategy that changes how components are tracked and saved internally. Right now, it's just an initial architectural discussion, so I’m going to hold off on writing code until the rest of the mentoring group weighs in. We'll likely dive deeper into this next week!

📺 Demo Day

I also got to showcase my progress during our weekly CircuitVerse GSoC Contributors' Meeting! Giving a live demonstration of the full export-to-import loop running seamlessly inside the active simulator environment was a proud moment, and the feedback from the community was incredibly warm and positive.

🔮 Looking Ahead: Midterm Evaluations!

With Week 7 officially wrapped, I am incredibly proud to say that the majority (arguably the most challenging) parts of my GSoC roadmap are finished.

Next week is the big one: Midterm Evaluations!

Wish me luck, and see you all in Week 8! ⚡💻

GSoC 2026 - Week 6

Harkeerat Singh — Sat, 11 Jul 2026 19:13:20 +0000

Week 6 of my Google Summer of Code journey with CircuitVerse (June 29th to July 5th) was arguably the most rewarding week of the summer so far.

🧠 The Power of Elite Code Review

This week, all my mentors dropped reviews on my initial three pull requests. It was the first time I’ve ever experienced code review at this level of depth, and honestly, I learned a lot from the reviews.

My mentors caught edge cases I hadn’t even considered:

⚡ A brilliant architectural idea: Caching the canonical hashes. Instead of recomputing the heavy Weisfeiler-Leman structure and SHA-256 hash every single time a project saves, we can cache the hash of circuits that haven't changed and reuse them.
💡 This caching suggestion completely shifted how I view the project's performance. It opens the door to fast saving pipelines! We decided to slate this optimisation for a dedicated upcoming PR.

🥞 CircuitVerse GSoC contributors' meeting

During our weekly CircuitVerse GSoC contributors' meeting, I shared my progress but also raised a genuine concern: since almost all of my upcoming PR's relies on my initial pull requests being merged, waiting for slow code reviews was starting to bottleneck my timeline.

My mentor, Aboo, dropped an absolute game-changer of a suggestion: Stacked PRs. If you want to know more about it, you can read https://newsletter.pragmaticengineer.com/p/stacked-diffs

⏳ Timeline Extensions & Midterms

My mentors decided to extend my project timeline by two weeks! 🗓️

It gives us plenty of room to run thorough testing, edge-case debugging, and performance polishing. Because of this timeline adjustment, my official GSoC midterm evaluation has also shifted by a week.

🥳 FINALLY... IT MERGED!

There couldn’t have been a better way to close out the week. On the very last day, I opened GitHub and saw the glorious notification: My first pull request as a GSoC contributor was officially merged into main! 😭🎉

PR https://github.com/CircuitVerse/cv-frontend-vue/pull/1095 MERGED!

🔮 Looking Ahead to Week 7

I am riding a massive wave of motivation right now. Thank you to my mentors for the incredible guidance this week.

Let’s keep this momentum rolling! ⚡💻

GSoC 2026 - Week 5

Harkeerat Singh — Sat, 11 Jul 2026 18:53:27 +0000

Week 5 of my Google Summer of Code journey with CircuitVerse (June 22nd to June 28th) is officially in the books.

After dealing with a rough sickness last week, I’m happy to say this week was incredibly positive.

🔄 Reconnecting with the Community

Since I had to miss last week's sync because I was under the weather, I had to attend the CircuitVerse GSoC Contributors' Meeting this week. It felt so good to reconnect with everyone!

I shared the progress I'd managed to scrape together over the last couple of weeks, and the mentors were incredibly understanding and kind about my slower pace due to being sick. The CircuitVerse community is genuinely unmatched! Everyone is so encouraging, and having that layer of support makes a world of difference.

It was also super motivating to hear what the other contributors have been up to. Seeing how much progress everyone has made gave me a massive burst of inspiration to jump right back into development!

🛠️ importCanonical.ts is Completed!

Once the meeting was over, I officially finished implementing the entire import pipeline in importCanonical.ts! 🥳

This file does the heavy lifting of taking our clean, deterministic canonical JSON and reconstructing the circuit right back onto the user's canvas. Here is what's packed inside:

🔀 Full Multi-Circuit Support: The import pipeline seamlessly handles projects containing multiple individual circuits.
📐 Smart Subcircuit Dependency Resolution: Just like the export pipeline, the import engine now uses Kahn's Algorithm to figure out the exact sequence the circuits need to be loaded in so that nested dependencies never break.
🛑 What's Missing? (For Now): The import pipeline doesn't validate the incoming JSON file. I am waiting until the canonical format is finalised. Once that's locked in, I will add JSON schema validation in the file.

🚀 The PR Status

On the GitHub side of things, the three foundational Pull Requests I opened earlier are still actively under review.

One of my mentors gave them a look this week and left some excellent feedback. I spent a good chunk of time addressing all the requested changes and polishing the code. Now, I’m just waiting for another round of reviews and final green lights from the rest of the mentoring team.

💡 Because my new import pipeline relies entirely on the foundational changes I introduced in canonical.ts, I haven't opened a fresh PR for the import code just yet. I’m keeping it local for now and will raise the PR the second those core building blocks get merged into main!

🔮 Final Reflections & Looking Ahead to Week 6

All in all, Week 5 was exactly what I needed. It felt amazing to get back into a solid development groove, receive highly detailed feedback on my work, and keep the momentum moving forward.

Let's see what Week 6 brings! ⚡💻

GSoC 2026 – Week 4

Harkeerat Singh — Mon, 22 Jun 2026 19:07:54 +0000

Week 4 of my Google Summer of Code journey (June 15th to June 21st)!

If I’m being completely honest, this week didn’t exactly go according to plan. I was not feeling well this week. Because of that, my main focus had to shift from coding to resting up and recovering.

Even though it was a slower week, I still managed to get some work done.

My main goals for this week were to write importCanonical.ts and set up a JSON Schema.

The import file is super important because it takes the clean, hashed canonical JSON we built in the last few weeks and actually reconstructs the digital circuits back onto the screen.

Despite feeling sick, I managed to complete most of importCanonical.ts! The core logic is written, and there are only a few small pieces left to polish.

Because I was running on low energy, I talked things over with my mentors. We agreed to push the JSON Schema work to next week. I’ll be combining the leftover tasks with my Week 5 goals, and I'm confident I can catch up!

(Due to my health, I also had to skip our weekly GSoC contributors' meeting this time around!)

🎉 The Blockade is Cleared

Remember that annoying upstream bug in the V1 version of CircuitVerse I mentioned in my previous updates? The one that was stopping me from submitting my code?

It finally got fixed by the maintainers! 🥳

As soon as the repository patch went live, I cleaned up my branches and opened the Pull Requests (PRs) for all the work I completed over the last few weeks.

The PRs are now sitting with my mentors for review, and I’m looking forward to getting their feedback, tweaking things based on their notes, and getting everything merged.

Time to bounce back stronger for Week 5—let's get it! 🚀🔥

GSoC'26: Week 3

Harkeerat Singh — Mon, 15 Jun 2026 19:32:45 +0000

Week 3 of my Google Summer of Code 2026 coding period at CircuitVerse lasted from June 8th to June 14th. This was a productive week! Let's break down exactly what went down! 👇

🏗️ Mastering Subcircuits with Topological Sorting

My primary goal this week was to implement subcircuit support in the canonical.ts file, which I successfully implemented!

For example, if Circuit B uses Circuit A as a nested subcircuit component, Circuit A must be processed and loaded before Circuit B.

To handle these nested dependencies deterministically, I introduced two key system updates:

1️⃣ Kahn’s Algorithm for Topological Sorting
I implemented Kahn’s Algorithm to evaluate the structural dependency graph. It calculates the incoming degrees of each circuit layout, processing zero-dependency blocks first to construct a perfectly ordered, linear topological array.

If you want to know more about the Khan's Algorithm, you can explore https://www.geeksforgeeks.org/dsa/topological-sorting-indegree-based-solution/

2️⃣ Circular Dependency Detection
What happens if a user accidentally makes Circuit A depend on Circuit B, while Circuit B simultaneously loops back to depend on Circuit A? Khan's algorithm made it very easy to detect these cycles!

I had studied and experimented with topological graph sort algorithms during college, which made writing code for this week fun and interesting!

The canonical.ts can now generate deterministic canonical JSON for any valid layout. I could not be happier with the progress!

📺 Demo Day

This week I had my first Demo Day! 💡

This was a live session where all CircuitVerse GSoC contributors stepped up to present their feature updates. I ran a live demo on the console by running the canonical.ts file, which generated the deterministic JSON successfully!

It was incredibly rewarding to receive positive feedback from the team, and equally amazing to witness the progress being made by the other contributors.

You can see the JSON in the image:

🏀 Off-Duty: The Craziest Finals Games in NBA History!

If you've been reading my updates, you know I’ve been completely locked into the 2026 NBA Finals matchup between the Knicks and the Spurs. This past week brought us three more games, and calling them "entertaining" is a massive understatement!🍿

The headline story of the week has to be Game 4. The Knicks were down by a mind-boggling 29 points in the first half. What followed was absolute cinema. They launched a historic second-half comeback to scratch all the way back and win it 107-106, marking the largest comeback victory in NBA Finals history! 🤯

With yet another signature double-digit comeback under their belts in Game 5, Jalen Brunson dropped a masterclass 45 points to lead the Knicks to a 94-90 victory, ending a legendary 53-year championship drought to win the title 4-1!

The momentum is real, and I'm incredibly excited to keep pushing forward. Catch you next week! ⚡💻

GSoC'26: Week 2

Harkeerat Singh — Fri, 12 Jun 2026 20:18:20 +0000

The second week of my Google Summer of Code 2026 coding period at CircuitVerse (June 1st to June 7th) is officially in the books. This week was all about scaling up architectural ideas and having some unexpected fun during community hangouts.

🏗️ Scaling to Multi-Circuit Support

This week, my main technical focus shifted toward implementing multi-circuit support for our canonical JSON format. The core goal here is to ensure that the canonical representation remains completely deterministic even for complex projects containing multiple individual circuits.

🟢 The majority of the implementation was straightforward and easy
🧠 Now, only the subcircuit dependency part is left! It’s a beautifully complex problem that involves handling nested circuit hierarchies.

⏳ Navigating a Minor Pull Request Blocker

While the code is running great locally (in V0), I wasn't able to officially open a Pull Request in the V1 version this week.

⚠️ The Reason: We ran into a few underlying issues with the V1 version of the system. I am currently waiting for the core maintainers to patch those upstream issues so the environment is stable. Once that’s cleared up, the PR is going straight up for review! 🚀

🤝 GSoC Student Meeting

I also attended our regular weekly GSoC student meeting. It was a great space to share my progress on the multi-circuit framework and see the incredible work the other contributors are pulling off.

But the absolute highlight happened after the official meeting wrapped up!

☕ Some of the mentors stuck around, and we ended up having an amazing, casual conversation. We talked about what everyone has been up to, shared personal stories, and walked away with some incredibly unique insights.

Honestly, I never thought meetings could be this much fun! The culture here is genuinely unmatched. 🩵

🏀 Off-Duty: NBA Finals!

The 2026 NBA Finals are finally here, and it's a wild matchup between the New York Knicks and the San Antonio Spurs! 🤯

As a basketball fan, the Finals are always the best time of the year. The first two games are already over, and the Knicks have taken a quick 2-0 lead!

Will the Spurs pull off a massive comeback, or are the Knicks going to run away with this? Let’s see what happens next! 🍿

🔮 Final Reflections & Looking Ahead

Week 2 was fantastic, let's see what the next week brings! Week 3 is going to be all about handling subcircuit hierarchies.🚀

GSoC'26: Week 1

Harkeerat Singh — Fri, 05 Jun 2026 21:01:21 +0000

The first week of my Google Summer of Code 2026 coding period at CircuitVerse ran from May 25th to May 31st. It turned out to be an exciting mix of core development work, community activities, deep learning, and even a little bit of friendly competition!

🛠️ Getting Started on the Project

After the intense discussions and planning sessions during the Community Bonding Period, I spent this week implementing many of the structural changes that had been finalised with my mentors.

One of the key pillars of my project is generating a deterministic canonical JSON representation of digital circuits. During my initial proof-of-concept phase, I had implemented the core logic in a raw canonical.js file. However, after diving deep into the architectural standards of the project, we decided that the implementation should be migrated to TypeScript to ensure long-term maintainability and codebase alignment.

As a result, I completely rewrote the implementation in canonical.ts.

🧬 Building the Canonicalization Pipeline

Beyond simply migrating the codebase, I worked extensively on implementing the main pipeline responsible for generating the canonical JSON output.

This involved integrating the 1-Dimensional Weisfeiler-Leman (1-WL) graph algorithm into our component sorting pipeline.

🏆 CircuitVerse Repository Cleanup Contest

Project work wasn't the only exciting part of the week! CircuitVerse organised a Repository Cleanup Contest, which was MERGATHONE, where contributors competed to close as many issues and pull requests as possible across the entire GitHub ecosystem.

I'm incredibly happy to share that my team secured 1st place! 🎉
The contest was both highly productive and fun. As a bonus, we'll also be receiving exclusive CircuitVerse T-shirts later this month! 👕

🤝 GSoC Contributors Meetup

We also held our official CircuitVerse GSoC 2026 contributors meetup during the week. Each contributor shared updates about their ongoing work and talked about their progress.

One thing I really appreciate about the CircuitVerse community is how welcoming and relaxed everyone is. The meetings are highly productive while still maintaining a warm, friendly atmosphere, making it easy to engage in deep technical discussions.

There was even a hilarious moment during the meetup when contributors started guessing the age of one of the organisation admins (Aboo Bhaiyaa) before he joined the call. Somehow, I managed to guess it exactly right, which felt like a small but satisfying victory! 😄

🔮 Reflections & What's Next

Looking back, this first week had a little bit of everything:

📈 Significant progress on my core GSoC project
🔄 Migration of core architecture from JavaScript to TypeScript
🧠 Implementation of key topological canonicalization algorithms (1-WL)
🥇 A successful (and victorious!) repository cleanup contest
🌐 Awesome community interactions and contributor meetups

I'm excited to continue building on this progress in the coming weeks and look forward to sharing more updates as the summer progresses.

Excited for Week 2! 🚀🔥

From a Student Who Used CircuitVerse to a GSoC Contributor — My Community Bonding Story

Harkeerat Singh — Sun, 24 May 2026 18:09:06 +0000

📍 Where It All Started

In January 2026, I was browsing through GSoC organisations, shortlisting ones that matched my interests in computer science. Then I came across CircuitVerse — and it wasn't a new name to me at all.

A year before, I was struggling with my Digital and Logic Design course. Sequential circuits felt abstract until I started building them on CircuitVerse. Being able to see a D flip-flop hold state, or watch a 3-bit counter tick through its sequence in real time, made concepts click in a way no textbook had managed. CircuitVerse genuinely helped me get there.

So seeing it listed as a GSoC organisation felt personal. This was a chance to give something back to the platform that had helped me. I decided to start contributing.

💻 February — Getting Into the Codebase

I started with beginner-friendly issues in February, exploring both the Vue frontend and the main Rails repository. My first contributions were small but impactful:

🔤 Fixing typos
⌨️ Improving keyboard accessibility for the header dropdowns
🔍 Making the search icon focusable

Nothing glamorous, but it taught me how the codebase was structured and how the contribution process worked.

📝 The Proposal — Late Nights and Midterms

Of all the projects listed on the idea list, one stood out: Structured Format for Saved Circuit Data.

The problem was "elegant" and "genuinely hard". Currently, two logically identical circuits saved in different orders produce completely different files. The goal was to build a canonical, deterministic format that produces identical output for any two logically equivalent circuits.

I decided to build a Proof of Concept before writing a single word of the proposal and recorded a demo showing matching hashes on import and export.

And then I wrote the proposal. I will be honest, that was the least interesting part of all. But somehow I was doing all of this while preparing for my midterms.

FINALLY, on March 30th 07:49 PM , I submitted the proposal! Late — but worth it!

⏳ April — The Wait and the Interview

After submitting, I checked Slack every single day. Every morning, first thing. Waiting to see if a mentor had messaged me for an interview. A few days of silence, and I started second-guessing everything. These were really stressful weeks.

Then on April 14th, the message came. I said yes without a second thought. I prepared for the interview. The mentors asked sharp, thoughtful questions — some I answered well, some made me realise there were corners of the project I needed to think through more carefully. It was a good kind of difficult.

🎉 April 30th, 2026 | 11:33 PM

I opened the GSoC dashboard. My project was live.

I sat there for a moment just staring at the screen. A year of using the platform, two months of contributing, late nights on the proposal, the interview — it had all landed.

The next morning, I woke up and genuinely thought I had dreamed it. I checked the dashboard again just to be sure.

It was real.

🤝 The Community Bonding Period

May 2nd — Organization Meeting

The community bonding period kicked off with an organisation-wide meeting. We met mentors, fellow GSoC contributors, and the people behind other projects. It was relaxed, warm, and genuinely fun — less like a formal meeting and more like a friendly group hangout.

May 9th — Project Kickoff

My project-specific meeting was with my mentors Aboobacker, JoshVarga, Arnabdaz, Aryann. We went through the timeline, discussed the algorithm design in depth, and aligned on how the canonical format should handle edge.

The meeting was fun, and I learned many new things and got very useful insights.

🔮 What's Next

The coding period begins May 25th.

The community bonding period has been everything I hoped — technically productive, genuinely warm, and motivating.

I'm grateful to my mentors for the opportunity and for the quality of feedback they've already given.

Let's see what the coding period brings. Very excited! 🔥

DEV Community: Harkeerat Singh

GSoC 2026 - Week 7

🔌 Building the End-to-End Pipeline

🖥️ Wireframing the New Export & Import UI

🚀 Pushing the Pull Requests & Demo Time

🧠 Brainstorming Determinism with Aboo

📺 Demo Day

🔮 Looking Ahead: Midterm Evaluations!

GSoC 2026 - Week 6

🧠 The Power of Elite Code Review

🥞 CircuitVerse GSoC contributors' meeting

⏳ Timeline Extensions & Midterms

🥳 FINALLY... IT MERGED!

🔮 Looking Ahead to Week 7

GSoC 2026 - Week 5

🔄 Reconnecting with the Community

🛠️ importCanonical.ts is Completed!

🚀 The PR Status

🔮 Final Reflections & Looking Ahead to Week 6

GSoC 2026 – Week 4

🎉 The Blockade is Cleared

GSoC'26: Week 3

🏗️ Mastering Subcircuits with Topological Sorting

📺 Demo Day

🏀 Off-Duty: The Craziest Finals Games in NBA History!

GSoC'26: Week 2

🏗️ Scaling to Multi-Circuit Support

⏳** Navigating a Minor Pull Request Blocker**

🤝 GSoC Student Meeting

🏀 Off-Duty: NBA Finals!

🔮 Final Reflections & Looking Ahead

GSoC'26: Week 1

🛠️ Getting Started on the Project

🧬 Building the Canonicalization Pipeline

🏆 CircuitVerse Repository Cleanup Contest

🤝 GSoC Contributors Meetup

🔮 Reflections & What's Next

From a Student Who Used CircuitVerse to a GSoC Contributor — My Community Bonding Story

📍 Where It All Started

💻 February — Getting Into the Codebase

📝 The Proposal — Late Nights and Midterms

⏳ April — The Wait and the Interview

🎉 April 30th, 2026 | 11:33 PM

🤝 The Community Bonding Period

May 9th — Project Kickoff

🔮 What's Next

⏳ Navigating a Minor Pull Request Blocker