Turning a natural-language hardware request into verified RTL — and keeping what's measured separate from what's guessed

At the Inference-Time Compute Hackathon, my teammates and I built Fairchild, a tuned chip-design model paired with an evaluation-native IDE. You type a natural-language hardware request, and the system turns it into a structured spec, extracts the compute kernels, proposes hardware candidates, estimates how the workload runs on each, generates real RTL for the winner, verifies that RTL with Verilator, and writes an evidence-backed report. You can read more on the Devpost.

The Problem

Generic LLMs are bad at hardware design. They produce confidently incorrect RTL that is hard to validate, blurring the line between numbers the model guessed and numbers a tool actually measured. Fairchild's core idea is to keep those two things visually and verbally separate everywhere: every estimated performance number is tagged [ESTIMATE], and every tool-verified result is tagged [MEASURED].

How It Works

The system is two layers:

• The model: Qwen2.5-Coder-7B-Instruct, fine-tuned with QLoRA for Verilog generation and tool-error repair, measured on a held-out benchmark as base vs. tuned vs. tuned+repair.
• The IDE: a Streamlit app that drives a staged pipeline and shows the tuned model working inside a verification-driven loop. The model proposes, the tools evaluate, and the IDE explains.

The pipeline runs as a sequence of grounded stages: a natural-language prompt is compiled into a structured spec, the spec's compute kernels are extracted, hardware candidates are generated and ranked under the stated constraints, RTL is generated for the winning candidate, and Verilator lints that RTL to produce a measured result rather than an estimated one.

What I Worked On

My focus was the model training side — the QLoRA fine-tuning of Qwen2.5-Coder for Verilog generation and RTL repair, and the benchmark that proves the tuned model actually beats the base model. This was built together with Eva Zhu, Yeabsira Teshome, and Arpit Khandelwal.

Results

Post-training clearly helped. On the held-out SFT validation split, the tuned LoRA adapter roughly halved the eval loss (0.490 → 0.245), dropped perplexity from 1.63 to 1.28, and improved next-token accuracy by ~4 percentage points (88.6% → 92.7%) — all from a single ~4-hour run on one H100.

What matters more than LM loss, though, is whether the generated RTL actually compiles and passes testbenches. On a held-out set of 155 VerilogEval spec-to-RTL tasks scored with Icarus/Verilator, the tuned model (v5) beat the base model across the board — compile pass rate 0.81 → 0.89, functional test pass 0.35 → 0.38, and pass@3 0.46 → 0.50.

Grounding in the Literature

The design draws on two papers: ChipNeMo shows generic LLMs are weak at chip design and that domain adaptation plus grounded evaluation is what moves the needle, and NL2GDS argues natural-language-to-chip should be a staged flow with tool feedback and iterative repair. Fairchild is our attempt to put both lessons into a single working product.

Check out the project: github.com/rishabhranawat/chips. You can also browse the full hackathon slide deck.

A Chrome extension that turns passive scrolling into active learning

I built XQuiz, a Chrome extension that generates AI-powered quiz questions based on the content you scroll past on Twitter/X. The idea is to enhance focus and information retention while browsing.

Scroll the gallery above horizontally to see more screenshots.

The Problem

We scroll through enormous amounts of information on social media, but how much do we actually retain? Most content passes through our attention without sticking. What if we could turn that passive consumption into active learning?

How It Works

1. Content Tracking: The extension monitors tweets as you scroll through your feed
2. AI Question Generation: Using Google's Gemini API, it generates quiz questions (multiple choice, true/false, fill-in-the-blank) based on what you've seen
3. Assessment: Periodic quizzes test your retention of the content
4. Analytics: Track your scores, accuracy, and answer streaks over time

Features

• Customizable frequency: Adjust how often quizzes appear
• Attention timer: Set thresholds for when content counts as "viewed"
• Video-hiding mode: Optional feature to reduce distractions
• Quiz history: Review past questions and your performance

Technical Stack

• Chrome Extension (Manifest V3)
• Service worker backend for background processing
• Content script for page monitoring
• Side panel UI for quiz interface
• Google Gemini API for question generation

Development Note

This project was built entirely with AI agents as a coding companion, exploring how far AI-assisted development can go for a complete, functional product.

Check out the project: github.com/rishabhranawat/xquiz

Automatically learning which training data points are valuable

I recently open-sourced an implementation of DataRater, a meta-learning framework for automated dataset curation based on the paper accepted at NeurIPS 2025.

The Problem

Foundation model quality depends heavily on training data quality. Current approaches to dataset curation rely on:

• Manual tuning of coarse-grained mixtures of large data buckets
• Filtering by hand-crafted heuristics

These methods lack sophistication and don't scale well. What if we could learn which data points are valuable automatically?

The DataRater Approach

DataRater uses meta-learning to estimate the value of individual data points. The key insight is to use meta-gradients: optimizing data selection to improve performance on held-out validation data.

The framework consists of three main components:

1. Inner Models: Task-specific neural networks that train on data weighted by DataRater scores
2. DataRater Model: A meta-learner that assigns quality scores to individual training samples
3. Meta-Training Loop: An iterative process alternating between inner model training and DataRater optimization

How It Works

During each meta-training iteration:

1. DataRater assigns scores to training samples
2. Scores are converted to sample weights using softmax normalization
3. Inner models train on the reweighted data
4. DataRater is optimized based on inner model performance on validation data

The population management strategy maintains multiple inner models that are periodically refreshed, providing diverse gradients for DataRater optimization.

Results

Evaluating on corrupted MNIST data, filtering out the lowest 10% of samples based on DataRater scores achieved ~97.32% test accuracy versus 97.08% for baseline training. The system learns to identify and downweight corrupted or mislabeled samples without explicit supervision.

The plot above shows how DataRater's scores relate to the fraction of corrupted pixels in each MNIST image as meta-training progresses. Early on (step 1) the relationship is essentially uninformative, but over successive meta-iterations DataRater learns a clear negative correlation: more heavily corrupted images receive progressively lower scores. In other words, the meta-learner discovers how to weight examples in inverse proportion to their corruption, without ever being told which samples were corrupted.

Key Benefits

• Fine-grained curation: Works at the individual data point level, not coarse buckets
• Improved compute efficiency: Train on higher-quality subsets of data
• Automated and scalable: No manual heuristic design required

Try It Out

The implementation is available at github.com/rishabhranawat/DataRater. Quick start:

pip install -r requirements.txt
sh runbin/mnist_v1.sh

The codebase is designed to be extensible - you can register custom datasets and models through factory functions.