DEV Community: Harkeerat Singh

GSoC'26_Week12 : T-Shirt, Tests & Auto Layout

Harkeerat Singh — Mon, 17 Aug 2026 12:18:38 +0000

Week 12 of my Google Summer of Code journey with CircuitVerse (August 10th to August 16th) was a really fun mix of something personal and a lot of progress on the project.

👕 The Most Awaited Package!

At the start of the week, something I had been waiting for finally arrived — my CircuitVerse T-shirt! 🎉

If you guys have been following my blogs, you might remember that my team won CircuitVerse's MERGATHONE Repository Cleanup Contest at the end of May. I wrote about it in my Week 1 blog.

When I opened the package and saw the CircuitVerse logo, it honestly felt amazing.

It might just look like a T-shirt, but for me it was a small reminder of where I started — using CircuitVerse as a student for my digital logic course, then contributing to it, and now spending my summer working on it through GSoC. 🩵

🧪 Finally Fixing the Round-Trip Gaps

Coming back to the technical work, I followed up on all the problems the Editor's Picks tests had exposed last week.

The main fixes were around:

🔌 Preserving complete wire topology, including dangling, standalone and multi-port nets.
📐 Preserving routing, intermediate nodes, component port positions and other layout details.
🗂️ Restoring important project state like the project name, clock settings, focused circuit, tab order and annotations.

After working through these issues, all 12 Editor's Picks projects were finally passing the complete round-trip tests! 🎉

I raised PR #1194 with the fixes and the new test coverage.

The PR is still under review, so there may still be a few edge cases to clean up before it gets merged.

🔄 Starting the Auto Layout Feature

I wasted no time and moved on to the next part of my GSoC project — Auto Layout using ELK.js.

This was actually a feature my mentors and I had discussed way back during the Community Bonding period. The idea is simple: when a canonical circuit does not already have component positions, the importer should still be able to generate a clean and readable layout automatically.

ELK.js brings the Eclipse Layout Kernel's graph-layout algorithms to JavaScript, letting us automatically calculate clean positions for connected nodes and edges. That makes it a really good fit for laying out circuits when position data is missing.

I had already spent some time researching ELK.js earlier in the summer, so starting the implementation after finishing the canonical pipeline was not too difficult.

It is also a pretty interesting feature to work on because now the problem is not just about preserving circuit data — it is also about deciding where everything should actually appear on the canvas.

🔮 What's Next

Next week, I want to get PR #1194 through review and merged, addressing any mentor feedback or edge cases that come up.

Alongside that, I'll finish the Auto Layout feature and raise a PR for it.

Really looking forward to next week! ⚡💻

GSoC'26_Week11 : Real Circuits Broke My Assumptions

Harkeerat Singh — Mon, 17 Aug 2026 11:19:54 +0000

Week 11 of my Google Summer of Code journey with CircuitVerse (August 3rd to August 9th) was all about one thing: testing the canonical pipeline against real circuits.

This week, Aboo suggested verifying canonical import/export against all the projects in CircuitVerse Editor's Picks.

🧪 Testing the Editor's Picks

I created a new editorPicks.spec.ts test file for this.

My first approach was to fetch each project's circuit_data through the CircuitVerse API while the test was running.

After discussing it with my mentors, we changed the approach. Depending on the network/API would make the tests slower and could make them fail for reasons completely unrelated to the canonical pipeline.

So instead, I downloaded the Editor's Picks circuit data and kept all 12 projects as local fixtures inside the test suite.

That made the tests repeatable and gave us a fixed set of real-world circuits to keep checking in the future.

🔄 The Round-Trip Test

The test flow was as follows:

1️⃣ Load the original legacy circuit_data using CircuitVerse's legacy loader.

2️⃣ Export the loaded project through canonicaliseProject().

3️⃣ Import that canonical JSON again through importCanonical().

4️⃣ Re-export the reconstructed project.

5️⃣ Compare the hashes and canonical project data.

Basically, if the canonical pipeline is really preserving the project, legacy → canonical → import → canonical should come back to the same result.

That was the theory at least 😅

🐛 And... A Lot of Projects Failed

Once I ran the tests across the Editor's Picks, many of the real circuits started failing the round trip.

This was actually useful because the tests immediately exposed things my original pipeline wasn't preserving properly:

🔌 Complete wire topology: dangling wires, standalone wires and some multi-port/fan-out nets could lose information.
📐 Routing and layout details: intermediate routing, port positions and some canvas/subcircuit visual data were incomplete.
🗂️ Project-level state: things like the project name, clock settings, focused circuit, tab order and annotations were not fully round-tripping.

My earlier tests were mostly hitting the happy path. The Editor's Picks were much bigger and messier, which is exactly why they were such a good test set.

🧠 Back to Research

I spent the rest of the week going through the failed projects one by one and trying to understand what information was being lost and where it should live in the canonical structure.

There were a few design decisions to think through, especially around representing complete wire/routing topology without making the canonical format unnecessarily complicated.

So I did not rush a PR this week.

🔮 What's Next

The tests did exactly what good tests are supposed to do — they broke my assumptions before users did. 😄

Hopefully next week I can start fixing these round-trip gaps and raise a PR with the Editor's Picks verification passing.

Looking forward to next week! 🚀

GSoC'26_Week10 : Stricter Types, PR Merged

Harkeerat Singh — Mon, 17 Aug 2026 11:17:23 +0000

Week 10 of my Google Summer of Code journey with CircuitVerse (July 27th to August 2nd) was all about getting back on track.

Last week was a little slow because I was travelling back to college and setting everything up again. As soon as this week started, I wanted to catch up and finally turn the type-safety discussion from Week 9 into actual code.

🛡️ Making the Pipeline More Type-Safe

I spent the start of the week researching how to make the types stricter.
The main refactor ended up being:

🧩 Moving the canonical data contracts into a dedicated canonical.types.ts file.
🔌 Replacing loose WireNode / CVScope style structures with the real simulator Node and Scope types wherever possible.
🧱 Defining proper shared types such as CanonicalProject, CanonicalScope, CanonicalComponent, CanonicalNet, CanonicalLayout and component property types.
🎯 Keeping the truly dynamic component lookup at one documented boundary instead of letting unknown and type assertions spread through the whole pipeline.
🏗️ Adding typed component-constructor handling so the importer can dynamically rebuild components without falling back to any.

The main idea was pretty simple: if the pipeline already knows the shape of something, TypeScript should know it too.

On July 29th, I raised PR #1173 with this refactor.

🤖 PR Review

Soon after opening the PR, CodeRabbit caught something much more interesting than a normal type issue.

The comparator inside canonicalSort was using interface order for some component pairs and structural fingerprints for others. That meant the comparison was not a proper total order and, in some cases, sorting could depend on the original array order.

For a normal application that might just look like a sorting bug. For a canonical format, that is dangerous because component IDs, net IDs and eventually the canonical hash all depend on deterministic ordering.

The fix was to make the rule consistent:

🧠 Compare the structural fingerprint first. Only when the fingerprints are equal, use the interface order as the tie-breaker.

I updated the comparator and also cleaned up a few unsafe non-null assumptions around wire-port and routing lookups.

CodeRabbit marked the issue as addressed after the follow-up commit. 🎉

After the review fixes, PR #1173 was merged later this week!

🔮 What's Next

Next week, I’ll start working on tests and see how the canonical pipeline holds up on more real circuits.

Back on track. Time to test! 🧪⚡

GSoC'26_Week9 : Rethinking Type Safety

Harkeerat Singh — Mon, 17 Aug 2026 10:54:23 +0000

Week 9 of my Google Summer of Code journey with CircuitVerse (July 20th to July 26th) was a quieter week, but an important one.

After the excitement of passing midterms, I spent most of this week thinking about something my mentor Aboo had raised: how type-safe is the canonical pipeline actually?

🧠 Aboo's Concern: Type Safety

The canonical pipeline was already written in TypeScript, but there were still places where I was relying on dynamic structures such as:

[key: string]: unknown

CircuitVerse components are a little tricky here because different components expose different ports and properties at runtime.

At first, using unknown felt like the safest way to represent all of that. But after discussing it with Aboo, I realised the better approach was to keep unknown only for values whose types genuinely can't be known beforehand — and document those cases clearly.

🛠️ Rethinking the Type Structure

I spent time tracing where the loose types were actually entering canonical.ts and importCanonical.ts.

The direction we discussed was to keep the pipeline strongly typed for everything we know, move shared canonical interfaces into a dedicated types folder, and isolate the genuinely dynamic simulator boundary instead of allowing unknown to spread everywhere.

The shared definitions would live under:

v1/src/simulator/src/types/

This keeps the canonical data model separate from the implementation and makes the types reusable by both export and import.

🎒 Back to College

The coding side was a little slower this week because I also had to travel back to college for the new semester. 🚆🎒

Between travelling, settling back in and getting everything ready, I could not put in the same number of hours as the previous weeks.

Still, this week gave me a clear direction for the refactor instead of rushing into another patch.

🔮 What's Next

Once I am properly settled back at college, the plan is to start implementing the stricter type structure and clean up the weak points inside the canonical pipeline.

I will get back to coding next week! ⚡💻

GSoC'26_Week8 : Midterms Passed!

Harkeerat Singh — Mon, 17 Aug 2026 10:50:40 +0000

Week 8 of my Google Summer of Code journey with CircuitVerse (July 13th to July 19th) was a pretty big one — Midterm Evaluations! 🥳

After seven weeks of building the canonical pipeline, this week was mostly about wrapping up the first half properly, getting my open PRs merged, and waiting for that one green check on the GSoC dashboard.

📝 Writing the Midterm Progress Report

I started the week by finishing my official Midterm Progress Blog for CircuitVerse. You can read it here.

Writing it made me realise how much the project had changed since the first proof of concept. What started as a small JavaScript experiment had now grown into a deterministic, type-safe export and import pipeline using things like 1-WL, Kahn's Algorithm and SHA-256 hashing.

It was genuinely satisfying to look back at everything in one place.

🛠️ Two More PRs Through Review

My main coding focus was getting the two Pull Requests from Week 7 through mentor review:

📦 PR #1131: The complete canonical JSON import pipeline with round-trip verification.
🖥️ PR #1132: Connecting the canonical export/import pipeline to the actual simulator UI.

The reviews caught a few important edge cases I had missed, including making sure exported project files stayed strictly in the .cv format and cleaning up the remaining legacy save/import behaviour in V1.

I addressed the review comments, pushed the fixes, and by the end of the week both PR #1131 and PR #1132 were merged! 🎉

🥳 MIDTERMS... PASSED!

Then came the part I had been waiting for all week.

On Friday night at around 11:30 PM, I opened the GSoC contributor dashboard and finally saw it:

PASSED! 🚀

I just stared at it for a while. The first half had been full of graph algorithms, TypeScript refactors, review comments, bugs, demos and a lot of late-night debugging, so seeing that green result felt amazing.

Passing the midterm also meant receiving my first developer stipend, which made the milestone even more special for me.

🔮 Looking Ahead to Phase 2

I spent the weekend resting and celebrating a little with family and friends.

The core canonical export/import pipeline is now in a much stronger place, so the second half can move toward the remaining work:

📜 JSON Schema validation

🧪 Writing tests

🔄 Auto Layout Feature

The first half of GSoC has genuinely taught me a lot.

Midterms done. Time for Phase 2! 🚀🔥

GSoC'26_Week7 : The Full Pipeline Comes Alive

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'26_Week6 : First PR Finally Merged

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'26_Week5 : Back on Track with Import

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'26_Week4 : A Slow Week, Big Progress

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_Week3 : Subcircuits, Sorting & Demo Day

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_Week2 : Scaling to Multi-Circuit Support

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_Week1 : Canonicalization, Community & a Win

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! 🚀🔥

DEV Community: Harkeerat Singh

GSoC'26_Week12 : T-Shirt, Tests & Auto Layout

👕 The Most Awaited Package!

🧪 Finally Fixing the Round-Trip Gaps

🔄 Starting the Auto Layout Feature

🔮 What's Next

GSoC'26_Week11 : Real Circuits Broke My Assumptions

🧪 Testing the Editor's Picks

🔄 The Round-Trip Test

🐛 And... A Lot of Projects Failed

🧠 Back to Research

🔮 What's Next

GSoC'26_Week10 : Stricter Types, PR Merged

🛡️ Making the Pipeline More Type-Safe

🤖 PR Review

🔮 What's Next

GSoC'26_Week9 : Rethinking Type Safety

🧠 Aboo's Concern: Type Safety

🛠️ Rethinking the Type Structure

🎒 Back to College

🔮 What's Next

GSoC'26_Week8 : Midterms Passed!

📝 Writing the Midterm Progress Report

🛠️ Two More PRs Through Review

🥳 MIDTERMS... PASSED!

🔮 Looking Ahead to Phase 2

GSoC'26_Week7 : The Full Pipeline Comes Alive

🔌 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'26_Week6 : First PR Finally Merged

🧠 The Power of Elite Code Review

🥞 CircuitVerse GSoC contributors' meeting

⏳ Timeline Extensions & Midterms

🥳 FINALLY... IT MERGED!

🔮 Looking Ahead to Week 7

GSoC'26_Week5 : Back on Track with Import

🔄 Reconnecting with the Community

🛠️ importCanonical.ts is Completed!

🚀 The PR Status

🔮 Final Reflections & Looking Ahead to Week 6

GSoC'26_Week4 : A Slow Week, Big Progress

🎉 The Blockade is Cleared

GSoC'26_Week3 : Subcircuits, Sorting & Demo Day

🏗️ Mastering Subcircuits with Topological Sorting

📺 Demo Day

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

GSoC'26_Week2 : Scaling to Multi-Circuit Support

🏗️ Scaling to Multi-Circuit Support

⏳** Navigating a Minor Pull Request Blocker**

🤝 GSoC Student Meeting

🏀 Off-Duty: NBA Finals!

🔮 Final Reflections & Looking Ahead

GSoC'26_Week1 : Canonicalization, Community & a Win

🛠️ Getting Started on the Project

🧬 Building the Canonicalization Pipeline

🏆 CircuitVerse Repository Cleanup Contest

🤝 GSoC Contributors Meetup

🔮 Reflections & What's Next

⏳ Navigating a Minor Pull Request Blocker