DEV Community: Harsh Singh

I built an open source alternative to Perplexity Comet

Harsh Singh — Tue, 22 Jul 2025 09:23:42 +0000

It feels like every week there's a new AI-powered browser launching, promising to revolutionize how we browse the web. But honestly, Chrome is already perfect for many of us. Instead of switching to a new browser, I wanted to enhance my existing experience with AI features. That's why I built my own open-source, local alternative to tools like Perplexity Comet.

Chrome is already perfect

Chrome offers a great user experience, and I didn't want to switch browsers just for a few AI features. That's why I created a Chrome extension that adds the functionality I was looking for directly into my existing browser.

Just usesuperpowers.app - a Chrome extension which adds AI Browsing features similar to Dia and Comet in Chrome itself.

My solution is Superpowers AI, a Chrome extension that seamlessly integrates AI browsing features. It brings the power of tools like Perplexity Comet and others directly into Chrome.

Completely open-source and local

One of the most important aspects of this project is that it's completely open-source. You can view the code, contribute to its development, and customize it to your specific needs.

Furthermore, it runs locally, meaning your data stays on your machine.

Open to contributions

I'm excited to share this project with the community and welcome any contributions. Whether you're a developer, designer, or simply an AI enthusiast, your help is greatly appreciated!

Top 5 v0 Alternatives for AI-Powered UI Component Building

Harsh Singh — Fri, 27 Jun 2025 14:28:22 +0000

The rise of AI-driven development tools has transformed how developers create user interfaces, making it faster and more accessible to build polished, production-ready UI components. Vercel's v0 has gained significant traction for its ability to generate React components from text prompts, leveraging AI to streamline front-end development. However, v0 is not the only player in this space. If you are exploring alternatives that offer unique features, better customization, or different workflows, this article highlights five compelling options, including Supafine, a promising AI-powered UI component builder for React. Let's dive into the top alternatives to v0 and what makes them stand out.

1. Supafine

Supafine is an AI-powered UI component builder tailored for React developers, designed to generate clean, customizable, and production-ready components. Unlike some competitors, Supafine emphasizes seamless integration with modern React workflows, leveraging Tailwind CSS for styling. Its intuitive interface allows developers to describe UI requirements in natural language, and the AI generates React components that align with best practices, such as component-based architecture and accessibility.

Key Features:

React-First Approach: Generates components optimized for React ecosystems, including Next.js.
Customizable Outputs: Offers flexibility to tweak generated code, ensuring it fits your project's design system.
Integration with Modern Tools: Supports Tailwind CSS, Remix Icons, Recharts and other popular npm packages for rapid development.
Developer-Friendly: Reduces the need for manual code reviews by producing reliable, error-free components.

Why Choose Supafine?

Supafine stands out for its focus on React developers who want AI-generated components that feel handcrafted. Its ability to understand complex requirements and produce components makes it a strong contender for teams building scalable applications. Give it a try at create.supafine.app and get 30 free credits every day.

2. Dyad

Dyad is an open-source, local-first alternative to v0, designed for developers who prioritize control and privacy. It allows users to generate UI components and entire web applications using AI, with a focus on offline capabilities. Dyad supports multiple frameworks, including React, and is ideal for developers who want to experiment with AI-driven development without relying on cloud-based services.

Key Features:

Open-Source: Free to use and customizable, with a transparent codebase.
Offline Support: Runs locally, ensuring data privacy and no dependency on internet connectivity.
Multi-Framework Compatibility: Supports React, Vue, and other frameworks.
Community-Driven: Benefits from contributions by developers worldwide.

Why Choose Dyad?

Dyad is perfect for developers who value open-source principles and want a lightweight, customizable tool for generating UI components. Its offline capabilities make it unique, though it may lack the polish of cloud-based solutions like v0.

3. Bolt

Bolt is another AI-driven tool that focuses on generating full-stack applications, including UI components, from high-level prompts. While it supports React, Bolt's strength lies in its ability to scaffold entire projects, making it a good fit for developers building MVPs or prototypes. It integrates with popular package managers like npm and supports modern frameworks like Next.js.

Key Features:

Full-Stack Generation: Creates both front-end and back-end code, reducing setup time.
Rapid Prototyping: Ideal for quickly iterating on app ideas.
Extensible Outputs: Allows developers to modify generated code to suit specific needs.
AI-Powered Planning: Analyzes requirements to propose project structures.

Why Choose Bolt?

Bolt is a great choice for developers who need more than just UI components and want a tool that can jumpstart an entire project. However, its broader scope may feel overwhelming for those focused solely on UI development.

4. Fine

Fine takes a unique approach by positioning its AI agents as "software developers that never sleep". It excels at understanding business requirements and generating production-ready React components, complete with testing and documentation. Fine's AI can analyze existing codebases to ensure consistency, making it a strong choice for enterprise teams or developers working on large-scale projects.

Key Features:

Codebase Analysis: Adapts to your project's coding style and standards.
End-to-End Development: Generates, tests, and deploys components with minimal human intervention.
Technical Product Manager Mindset: Encourages clear, detailed prompts for better results.
High Efficiency: Handles tedious tasks like boilerplate code and testing.

Why Choose Fine?

Fine is ideal for teams that need AI to act as a virtual developer, handling repetitive tasks while maintaining high code quality. Its learning curve may be steeper due to the need for precise prompts, but the payoff is robust, production-ready components.

5. Same.new

Same.new is an AI-powered platform focused on generating modern, responsive UI components for React and other frameworks. It emphasizes delivering clean, modular code that integrates seamlessly with existing projects. With a focus on developer experience, Same.New allows users to input design preferences or text prompts, producing components optimized for performance and scalability.

Key Features:

Clean Code Generation: Produces modular, well-documented React components.
Multi-Framework Support: Works with React, Vue, and more.
Performance Optimization: Ensures components are lightweight and efficient.
Customizable Templates: Offers pre-built templates for common UI patterns.

Why Choose Same.new?

Same.new is ideal for developers seeking a balance between rapid component generation and high-quality, production-ready code. Its focus on performance and modularity makes it a great fit for scalable applications, though it may lack some of the design-to-code features of other tools.

Conclusion

While v0 has set a high bar for AI-powered UI component generation, alternatives like Supafine, Dyad, Bolt, Fine, and Morph offer unique strengths that cater to different developer needs. Supafine shines for React developers seeking seamless integration and customization, while Dyad appeals to those who value open-source and offline capabilities. Bolt is perfect for full-stack prototyping. Depending on your project requirements, one of these tools could be the perfect fit to enhance your UI development workflow.

Explore these alternatives, starting with Supafine on Product Hunt, and find the tool that best aligns with your development goals. Happy coding!

A Minimalist Python Version Manager

Harsh Singh — Wed, 02 Oct 2024 07:17:01 +0000

Python Support in Shuru: Version 0.0.9

Shuru just got an upgrade—Python version management is now live! If you’ve been using Shuru for your Node.js tasks, you'll be glad to know you can now manage your Python versions with the same ease.

What’s New?

With this latest release (v0.0.9), Shuru can download, build, and install Python from source, all by simply configuring your shuru.toml. No need for extra tools like pyenv anymore. Just define the Python version you need, and Shuru takes care of the rest.

Here’s how it looks in your shuru.toml:

[versions]
python = "3.10.2"

[[task]]
name = "setup"
command = "pip install -r requirements.txt"

[[task]]
name = "run"
command = "python app.py"
default = true

Under the Hood

When you specify a Python version, Shuru will:

Download the Source: It grabs the specified version from the official Python website.
Compile It: This isn’t just a simple download and go. Shuru compiles Python from source, allowing for greater customization if you need it.
Install: Finally, it installs Python in your designated environment.

If you want to see the build process in real-time, set the SHURU_BUILD_PYTHON_VERBOSE environment variable:

export SHURU_BUILD_PYTHON_VERBOSE=1

With this variable enabled, you’ll get detailed output during the build, making it easier to troubleshoot if anything goes wrong.

What About Node.js?

Python isn’t the only language Shuru supports. It still manages your Node.js versions in the same way, so you can seamlessly switch between environments for different projects. Shuru makes it easy to configure both in a single file, ensuring you’re always running the correct versions for your applications.

Final Thoughts

This addition makes Shuru a more versatile tool for developers who work in both JavaScript and Python. Managing your development environment should be straightforward, and Shuru aims to simplify that process.

Check out the latest version on GitHub and start integrating Python management into your workflow. Happy coding!

Shuru: A Simple Task Runner with Built-in Node Version Management

Harsh Singh — Sat, 28 Sep 2024 19:11:26 +0000

Alright, you’ve got projects to run, Node versions to switch between, and tasks to automate. You don’t want a bloated tool or to keep bouncing between nvm and npm scripts. Shuru is here to simplify all that: a task runner with a built-in node version manager. It’s lightweight, written in Rust, and gets out of your way while making sure your tasks run smoothly.

What’s Shuru?

Shuru does two things:

Manages Node.js versions per project.
Runs project-specific tasks defined in a simple config file.

That’s it. No fancy features you’ll never use. It’s focused on making your workflow simpler by handling the stuff that’s usually a pain when switching projects — like making sure you're on the right version of Node and running the same commands every time.

How to Install

Linux/macOS

Installation is super easy:

curl -s https://raw.githubusercontent.com/harshdoesdev/shuru/main/install.sh | sh

Windows

Head over to the Shuru GitHub releases page.
Download the Windows executable.
Add it to your system's PATH for easy access.

That’s it. You’re set up.

Using Shuru

You define your tasks and node version in a shuru.toml file at the root of your project. Here’s a basic example:

[versions]
node = "v16.14.0"

[[task]]
name = "setup"
command = "npm install"

[[task]]
name = "dev"
command = "npm run dev"

[[task]]
name = "build"
command = "npm run build"

Shuru will make sure you’re using the specified Node.js version (v16.14.0 in this case) and run the tasks like npm install or npm run dev with a single command.

Running Tasks

Once your shuru.toml file is ready, you can run any task with:

shuru <task_name>

For example:

shuru setup

Shuru will switch to the correct Node.js version (if necessary) and run the command npm install. Want to check the Node version your project is using? Just add this to your shuru.toml:

[[task]]
name = "version"
command = "node --version"

Now, run:

shuru version

Shuru will switch to the right version of Node and give you the info in one go.

Real-World Example

Let’s say you’ve got a project that needs Node.js v18.5.0. You want to install dependencies, run tests, build the project, and start the dev server. Here’s what your shuru.toml might look like:

[versions]
node = "v18.5.0"

[[task]]
name = "setup"
command = "npm install"

[[task]]
name = "test"
command = "npm run test"

[[task]]
name = "build"
command = "npm run build"

[[task]]
name = "start"
command = "npm start"
default = true

Now, instead of manually running these commands or worrying about Node versions, you can just do:

shuru setup    # Installs dependencies
shuru test     # Runs tests
shuru build    # Builds the project
shuru          # Defaults to starting the server

Shuru ensures the right Node version is active for every command without you having to think about it.

Why Shuru?

Shuru is all about simplicity and focus. It doesn’t try to replace task runners like Gulp or npm scripts. Instead, it’s a lightweight tool that:

Manages your Node versions.
Automates running project-specific tasks.

Nothing more, nothing less. If you want something that just works, Shuru is for you. Check it out on GitHub and see if it fits your workflow.

Give it a shot, contribute if you want, and simplify the way you run tasks across projects.

Meet RayQL - A Schema and Query Language for Your SQLite Side Projects

Harsh Singh — Tue, 30 Apr 2024 18:02:58 +0000

Let's be real, as developers, we've all spent way too much time setting up backends, writing validation schemas, and reinventing the wheel for common tasks when working on side projects. It's a massive time sink that takes away from the actual fun of building something new.

That's why I created RayQL, a schema definition and query language for SQLite, built with Rust. The core goal is to provide a compact and familiar syntax that eliminates the need to reinvent the wheel for data validation, allowing you to quickly prototype and build backends without juggling multiple components. With RayQL, everything you need lives in a single executable, which makes it super-easy to get started on your side projects.

RayQL gives superpowers to SQLite by providing built-in validation functions (more on that in future releases) and everything you need for building SQLite-based backends. It's designed specifically for side projects, where you want to focus on your core idea rather than getting bogged down by redundant tasks.

One of the main pain points when working with databases is defining models and setting up relationships. RayQL makes this process a walk in the park:

# Enum for user types
enum user_type {
  admin
  developer
  normal
}

# Model for 'user'
model user {
  id: int primary_key auto_increment,
  username: str unique,
  email: str unique,
  phone_number: str?,
  user_type: user_type default(user_type.normal)
}

No more dealing with string literals for enums or forgetting to set default values. It just works.

Let's say you want to create a post model with a foreign key relationship to the user model. With RayQL, it's as simple as:

model post {
  id: int primary_key auto_increment,
  title: str default('New Post'),
  content: str,
  author_id: int foreign_key(user.id),
  created_at: timestamp default(now()),
}

Yup, that's it. No more jumping through hoops to set up foreign keys or default values.

You can try out RayQL right now using the online editor – RayQL Studio, or install it locally using this simple command:

curl -s https://raw.githubusercontent.com/harshdoesdev/rayql/main/install.sh | sh

RayQL is an open-source project, so feel free to contribute, report issues, or propose new features on the GitHub repository.

The team has some exciting plans for the future, including automatic TypeScript type generation (coming in the 0.2 release) and support for writing database queries using the RayQL syntax.

So, if you're tired of spending more time on the backend than the actual project, give RayQL a try. It might just be the superpower you need to focus on what really matters – bringing your ideas to life.