DEV Community: marwane

Upscale an Image Without Losing Quality: What Works, What Doesn't

marwane — Tue, 03 Nov 2026 01:55:40 +0000

Everyone has one photo like this. The only picture of the dog as a puppy, the shot a friend took on the beach, the product photo a supplier sent at the size of a postage stamp. It looks fine on a phone. Then you try to print it, put it in a listing or set it as a wallpaper, and it falls apart into soft edges and little squares.

The honest answer to whether you can upscale an image without losing quality is yes, when the photo is small but sharp. When it is blurry to begin with, upscaling mostly gives you a bigger blurry photo. Most of what follows is about telling the two apart before you spend the time, and about how big you need to go for a print, a wallpaper or a product page.

Why a resized photo looks worse

Most people never type the word upscale. They ask how to increase picture resolution, how to make an image higher resolution, or how to make a photo better quality. They usually ask because someone else set the bar: the print shop, a marketplace upload form, a client, the school website that bounced the headshot.

A normal resize, the kind every editor has done for thirty years, makes a photo bigger by spreading the pixels it already has over more space. Nothing new is added, so edges go soft and small areas of detail turn to mush. The resolution went up on paper and the picture got worse.

An upscaler guesses. It reads the pattern of pixels and predicts what the finer detail probably was: the edge of a petal, the strands in a curl, the grain of leather. When the guess is good, the result looks like the same photo taken with a better camera. When the guess is bad, you get hair that looks painted, skin like plastic, or a face that is almost, but not quite, the person. Increasing resolution and upscaling are the same job, then. The only question that matters is how good the guess will be, and that depends almost entirely on the photo you start with.

Which photos upscale well, and which don't

A small but sharp photo is the best case. A clean 800-pixel crop from a phone has real information in it, and a good upscaler builds on it. Most phone photos from the last few years are this: the camera did its job, and you either cropped too far in or sent it through an app that shrank it. This is where the "without losing quality" promise holds.

A blurry, shaken or out-of-focus photo is the worst case, and it is the one most people arrive with. An upscaler cannot tell blur from soft detail, so it hands you a larger blurry photo and sometimes invents texture on top. Fix the blur first, with an enhancer or a restoration tool, and upscale after.

Heavily compressed images, the ones that came through a chat app and turned into blocky squares, sit in between. They are usable, but look closely at faces and text afterwards, because blocks can be read as detail and rebuilt as something that was never there.

Scans of old prints are their own case. The paper grain, the dust and the fade get enlarged along with the picture, so a straight upscale often looks worse than the print did. Restore first and upscale second, and scan at the highest setting the scanner offers so the tool has something to work with.

Text, logos and small faces in a crowd are the riskiest. Letters get redrawn, and a face that takes up fifty pixels can come back as a different person. If you are upscaling a group photo or a screenshot, that is where to look first. Plenty of people go looking for an upscaler that won't change the face, or for one that does not use AI at all, and the worry is fair: the better the tool, the more it invents. Whatever you use, compare the result against the original at full size.

AI-generated images are the easy case. They are clean, they carry no camera noise, and they upscale beautifully, which is why so many people enlarge their own renders for print.

Upscaler or enhancer? If the photo looks fine and is only too small, you want an upscaler. If it looks bad at its current size, blurry, grainy or faded, you want an enhancer first, and an upscaler after that only if you also need it bigger. Running them in the wrong order is the most common way to end up with a big, sharp version of the wrong thing.

Five photos, before and after

These are the sample pairs from our own upscaler page, cropped to the part where the difference shows and enlarged so it is visible on a phone. They are demo images rather than someone's uploads, so read them as what the tool does on a clean source.

A street portrait. The curls go from a smear of blocks to separate strands and the eyes come back, and she is still the same person.

A dog mid-run, usually too small because it was cropped out of a wider shot. Fur, whiskers and the wet nose come back, and the pose is untouched.

A product photo at supplier size. The leather grain and the clasp edges are what a shopper zooms in on, and the first thing a small file loses.

Two faces close together, the test for the "don't change the face" worry. Stubble, hair and the weave of the jacket come back, and both people still look like themselves.

The worst starting point of the five, a file so small the sky had turned into squares. The ridgeline, the snow and the clouds come back cleanly, which is about the limit of what to expect from a source like this.

How big do you really need to go?

A lot of the frustration with upscaling comes from chasing a number without knowing where it came from. 4K is a screen size, 3,840 pixels across, so a photo around 1,000 pixels wide gets there with a 4x upscale. A print shop talks in dots per inch instead, usually 300. That is why an A4 or letter print wants about 3,500 pixels on the long side, and a 24 by 36 inch poster wants 5,000 or more unless it hangs where nobody gets close. A wallpaper only needs to match the screen it is going on, and taking a 1080p image to 1440p is a modest step that almost any sharp source can take. A product page is similar: most marketplaces zoom to about twice the displayed size, so a listing wants two to three thousand pixels and gains nothing beyond that.

Rough targets for the long side of the image. A print shop will give you its own numbers, and a poster seen from across a room can get away with less.

Expect the file to grow, whatever the target: a 4x upscale has sixteen times the pixels, so a 300 KB photo can turn into several megabytes. The dimensions changing is the point; the aspect ratio should not change at all. 8K exists, and a few tools offer it, but few screens can show it, and a source that was small to begin with has no business going that far. Stop at the size the use needs. If you have a whole catalogue of product photos to do, run one first, check it at full size, and only then put the rest through at the same setting.

How to get a better upscale

1. Start from the best original you have

Go back to the source: the photo in the camera roll, the file the designer sent, the scan at the highest setting the scanner offers. Never upscale a copy that came through a chat app or was already enlarged once. Every step in between threw away pixels the upscaler could have used.

2. Fix blur and noise before you enlarge

If the photo is soft, grainy or faded at its current size, run an enhancer or a restoration tool first. Upscaling cannot tell blur from detail, and a blurry photo made four times bigger is a bigger blurry photo. For a photo that is blurry or old rather than small, the Image Enhancer is the right first stop; come back to the upscaler afterwards.

3. Crop first, then upscale

Decide what the final picture shows and crop to it before you enlarge. Most tools cap the output size, and you want that budget spent on the face or the product, not on sky you were going to trim anyway.

4. Pick the size the use needs, not the biggest on offer

Match the target from the chart above: 2x is usually enough for a phone wallpaper or a listing, 4x for a print or a 4K screen. Going past what the use needs adds file size and, from a small source, invented detail.

5. Run it once, from the original

The five pairs above came from the AIGenTools Image Upscaler: drop in a JPG, PNG or WebP, pick 2x or 4x, and download the larger version in the browser, with nothing to install. Whichever tool you use, run it once. Running 2x on top of 2x stacks one guess on another, and a single 4x from the original comes out cleaner. If the first result is wrong, go back to the original and change the setting rather than upscaling the result again.

6. Check it at full size before you use it

Open the file you downloaded and confirm its pixel size, because some tools hand back the same dimensions with a sharpening filter on top. Then look at the places where upscalers go wrong: the edge of hair against the background, the skin on a cheek, any straight line or lettering, and fine repeating patterns like a knit or a brick wall, which can turn into ripples. If those hold up, the rest of the photo will too.

Try it here: Image Upscaler. Upload a small photo, pick 2x or 4x, and download the larger version.

“Follow human intent” sounds obvious—until that intent conflicts with safety, honesty, or someone else’s autonomy. A model spec isn’t really tested by its list of values. It’s tested by what the model does when those values collide.

marwane — Sat, 31 Oct 2026 12:12:02 +0000

Google just launched Gemini 3.5 Flash Cyber. The bigger signal isn’t another model release—it’s specialization. AI is moving beyond general chatbots toward systems built for high-value, high-risk work.

marwane — Thu, 23 Jul 2026 01:18:49 +0000

A simple random-number test can expose whether an AI API is secretly swapping models. Each model develops its own numerical “fingerprint”—turning randomness into a surprisingly effective lie detector for AI providers.

marwane — Tue, 21 Jul 2026 01:51:16 +0000

I've been waiting for a model that understands sound. Seed Audio is the first time TTS felt over

marwane — Wed, 01 Jul 2026 04:47:50 +0000

I make AI videos, and for the longest time the sound was the part I quietly dreaded.

Not because a clip has no audio. Because every voice tool I tried just didn't understand the scene. They could read a script fine, but the second a character needed to actually feel something, the voice went flat and robotic. The ambience never matched the shot. I'd still end up hunting for effects and mixing the whole thing by hand to make thirty seconds feel like one real moment. The visuals kept
getting better every month. The audio stayed stuck at "good enough."

Then last week I tried Seed Audio, and it kind of stopped me. It's the first one that feels like it actually understands what it's making.

What it is

Seed Audio is ByteDance's new audio model. You tell it what you want to hear, a line, a whole scene, a mood, and it generates the entire thing together. Voices with real emotion, several characters talking to each other, the room they're in, the sound effects around them, all in sync. Not a bare voice track you have to score and patch afterward. The actual moment.

If you remember the point where image models suddenly understood pictures instead of guessing at them, this is that same jump, for sound.

It does far more than one thing

That's the part that's hard to get across in text. The same model will do a calm narration, a two-person argument, a meditation that keeps getting slower and softer, a stand-up bit where it adds its own room laughter, a tense ghost story, cinematic scenes, weather, crowds, whole environments. Different feel every time,
and each one sounds like it belongs to the scene instead of being pasted on top of it.

voice reference

You can hand it a short clip of a voice and it locks onto that voice, the tone, the pacing, the little habits in how someone talks. Then you reuse that exact voice anywhere.

For video this is the thing I've wanted forever: one consistent character voice across a whole series, from a single reference, without re-recording anything. I cloned a voice once and dropped it into completely different scenes, calm, panicked, tired, amused, and it held up in all of them. Every cloning tool I'd tried before nailed exactly one read. This one carried.

voice a character from a picture

Here's the one that really got me as a video person: you can hand it an image of a character and it works out a voice that fits the face. My characters usually start as a still, so pulling a voice straight from that image, no casting, no guessing, feels almost unfair.

What you can actually make with it

you can use seed audio to handle all kinds of scenarios.

Film & video voiceover — narration and character voices that match the mood of a shot instead of sitting flatly on top of it.
Sound effects & ambience — rain, wind, crowds, room tone, whole environments, without digging through a stock library.
Podcasts — multi-host conversations that actually sound like two people talking, not one voice split in two.
Audio drama & multi-character scenes — short dramas and dialogue-heavy scenes cast and performed in a single pass.
Audiobooks & narration — long reads that hold one character's voice consistently from the first chapter to the last.
Ads & brand spots — a finished voiceover-and-effects spot straight from a single description.

It's a 1.0, so it's not flawless. Sometimes a read comes back a little flat and I regenerate, and it's strongest in English and Chinese right now. Small stuff. Didn't change how I feel about it. AIGenTools helped me complete a full day's work in just one hour, giving me more time to do other things.

If audio has always been the weak link in your AI videos, also you can try seed audio，You will also discover some aspects that truly amaze you.

Hermes Agent: The Self-Improving AI Agent That Runs 24/7 on Your Own Server — A Deep Dive

marwane — Tue, 14 Apr 2026 13:34:30 +0000

What Is Hermes Agent?

Hermes Agent is an open-source AI agent framework built by Nous Research (the team behind the Hermes model family). It runs on your own machine or server, connects to any LLM you choose, and can be reached through Telegram, Discord, Slack, WhatsApp, Signal, and more — 14 platforms total.

But what makes it genuinely different from the dozens of other agent tools out there is this: Hermes builds its own harness and improves itself over time. Every time you use it, it gets a little better at working with you specifically.

It's not a chatbot. It's not a code completion tool. It's an autonomous agent that can run shell commands, read files, browse the web, schedule tasks, delegate to sub-agents, and remember everything about how you work — across sessions, across platforms, across months of use.

The Five Core Mechanisms

1. The Learning Loop — It Gets Better Without You Teaching It

This is the heart of Hermes. After every task, it runs an automatic retrospective:

What should I remember? → writes to memory
Is this a recurring pattern? → creates a Skill
Did the user correct me? → updates the Skill

You don't trigger this. It just happens. The first time you ask it to write a Python script, the output might be generic. By the tenth time, it knows you prefer httpx over requests, you like error logs written to files instead of printed to terminal, and you hate long functions. Nobody taught it any of that — it observed and extracted the patterns itself.

2. Three-Layer Memory — From Goldfish to Old Friend

Most AI tools forget you the moment you close the tab. Hermes has three memory layers:

Session memory (SQLite + FTS5): Raw conversation history, full-text indexed. Hermes doesn't dump all of this into context — it searches by topic and pulls only what's relevant. Three months of use feels as fast as three days.
Persistent memory: A small, curated profile — your preferences, habits, tool choices. This loads into every conversation automatically.
Skill memory: Markdown files that capture "how to do things" — your validated workflows, stored in ~/.hermes/skills/.

The key design choice: on-demand retrieval, not full-context loading. FTS5 full-text search means Hermes finds the right memory at the right time without bloating token usage.

Optional add-on: Honcho user modeling (by Plastic Labs) — a 12-layer dialectical identity system that infers things about you that you never explicitly said. Like noticing you always pick the cheapest option and inferring you're cost-sensitive, so next time it surfaces pricing info first.

3. Self-Evolving Skills

A Skill in Hermes is a standalone markdown file in ~/.hermes/skills/ — instructions for how to do something well. Skills come from three sources:

Source	How it works
Bundled	40+ pre-built Skills ship with installation
Agent-created	Hermes auto-creates Skills from recurring tasks
Community Hub	Install with one command

The killer feature: Skills self-improve through use. Every time you give feedback ("next time check if the table exists first"), Hermes goes back and edits the Skill file. Next run, the improvement is baked in.

Skills follow the agentskills.io standard — they're portable across Claude Code, Cursor, Codex CLI, Gemini CLI, and more. A Skill you wrote for one tool works in another.

4. 40+ Built-in Tools + MCP

Five categories of native tools:

Category	Examples	What they do
Execution	terminal, code_execution, file	Run commands (sandboxed), read/write files
Information	web, browser, session_search	Search, scrape, search conversation history
Media	vision, image_gen, tts	Understand images, generate images, text-to-speech
Memory	memory, skills, todo, cronjob	Manage memory, Skills, scheduled tasks
Coordination	delegation, moa, clarify	Sub-agents, multi-model answering, ask user

Beyond the built-in tools, Hermes supports MCP (Model Context Protocol) — connecting to 6,000+ external apps. GitHub, Slack, Jira, databases, Google Drive — add a config block to config.yaml and it just works. You can also filter which tools each MCP server exposes for security.

5. Multi-Platform Gateway

One unified process connects to all your messaging platforms simultaneously. Start a conversation on Telegram during your commute, continue it in the terminal at your desk — Hermes doesn't distinguish where a message came from. Same brain, same memory, same Skills.

Supports: Telegram, Discord, Slack, WhatsApp, Signal, Email, SMS (Twilio), Home Assistant, Mattermost, Matrix, DingTalk, Feishu/Lark, WeCom, and Open WebUI.

How It Compares: Hermes vs Claude Code vs OpenClaw

These three tools aren't competing — they solve different problems.

Dimension	Claude Code	OpenClaw	Hermes Agent
Core philosophy	Interactive coding	Configuration-as-behavior	Autonomous background + self-improvement
Your role	Sitting at the terminal directing	Writing config files	Deploy and check in occasionally
Memory	CLAUDE.md + auto-memory	SOUL.md + Daily Logs + semantic search	Three-layer self-improving memory
Skill source	Manually installed	ClawHub 5,700+ community	Agent-created + community Hub
Run mode	On-demand	On-demand	24/7 background
Deployment	Local CLI (subscription)	Local CLI (free + API costs)	Self-hosted (VPS / Docker / Serverless)

The practical way to think about it:

Need real-time pair programming? → Claude Code
Need transparent, auditable agent behavior for a team? → OpenClaw
Need 24/7 automated code review, scheduled tasks, persistent memory? → Hermes
Long-term content project? → Hermes for research + Claude Code for writing

They're complementary. The agentskills.io standard means Skills are portable between all three.

Getting Started: From Zero to Running in 15 Minutes

Step 1: Install

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes version  # verify

Works on macOS, Linux, WSL2, and even Termux on Android. The script handles Python, Node.js, and all dependencies.

Docker alternative:

docker pull nousresearch/hermes-agent:latest
docker run -v ~/.hermes:/opt/data nousresearch/hermes-agent:latest

Step 2: Configure a model

All configuration lives in one file: ~/.hermes/config.yaml

model:
  provider: openrouter       # or nousportal, openai, anthropic, ollama, etc.
  api_key: sk-or-xxxxx
  model: anthropic/claude-sonnet-4
terminal: local              # or docker, ssh, daytona, modal

Supported providers include OpenRouter (200+ models with one key), Nous Portal (officially recommended), OpenAI, Anthropic, z.ai/Zhipu, and Ollama for fully offline local models.

Step 3: Start talking

hermes

That's it. Ask it to search the web, read files, run shell commands. It will ask for permission before executing anything potentially dangerous.

Step 4: Connect Telegram (optional but game-changing)

Create a bot with @botfather in Telegram → get a token
Add to ~/.hermes/config.yaml:

gateway:
  telegram:
    token: YOUR_BOT_TOKEN

Run hermes — it connects to the Telegram Gateway automatically

You now have a personal AI assistant reachable from your phone, anywhere in the world.

Step 5: Deploy to a VPS for 24/7 uptime

Any cheap VPS will do (Hetzner, DigitalOcean, Vultr — whatever you already use). Hermes is lightweight without a local LLM.

docker run -d \
  --name hermes \
  --restart unless-stopped \
  -v ~/.hermes:/opt/data \
  nousresearch/hermes-agent:latest

That's a 24/7 AI assistant with persistent memory, reachable from your phone.

What Makes It Actually Special

After spending a week with this, here's what I think the real differentiators are:

The harness builds itself. Other tools need you to write the rules (CLAUDE.md, SOUL.md). Hermes observes, learns, and writes its own rules. You can override anything, but the default is zero-config improvement.
Memory that actually works long-term. FTS5 on-demand retrieval means it doesn't slow down after months. Your data stays local in SQLite — no cloud vector database needed.
Everything stays on your machine. MIT license, self-hosted, any LLM you want. No vendor lock-in, no data leaving your server. A basic VPS runs it comfortably — memory usage is under 500MB without a local model.
Skills are portable. The agentskills.io standard means your investment in Skills isn't locked to one platform. Switch tools, keep your workflows.
It works when you're not there. Cron scheduling + Telegram gateway = an agent that reviews PRs at 2am, monitors your servers, drafts daily reports, and sends you the results over breakfast.

Limitations to Be Aware Of

No automatic memory expiration. The memory database only grows. You need to manually audit ~/.hermes/ occasionally.
Skill self-improvement depends on feedback quality. Vague feedback ("this doesn't feel right") won't improve anything. Specific feedback works.
Auto-generated rules can drift. The convenience of automatic improvement comes with the trade-off that you're giving up some control. Check your Skill files periodically.
Community ecosystem is still young. OpenClaw's ClawHub has 5,700+ Skills from the lobster craze's network effects. Hermes's community is growing but isn't there yet.