Forem: UltimateHobbyCoder

ImgTool: When You Need to Process Images Without the GUI Drama

UltimateHobbyCoder — Mon, 14 Jul 2025 14:16:03 +0000

So here's the thing - I was tired of opening heavy image editing software or uploading images to online converters just to convert a bunch of PNGs to JPGs or resize images for web use. Then I thought that is a cool project to do: an lightweight image processing tool that does one thing really well and efficiently: coverting and resizing images.

What It Actually Does

ImgTool is a CLI tool written in Go that handles the most common image processing tasks you'll encounter:

Format conversion between PNG, JPG, GIF, and WebP
Quality adjustment for lossy formats (because nobody wants 10MB JPGs)
Image resizing with percentage scaling or specific dimensions
Watermarking with opacity control
Batch processing entire directories
Concurrent processing because why wait when you have multiple CPU cores?

Why Go?

I chose Go for a few reasons. First, it compiles to a single binary - no dependency hell, no "works on my machine" issues. Second, Go's concurrency model makes it perfect for processing multiple images simultaneously. And honestly, Go's standard library plus a few choice packages (cobra for CLI and viper for config) gave me everything I needed without bloat.

The Real-World Stuff

Let me show you how this actually works in practice:

Basic Format Conversion

.\imgtool.exe convert photo.png photo.jpg --to jpg --quality 85

Resize for Web

.\imgtool.exe convert large-image.jpg thumbnail.jpg --resize "300x200"

Bulk Processing

This is where it gets interesting. Need to convert an entire folder of images to WebP for better web performance?

.\imgtool.exe convert input-folder output-folder --mode dir --to webp --workers 8

The --workers flag lets you control how many images get processed simultaneously. On my machine, 8 workers seems to hit the sweet spot between speed and not melting my CPU.

Adding Watermarks

.\imgtool.exe convert photo.jpg watermarked.jpg --watermark logo.png --watermark-opacity 70

Configuration That Actually Makes Sense

Instead of remembering all those flags, you can create a config.yaml file:

to: "webp"
quality: 75
watermark: "/path/to/your/logo.png"
watermark-opacity: 60
workers: 8

Now your common settings are defaults, and you only need to specify what's different for each job.

The Technical Bits

Under the hood, ImgTool uses Go's image package along with format-specific libraries. The concurrency is handled with goroutines and channels - nothing fancy, just effective. For directory processing, it walks the file tree, spawns worker goroutines, and processes images in parallel while maintaining a reasonable memory footprint.

The CLI is built with Cobra, which gives you all the nice help text and flag parsing without having to write boilerplate. Viper handles the configuration file parsing and merging with command-line flags.

Why I Built This

Look, there are plenty of image processing tools out there. ImageMagick is powerful but can be overwhelming. Online converters work but who wants to upload files for simple tasks? GUI tools are great but slow for batch operations.

I wanted something that:

Starts instantly (no splash screens)
Handles the 80% use case really well
Doesn't require learning a complex syntax
Can process hundreds of images without breaking a sweat

What's Next

The tool is available for Windows right now, and I'm working on making it easily installable for Linux and macOS (if you're on those platforms, you can still build from source with a bit configuration(maybe?!).). I'm also considering adding more filters and effects, but only if they serve real-world use cases.

The code is open source on GitHub, and I've got documentation at prathamghaywat.github.io/imgtool-docs/.

Try It Out

If you're dealing with image processing tasks regularly, give ImgTool a shot. It's designed to be the tool you reach for when you need something done quickly and correctly, without the overhead of larger applications.

And hey, if you find bugs or have ideas for improvements, the issues tab on GitHub is always open. Building tools that people actually use is the best kind of feedback loop.

*ImgTool is MIT licensed and available on GitHub. *

Is selfhosting a good idea?

UltimateHobbyCoder — Thu, 26 Jun 2025 07:18:00 +0000

I often hear a lot of how companies and users get huge bills for sometimes literally doing nothing.

Often you will hear developers talking about how selfhosting is the best way to host sites and it is also more cost effective than cloud solutions.

So why don't many people selfhost?

I think that in my 5 years of experience of talking to devs, the main reason was: they weren't comfortable enough. And that was fair enough, but since Coolify and similar platforms have emerged, the landscape has completely changed.

The Traditional Barriers

Setting up your own server used to mean:

Configuring nginx or Apache from scratch
Setting up SSL certificates manually
Managing Docker containers with complex compose files
Handling database backups and monitoring
Dealing with security patches and updates
Troubleshooting deployment issues at 2 AM

No wonder most developers just threw money at Vercel, Netlify, or AWS and called it a day.

Enter Modern Selfhosting Tools

Tools like Coolify, CapRover, and Dokku have made selfhosting accessible to developers who don't want to become system administrators. With Coolify, you can:

Deploy applications with a simple git push
Get automatic SSL certificates via Let's Encrypt
Monitor your applications with built-in dashboards
Handle database deployments with one-click setups
Scale services without touching configuration files

The Real Cost Comparison

Let's be honest about the numbers. A $5/month VPS can host what would cost you $50-200/month on major cloud platforms. That's particularly true for:

Static sites (why pay $20/month when you can host dozens for $5?)
Small to medium web applications
Personal projects and side hustles
Development and staging environments

When Selfhosting Makes Sense

Selfhosting is great when you:

Want predictable monthly costs
Have multiple projects to host
Care about data ownership and privacy
Enjoy learning about infrastructure (even just a little)
Need custom configurations that cloud platforms don't offer

When to Stick with Cloud

Cloud platforms still win for:

Mission-critical applications requiring 99.99% uptime
Applications with unpredictable traffic spikes
Teams without any infrastructure knowledge
Compliance requirements that need specific certifications
Global CDN requirements

The Coolify Revolution

What makes Coolify special is that it brings the developer experience of modern PaaS platforms to your own server. You get:

GitHub/GitLab integration for automatic deployments
Environment variable management
Service discovery and networking
Backup management
A clean web interface that doesn't require terminal expertise

It's like having your own private Heroku, but better and cheaper.

My Recommendation

Start small. Grab a 4$ Digitalocean Droplet, install Coolify, and migrate one non-critical project. And if you really want the local experience then grab a Raspberry Pi or even a mini pc and set it up something like Headless Raspberry Pi OS. You'll be surprised how smooth and fast the experience is compared to the old days of manual server management.

For most developers, the sweet spot is a hybrid approach: use selfhosting for personal projects, staging environments, and cost-sensitive applications, while keeping mission-critical production workloads on managed cloud platforms.

The barrier to entry has never been lower, and your wallet will thank you. Plus, you'll actually learn something about how the internet works beneath all those abstraction layers.

Final Thoughts

Selfhosting isn't just about saving money—though you definitely will. It's about taking control of your infrastructure, understanding your stack better, and having the flexibility to build exactly what you need.

With tools like Coolify I think it makes the whole process easier and better.
Up for the challenge?

Links to check out:

Mini PC(Affiliate): https://amzn.to/4etWSHx
Raspberry Pi 5(Affiliate): https://amzn.to/4kXC4L1
Coolify: https://coolify.io
DigitalOcean Droplets: https://www.digitalocean.com/pricing/droplets#basic-droplets

By buying the products through my referral link, I will earn a small commision. So thank you if you buy a product through my link!

Get the best Techstack in seconds

UltimateHobbyCoder — Tue, 17 Jun 2025 15:33:33 +0000

We've all been here:

Have you had an project idea, something really exciting or just mind blowing, but didn't know how to choose the right technologies for your project? This seems to not only happen to me but many other developers as well, so I decided to create an AI Techstack recommender! You just need to input a few details about your project and then let the magic happen. Just in a matter of a few seconds you will get a beautiful Techstack tailored specifically to your project!

How did I make it?

Well initally I was thinking of using Vite, but later on decided on using NextJS. For the AI behind this I choose Gemini 2.0 Flash, because google offers a really nice free tier. I deployed in on vercel(also because it's free). I got the subdomain at ZoneID which offers free subdomain registry.

Please comment if you like it and if it works for you!

[Boost]

UltimateHobbyCoder — Sun, 01 Jun 2025 13:55:31 +0000

UltimateHobbyCoder

Feb 24 '25

Bolt.new vs v0.dev - Which one is better?

#webdev #productivity #frontend #ai

Comments

3 min read

Google is dead - Perplexity took over

UltimateHobbyCoder — Wed, 26 Feb 2025 11:24:17 +0000

Every day we searc- sorry google something. But with AI we have new options that are changing how we find information online. The choice between traditional search engines like Google and AI-powered alternatives like Perplexity is becoming increasingly relevant, especially for developers who rely heavily on quick access to technical information.

The Rise of AI-Powered Search

Perplexity has emerged as one of the leading AI-first search platforms, offering a conversational approach to finding information. Rather than simply returning a list of links, Perplexity attempts to synthesize information into direct answers while providing citations to sources.

For developers, this means:

Faster answers to technical questions: Instead of clicking through multiple StackOverflow links, you can often get synthesized solutions directly
Contextual follow-ups: The ability to ask follow-up questions maintains your train of thought
Code snippets with explanation: Perplexity can provide code samples with the reasoning behind them

The Google Standard

Google remains the dominant search engine with decades of refinement behind it. Its core strengths for developers include the following:

Vast index coverage: Virtually every programming resource, documentation site, and forum thread is indexed
Advanced search operators: Powerful search syntax for narrowing down specific technical queries
Integration with developer-specific services: Direct connections to Stack Overflow, GitHub, and other development resources

When to Use Which Tool

As developers, our choice of search tool should depend on our specific needs:

Consider Perplexity when:

You need a conceptual explanation of a programming pattern or approach
You want to compare multiple technologies without jumping between tabs
You're looking for synthesized information from documentation that might be spread across multiple sources

Stick with Google when:

You're searching for specific error messages or stack traces
You need to find the most current discussions on emerging technologies
You want to leverage advanced search operators to pinpoint exact resources

The Developer's Hybrid Approach

In my experience, the most effective strategy isn't choosing one or the other, but integrating both into your workflow:

Start with Perplexity for conceptual questions and broad overviews
Use Google to pinpoint specific documentation or GitHub issues
Return to Perplexity to help synthesize complex information from multiple sources

Looking Forward

The search landscape will likely continue evolving rapidly with AI advancements. Tools like GitHub Copilot, which brings AI assistance directly into the IDE, suggest that the future may involve less context-switching to external search tools altogether.

What's your experience with these search tools? Have you incorporated AI search into your development workflow? Share your thoughts in the comments!

Bolt.new vs v0.dev - Which one is better?

UltimateHobbyCoder — Mon, 24 Feb 2025 15:33:56 +0000

In today's rapidly evolving technology landscape, AI-powered development tools are transforming how developers approach their projects. This article examines two notable contenders in this space: Bolt.new and v0.dev. To provide a structured evaluation, I built the same application—a simple to-do list—with both platforms and analyzed their performance across multiple dimensions.

Evaluation Criteria

The assessment focuses on four key areas:

User Interface & Experience
Development Efficiency
Pricing Structure
Code Quality & Implementation

UI/UX Analysis

Both platforms generated visually appealing interfaces that prioritize simplicity and usability—essential qualities for a to-do application.

Bolt.new delivered superior results in this category by implementing a cohesive design language with a consistent color theme. The interface components worked together harmoniously, creating a polished user experience.

v0.dev produced a functional interface but relied heavily on a monochromatic color scheme. While clean and minimal, it lacked the visual distinction and personality present in Bolt's solution.

Development Efficiency

Time-to-completion and prompt efficiency are critical metrics for evaluating AI development tools:

Bolt.new required only a single comprehensive prompt to generate the complete application. This streamlined approach demonstrates Bolt's robust understanding of application requirements from minimal input.

v0.dev needed two separate prompts to achieve the same functionality. While the iterative process provides more control, it extends the development timeline and requires additional user intervention.

Both platforms completed the task within minutes, representing significant efficiency gains compared to traditional development approaches.

Pricing Structure

Bolt.new employs a token-based system with clearly defined limits:

Free tier: 150,000 daily tokens and 1 million monthly tokens
Additional tokens available for purchase
Referral program provides 200,000 bonus tokens for both parties(P.S: Here is mine for you and me to profit off: https://bolt.new/?rid=vil43j

v0.dev also uses a token-based approach but with less transparency:

Free tier includes a limited number of messages
Paid plans offer increased capacity without specific quantity disclosures
Pricing structure appears less defined than Bolt's offering

The transparency and generosity of Bolt's free tier make it particularly attractive for developers looking to experiment with AI-assisted development without significant investment.

Code Quality

Both platforms generated functional, well-structured code for the to-do application. Neither included comprehensive comments explaining component functionality, which would have enhanced code maintainability.

After thorough analysis, I found both implementations to be technically sound with no significant quality differences between them. Both platforms demonstrated strong code generation capabilities with clean architecture and appropriate functionality.

Conclusion

While both tools demonstrate impressive capabilities for rapid application development, Bolt.new emerges as the preferred option for most use cases. Its advantages include:

More cohesive UI design implementation
Streamlined development process requiring fewer prompts
Transparent pricing with generous free tier allowances
Equivalent code quality to its competitor

Bolt.new appears particularly well-suited for rapid prototyping and concept development, offering an efficient pathway from idea to functional implementation.

Live Demonstrations

Experience both implementations firsthand:

What AI development tools have you found most effective for your projects? Share your experiences in the comments below.

Note: This article contains referral links to Bolt.new. Using these links provides both me and new users with additional tokens. I am not sponsored by Bolt