DEV Community: Nihal Rajpal

GSoC 2025 - Week 8: Designing Serial Port Component and Real Hardware Demo

Nihal Rajpal — Sat, 02 Aug 2025 07:32:57 +0000

Week 8 began with our second meeting with Prof. Gargi Khanna, joined by my mentor Aman Asrani. We showcased the improvements made to previously added components based on feedback from the first meeting. We then brainstormed the design of the Serial Port component, and were joined by Vivek Rao, who provided insightful inputs that greatly enriched the discussion.

Serial Port Component Design

During the discussion, we explored how a Serial Port component could enable educational simulations involving real hardware. The conversation highlighted several practical use cases and helped refine the expectations for the component's interface and user experience.

One of the most informative parts of the session was the detailed discussion around the bit width property of the components give in circuit simulators.

🔧 Planning the Demo

Following these discussions, I focused on preparing a comprehensive demonstration of the Serial Port component, which had been developed in the previous weeks.

Initially, I considered two separate examples:

One for receiving input from actual hardware.
Another for sending output to hardware.

However, we finalized the idea of a single integrated demo that covers both input and output as it would be much more practical & intuitive.

🛠️ Final Demo Setup

The finalized setup includes:

Arduino Uno
LDR (Light Dependent Resistor)
Relay Module
Bulb
(Most importantly) CircuitVerse with Serial Port Component

Workflow:

Arduino reads analog data from LDR (connected to A0).
This data is sent to CircuitVerse via the Web Serial API.
Based on the reading, CircuitVerse sends a control bit (0 or 1) back to the Arduino — it sends 1 if the LDR reading is less than a threshold value (indicating low light).
Arduino uses this bit to toggle Digital Pin 7 high or low.
Digital Pin 7 controls the relay, which switches the bulb on/off.

This setup effectively demonstrates bi-directional communication (Tx & Rx) using the Serial Port component — making it a powerful example of real hardware-software integration in CircuitVerse.

🧩 Circuit Diagram

🎥 Demo Video: Serial Port in Action

✅ Other Progress

At the end of the week, I also raised a Pull Request for the documentation of the Bit Extender component, which was developed and finalized in the previous week.

Looking Ahead

In the coming week, I plan to write the documentation for the Serial Port component and begin designing the next component: a FIFO Queue, which will enhance data handling capabilities within the simulator.

Thanks for reading.

GSoC 2025 - Week 7: Setting Up Hugo, Submitting PRs, and Documentation Work

Nihal Rajpal — Tue, 29 Jul 2025 17:11:01 +0000

This week focused primarily on non-development tasks that are essential for project visibility and continuity. One of the key responsibilities was to draft and submit the GSoC Phase 1 blog for the official CircuitVerse blog site.

Setting Up Hugo

CircuitVerse uses Hugo, a fast static site generator, to build its blog website. Since this was my first time working with Hugo, I began by reading the official documentation and installing it on my local Windows machine using winget install Hugo.Hugo.Extended.

However, when attempting to serve the blog locally using hugo server -D, I encountered a breaking error:

ERROR deprecated: site config key paginate was deprecated in Hugo v0.128.0 and subsequently removed.
...
ERROR: can't evaluate field DisqusShortname in type page.Site

I double-checked the Hugo installation steps, ensured that I was using the extended version, and even tried installing older versions and prebuilt binaries — all without success.

I also tried installing additional dependencies like Go and Dart Sass, suspecting they might be missing prerequisites. Unfortunately, the error persisted.

Eventually, I decided to switch environments and set everything up using Ubuntu WSL. After forking the blog repository, installing Hugo on Linux, and running hugo server -D, the site finally compiled and served successfully. This experience reaffirmed how certain development tools and configurations often work more reliably in Unix-based environments.

PR Submission: Bit Extender Component

Alongside the blog task, I submitted the raised pull request for Bit Extender component which was built during Week 6 and includes support for configurable bit-width extensions using multiple strategies like zero, sign, one, and input-based extension.

PR Link: Bit Extender Component

Documentation: Bit Extender

Finally, I wrapped up the week by writing the official documentation for the Bit Extender. Following the standard structure of CircuitVerse docs (Description, Ports, Example, and Embedded Circuit), the documentation explains the component’s usage, properties, and scenarios where it is typically useful.

Summary

Week 7 was focused on documenting and polishing the work completed during Phase 1. With the blog post prepared, Bit Extender submitted, and its documentation written, the project is on track to successfully achieve its goal.

Thanks for reading.

GSoC 2025 - Week 6: Completing Serial Port Integration and Introducing Bit Extender

Nihal Rajpal — Mon, 28 Jul 2025 18:41:03 +0000

The week began with a productive meeting with my mentor Aman Asrani and Prof. Gargi Khanna, who joined us to review the progress. We showcased the previously added components — Shift Register, Comparator, and Pull Resistor — and received valuable feedback from her, particularly around usability. Her insights were encouraging and helped validate the component design choices, ensuring they align well with educational objectives.

With the tauri-plugin-serialplugin already integrated into the Tauri-based desktop app, this week focused on designing a Serial Port component that works seamlessly across both web and desktop environments.

We designed and implemented the Serial Port component such that it works uniformly across both web and desktop platforms. Internally, it checks the runtime environment (browser or Tauri) and invokes the appropriate serial communication APIs accordingly. This component allows users to send and receive data from devices such as Arduino boards in real time, acting as a bridge between digital circuits in the simulator and real-world hardware.

With this, hardware interaction via serial ports is now fully supported and tested across both platforms — a key milestone for the project.

Bit Extender Component

In addition to the Serial Port interface, we introduced a new core component this week: the Bit Extender.

The Bit Extender is a combinational digital circuit component that extends an input binary value to a specified larger bit width. It supports multiple extension strategies:

Zero-extension
Sign-extension
One-extension
Custom input-based extension

This component is especially useful in arithmetic and logical designs that require uniform bit widths. A user-friendly interface is provided via the PROPERTIES panel, where users can configure the extension method, bit widths, and direction of extension.

Looking Ahead

In the coming week, we plan to:

Finalize and test the Serial Port component with various Arduino circuits.
Begin writing documentation for the Serial Port and Bit Extender components.
Continue internal testing and prepare for raising PRs.
Perform UI polish and address remaining review comments.

Thanks for reading.

GSoC 2025 – Week 5: Hardware Integration on Tauri Begins!🔌

Nihal Rajpal — Thu, 10 Jul 2025 17:41:58 +0000

This week was all about pushing through a major challenge: bringing hardware integration to the CircuitVerse desktop app built using Tauri. With the web version already working thanks to the Web Serial API, it was time to get the same functionality working on the desktop — and that came with a whole new set of problems to solve.

The week started with a productive meeting with Harsh Rao and my mentor, Aman Asrani, to discuss hardware integration for the desktop app.
Harsh gave us a thorough overview of how Tauri works. I learned that the desktop app internally uses a WebView to load the simulator’s website.

This became the core issue because Web Serial APIs aren't supported inside a WebView, which meant our current browser-based solution wouldn’t work on the desktop app.

🔍 Searching for a Workaround

To solve this, the first thing I needed was a way to differentiate between a browser and Tauri environment in the code. Harsh told us about the isTauri hook, which made this detection easy.

He also explained that Tauri provides plugins for native functionalities (like file downloads using the fs plugin), and that serial communication would need a plugin too.

So I began researching the Tauri ecosystem and came across a very informative article: Serial Communication with Tauri Plugin (v1)

This gave me a clear understanding of how serial plugins work within Tauri. However, the plugin described in the article only supported Tauri v1, and our project uses Tauri v2, so I had to keep searching.

🎉 Finally, a Working Plugin for Tauri v2

After some digging, I found a plugin that supports Tauri v2:
tauri-plugin-serialplugin on crates.io

This plugin was exactly what I needed!

I read through its documentation, understood the setup and usage, integrated it into the Tauri project, and tested everything — and yes, it works perfectly until now! 🚀

🔁 Other Progress

Alongside the Tauri integration work, I also:
Resolved review comments on my previous PRs as suggested by Aman
Cleaned up and improved the code for already added components
Began preparing for the upcoming PR that will integrate the working serial port support into the desktop app

This week ended on a really positive note. We finally figured out a way to enable serial communication in the desktop version of CircuitVerse. The support and collaboration from Aman and Harsh were key to unblocking this task.

Collaboration really does lead to success — and this week proved that once again.

Next week, I’ll be working on polishing the Tauri integration further and raising a proper PR for the same after thorough testing.

GSoC 2025 - Week 4: Jumping into Hardware Integration

Nihal Rajpal — Mon, 30 Jun 2025 18:29:13 +0000

I began this week with one thought in mind:

Let’s finally fix this versioning issue!

During our weekly community call, I shared my blocker again. That’s when our awesome org admin Aboobacker came up with a brilliant solution:

🔁 Create a new branch from master (e.g., gsoc2025-open-hardware-library) and merge all your PRs there for now.
Once the simulator is fully synced with v1, we can merge that branch into master.

This was the perfect way to keep things moving forward without being stuck on versioning.

So, I took a fresh clone of the project, created the branch locally, added all my components, and tested everything thoroughly.

And then... something unexpected happened. Guess what?

ERROR: Permission to CircuitVerse/cv-frontend-vue.git denied to Nihal4777.
fatal: unable to access 'https://github.com/CircuitVerse/cv-frontend-vue/': The requested URL returned error: 403
Please make sure you have the correct access rights
and the repository exists.

I didn’t have the rights to create a new branch on the upstream repo 😅

But no worries — I reached out to my mentor Aman Asrani and requested him to create the branch for me. Once it's there, I’ll fork it and raise all the PRs to that new branch.

⚙️ Meanwhile: Starting Hardware Integration with Web Serial API

While waiting for the branch setup, I started working on this week’s task — hardware integration using the Web Serial API.

I began with some research to explore all the possible approaches.

I quickly got it working on our web-based simulator since I had already built a Proof of Concept (PoC) for it earlier.

Now comes the real challenge — integrating it into the desktop app built with Tauri. I explored multiple options and possible ways to make it work.

Next week, I’ll be diving into that and aim to complete the desktop integration too. Let’s see how it goes!

GSoC 2025 - Week 3: Feedback, Finalization & Documentation

Nihal Rajpal — Sun, 22 Jun 2025 12:29:52 +0000

This week began with a productive meeting with my mentor Aman, where I showcased the components I’ve implemented so far — the Shift Register, Comparator, and Pull Resistor.

We also discussed the versioning issue I’ve been facing. This has been a blocker for me since I haven't been able to raise a PR for my work because of it.

To make good use of time while the issue is being resolved, we decided to focus on writing documentation for the components I’ve already completed.

I first looked at how documentation is written for the existing components. Most of them follow a standard structure:

- A description of the component
- A list of its ports
- An example
- An embedded circuit showing how it works

At first, I thought writing the docs would be easy. But I soon realized —

simple isn’t always easy.

The problem? I couldn’t embed my circuit examples in the documentation because the components haven’t been merged yet due to the versioning issue.

For now, I’ve created the example circuits on my local machine. Once the components are merged, I’ll update the links in the docs to include the live embedded circuits.

Hoping the versioning issue will be solved in the upcoming week so that tasks dependent on each other can finally be marked as completed.

GSoC 2025 – Week 2: Comparator and Pull Resistor Implementation

Nihal Rajpal — Sun, 15 Jun 2025 09:56:53 +0000

This week (June 9–15), I continued with component development for CircuitVerse by focusing on adding two new hardware-oriented elements: the Comparator and the Pull Resistor.

Comparator Component

I began the week by implementing a Comparator component, which takes two inputs (A and B) and provides three outputs:

greater (when A > B),
equal (when A == B), and
less (when A < B).

Internally, the resolve() method handles this comparison logic, and results are forwarded to the simulation queue. I also used the fillText4 method to draw appropriate comparison symbols on the canvas for clarity.

After implementation, I tested the component thoroughly to ensure correctness across bit-widths and edge cases.

Unfortunately, I was unwell for a day after finishing the Comparator, which slightly affected the pace of progress. However, I was able to resume soon after and complete the remaining work.

Pull Resistor Component

Following that, I designed and implemented a Pull Resistor component. This component forces a floating input to either logic high (Pull-Up) or logic low (Pull-Down) based on the selected configuration. To make this configurable, I introduced a pullDirection property and allowed users to switch it via a dropdown.

Initially, CircuitVerse did not support dropdown input type in mutableProperties, so I extended the simulator UI to support dropdowns. This involved modifying the Vue template that renders object properties, enabling reusable dropdown support for future components as well.

To simulate pull resistors accurately, I relied on the simulator’s use of undefined to represent floating (undriven) nodes. The Pull Resistor component monitors its connected input and asserts a logic level — either high (1) or low (0) — only when the input is floating. This design ensures that the resistor doesn’t interfere with actively driven signals, come into play only when no other signal is present on the line.

Looking ahead to Week 3 with more implementation and refinements in mind.

GSoC 2025 – Week 1: Shift Happens🔄

Nihal Rajpal — Sun, 08 Jun 2025 16:13:29 +0000

This week (June 2–8) marked a big shift — not just in terms of clock signals and data bits (hello shift registers!), but also a personal shift from the Community Bonding Period to the real deal: the Coding Phase of GSoC.

The coding period kicked off and I dove straight into implementing shift registers — SISO, SIPO, PISO, PIPO. Classic stuff. The first question was: do I create separate components for each? Or just one smart, configurable one?

Took a inspiration from Logisim, discussed with mentor and went with the second one. Just one “Shifter” component with properties like parallelLoad: yes/no. Cleaner UI, less clutter, and feels more user-friendly.

Then came the design phase. I built the component UI using the Canvas API. Control signals (Reset, Clock, Shift/Load) go on the top, and inputs/outputs on the bottom. As you increase the number of stages, the bottom part grows — dynamic and neat.

Initially had it in vertical layout, but then switched to horizontal because it just makes more sense when visualizing right shifts.

With the UI structure done, I started implementing the core logic in the resolve() method. This method detects rising clock edges and handles:

Resetting the register
Parallel loading the input data
Shifting values serially to the right

Everything seemed fine — until it came....

🐛 The Unexpected Issue

Strangely, I noticed that the resolve() method wasn’t being called at all during simulation. I checked the logic, rewrote parts of it, even added logs — nothing. Eventually, I rolled back and tried running the same code outside the versioned folder (v0), and it worked perfectly.

That gave me a strong hint: the issue was somehow tied to the versioning structure. I’m still not sure why this happens, so I decided to take it up with my mentor Aman Asrani. Meanwhile, to keep the flow going, I completed the implementation without using the versioned folder.

Towards the end of the week, I tested edge cases, tweaked a few last-minute design elements (like defaulting to horizontal layout), and handed over the logic for review. I’m now waiting on the versioning issue to be resolved, after which I’ll raise a proper PR for this new component.

Looking forward to Week 2 — and hopefully resolving the versioning quirk! 🚀

GSoC 2025 – Community Bonding with CircuitVerse

Nihal Rajpal — Mon, 02 Jun 2025 17:22:41 +0000

Hi everyone! 👋
I’m Nihal Rajpal, and I’m honored to be a GSoC 2025 contributor with CircuitVerse. The past few weeks (May 8 – June 1) have been a wonderful beginning to this exciting journey during the Community Bonding Period.

On May 11, we had our first Community Bonding Meeting with the entire CircuitVerse team — mentors, project admins, and fellow contributors. Everyone introduced themselves, and we had a warm, open conversation to kick things off. It was a good kickoff — I felt welcomed, part of something meaningful.

Then came the GSoC Contributor Welcome Session on May 14, hosted by Google with Stephanie Taylor and Mary Radomile.

They shared advice, best practices, and answered a ton of questions. It gave me a bigger picture of what GSoC is — more than just code, it’s about community and growth.

Shortly after, I registered for the GSoC Alumni Discord. Still waiting to be added in 😅, but really looking forward to connecting with past contributors once that happens. I think there’s a lot to learn from those who’ve already walked this path.

On May 25, We had a casual catch-up call with fellow contributors and the CircuitVerse team.☕
It was refreshing to talk not just about code but also about how everyone was doing outside of GSoC — life, internships, exams, and hobbies. This made the whole experience feel even more human and supportive.

Around the same time, My mentor Aman Asrani (who, by the way, has been incredibly supportive and approachable) and I started listing out the pending components for the project. We shared the list with Prof. Gargi Khanna for review and also asked for input from the community. It felt good to collaborate like that — getting different perspectives helped shape the roadmap.

We decided to prioritize Shift Registers, Comparators, and Pull-down Resistors — these are essential, frequently used components and a great place to start.

On June 1, we had a sync-up to check on progress and discuss any issues before the coding phase begins.

With the bonding period officially wrapped up, I can honestly say I feel ready. I understand the project and workflow much better, I know who to reach out to when needed, and I feel genuinely connected to the community.

Now begins the real work — the coding phase! I’ll be working on the first set of components and sharing regular updates.

Stay tuned — more updates coming soon :)