DEV Community: Akhouri Anmol Kumar

APIC v2 Sneak Peek: A Free, Offline Image Editor, Converter & Compressor for Desktop

Akhouri Anmol Kumar — Mon, 02 Nov 2026 07:20:10 +0000

Description: Development Update #2 from Akhouri Systems: exclusive glimpses of APIC v2, a privacy-first desktop image editor with Smart Export, batch convert and compress, GPS metadata removal and more. Try APIC v1 while you wait.

🚀 APIC v2 Development Update #2: The First Real Glimpse

A weeks ago I told you APIC v2 development had begun and showed you nothing.

Today the silence ends. 🎬

This is Development Update #2 from Akhouri Systems: a behind-the-scenes look at what we're building, how we're building it, and why we think APIC v2 can become one of the best free desktop image editors you can run offline on the planet earth 🌎.

📍 Missed Update #1? Read it here.

🧭 What is APIC?

APIC (Advanced Image Processing Center) is a free image tool for editing, converting, compressing and searching images, built by Akhouri Systems.

🌐 APIC Web: a browser-based photo editor
🖥️ APIC Desktop v1: the portable Windows app available right now
⚡ APIC Desktop v2: the next generation, in active development

If you've ever opened three different tools just to edit a photo, convert it to WebP, and compress it for the web, v2 is built for you.

👀 Glimpse #1: Smart Export, Where You See the Real Result Before You Save

Most editors make you guess. You drag a quality slider, export, check the file size, and repeat.

APIC v2 shows you the real encoded result next to your original, with a draggable before/after divider and a 1:1 zoom crop.

It also ships a Format Advisor. It encodes your image as JPEG, WebP, AVIF and PNG several ways, measures the quality of each (PSNR) and recommends the smallest file that still looks identical.

No more "is 80% quality enough?" Now you get numbers. 📊

🔐 Glimpse #2: The Privacy Inspector

Your photos can say more than you think. A single JPEG can carry:

📍 GPS location
📷 Camera serial number
🧑 Your name
🕒 Dates and times

APIC v2 decodes and shows you exactly what a file would reveal. It warns you when you open it, flags GPS files in batch jobs, and switches on metadata removal automatically when you export.

The core is built around one promise: local-only processing. No network. No telemetry. No accounts. 🛡️ peak Akhouri Systems stuff ✋🤚🔥

✨ Glimpse #3: Auto Enhance That Isn't a Black Box

Most "auto" buttons bake changes into your image and leave you stuck.

APIC's Auto Enhance analyses the photo and then sets ordinary Levels, White Balance and Vibrance sliders. Nothing is baked in, so you can fine-tune every value or undo it.

🧱 Glimpse #4: Fully Non-Destructive Editing

Your original file is never touched
Every step lives in a History you can travel back through
Text and logo layers (drag to place) are saved inside .apic project files
A live histogram with clipping warnings helps you catch blown highlights and crushed shadows
Split view compares before and after right on the canvas
Crash recovery autosaves your work, so a power cut doesn't cost you the edit

📦 Glimpse #5: Batch Studio

Got 500 photos? Batch Studio handles convert + compress + resize + text/logo watermark in one pass. It can reuse the edits from the image you have open.

You get per-file results, cancel, and retry, so one bad file doesn't ruin the run.

This is the batch image converter and compressor many of you asked for in the comments. 🙌

🎨 Glimpse #6: A Brand-New Workspace (This Week's Big Change)

The v2 interface was reworked this week, based on direct feedback:

Before	Now in v2
Left sidebar eating screen space	Top tab bar, like a browser, so the canvas and panels get more room
Features hard to find	Centered home search: type "compress", "convert" or "crop" and jump straight in
Small sliders	Larger sliders with exact number inputs for precise values
Crop was a bare draw-a-box tool	Full crop tool with drag handles, move, aspect-ratio presets and typed X / Y / Width / Height
Edit, then export, then convert, then compress	Export tab inside the editor: pick a format, set quality or a target file size, resize, remove metadata and save in one step, with a live size estimate
Default scrollbars	Custom thin themed scrollbars
Zoom felt off	Smoother wheel and touchpad zoom plus an option to invert the wheel direction

The goal: edit → convert → compress → done. One window. One flow.

⌨️ Power users get a command palette (Ctrl+K) to run any action by typing its name.

🔧 Under the Hood: How We're Building It

For the developers reading this (hi 👋), here's the engineering side:

Python + PyQt6 for the desktop UI
Pillow + NumPy for the imaging engine
A Qt-free core (apic/core), fully unit-tested, kept separate from the UI
One shared pipeline for the editor preview, export and batch, so what you see is what you export
Validated, serialisable operations, which is why projects save and reload reliably
Headless UI tests: the suite is currently 128 tests passing
Heavy work runs on background workers, so the interface stays responsive

Thanks to everyone who left architecture advice on Update #1. Versioned project files and a clean separation between the document model and the canvas are exactly the direction we're taking. 💡

🌍 Platforms: You Asked, We Listened

The most common request on Update #1 was macOS and Linux support. 🍎🐧

Honest status:

✅ Windows is the first target
🧪 The v2 app already starts on Linux in our builds
🗺️ macOS and Linux are on the roadmap, and I'm not forgetting them okay @xulingfeng @effessdev 🤣

⏳ When Does APIC v2 Release?

The rule hasn't changed:

APIC v2 goes public when Akhouri Systems reaches 2,000 total downloads across all products.

Update #1 started at 1,400. As of today we're at [1470]. Every download moves v2 closer. 📈

🛠️ While You Wait: Try APIC v1 (and Break It!)

APIC v1 is free, portable and needs no installer.

👉 Download APIC v1 (APIC.zip)

Why try it today?

⚡ It's the fastest way to see how APIC thinks about editing, converting and compressing images
🐞 Your feedback shapes v2, and worthy suggestions get built
📈 Every download helps unlock the v2 release

What to do: push it hard. Try huge images, strange formats and awkward workflows, then tell me what annoyed you.

❓ FAQ

Is APIC free?
Yes. APIC Web and APIC Desktop v1 are free.

Does APIC upload my images?
v2 is designed to be local-only: no network, no telemetry, no accounts.

Can APIC convert images to WebP, AVIF, JPEG and PNG?
Yes. v2 supports JPEG, PNG, WebP, BMP, TIFF, GIF and ICO, plus AVIF and HEIC when the optional codecs are installed.

Can it remove EXIF and GPS data?
Yes. The Privacy Inspector shows what a file reveals and can strip it on export.

Can I compress to a target file size?
Yes. Set a size goal like "under 500 KB" and APIC searches for the right quality.

Is there a macOS or Linux version?
Windows comes first. macOS and Linux are on the roadmap.

When is APIC v2 coming?
At 2,000 total downloads across Akhouri Systems products.

💬 Your Turn

Tell me in the comments:

Which glimpse excited you most?
What's the one feature that would make you switch to APIC?
Windows, macOS or Linux, and which one first?

Drop your answer 👇, follow me here on dev.to for Update #3, and share this post with someone who still opens three apps to resize one photo. 😄

Stay tuned. The best is coming.

— Akhouri Anmol Kumar, Founder, Akhouri Systems

Special Thanks to @effessdev for giving me ideas for APIC v2 UI and features
Also
Akhouri Systems & I wishes @effessdev happy birthday this day he spawned in the planet earth 🌎 👏👏👏🥳🥳🎂

Are You a Web Developer or a Browser Expert? 7 Tests I Failed Building a Photo Editor That Never Uploads Your Photos

Akhouri Anmol Kumar — Sun, 01 Nov 2026 05:18:13 +0000

Description: On-device AI, WASM threads, target-size compression, inpainting and 3D LUTs in a single HTML file. 7 real lessons from building APIC Web.

Most web developers can build a form, fetch an API and center a div.

Browser experts know what the browser refuses to do, what happens on a phone instead of your laptop, and how to ship real software with no server at all.

I found out which one I was while building APIC Web: a free photo editor, background remover, object remover, converter and compressor where your photos never leave your device. No upload queue, no backend, and the whole thing is one HTML file hosted on GitHub Pages.

Every test below is a real bug or design decision from that build. Score yourself honestly. 👇

Test 1: Why did my AI step silently never finish on phones?

APIC runs AI models in the browser with ONNX Runtime Web (WebAssembly). Multi-threaded WASM needs SharedArrayBuffer, and that needs special response headers (COOP/COEP). A plain static host like GitHub Pages doesn't send them, so crossOriginIsolated is false.

On desktop, the runtime usually degrades gracefully. On phones it often doesn't, and the AI step just hangs with no error. The fix was to stop relying on the fallback:

// Static hosts can't send COOP/COEP, so threads aren't available.
// Force the one configuration that behaves the same everywhere.
ort.env.wasm.numThreads = 1;
ort.env.wasm.proxy = false;

const session = await ort.InferenceSession.create(modelBytes, {
  executionProviders: ['wasm'],
  enableCpuMemArena: false,
  enableMemPattern: false,
});

Where headers are available, APIC checks self.crossOriginIsolated before asking for more than one thread.

Developer: "It works on my laptop."
Expert: knows that "falls back gracefully" is a claim to test on a real phone, not a promise.

Test 2: Can you tell a slow download from a dead one?

APIC's AI models are big: 5 MB (Lite), 44 MB (Fast), 176 MB (Maximum) for background removal, and about 208 MB for the highest-quality object remover. A fixed 30-second timeout would kill every slow phone connection.

So the timeout is stall-based: abort only if no bytes arrive for 40 seconds. A huge model on bad Wi-Fi is allowed to take as long as it needs. A dead link is not. After that it goes into the Cache API so the second run is instant:

const CACHE = 'apic-models-v1';
const cache = await caches.open(CACHE);

let hit = await cache.match(url);
if (hit) return hit.arrayBuffer();           // cached: no download

const bytes = await downloadWithStallTimeout(url);   // abort only if the stream goes quiet
await cache.put(url, new Response(bytes));   // wrapped in try/catch: private mode & quota can fail
return bytes;

And if a model can't load at all, the tool steps down instead of failing: Ultra (LaMa) → MI-GAN → a quick patch fill.

Developer: fetch() with a timeout.
Expert: measures progress, caches the result, and always has a plan B.

Test 3: Can your app hit "under 200 KB" without guessing?

Upload forms say "max 200 KB" and users play quality-slider roulette. APIC's Compress tool does a binary search on JPEG quality instead:

async function findQualityForTarget(canvas, targetBytes) {
  let lo = 0.05, hi = 0.98, best = null;
  for (let i = 0; i < 7; i++) {
    const mid = (lo + hi) / 2;
    const blob = await toBlob(canvas, 'image/jpeg', mid);
    if (blob.size <= targetBytes) { best = { blob, q: mid }; lo = mid; }  // fits: try higher quality
    else { hi = mid; }                                                   // too big: go lower
  }
  return best;
}

Seven encodes find the highest quality that still fits. If even the lowest quality is too big, APIC shrinks the image by about 20% and searches again, up to 8 times. If it still can't make it, it tells you the real size instead of pretending.

Developer: quality = 0.7 and hope.
Expert: turns a guess into a search and is honest when the answer is "can't".

Test 4: Why did my transparent PNG turn black as a JPEG?

JPEG has no alpha channel. When a canvas with transparent pixels is encoded as JPEG, those pixels come out black. After background removal (which creates lots of transparency), that's a nasty surprise.

The fix is to paint white first, then draw the image on top:

function flattenToWhite(src) {
  const out = document.createElement('canvas');
  out.width = src.width; out.height = src.height;
  const ctx = out.getContext('2d');
  ctx.fillStyle = '#fff';
  ctx.fillRect(0, 0, out.width, out.height);
  ctx.drawImage(src, 0, 0);
  return out;
}

APIC also tells you which formats keep transparency (PNG, WebP) and which don't, right in the Convert panel.

Developer: assumes a canvas is just pixels.
Expert: knows every output format has rules about alpha.

Test 5: Do you process the whole image, or only what changed?

Removing an object means running an inpainting model (LaMa, a Fourier-convolution network, or the lighter MI-GAN). LaMa works on a fixed 512×512 window, so feeding it a 12-megapixel photo would be slow and blurry.

APIC only processes the area around your brush:

Take a region around the mask (at least 512 native pixels when the photo allows).
Run the model on just that crop.
Feather the edge with box blurs, colour-match the fill to its surroundings, and re-add film grain so it doesn't look "too clean".
Paste it back.

Small edit, small compute, and the rest of your photo is untouched.

Developer: runs the model on the full image.
Expert: shrinks the problem first, then blends the result back so nobody can see the seam.

Test 6: Can you export your whole colour grade as a `.cube` LUT?

APIC has curves, an 8-band HSL mixer and 3-way colour grading. People wanted to use those grades in DaVinci Resolve or Premiere. A .cube file is a 3D lookup table: for every input colour, what colour comes out.

The trick: you don't need to reverse-engineer your pipeline. Feed an identity grid of colours through the same pixel function, and write down what comes out:

const N = 33;                       // 33×33×33 lattice
const buf = new Uint8ClampedArray(N * N * N * 4);
let i = 0;
for (let b = 0; b < N; b++)
  for (let g = 0; g < N; g++)
    for (let r = 0; r < N; r++) {   // red changes fastest, as .cube requires
      buf[i++] = Math.round(r / (N - 1) * 255);
      buf[i++] = Math.round(g / (N - 1) * 255);
      buf[i++] = Math.round(b / (N - 1) * 255);
      buf[i++] = 255;
    }

processPixels(buf, gradeWithoutSpatialEffects);   // same code that edits your photo

const lines = ['TITLE "APIC grade"', 'LUT_3D_SIZE 33',
               'DOMAIN_MIN 0.0 0.0 0.0', 'DOMAIN_MAX 1.0 1.0 1.0', ''];
for (let j = 0; j < buf.length; j += 4)
  lines.push(`${(buf[j]/255).toFixed(6)} ${(buf[j+1]/255).toFixed(6)} ${(buf[j+2]/255).toFixed(6)}`);

One catch: a LUT can only hold colour operations. Clarity, sharpen, vignette and grain depend on neighbouring pixels, so they're excluded and the UI says so.

Developer: exports a screenshot of the look.
Expert: samples the function itself.

Test 7: Why does your resized image look soft?

ctx.drawImage(img, 0, 0, smallW, smallH);   // one big jump: soft, aliased

Shrinking a large image in one drawImage call looks muddy. APIC's Resize tool halves the image step by step until it's within 2× of the target, then does one final pass:

function highQualityResize(src, targetW, targetH) {
  let cur = src, w = src.width, h = src.height;
  while (w > targetW * 2 || h > targetH * 2) {
    const nw = Math.max(targetW, Math.round(w / 2));
    const nh = Math.max(targetH, Math.round(h / 2));
    const step = document.createElement('canvas');
    step.width = nw; step.height = nh;
    const c = step.getContext('2d');
    c.imageSmoothingEnabled = true;
    c.imageSmoothingQuality = 'high';
    c.drawImage(cur, 0, 0, nw, nh);
    cur = step; w = nw; h = nh;
  }
  // ...then one last high-quality pass onto the exact target size
}

Developer: drawImage once and move on.
Expert: knows the order of operations changes the result.

Bonus: How do you ship a Web Worker inside a single HTML file?

No build step, no separate worker.js. APIC keeps the worker's source as a string, turns it into a Blob and starts it from a Blob URL:

const SRC = `/* worker code as a string */`;
const worker = new Worker(
  URL.createObjectURL(new Blob([SRC], { type: 'application/javascript' }))
);

Heavy inpainting runs off the main thread, and the whole app is still one file you can host anywhere.

Try it yourself

APIC is built by Akhouri Systems. It runs in your browser, and your images are never uploaded. The only thing the browser downloads is the AI model files (from Hugging Face), cached after the first run. Being upfront about the trade-offs: editing needs no account, you sign in with one tap on Google only when you export, and the web version shows one small banner ad to stay free. The offline PC app has none.

App	What it is	Lessons it proves	Get it
🖼️ APIC Web	Edit, pro colour tools, remove objects, remove backgrounds with AI, resize, convert, compress, 15-network social presets, batch ZIP	Tests 1-7	Open APIC Web
💻 APIC for PC	Windows version, runs fully offline, no account	The desktop twin	Download (zip)

If you're learning how the browser works outside a tutorial, open it, drop a photo, then open DevTools and see what's going on under the hood. That's the fastest way I know to level up.

Your score

0-2 tests known: You're a web developer. Great start, now break something on a real phone.
3-5: Solid. You've shipped something real.
6-7: You're a browser expert. Come argue with me in the comments.

Which test did you fail first? Mine was [the AI step that worked on desktop and silently hung on phones]. Tell me yours below 👇

What's Your Dream Job? Mine Is Founder & CEO of My Own Startup 🚀 (Yours Can Be Anything)

Akhouri Anmol Kumar — Sat, 31 Oct 2026 04:48:33 +0000

Description: "I'm telling you my dream job, and I want to hear yours. Developer, astronaut, CEO, game designer, chef, anything goes."

🎤 The question: If money, fear, and "be realistic" didn't exist, what job would you wake up excited to do every single day?

I'll go first. Then it's your turn. 👇

🎯 My Dream Job

const me = {
  dreamJob: "Founder & CEO",
  company:  "My own startup",
  status:   "Building toward it. Every. Single. Day.",
  fuel:     ["dedication fire 🔥", "curiosity 🔍", "stubbornness 💪"],
};

console.log(`${me.dreamJob} of ${me.company}`);
// → "Founder & CEO of My own startup"

Yes, I want to be the person who starts with a blank editor and a wild idea, and ends up with a company that real people use, love, and work at. 🌱➡️🌳

🤔 Why Founder & CEO?

1. I want to build things that matter.
As developers we already turn ideas into reality with a keyboard. A founder takes it one step further: you pick which problem deserves to be solved.

2. The learning curve is a vertical wall, and I love it. 🧗
In one day a founder might be:

🕘 Time	🎭 Role
9:00 AM	Product Manager
11:00 AM	Developer (fixing a production bug)
1:00 PM	Salesperson
3:00 PM	Designer (yes, you picked that button color)
5:00 PM	Recruiter
8:00 PM	Therapist (for yourself)
11:00 PM	Developer again 😅

Where else do you get that many careers in one job?

3. Ownership. 🔑
Every decision, win, and failure is yours. It's terrifying, and it's also the most motivating thing I can imagine.

4. Creating jobs and opportunities. 🌍
Building a team that believes in the same mission and grows together is the part that excites me most.

⚖️ The Honest Part (Because Dreams Deserve Reality Checks)

✨ The Instagram version	🔥 The real version
"Being my own boss!"	Your boss is now every customer, investor, and deadline
"Big vision, big impact"	Big spreadsheets, small runway
"Pitching on stage"	Pitching to 40 people who say "interesting, let's keep in touch"
"Launch day 🎉"	Launch day → 3 signups (2 are your mom)
"Freedom"	Freedom to work 80 hours on whatever you want

I know all this and I still want it. Maybe that's how you know it's a dream and not just a job. 😄

🎲 Plot Twist: It Doesn't Have to Be My Startup

The CEO dream has a second version: becoming CEO of someone else's startup. Joining as early talent, growing with the company, earning the trust of the team, and eventually leading it.

Both paths are valid. Both are hard. Both are awesome.

🗳️ Quick Poll (Comment Edition)

Which dream-job category is closest to yours? Reply with the number:

1️⃣ 🚀 Founder / CEO
2️⃣ 💻 Dream dev role (open source, big tech, indie hacker)
3️⃣ 🎨 Creative (game dev, design, music, content)
4️⃣ 🌌 Totally outside tech (chef, pilot, astronaut, etc.)

I'll tally the results in the comments later. 📊

💬 Your Turn! Drop Your Dream Job Below

Any job is welcome. Developer, CEO, CTO, game designer, teacher, footballer, astronaut, farmer, YouTuber, anything. There are no wrong answers here, only inspiring ones. ✨

Copy this template and fill it in:

🎯 Dream job:
🧠 Why this one:
🛠️ What I'm doing right now to get there:
😅 The scariest part:
💡 One piece of advice I'd give someone with the same dream:

Not sure what to answer? Here are some conversation starters:

🧒 What did 5-year-old you want to be, and how far off is it from today?
🔄 Have you changed your dream job over the years? What changed it?
🏆 If you could be great at anything instantly, what would you pick?
🧭 Is your dream job something you want or something you were told to want?

🙌 Let's Make This Thread Awesome

I'll reply to every comment, because someone's dream deserves a response. 💙

Maybe someone here will find a co-founder, a mentor, or just the push they needed to start.

So tell me: what's your dream job, and what's one step you can take this week toward it? 👇

(And if your answer is "Founder & CEO" too, let's connect. The world needs more builders. 🚀)

P.S. If this post made you smile, think, or finally admit your dream out loud, drop a ❤️ or 🦄 and share it with someone who needs to hear that dreams are worth chasing.

Here's what I've built so far under the title of Founder & CEO @(Akhouri Systems)
👉https://akhouri-anmol-kumar.github.io/Akhouri-systems/

APIC v2 Development Has Begun: A New Desktop Image Editor Is Coming

Akhouri Anmol Kumar — Thu, 29 Oct 2026 12:41:00 +0000

Description: "Akhouri Systems has started building APIC v2, a desktop image editing tool. Here's the roadmap, the release condition, and how you can shape it by breaking APIC v1."

🚀 APIC v2 Development Starts Today — 29 October 2026

Short announcement, big news: as of 29 October 2026, the APIC v2 development program is officially initiated. I've started building it.

What is APIC?

APIC (Advanced Image Processing Center) is a free image tool from Akhouri Systems for editing, converting and compressing images. It comes in two forms:

🌐 APIC Web: a free online photo editor that runs entirely in your browser, with on-device AI background removal, no uploads and just signup to export the image. https://akhouri-anmol-kumar.github.io/APIC-web/
🖥️ APIC Desktop v1: a portable Windows app with Edit, Convert, Compress and Search modes, no installer needed.

APIC v2 is the next generation of the desktop version.

What will v2 have?

No spoilers yet. 🤐

I'm not showing a single feature today. But one thing is certain:

APIC v2 is set to be one of the best desktop image editing tools on the planet. 🌎

Akhouri Systems stands behind that. APIC Web is already holding its own against the big names, and APIC Desktop v2 is being built to do the same on the desktop.

When will it release?

The release is tied to the community, not a calendar date:

APIC v2 goes public when Akhouri Systems reaches 2,000 total downloads across all products.

As of 29 October 2026, the total is 1,400. That leaves 600 downloads to go. Every download moves the release date closer.

🛠️ Help shape v2: break APIC v1

While v2 is in the oven, download APIC v1 and put it through its paces:

👉 Download APIC v1 (APIC.zip)

Then:

Break it. Weird file formats, huge images, odd workflows. Try everything.
Find upgrades. Think of a missing feature, a slow spot or a clunky UX moment.
Tell me in the comments below.

My guarantee: if your suggestion is worthy, and I'll know it when I see it, I will implement it in APIC v2. 💯

Stay tuned

Follow me here on dev.to to see APIC v2 take shape. Share this post, download v1, and drop your feedback below.

What's the one feature you'd want in a desktop image editor? 👇

— Akhouri Systems

Are You a Python Developer or a Python Expert? 7 Tests I Failed Building 3 Desktop Apps

Akhouri Anmol Kumar — Wed, 28 Oct 2026 10:13:29 +0000

Description: Python security, screen capture, spring physics, HiDPI and PyInstaller .exe gotchas. 7 tests from shipping 3 no-telemetry Python apps for Windows (ATLOCK, ASNIPP, APIC).

Most Python developers can write a for loop, a Flask route and a pandas one-liner.

Python experts know what happens before line 1 runs, what Python can't do, and what breaks the moment your script leaves your laptop.

I found out which one I was while building three Windows desktop apps in pure Python: ATLOCK (a security suite), ASNIPP (a screenshot and screen recorder) and APIC (an image toolkit). No ads, no analytics SDKs, no bloat. Every test below is a real bug or design decision from one of them.

Score yourself honestly. 👇

Test 1: Do you know that import order can be a security decision? (ATLOCK)

Quick: what does import ctypes have to do with security?

On Windows, a DLL imported later can be loaded from the current directory. That is how DLL planting attacks work. The fix has to run before the other imports:

import sys, ctypes

if sys.platform == "win32":
    k32 = ctypes.WinDLL("kernel32", use_last_error=True)
    k32.SetDllDirectoryW.argtypes = [ctypes.c_wchar_p]
    k32.SetDllDirectoryW("")                      # drop the CWD from the DLL search path
    k32.SetDefaultDllDirectories.argtypes = [ctypes.c_uint32]
    k32.SetDefaultDllDirectories(0x1000)          # LOAD_LIBRARY_SEARCH_DEFAULT_DIRS

# only NOW import the heavy stuff
import cryptography, argon2

Developer: puts imports in alphabetical order.
Expert: knows import order is a runtime security boundary.

This is the very first thing that runs in ATLOCK, my pure-Python security suite.

Test 2: Can your screen recorder avoid recording itself? (ASNIPP)

I built a screen recorder with a floating control bar. First recording: the bar showed up in the video. 🤦

You don't need to hide and show windows. One Win32 call, straight from Python, does it:

import ctypes

def exclude_from_capture(widget):
    hwnd = int(widget.winId())
    # 0x11 = WDA_EXCLUDEFROMCAPTURE (Windows 10 2004+)
    ctypes.windll.user32.SetWindowDisplayAffinity(hwnd, 0x11)

The window stays visible to you and is invisible to every screen capture. That is how ASNIPP keeps its own toolbars, drawing overlay and recording border out of your videos.

Developer: crops the bar out in post.
Expert: knows ctypes gives Python the whole Windows API.

Test 3: Can your app decide what you meant, without asking? (APIC)

Good desktop software removes clicks. In APIC, my image toolkit, the rule is simple:

Drop one image → open it in the editor.
Drop many → open the batch converter.

def on_files(self, paths: list[str]):
    if not paths:
        paths, _ = QFileDialog.getOpenFileNames(
            self, "Open Image(s)", "",
            "Images (*.png *.jpg *.jpeg *.webp *.bmp *.tiff *.gif *.ico *.heic *.avif)")
    if len(paths) == 1:
        self.open_in_edit(paths[0])
    elif paths:
        self.open_in_convert(paths)

def dropEvent(self, event):
    self.on_files([u.toLocalFile() for u in event.mimeData().urls()])

The home screen, the file dialog and drag-and-drop all go through one function. Add a new entry point and you add zero logic.

Developer: writes three code paths.
Expert: writes one funnel and lets every input flow into it. The UI is split into one module per mode (edit, convert, compress, search), and main.py only wires them together.

Test 4: Do you know the difference between "encrypted" and "encrypted correctly"? (ATLOCK)

Developer: AES.new(key, AES.MODE_ECB) and done.

Expert checklist:

AEAD, not just encryption: AES-256-GCM authenticates every chunk.
Slow KDF for passwords: Argon2id, not a bare SHA-256.
Never reuse a nonce with the same key.
Bind the header with AAD so metadata can't be swapped.

import os
from argon2.low_level import hash_secret_raw, Type
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def seal(password: bytes, data: bytes) -> bytes:
    salt = os.urandom(16)
    key = hash_secret_raw(password, salt, time_cost=3, memory_cost=64 * 1024,
                          parallelism=4, hash_len=32, type=Type.ID)
    nonce = os.urandom(12)
    ct = AESGCM(key).encrypt(nonce, data, associated_data=b"v1")
    return salt + nonce + ct

(Simplified. ATLOCK's real container format also does chunking, key commitment and versioning.)

Test 5: Can you make a Qt animation feel alive with 6 lines of math? (ASNIPP)

ASNIPP's capture bar is a "Dynamic Island" that bounces open. Qt's built-in easing curves felt stiff, so I wrote a damped spring and plugged it into QEasingCurve:

import math
from PyQt6.QtCore import QEasingCurve

def spring(zeta, omega):
    wd = omega * math.sqrt(max(1e-6, 1 - zeta * zeta)) if zeta < 1 else 0.0
    def f(t):
        if t <= 0: return 0.0
        if t >= 1: return 1.0
        if zeta < 1:    # under-damped: overshoots, then settles (the bounce)
            return 1 - math.exp(-zeta * omega * t) * (math.cos(wd * t) + (zeta * omega / wd) * math.sin(wd * t))
        return 1 - math.exp(-omega * t) * (1 + omega * t)   # critically damped: no overshoot
    return f

BOUNCY = spring(0.66, 11.0)   # keep it at MODULE level (see below)

curve = QEasingCurve(QEasingCurve.Type.Linear)
curve.setCustomType(BOUNCY)

The trap: if the function is a temporary object, Python garbage-collects it while Qt still holds a pointer, and you get random crashes. Keep custom callables alive at module level. Only people who've been bitten know this one.

Test 6: Does your app look sharp on a 4K laptop with 150% scaling? (APIC)

Most Python GUI apps look blurry or oddly sized on modern displays. In Qt 6 the fix is one policy before you create the app:

from PyQt6.QtWidgets import QApplication
from PyQt6.QtCore import Qt

QApplication.setHighDpiScaleFactorRoundingPolicy(
    Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)   # no rounding: 125%/150% stay crisp

app = QApplication(sys.argv)
app.setApplicationName("APIC")
app.setOrganizationName("Akhouri Systems")

PassThrough keeps fractional scales like 125% and 150% exact instead of snapping to 100% or 200%. Add one try/except AttributeError for older Qt builds, and your app looks native everywhere.

Developer: tests on their own monitor.
Expert: tests at 100%, 125%, 150% and 200%.

Test 7: Can you explain why Python can't truly erase a password from memory? (ATLOCK)

password = "hunter2"
password = None   # is it gone? 🙂

No. Python str and bytes are immutable, and the interpreter is free to copy them. The best you can do is keep secrets in a mutable bytearray and wipe it explicitly:

buf = bytearray(b"hunter2")
# ... use it ...
for i in range(len(buf)):
    buf[i] = 0

An honest Python security tool says this out loud instead of promising magic. ATLOCK's source header lists what it can't do: memory wiping is best-effort, SSD shredding can't be guaranteed, and a same-user attacker can modify the script. Python experts document their limits.

Bonus: "Why does it work in VS Code and silently do nothing as a `.exe`?"

All three of my apps ship as Python compiled with PyInstaller (--onefile --windowed). It cost me an evening before I learned this: in a windowed build, sys.stdout and sys.stderr are None. Any print(), logging call or library traceback can fail silently, and your app "just doesn't open."

import sys, os

for name in ("stdout", "stderr"):
    if getattr(sys, name, None) is None:
        setattr(sys, name, open(os.devnull, "w", encoding="utf-8"))

# and show errors somewhere a human can see them:
import ctypes
ctypes.windll.user32.MessageBoxW(None, "Startup failed: ...", "App error", 0x10)

Try the code yourself

I'm the developer behind all of this, and the three apps are the proof that it works outside tutorials. They're built by Akhouri Systems, each is pure Python packaged as an .exe in a zip, with no ads and no analytics. The only network features are the ones you trigger yourself (for example ATLOCK's optional breach check, which sends only a 5-character hash prefix).

App	Python lesson it proves	What it is	Get it
🔐 ATLOCK v5	Tests 1, 4, 7	Security suite: AES-256-GCM + Argon2id file guard, password vault, TOTP/FIDO2, anti-tamper	Direct download (zip) · Microsoft Store
📸 ASNIPP v1	Tests 2, 5	Dynamic-Island-style screenshot, screen recorder, live drawing and editor	Direct download (zip)
🖼️ APIC v1	Tests 3, 6	Image edit, convert, compress and search toolkit	Direct download (zip)

If you're learning how Python behaves outside a notebook, run them and then ask what's going on under the hood. That's the fastest way I know to level up.

Your score

0–2 tests known: You're a Python developer. Great start, now go break things.
3–5: Solid. You've shipped something real.
6–7: You're a Python expert. Come argue with me in the comments.

Which test did you fail first? Mine was the windowed-.exe one, and I lost an entire evening to it. Tell me yours below 👇

ASNIPP: The Dynamic Island Snipping Tool for Windows (A Free ShareX & Snipping Tool Alternative)

Akhouri Anmol Kumar — Tue, 27 Oct 2026 10:27:43 +0000

Description: "ASNIPP is a free Dynamic Island-style screenshot tool, screen recorder and editor for Windows, with live drawing, OCR, a color picker and a capture library. A cool alternative to ShareX and the Windows Snipping Tool."

I Built a Dynamic Island Snipping Tool for Windows. Here's Why It Might Replace ShareX and the Snipping Tool for You

Every Windows screenshot tool I tried made me choose between simple but limited (the built-in Snipping Tool) and powerful but overwhelming (ShareX, with its dozens of menus and workflows).

I wanted neither. I wanted something that feels like a 2026 app: fast, beautiful, and always one hotkey away.

So I built ASNIPP, a Dynamic Island-style snipping tool, screen recorder and editor for Windows. It's free, and you can run it in about 10 seconds.

👉 Download ASNIPP v1.0.0 (.zip), then extract it and run ASNIPP.exe. No installer.

What Is a "Dynamic Island" Snipping Tool?

If you've used an iPhone, you know the Dynamic Island: a small pill that expands and contracts depending on what you're doing.

ASNIPP brings that idea to your Windows desktop. A floating, animated pill sits at the top of your screen. It:

Morphs between idle, capture and recording states with spring-physics animation
Expands into a recording bar with a live timer and audio level meters
Stays out of the way until you need it

It's the same job as the Snipping Tool, with a UI that feels designed rather than assembled.

Feature Tour

📸 Screenshots in one keystroke

Hotkey	Action
`Win + Shift + S` / `Ctrl + Shift + S` / `PrintScreen`	Capture a photo
`Win + Shift + R`	Start or stop video recording
`Ctrl + Alt + D`	Live screen drawing
`Ctrl + Alt + P`	Color picker + pixel ruler
`Ctrl + Alt + L`	Capture library

Captures are saved and copied to your clipboard, so you can paste straight into Slack, Discord or a GitHub issue.

🎥 A screen recorder with real audio

Record system audio (WASAPI loopback, meaning whatever your PC is playing)
Record your microphone for voice-over
Both tracks are mixed and embedded into the video automatically
ASNIPP hides its own windows from the recording (Windows 10 2004+)
Pause and resume without desyncing audio and video

✏️ Draw on your screen, even while recording

This is my favorite feature. Press Ctrl + Alt + D for a presentation-mode drawing overlay with:

Pen, highlighter, arrow, rectangle, eraser and a laser pointer
Number-key color shortcuts
Mouse-wheel brush sizing

And because it works during recording, your annotations are recorded into the video. That makes it very handy for tutorials, demos and code walkthroughs.

🖼️ A full editor, not just a crop box

After a capture you land in an editor with:

Pen, highlighter, arrows, rectangles and text
Pixelate tool to hide API keys, emails and other sensitive info
OCR to extract text from any screenshot (uses the Windows built-in OCR engine)
Pin to screen, which floats a capture always-on-top as a reference (scroll to resize)
Undo/redo, copy to clipboard and one-click Done

🎞️ A video editor hiding inside

Recorded a clip? You don't need another app to clean it up:

Trim, split at the current frame, and join clips together
Speed from 0.1× to 16×, plus reverse
Color looks and filters (B&W, noir, sepia, vivid, warm and more), with brightness, contrast and saturation
Rotate and flip, fade in and out, change aspect ratio
Export to MP4, AVI, WMV, MOV or animated GIF

🎯 A color picker and pixel ruler

Press Ctrl + Alt + P for a magnifying loupe, HEX/RGB readout, and a pixel measuring tool with angle snapping. If you do front-end work, this alone might earn it a spot in your startup folder.

🗂️ Capture library

Every screenshot and recording goes into a searchable visual library with thumbnails and favorites. It keeps your newest 50 non-favorite captures, and favorites are never auto-deleted. You can pin, copy or send anything to the Recycle Bin from there.

ASNIPP vs ShareX vs Windows Snipping Tool

I respect both of these tools. ShareX is genuinely powerful, and the Snipping Tool is everywhere. This is where ASNIPP positions itself:

	ASNIPP	ShareX	Windows Snipping Tool
Dynamic Island-style animated UI	✅	❌	❌
Screenshot + screen recording + editor in one	✅	✅	Partial
Live on-screen drawing, recorded into the video	✅	❌	❌
Built-in color picker + pixel ruler	✅	✅	❌
Built-in video trim / speed / filters / join	✅	Limited	Limited
Visual capture library with favorites	✅	History window	❌
Learning curve	Low	High (many workflows)	Very low
Setup	Unzip and run	Installer	Preinstalled

Choose ShareX if you need automated upload pipelines to dozens of hosting services.
Choose the Snipping Tool if you just need a quick crop.
Choose ASNIPP if you want a beautiful, fast, all-in-one capture tool that doesn't need a manual.

Is ASNIPP Safe? Does It Phone Home?

I know that's the first question when you run a random .exe from the internet, so here is the honest answer:

The code has no network or upload logic. Your captures stay in Pictures/ASNIPP Pics and Pictures/ASNIPP Vid
It doesn't replace the Windows Snipping Tool shortcut unless you opt in
Windows may show a SmartScreen prompt for any new, unsigned app. Click More info → Run anyway, or scan the zip on VirusTotal first

Under the Hood (for the devs)

Since this is DEV, here's the stack:

Python + PyQt6 for the UI, custom-painted glass bars and spring-physics animations
mss for fast multi-monitor screen capture
OpenCV + NumPy for frame processing, filters and export
WASAPI loopback (PyAudioWPatch) and sounddevice for system audio and mic
FFmpeg (bundled via imageio-ffmpeg) to mix audio and mux it into the final video
Win32 hooks via ctypes for global hotkeys, click-through overlays, capture exclusion and Recycle Bin integration

The hardest parts were keeping loopback audio in sync with video when nothing is playing (Windows loopback goes silent), and making the island morph feel smooth instead of janky.

Get Started in 10 Seconds

Download ASNIPP_v1.zip
Extract the zip
Run ASNIPP.exe
Press Win + Shift + S and watch the island come alive

⭐ If it saves you time, star the repo at github.com/Akhouri-Systems/ASNIPP. It's the single biggest thing that helps a solo project get discovered.

FAQ

What is the best free alternative to the Windows Snipping Tool?
ASNIPP is a free alternative that adds screen recording, live drawing, OCR, a color picker and a video editor on top of screenshots.

Is there a ShareX alternative with a simpler, modern UI?
ASNIPP's Dynamic Island interface is built to be simpler than ShareX, with one pill, a few hotkeys and no workflow configuration.

Is there a Dynamic Island app for Windows that takes screenshots?
Yes. ASNIPP is a Dynamic Island-style snipping tool and screen recorder for Windows.

Can I record system audio and my microphone together?
Yes. ASNIPP records both and mixes them into a single MP4.

Can I annotate my screen while recording?
Yes. Press Ctrl + Alt + D, and your drawings are captured in the video.

Does it export GIFs?
Yes, with trim and speed controls, up to about 30 seconds per GIF.

Which Windows versions are supported?
Built for Windows. Some features, like hiding ASNIPP from recordings, need Windows 10 version 2004 or later.

What Should I Build Next?

I'm shipping updates fast. What's the one feature that would make you switch from your current screenshot tool? Scrolling capture? Cloud sharing? Tell me in the comments 👇 and I'll prioritize the most-requested ones.

Built with 💖 by Akhouri Systems.

Does Encryption Really Matter? An Honest Answer for Windows Users

Akhouri Anmol Kumar — Mon, 26 Oct 2026 10:33:13 +0000

Description: Does encryption really matter if you have nothing to hide? What it protects, where it fails, and how to use it on Windows without being an expert.

Short answer: yes, but not for the reason most people think. Encryption isn't about hiding secrets. It's about making sure that the worst day of your digital life (a stolen laptop, a leaked password, a curious stranger on your PC) stays an inconvenience instead of a disaster.

Ask ten people whether they need encryption and you'll hear the same two answers. The first: "I have nothing to hide." The second: "That's for hackers and governments."

Both answers feel logical. Both are quietly wrong. Let's walk through why, without jargon, and then look at what a sensible setup actually looks like on an ordinary Windows PC.

What encryption actually does

Encryption scrambles your data using a key, so it's unreadable to anyone who doesn't have that key. The scrambling is done with maths, not obscurity. A modern cipher like AES-256 is designed so that guessing the key by brute force is not realistic on any hardware that exists or is likely to exist.

So when encryption is done properly, nobody "breaks" it. The attacker goes around it: they guess your password, find the key lying next to the lock, or take advantage of a file you forgot to protect. That single idea explains almost everything else in this article.

"I have nothing to hide"

Most people aren't hiding anything illegal. But privacy was never only about secrets. Think about what's sitting on your drive right now:

Scans of your Aadhaar, PAN, passport or driving licence
Bank statements and tax returns
Saved logins and browser sessions
Family photos, private chats, medical reports
Client files or work documents that aren't yours to leak

You don't need to be hiding something for those to be valuable. Identity documents are exactly what fraudsters want. Photos and messages are exactly what hurts when they get out. "Nothing to hide" really means "nothing I'd be happy to hand over", and that's a much shorter list than most of us admit.

"My Windows password protects my files"

This is the most common misunderstanding, so it's worth being precise. Your Windows sign-in password protects the session: it decides who gets to the desktop. It does not scramble your files.

If someone removes your drive and plugs it into another computer, or boots from a USB stick, the sign-in screen is simply never part of the story. Your files are right there, readable, because nothing on the disk was encrypted.

A login screen is a door. Encryption is what makes the walls solid. A door alone doesn't help much if someone can walk around the building.

"That's for hackers and governments"

The realistic threats for most of us are far more boring:

A lost or stolen laptop. The most common one, and the one encryption handles best.
Someone with brief physical access. A shared PC, a repair shop, a relative, a curious colleague.
Leaked or reused passwords. Billions of credentials from old breaches are floating around. If you reuse passwords, one leak can open many doors.
Cloud mishaps. Sync the wrong folder to the wrong place and plaintext copies are suddenly everywhere.

None of these need a movie-style hacker. They need an ordinary bad day. Encryption is the thing that stays quiet and works anyway.

Where encryption quietly fails

Here's the part most "just encrypt everything!" articles skip. Encryption can be real and still useless in practice. The usual culprits:

Failure	What it looks like
Weak password	A strong cipher protected by `Name@123` is as strong as `Name@123`.
Cheap key derivation	Your password is turned into a key too quickly, so attackers can try billions of guesses per second.
Key stored beside the lock	The decryption key sits in a plain file or note on the same machine.
Forgotten plaintext copies	Temp files, "Downloads", cloud-synced originals, and old backups.
No recovery plan	You forget the password, and the data is gone for good. Which is exactly how it's supposed to work.

The second row deserves a closer look, because it's invisible to users. When you type a password, the software has to turn it into an actual encryption key. This step is called a key derivation function, and its job is to be deliberately slow and memory-hungry so that guessing becomes expensive. A modern choice here is Argon2id, the winner of the Password Hashing Competition. It forces every guess to burn real memory and time, which makes mass guessing on GPUs far less practical.

When I built ATLOCK, this was one of the first decisions I made. Its vault and protected files use Argon2id to derive keys and AES-256-GCM to seal the data. GCM matters because it's authenticated: if even one byte of an encrypted file is tampered with, decryption fails loudly instead of silently handing you corrupted data. I mention it not to show off but because it's a good test for any tool you consider: can it tell you plainly what it uses, and does it make sense?

A sensible setup for a normal person

You don't need to encrypt your whole life. You need a few layers that cover the realistic risks.

1. Turn on full-disk encryption

This protects everything if the laptop is lost or stolen. On Windows 10/11 Pro that's BitLocker; many Home editions offer "Device encryption" in Settings → Privacy & security. Check which one you have, and save the recovery key somewhere that isn't the same laptop.

2. Stop reusing passwords

Use a password vault and let it generate a unique password per site. A vault that lives on your own device, with no account and no cloud sync, removes an entire category of risk. I wrote a separate walkthrough on that: How to keep an offline encrypted password vault on Windows.

3. Give your most sensitive folders their own lock

Full-disk encryption protects a powered-off laptop. It does very little once you're signed in and walk away from your desk. A second layer for the genuinely sensitive stuff (ID scans, financial records, client data) means that someone who gets onto your unlocked PC still can't open it. This is the job of a file-level lock like ATLOCK's File Guard, and there's a step-by-step in how to protect a folder in Windows.

4. Use a long passphrase, not a clever password

Four or five unrelated words beat P@ssw0rd! every time, and they're easier to remember. If a tool offers a key file or hardware key as an extra factor on top of your password, even better.

5. Keep an encrypted backup, and test the recovery

Encryption without a backup is a trap. Encrypted backups without a tested recovery are the same trap with extra steps. Do one restore a year to be sure it works.

How to judge any encryption tool

Whether you pick BitLocker, VeraCrypt, KeePass, ATLOCK or something else, ask the same questions:

Does it name its algorithms? "Military-grade" is marketing. "AES-256-GCM with Argon2id" is information.
Does it work offline? Fewer network connections means fewer places for your data to leak.
Does it need an account? If your lock depends on someone else's server, you've added a dependency you don't control.
Is it honest about its limits? Good security software tells you what it cannot do.

That last one is worth a pause. Software running as you, on your PC, can't fully defend against an attacker who already controls your account. Secure deletion on SSDs can't be guaranteed. Full-disk encryption like BitLocker is still the right foundation. I've put these caveats in ATLOCK's own documentation because pretending otherwise would be a worse kind of security. A tool that promises you "unbreakable" is a tool that hasn't thought hard about the problem.

So, does encryption really matter?

Yes. Not because someone is hunting you, but because computers get lost, passwords get leaked, and people get curious. Encryption is cheap insurance against all three, and unlike most insurance, it costs you nothing when nothing goes wrong.

You don't have to do everything today. Pick one: turn on disk encryption, move your passwords into a vault, or lock the one folder you'd hate to see leaked. Any one of those puts you ahead of most people.

Originally published on Akhouri Systems. I'm Akhouri Anmol Kumar, developer of ATLOCK, APIC and ASNIPP: free, portable Windows tools with zero telemetry.

Which Programming Language Is the Best Overall? Python vs JavaScript vs Java vs C++ vs Rust

Akhouri Anmol Kumar — Sun, 25 Oct 2026 10:33:01 +0000

Description: An honest battle of the top 5 programming languages, with real pros, cons, and use cases, plus what I learned shipping Python apps as .exe files.

Which Programming Language Is the Best Overall?

Every few months this question blows up a comment section: "What is the best programming language?"

Here is the honest answer: the best programming language overall is the one that gets your project shipped. But "it depends" is a boring answer, so let's do this properly. Below is a head-to-head battle of five major languages, with pros, cons, ideal use cases, and a final scorecard.

Quick disclosure: I'm the developer behind Akhouri Systems, where I build Windows tools in Python. I'll share that experience where it's relevant, because real shipping experience beats theory.

How I'm judging "best overall"

Criteria	Why it matters
Learning curve	How fast can a beginner become productive?
Performance	Speed and memory efficiency
Ecosystem	Libraries, frameworks, community
Job market	Demand and salary potential
Versatility	Web, desktop, AI, mobile, systems
Shipping speed	Idea to working product

1. Python: The Swiss Army Knife

Best for: AI/ML, automation, scripting, data science, backend APIs, desktop utilities.

Pros

Readable, beginner-friendly syntax
Massive library ecosystem (NumPy, pandas, PyTorch, FastAPI, Tkinter, and more)
Fastest path from idea to prototype
Huge community and endless tutorials

Cons

Slower than compiled languages at raw computation
Not the first choice for mobile apps or low-level systems work
Distributing desktop apps takes extra steps (more on that below)

Verdict: If "best overall" means versatility plus speed of development, Python is the strongest contender.

Real-world note: shipping Python as a Windows .exe

Most people think Python is only for scripts and notebooks. But you can package a Python project into a standalone Windows executable using tools like PyInstaller, zip it, and let people run it with no Python install.

That's the approach I used for my own tools under Akhouri Systems:

ASNIPP - [Windows snipping tool alternative] - Download v1
ATLOCK - [Total Security Suite for Windows] - Download v5
APIC - [Local image editing suite] - Download v1

Lessons from packaging them:

File size grows. A bundled interpreter plus dependencies makes even a tiny tool tens of MB. Trim unused imports and consider --exclude-module.
Antivirus false positives happen. PyInstaller executables sometimes get flagged. Publishing on GitHub Releases with a clear source and changelog builds trust.
Zipping helps distribution. One zip, one download link, versioned releases.
Test on a clean machine. Missing DLLs show up only where Python isn't installed.

Python is not "just for scripts." It can ship real desktop software.

2. JavaScript (and TypeScript): The Language of the Web

Best for: Frontend, full-stack web, serverless, cross-platform apps (Electron, React Native).

Pros

The only language that runs natively in every browser
Node.js lets you use one language across frontend and backend
Enormous ecosystem (npm)
TypeScript adds safety and better tooling

Cons

Quirky type coercion and legacy baggage
Dependency sprawl and framework churn
Electron apps can be memory hungry

Verdict: If your goal is web development, JavaScript/TypeScript is non-negotiable.

3. Java: The Enterprise Workhorse

Best for: Enterprise backends, Android (alongside Kotlin), large-scale systems, banking.

Pros

"Write once, run anywhere" via the JVM
Mature tooling, strong typing, battle-tested at scale
Excellent job market in enterprise

Cons

Verbose compared to modern alternatives
Heavier startup and memory footprint
Slower to prototype

Verdict: Not flashy, but if you want stable, long-term career demand, Java still delivers.

4. C++: Maximum Performance, Maximum Responsibility

Best for: Game engines, embedded systems, high-frequency trading, operating systems, performance-critical software.

Pros

Near-metal performance and fine control over memory
Powers major game engines and system software
Huge legacy codebase means steady work

Cons

Steep learning curve
Manual memory management invites bugs
Long compile times, complex tooling

Verdict: Unmatched when performance is everything, but costly in development time.

5. Rust: The Modern Systems Challenger

Best for: Systems programming, CLI tools, WebAssembly, security-critical software.

Pros

Memory safety without a garbage collector
Performance comparable to C and C++
Excellent tooling (Cargo) and a passionate community

Cons

Steep learning curve (the borrow checker humbles everyone)
Smaller job market than the incumbents
Slower initial development

Verdict: The future of safe systems programming, but not the easiest first language.

The Battle Scorecard

Scores out of 5 (my opinion, not gospel):

Language	Learning curve	Performance	Ecosystem	Job market	Versatility	Shipping speed
Python	5	2	5	5	5	5
JavaScript/TS	4	3	5	5	4	4
Java	3	4	4	5	4	3
C++	1	5	4	4	3	2
Rust	2	5	3	3	3	3

So, which is the best overall?

Best overall (balance of everything): Python
Best for the web: JavaScript/TypeScript
Best for enterprise stability: Java
Best for raw performance: C++
Best for safe systems code: Rust

If you're picking one language to learn first and want the widest set of doors open, Python is hard to beat. If you already know one, learning a second from a different category (say Python plus Rust) makes you far more valuable than going deeper on a language similar to the one you know.

Your turn

I want to hear the disagreements:

Which language would you crown as the best overall, and why?
Did I underrate your favorite?
Have you ever shipped a Python project as a standalone .exe? What tripped you up?

Drop it in the comments. The best discussions on this topic always come from the people who disagree with the ranking.

Written by the Developer & Founder behind Akhouri Systems.

ASNIPP: Free Snipping Tool Alternative for Windows 11

Akhouri Anmol Kumar — Sat, 24 Oct 2026 07:39:52 +0000

Description: ASNIPP is a free, portable screenshot tool and screen recorder for Windows with OCR, live drawing, pin-to-screen and system audio. Download v1.0.0 now.

⬇️ Download ASNIPP v1.0.0 for Windows · portable ZIP · no installer

ASNIPP v1.0.0 is officially released. It is a free, portable screenshot tool, screen recorder and editor for Windows, with a floating Dynamic-Island style bar. If you want a Windows Snipping Tool alternative that records system audio, extracts text with OCR and lets you draw on screen, download it here, unzip it and run ASNIPP_v1.exe. It is built by Akhouri Systems.

⚠️ Honest notes up front: ASNIPP is Windows only. It is a new, unsigned app, so SmartScreen may warn you on first run. Audio recording depends on the audio libraries inside the app. Details below.

Why I built ASNIPP
Features at a glance
How to take a screenshot on Windows
How to record your screen with system audio
Screen recorder with live drawing
Screenshot editor with OCR
How to pin a screenshot to the screen
Color picker and pixel ruler
Capture library and video editor
Keyboard shortcuts
Specs and requirements
Download and first run
Privacy and safety
Comparison with Snipping Tool
FAQ
What's next

Why I built ASNIPP

I am Akhouri Anmol Kumar, founder of Akhouri Systems in India. My daily work needed screenshots, short screen recordings, a quick annotation and sometimes a copied color value. With the default Windows tools, that meant several apps and many extra clicks.

So I built one small tool that does all of it from one bar. It is a Python app (PyQt6, OpenCV, mss) and a portable screenshot tool, no install needed. If you are searching for the best Snipping Tool alternative for Windows 11, this is my entry.

Features at a glance

📸 Capture: region photo, region video, full-screen shot
🔊 Screen recorder with system audio (WASAPI loopback) and optional microphone
✏️ Live screen drawing, also while recording
🔍 OCR: extract text from any capture
📌 Pin screenshot to screen: floating, always on top
🎨 Color picker and pixel ruler with a magnifier
📚 Capture library with favorites
🎞 Video tools: trim, split, join, looks, speed, rotate, fades, aspect ratios
📦 Export: PNG, MP4, AVI, WMV, MOV, GIF
🖥 Win+Shift+S replacement: reversible from the tray

How to take a screenshot on Windows with ASNIPP

Press Win+Shift+S, Ctrl+Shift+S or PrtScn. The screen freezes. Drag to select an area. Press Esc or right-click to cancel.

Three things happen at once: it saves a PNG to Pictures\ASNIPP Pics, copies the image to your clipboard, and shows a preview in the bar. Click the preview to edit, or tap 📌 to pin it. The Screen button grabs the whole monitor under your cursor.

How to record your screen with system audio on Windows

This is the free screen recorder for Windows with system audio part.

Pick Video (or press Win+Shift+R) and drag the area to record.
Toggle 🔊 system audio (on by default) and 🎙 microphone (off by default) on the bar.
A 3-second countdown starts. A border marks the recording area.
Pause, restart or stop from the bar. Press Win+Shift+R again to stop.

Details from the code: video records at 30 FPS to MP4 in Pictures\ASNIPP Vid. System audio uses WASAPI loopback through PyAudioWPatch, with a "Stereo Mix" style device as fallback. Audio is mixed after you stop ("Mixing audio…") and embedded with a bundled ffmpeg (AAC, 192k in MP4). Live level meters show what is being captured. It also tries to keep its own bar out of the recording (Windows 10 version 2004 or newer).

If an audio library is missing, a toast tells you and the recording continues without that source.

Screen recorder with live drawing

Press Ctrl+Alt+D to draw on your screen. It works for presentations, and it also works while recording: click the pen on the recording bar and your ink ends up in the video. The drawing toolbar itself is excluded from capture.

Tool	Key
Use screen normally (click-through)	Space
Pen / Highlighter	P / H
Arrow / Rectangle / Circle	A / R / O
Laser pointer / Eraser	L / E
6 colors	1 to 6
Undo	Ctrl+Z or right-click
Clear all ink	Delete
Auto-fade ink / Hide-show ink	F / V
Brush size (2 to 40)	mouse wheel
Exit	Esc

Screenshot editor with OCR for Windows

Click a preview to open the editor. Tools: pen, highlighter, arrow, rectangle, text (double-click to edit), pixelate to hide sensitive info, crop (Enter applies), color picker and pixel ruler. There are 6 colors and a size slider. Ctrl+Z undoes, Ctrl+S saves a PNG, and Done saves, copies and closes. Ctrl+M shrinks the editor into a mini island.

OCR: click 🔍 and the text is extracted locally. It uses the Windows built-in OCR engine through PowerShell, preferring English and falling back to your other installed OCR languages. Results show in a window you can copy from. You can also change the aspect ratio (16:9, 9:16, 1:1, 4:5, 4:3). That adds black bars, nothing is stretched.

How to pin a screenshot to the screen on Windows

Tap 📌 on the preview or in the editor. The image becomes a frameless, always-on-top window.

Drag to move. Mouse wheel zooms (0.15× to 6×). Double-click resets size.
Ctrl+wheel changes opacity. Right-click for opacity 100/80/60/40%, copy, save or "Edit in ASNIPP".
Ctrl+C copies. Esc closes the pin.

It is handy for design references, error messages and docs you type from.

Color picker and pixel ruler for Windows

Press Ctrl+Alt+P. The screen freezes and a 15×15 pixel loupe follows your cursor.

Click copies HEX. Shift+click copies RGB. C copies HEX.
Arrow keys nudge by 1 pixel, Shift+arrow by 10.
Tab or M switches to the ruler: drag to measure dx, dy, distance and angle, C copies it.
Recent colors stay as swatches you can click to copy. Esc exits.

Capture library and video editor

Ctrl+Alt+L opens the library: filters for All, Photos, Videos and Favorites. The index keeps the newest 50 non-favorite captures (files stay on disk). Favorites are never pruned. Deleting sends the file to the Recycle Bin after confirmation.

Open a video and the editor adds a timeline:

Trim: [ and ] set in and out. Split at the current frame. Join another clip to the end.
Looks: Original, B&W, Noir, Sepia, Vivid, Warm, Cool, Matte, Invert, Vignette, Sharpen, Soften, plus brightness, contrast and saturation.
Speed: 0.25×, 0.5×, 1×, 2×, 4×. Reverse, rotate 90°, flip horizontally or vertically. Fade in and out up to 3 seconds.
Export (Ctrl+E): original, 75% or 50% size, as MP4, AVI (XVID or MJPG), WMV, MOV or GIF. Drawings and text are burned in, audio is kept (not in GIFs).

GIF export needs Pillow. It runs at up to 15 FPS, up to 640 px wide, and refuses output longer than about 30 seconds, so trim first.

⬇️ Want to try it? Download v1.0.0 (ZIP)

Keyboard shortcuts for Windows screenshots and recording

A real Win+Shift+S replacement needs good shortcuts. Global hotkeys:

Shortcut	Action
Win+Shift+S	Photo (needs the takeover, see below)
Ctrl+Shift+S	Photo
PrtScn	Photo
Win+Shift+R	Start video, press again to stop
Ctrl+Alt+D	Live screen drawing
Ctrl+Alt+P	Color picker and pixel ruler
Ctrl+Alt+L	Capture library

In the video editor: Space play/pause, ←/→ one frame, Shift+←/→ about one second.

Specs and system requirements

Item	Detail
Version	1.0.0
Platform	Windows only
Install type	Portable ZIP, run `ASNIPP_v1.exe`, no installer
Built with	Python, PyQt6, OpenCV, mss, NumPy
Audio libraries	sounddevice (mic), PyAudioWPatch (system audio), imageio-ffmpeg (mixing)
Optional	Pillow (GIF export)
Images	PNG, copied to clipboard
Video	MP4 recording at 30 FPS; export MP4, AVI, WMV, MOV, GIF
Audio sources	System audio (WASAPI loopback), microphone
Saves to	`Pictures\ASNIPP Pics`, `Pictures\ASNIPP Vid`
App data	`%USERPROFILE%\.asnipp` (settings, library index, thumbnails)
Account, ads, telemetry	None in the code

ASNIPP download and first run

Download the ZIP from the official GitHub releases.
Extract the ZIP anywhere.
Run ASNIPP_v1.exe. If SmartScreen warns, that is because the app is new and unsigned. Check that you downloaded it from the official repo, then choose More info → Run anyway.
The bar appears at the top of your screen and an icon appears in the system tray (the ^ near the clock). Only one instance runs at a time.

First launch, important: about 2.6 seconds in, the app makes itself your screenshot tool. It claims Win+Shift+S, Win+Shift+R and PrintScreen, and switches off Windows' "PrtScn opens screen capture" setting. A dialog tells you this. If Windows refuses, use Ctrl+Shift+S.

Get Snipping Tool back: right-click the tray icon and untick Use Win+Shift+S for ASNIPP. Your previous PrtScn setting is restored.

Start with Windows is opt-in, in the same tray menu. It starts quietly in the tray.

Is ASNIPP safe? Privacy explained

I would rather explain this than ask for trust.

The keyboard hook. To beat the shell for Win+Shift+S, it installs a Windows low-level keyboard hook. Windows passes key events to the hook, but the code only reacts to S and R while Win and Shift are held. Nothing is logged or stored.
No network code. The source has no HTTP calls, sockets, analytics or update checker. It works offline, and OCR runs on your PC.
What is stored. Your captures in Pictures, plus settings, a library index and thumbnails in .asnipp. Temporary audio and OCR files go to the Windows temp folder and are removed after use.
Registry. It changes the PrtScn capture setting when you enable the takeover, and writes the startup entry only if you enable Start with Windows. Both are in your user profile (HKCU).
PowerShell. OCR runs a short PowerShell script with -ExecutionPolicy Bypass for that single call.

ASNIPP vs Windows Snipping Tool

The Snipping Tool has improved a lot: Microsoft documents screen recording with audio, text actions (OCR) and a color picker. This table sticks to what Microsoft documents and what ASNIPP's code does. Check Microsoft's Snipping Tool page for the latest.

	ASNIPP v1.0.0	Windows Snipping Tool
Built into Windows, signed by Microsoft	No, separate unsigned download	Yes
Install	Portable ZIP	Included
Snip shapes	Rectangle, full screen	Rectangle, window, full screen, freeform
Screen recording with audio	Yes, system audio and microphone	Yes
OCR	Yes, Windows OCR engine	Yes, Text actions
Color picker	Yes, with loupe and HEX/RGB copy	Documented (some features need a Copilot+ PC)
Pixel ruler	Yes	Not in Microsoft's docs
Live screen drawing, also while recording	Yes	Not in Microsoft's docs
Pin screenshot to screen	Yes	Not in Microsoft's docs
Video looks, speed, reverse, join	Yes	Not in Microsoft's docs
Export formats	MP4, AVI, WMV, MOV, GIF	Check Microsoft's docs

If you want zero third-party software, keep the built-in tool. If you want the extra tools above, try it.

ASNIPP FAQ

Is ASNIPP free?
Yes. It is free to download, and the code has no accounts, licence checks or ads.

Does ASNIPP replace Windows Snipping Tool?
It replaces the shortcuts, not the app. On first launch it takes over Win+Shift+S, Win+Shift+R and PrintScreen. Snipping Tool stays installed.

How do I get Snipping Tool back?
Right-click the tray icon and untick "Use Win+Shift+S for ASNIPP". Or exit the app from the tray.

How do I record screen with audio on Windows using ASNIPP?
Click Video, keep 🔊 on for system audio, turn on 🎙 for your microphone, drag an area and wait for the countdown. Stop with the bar or Win+Shift+R.

Does ASNIPP work on Windows 11?
It is built for Windows and designed around the Win+Shift+S, Win+Shift+R and PrintScreen behaviour of Windows 11. Hiding its own bar from recordings needs Windows 10 version 2004 or newer.

Is ASNIPP safe?
It makes no network requests and does not log keys. It uses a keyboard hook for Win+Shift+S and Win+Shift+R only. It is unsigned, so download it only from the official GitHub release.

Why does SmartScreen warn about this app?
It is a new app without a code-signing certificate, so Windows has no reputation data for it yet.

Does it need to be installed?
No. It is a portable ZIP. Extract it and run ASNIPP_v1.exe.

Can it extract text from a screenshot (OCR)?
Yes. Open a capture in the editor and click 🔍. It uses the Windows engine on your PC, preferring English.

Where are my files saved?
Photos in Pictures\ASNIPP Pics, videos in Pictures\ASNIPP Vid, settings and library index in %USERPROFILE%.asnipp.

What's next

This is the first public release. I would like to hear what breaks, what is missing and which Windows setups misbehave. Open an issue on GitHub or comment below.

Download ASNIPP

⬇️ Download ASNIPP v1.0.0 for Windows

Download it and try the screenshot, recorder and live drawing.
Star the repo on GitHub if it saves you time.
Share feedback in the comments or as a GitHub issue.

More from Akhouri Systems: the website, Akhouri Systems on dev.to, ATLOCK (a desktop security suite) and APIC (an image processing center).

Akhouri Systems thanks @effessdev

The End of an Era: Akhouri Systems Is Officially Retiring ACALCU and ANOTE (And Why a Solo Founder Had to Do It)

Akhouri Anmol Kumar — Fri, 23 Oct 2026 07:03:18 +0000

Description: "Akhouri Systems is ending ACALCU and ANOTE with no further updates or maintenance. A solo founder explains the hardest strategic decision yet and teases ASNIPP, launching October 24, 2026."

The End of an Era: ACALCU and ANOTE Are Officially Discontinued

I've written a lot of announcements in my life as a developer. This is the hardest one.

Today, Akhouri Systems is officially ending ACALCU and ANOTE.
There will be no further updates and no further maintenance. As of today, both products are officially dead.

I'm Akhouri Anmol Kumar, Founder & CEO of Akhouri Systems, and I'm writing this with a heavy heart. Please read the whole post. You deserve a real explanation, not a corporate one-liner.

ACALCU: Where It All Started

ACALCU was the oldest product of Akhouri Systems. It's where the journey began.

It was built on one idea: a calculator shouldn't force you to use it the way someone else decided. It became the world's most customizable scientific calculator, with:

30+ themes, from Dark and Royal to Cyberpunk, Matrix, Sakura and Liquid Glass
Scientific functions
Buttons you could restyle with your own colors, fonts, images and videos
Calculation history and full customization

ACALCU was the first thing that made me believe a solo developer from India could build software people would actually enjoy using. Every product after it exists because ACALCU came first.

ANOTE: The Notepad Killer

ANOTE was personal. It was the product that motivated me the most.

I wanted to compete with the apps Windows ships by default, and Notepad was the giant I was aiming at. So ANOTE became a premium text editor with:

Multi-tab editing
Syntax highlighting
Password lock
A built-in translator
Meme mode
Auto-save

I called it "The Notepad Killer." Building it taught me more about UX, performance and polish than anything else I've made.

Why I Had to End Them

Let me be completely honest.

I'm a solo developer and founder. There is no team and no department. It's me, a HP 240 G9 laptop.

Right now Akhouri Systems has five products in play: ATLOCK, APIC, ASNIPP, ACALCU and ANOTE. Maintaining all five at once is not possible without hurting quality. If I tried, this is what would happen:

Updates would be delayed
Updates would be poor, rushed and half-tested
My mental health and focus would suffer
You, the people who trust my software, would pay the price

I refuse to let that happen. A product that's maintained badly is worse than one that's honestly retired.

So I made the strategic decision as a founder, even though as a creator it hurts:

It's better to do three things excellently than five things poorly.

What This Means for You

I want to be clear and not leave you guessing:

ACALCU and ANOTE will receive no further updates, features, bug fixes or any sort of update patches.
Copies you already have keep running on your machine, but they're no longer supported by Akhouri Systems :(
If you rely on ANOTE's password lock for anything important, please move sensitive data to a maintained tool. I'd recommend ATLOCK for that.
Thank you. If you ever used either of them, you were part of this story.

The Future: Akhouri Systems Focuses on Three Products

From today, Akhouri Systems operates exactly three products:

🔐 ATLOCK

A total security suite built on Argon2id and AES-256-GCM, with a password vault, File Guard, hardware-key support, ransomware canary decoys and more.
👉 github.com/Akhouri-Anmol-Kumar/ATLOCK

🖼️ APIC (Desktop and Web)

The Advanced Image Processing Center: edit, convert, compress, resize and remove backgrounds with on-device AI. It's free, private, and nothing gets uploaded.
👉 Try APIC on the web
👉 Try APIC on desktop

🚀 ASNIPP

A brand-new product, and I can't tell you what it is yet. 🤫

Something New Arrives Tomorrow: ASNIPP

I won't spoil it today. But I promise this: ASNIPP will be revealed and released tomorrow, October 24, 2026, as the newest product of Akhouri Systems.

Ending two products is a goodbye. Launching ASNIPP is my promise that this wasn't a retreat. It's a reset with focus.

Come back tomorrow. Be there for the reveal.

A Final Thank You

ACALCU gave me my start. ANOTE gave me my fire.

Retiring them isn't giving up. It's the opposite: it's choosing to give ATLOCK, APIC and ASNIPP my full energy, so that every update you get from now on is on time and built with care.

To everyone who downloaded, tested, shared or simply believed in a solo founder from India: thank you. Truly.

Rest in peace, ACALCU. Rest in peace, ANOTE. You mattered. 🕊️

See you tomorrow with something new.

— Akhouri Anmol Kumar
Founder & CEO, Akhouri Systems

🔗 Founder's GitHub: github.com/Akhouri-Anmol-Kumar
🏢 Organization's GitHub: github.com/Akhouri-Systems

------------------The END (ACALCU & ANOTE)---------------------

Encryption, Explained Properly: AES vs ChaCha20 vs Argon2id (and How to Actually Combine Them)

Akhouri Anmol Kumar — Thu, 22 Oct 2026 10:43:47 +0000

Description 👇
A hands-on guide to AES-GCM, ChaCha20-Poly1305, Argon2id, HKDF, X25519 and Shamir, with a comparison table, Python code, and a real-world case study.

"Just use AES-256" is the most repeated and least useful sentence in security.

Ciphers almost never break. What breaks is everything around them: a guessable password, a reused nonce, ciphertext nobody authenticated, a key derived with the wrong function. This post is a tour of the whole stack: AES, ChaCha20, Argon2id, HKDF, HMAC, X25519, Ed25519 and Shamir's Secret Sharing. For each one: how it works, why it exists, when to pick it, and how the pieces fit together.

We'll also look at a real implementation as a worked example: ATLOCK v5, a pure-Python security suite from Akhouri Systems, packaged as a single .exe. Seeing these ideas as design decisions in shipping code beats textbook diagrams.

TL;DR

AES-256-GCM and ChaCha20-Poly1305 are both excellent. Pick by hardware and by how safely you can manage nonces.

Turn passwords into keys with Argon2id, never a plain hash.

Always use AEAD (authenticated encryption). Encryption without authentication is a bug waiting for an attacker.

Your real security is usually password entropy and nonce discipline, not key size.

1. The mental model: three jobs, three tools

Encryption is several problems wearing one name:

Job	Question it answers	Typical tools
Confidentiality	Can someone else read this?	AES, ChaCha20
Integrity and authenticity	Was this modified? Who sent it?	GCM tag, Poly1305, HMAC, Ed25519
Key derivation	Where does the key come from?	Argon2id, HKDF
Key agreement	How do two parties share a key?	X25519
Recovery	What if the key is lost?	Shamir's Secret Sharing

Start with a threat model. Assume the attacker has a copy of your encrypted file, unlimited time and a rack of GPUs. Brute-forcing a 256-bit key is physically impossible, so a smart attacker goes after the password that produces the key. That single idea drives most modern design:

Encryption is only as strong as the cheapest thing an attacker can guess.

Sections 5 and 6 are all about making that "cheapest thing" as expensive as possible.

2. AES: the world's default block cipher

AES (Rijndael, FIPS 197) encrypts 128-bit blocks with a 128-, 192- or 256-bit key. It runs 10, 12 or 14 rounds of four operations on a 4x4 byte grid:

SubBytes: every byte goes through a non-linear lookup (the S-box), which defeats algebraic attacks.
ShiftRows: rows are rotated so bytes spread across columns.
MixColumns: each column is multiplied by a matrix in GF(2^8), so each output byte depends on four inputs.
AddRoundKey: XOR with a round key derived from your key.

No practical attack on full AES exists, and modern CPUs ship AES-NI instructions that execute rounds in hardware: fast and constant-time.

A block cipher only handles 16 bytes. How you chain blocks (the mode) is where security is won or lost:

Mode	What it is	Verdict
ECB	Each block encrypted independently	Never. Identical blocks leak patterns (the "ECB penguin").
CBC	Each block XORed with previous ciphertext	Legacy. Needs padding, no authentication, padding-oracle attacks.
CTR	Encrypts a counter to make a keystream	Fine, but no integrity: attackers can flip bits predictably.
XTS	Tweakable mode for disk sectors	Great for full-disk encryption; also unauthenticated.
GCM	CTR plus GHASH authentication	The modern default.

How GCM works, and where it bites

GCM (NIST SP 800-38D) encrypts with CTR mode and computes a 128-bit tag with GHASH, a polynomial hash over GF(2^128). On decryption the tag is verified first. If one bit of the ciphertext, nonce or associated data (AAD) changed, you get an error and no plaintext.

Three rules every engineer should tattoo somewhere:

Never reuse a (key, nonce) pair. It leaks the XOR of two plaintexts and lets an attacker recover the GHASH key, after which they can forge valid tags. This is the classic GCM disaster.
Random 96-bit nonces have a ceiling. Because of the birthday bound, NIST advises staying under about 2^32 messages per key with random nonces.
One message is capped at about 64 GiB per (key, nonce). Big files must be chunked.

GCM is also not key-committing: a crafted ciphertext can decrypt validly under two different keys, which enables "partitioning oracle" attacks (Len, Grubbs and Ristenpart, 2021) on password-based systems. The fix is an explicit key commitment, covered in Section 8.

3. ChaCha20-Poly1305: the software-friendly challenger

Daniel J. Bernstein's ChaCha20 is a stream cipher built only from Add, Rotate and Xor ("ARX"). No lookup tables means it is constant-time by construction and fast even on CPUs without AES hardware.

The state is a 4x4 grid of 32-bit words: four constants, the 256-bit key, a block counter and a 96-bit nonce (RFC 8439). It is scrambled by 20 rounds of the quarter-round:

a += b; d ^= a; d <<<= 16;
c += d; b ^= c; b <<<= 12;
a += b; d ^= a; d <<<=  8;
c += d; b ^= c; b <<<=  7;

The 64-byte output is a keystream block; XOR it with plaintext, bump the counter, repeat.

Poly1305 is the authenticator: it evaluates a polynomial modulo the prime 2^130 - 5 using a one-time key taken from the first keystream block (counter 0). Encryption starts at counter 1. The result is a 128-bit tag, just like GCM's.

XChaCha20-Poly1305 stretches the nonce to 192 bits by running HChaCha20 to derive a subkey from the key and the first 16 nonce bytes. With 192 bits you can pick nonces at random essentially forever, which removes GCM's biggest operational footgun.

ChaCha20-Poly1305 protects traffic in TLS 1.3, WireGuard and OpenSSH, and it is the preferred suite on many phones.

4. Head-to-head comparison

	AES-256-GCM	ChaCha20-Poly1305	XChaCha20-Poly1305
Design	SPN block cipher + CTR + GHASH	ARX stream cipher + Poly1305	HChaCha20 subkey + ChaCha20-Poly1305
Key size	256 bits	256 bits	256 bits
Nonce	96 bits	96 bits	192 bits
Tag	128 bits	128 bits	128 bits
Speed with AES-NI	Excellent	Very good	Very good
Speed without AES-NI	Slower; table-based AES can leak timing	Excellent, constant-time	Excellent
Random-nonce safety	Limited (~2^32 msgs/key)	Limited (96-bit)	Safe in practice
Max per (key, nonce)	~64 GiB	~256 GiB	~256 GiB
Standard	FIPS 197, SP 800-38D	RFC 8439	IETF draft
Best for	Servers, desktops, FIPS requirements	Phones, embedded, mixed hardware	Many messages per key with random nonces

How to choose. On modern x86/ARM with AES instructions, AES-256-GCM is hard to beat and is what compliance regimes expect. For unknown hardware, or if you want random nonces with zero worry, choose the ChaCha family. Same security level either way. Correct usage matters far more than the brand name.

5. From password to key: why Argon2id exists

Humans can't remember 256 random bits. They remember passwords, and passwords have little entropy. So we need a function that turns correct horse battery staple into a key deliberately slowly and expensively, so every guess costs the attacker real money.

A fast hash like SHA-256 is the wrong tool: a modern GPU tries billions per second. A proper password KDF adds cost:

KDF	Year	Cost it imposes	Notes
PBKDF2	2000	CPU time only	Ubiquitous but GPU/ASIC friendly. OWASP suggests ~600,000 iterations with HMAC-SHA256.
bcrypt	1999	CPU + tiny 4 KB state	Still decent; truncates input at 72 bytes.
scrypt	2009	CPU and memory	Memory-hard; parameters are harder to reason about.
Argon2	2015	CPU, memory, parallelism	Winner of the Password Hashing Competition; specified in RFC 9106.

Why memory-hardness wins

GPUs and ASICs are fast because they run thousands of tiny cores, but each core has very little memory. Argon2 fills a matrix of 1 KiB blocks (tens or hundreds of MiB) and reads it back in an unpredictable pattern. If one guess needs 64 MiB, a GPU with 16 GB of VRAM runs only about 250 guesses in parallel instead of tens of thousands. Memory is the one resource attackers can't cheaply scale.

The three flavours

Argon2d: data-dependent memory access. Strongest against GPUs, but leaks through side channels.
Argon2i: data-independent access. Side-channel resistant, weaker against time-memory trade-offs.
Argon2id: first half behaves like "i", second like "d". Use this one; it's what RFC 9106 recommends.

The knobs

m (memory): the main defence. Raise this first.
t (passes): linear time multiplier.
p (lanes): parallelism, matched to expected cores.
salt: at least 16 random bytes, unique per secret. Not secret, but it kills precomputed tables and makes identical passwords yield different keys.

RFC 9106 gives two profiles: t=1, p=4, m=2 GiB when memory is plentiful, and t=3, p=4, m=64 MiB as the constrained fallback. OWASP's absolute minimum is m=19 MiB, t=2, p=1. Rule of thumb: tune to roughly 0.5 to 1 second on your slowest supported machine.

The arithmetic of a strong passphrase

Four random words from a 7,776-word diceware list give log2(7776^4), about 51.7 bits. Suppose, generously, that an attacker manages 10,000 Argon2id guesses per second. Searching half the space takes roughly 5,500 years. Make the password Summer2024! and it falls in minutes, whatever the cipher. The KDF multiplies the cost of each guess; entropy decides how many guesses are needed. You need both.

6. The glue that holds it together

HKDF (RFC 5869). Argon2id is deliberately expensive, so run it once to get a master secret, then expand it into as many independent keys as you need with HKDF-SHA256 and a different info label per purpose (encryption, authentication, recovery, logging). This is domain separation: leak or misuse one key and the others stay safe.

HMAC. A keyed hash for integrity, key commitment and subkey derivation. Compare tags with a constant-time function (hmac.compare_digest), never ==.

AAD. Data that is authenticated but not encrypted, like a file header. Binding the header into the AEAD means an attacker can't swap parameters, reorder chunks or truncate the tail unnoticed.

Key commitment. Store HMAC(key, label) in the header and verify it before decrypting anything. It closes GCM's multi-key weakness and gives instant, clean "wrong password" detection.

Chunking. Encrypt big files in independent, individually authenticated chunks. Put the chunk index in the nonce and bind it with AAD so chunks can't be reordered or cut off. You also stay far below GCM's 64 GiB limit and can stream gigabytes in constant memory.

Length hiding. Ciphertext length leaks plaintext length. Padding to a scheme like Padme (at most about 12% overhead) blurs the true size.

A minimal sketch in Python

Here is the core pipeline in about 20 lines (a teaching sketch, not production code):

import os
from argon2.low_level import hash_secret_raw, Type
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

def derive(password: bytes, salt: bytes):
    # memory_cost is in KiB -> 64 MiB here
    master = hash_secret_raw(password, salt, time_cost=3, memory_cost=65536,
                             parallelism=4, hash_len=32, type=Type.ID)
    hk = lambda info: HKDF(hashes.SHA256(), 32, None, info).derive(master)
    return hk(b"demo/enc/v1")          # one label per purpose

def seal(password: bytes, data: bytes) -> bytes:
    salt, nonce = os.urandom(16), os.urandom(12)
    key = derive(password, salt)
    header = salt + nonce               # authenticated as AAD
    return header + AESGCM(key).encrypt(nonce, data, header)

def open_(password: bytes, blob: bytes) -> bytes:
    salt, nonce, ct = blob[:16], blob[16:28], blob[28:]
    key = derive(password, salt)
    return AESGCM(key).decrypt(nonce, ct, blob[:28])   # raises InvalidTag if tampered

Swap AESGCM for ChaCha20Poly1305 and the same code works. The API is identical, which is why choosing between them is mostly an operational decision.

7. Public keys and recovery

X25519 is elliptic-curve Diffie-Hellman on Curve25519: two parties swap public keys and each computes the same shared secret without ever transmitting it. Run that through HKDF and you have a symmetric key. Ed25519 is the matching signature scheme: fast, compact and deterministic, so there's no fragile per-signature randomness to get wrong.

In practice you use hybrid encryption: a random file key encrypts the data with AES or ChaCha, and X25519 wraps that small key for each recipient.

Shamir's Secret Sharing answers "what if I lose the key?" without a single point of failure. The secret becomes the constant term of a random polynomial and each share is a point on it. Any k of n shares rebuild the secret; k-1 shares reveal literally nothing. That is information-theoretic security, not just computational.

8. Case study: how ATLOCK v5 puts this into practice

Theory is cheap. Here is what these decisions look like in a shipping product.

ATLOCK v5 is the Akhouri Systems total security suite for Windows: pure Python, packaged as a single .exe inside a zip. It doesn't invent cryptography. It stands on the widely used cryptography and argon2-cffi libraries and spends its effort on the part that usually goes wrong: composition.

Here's the path your password takes when you lock a file (container format v3.1):

password (+ optional keyfile / hardware key)
   |
   v  Argon2id  (random 16-byte salt, >=64 MiB, t>=3, p=4)
master secret
   |
   v  HKDF-SHA256  (separate labels per purpose)
enc_key --> commitment = HMAC-SHA256(enc_key, label)   <- checked before any decryption
   |
   v  per-seal subkey = HMAC(enc_key, label || random nonce_base)
AES-256-GCM on every 8 MiB chunk
   nonce = nonce_base (8 bytes) || chunk_index (4 bytes)
   AAD   = header-bound

And the design choices, mapped to the ideas above:

Decision in ATLOCK v5	Problem it solves
Argon2id with auto-benchmark scaling memory toward ~0.6 s per hash, floor of 64 MiB / 3 passes / 4 lanes (128 MiB / 4 passes for vault and recovery keys)	Cost tuned to your machine, never below a safe minimum
HKDF domain separation: vault, recovery wrap, state MAC, audit log, TOTP wrap and more each get their own key	One compromised key doesn't cascade
Key commitment verified before any plaintext is produced	Blocks partitioning-oracle style attacks; instant clean "wrong password"
Fresh random `nonce_base` + per-seal subkey	Re-sealing a file can never reuse a (key, nonce) pair
8 MiB chunks, index in the nonce, header-bound AAD	Streams huge files, authenticates each chunk, detects reordering and truncation
Optional Padme padding	Hides true file size
KDF ceilings and floors from the header: a file can't demand more than 512 MiB / 6 passes / 8 lanes, nor downgrade below the minimum	A tampered file can neither DoS you nor weaken the KDF
Constant-time comparisons, atomic writes, verify-before-shred	Mistakes and crashes don't cost you data

Around that core sits a full suite in one program:

File Guard and folder locking with a password, optionally plus a keyfile or hardware key, so an attacker needs both
Password vault with TOTP codes, FIDO2 security keys (YubiKey and similar) and Windows Hello
TPM-backed hardware key mixed into the local state key via HKDF
Shamir M-of-N recovery and one-time recovery codes
Public-key mode: X25519 encryption plus Ed25519 signatures
Escalating lockouts with clock and state-rollback detection
Secure shredding, password-strength estimation and a signed-release check
A built-in self-test and a fuzzer that throws random corruptions at the container parser

Because it's a single readable Python program, every claim in this article is something you can follow line by line.

Try it on your own files. Download ATLOCK v5 (Windows 10/11): ATLOCK_v5.zip. Unzip, run it, lock a test folder with a four-word passphrase, then run --selftest and --fuzz and watch the container format from Section 6 defend itself.

9. What encryption can't do (an honest section)

A good security tool states its limits. ATLOCK's own documentation does, and so should every serious guide:

Malware running as you wins. Anyone who can execute code in your session can read process memory or alter the program. Anti-tamper and memory wiping raise the cost; they don't make it impossible.
Python can't guarantee RAM erasure. Strings and bytes are immutable and may be copied, so wiping is best-effort.
Shredding on SSDs isn't guaranteed. Wear-levelling and snapshots keep stale blocks. Turn on full-disk encryption (BitLocker) and treat shredding as an extra layer.
Weak passwords stay weak. Argon2id slows guessing; it can't rescue password123.
Not code-signed. Windows SmartScreen may warn on first run, as it does for most independent software. Verify the download source before running.

Honesty about the threat model isn't a weakness. It's what separates engineering from marketing.

10. Cheat sheet

If you need...	Use
Encrypt data at rest on a modern PC	AES-256-GCM, chunked, with key commitment
Mobile, embedded or unknown hardware	ChaCha20-Poly1305
Random nonces at huge scale	XChaCha20-Poly1305
Password to key	Argon2id (RFC 9106 params, tuned to ~0.5 to 1 s)
Many keys from one secret	HKDF-SHA256 with distinct `info` labels
Share a key over an open channel	X25519, then HKDF
Prove who sent it	Ed25519
Safe recovery	Shamir k-of-n
Whole-disk protection	BitLocker or LUKS (XTS)

Seven mistakes to avoid

Reusing a nonce with GCM or Poly1305.
Encrypting without authenticating (raw CBC or CTR).
Using a fast hash for password-based keys.
Skipping the salt, or using a short or constant one.
Using one key for several purposes instead of HKDF labels.
Comparing tags with == instead of a constant-time check.
Rolling your own cipher. Compose proven primitives; don't invent them.

Final word

The cipher is the easy part. Security lives in the key derivation, the nonce discipline, the authentication, and the humility to document what you can't protect. Learn those and you can evaluate any encryption tool, including ours.

If you'd rather watch these ideas work than read about them, download ATLOCK v5 from Akhouri Systems and test them on your own data.

Your turn: do you default to AES-GCM or ChaCha20-Poly1305 in your projects, and why? What's the nastiest nonce or KDF bug you've run into? Drop it in the comments.

ATLOCK is an Akhouri Systems product. Technical details reflect ATLOCK v5's container format v3.1 and its documented security notes.

I wrote a 10,000-line Windows security suite in one Python file. Here's how the crypto container works, and ₹50 if you can break it

Akhouri Anmol Kumar — Wed, 21 Oct 2026 05:05:38 +0000

Most small encryption tools fail in boring places, not in the cipher. They fail on what happens with a wrong password, a doctored header, a rolled-back state file, or a corrupted chunk.

I spent a long time on those boring places for ATLOCK v5, and this post walks through the design. At the end there's a challenge for you.

1. The container format

Files, folders and Quick Lock items all use one container (v3.1):

magic(8) | salt(16) | kdf_packed(6) | chunk_size(4) | nonce_base(8)
| commitment(32) | plain_len(8) | header_hash(32) | chunks...

Chunked AES-256-GCM. Every chunk is authenticated independently, so a single flipped bit is caught at that chunk and nothing gets decrypted blindly.
Per-seal chunk subkey. v3.1 derives a fresh subkey for each seal instead of encrypting everything under the raw master key.
Header-bound AAD. The header is mixed into authentication, so you can't swap parameters around without detection.
Optional Padme padding. The true file size is hidden by padding to a Padme bucket with random bytes, at no more than about 12% overhead.

2. Key commitment before any plaintext

AES-GCM alone doesn't commit to a key, which is why partitioning-oracle attacks exist. ATLOCK stores HMAC-SHA256(enc_key, "atlock-commit-v3") in the header and verifies it with a constant-time compare before a single byte of plaintext is produced. A wrong key is rejected at the header, and it never reaches the decryption loop.

3. KDF: Argon2id, and a parser that doesn't trust its own header

File floor: Argon2id, t=3, m=64 MiB, p=4
Vault and recovery: t=4, m=128 MiB, p=4
All sub-keys come from HKDF-SHA256 with per-purpose info strings (vault-enc, vault-verify, totp-wrap, backup-enc, and so on), so no key is ever reused across purposes.

The KDF parameters live in the header, which means an attacker can edit them. So the parser clamps untrusted values to hard ceilings (t≤6, m≤512 MiB, p≤8). A doctored file can't make ATLOCK burn gigabytes of RAM or minutes of CPU.

4. Sealed local state

Settings, guard list, vault index, lockout counters and logs are never stored as plain JSON. Every record goes through a SealedStore: AES-256-GCM with a key derived via HKDF from a DPAPI-protected state key (with extra entropy). A separate rollback anchor catches someone restoring an old state file to reset attempt counters.

There's also an optional hardware mode, where the state key becomes HKDF(DPAPI root || TPM secret) and every sealed file is re-sealed under it. If the TPM key is enabled but unusable, ATLOCK fails closed.

5. Public-key mode

Ephemeral X25519 for encryption (HKDF over the shared secret, salted with the ephemeral and recipient public keys), plus Ed25519 for signatures. Signatures can be pinned, so a file signed by a different key than the one you expect is rejected. There's also Shamir M-of-N splitting for recovery keys, FIDO2 hardware keys, TOTP and Windows Hello.

6. The unglamorous hardening

SetDefaultDllDirectories runs before any other import, against DLL planting.
Every child process is launched by full System32 path, never through a shell, with a rebuilt minimal environment (fixed COMSPEC/PATHEXT, no inherited PATH or PSModulePath).
PowerShell scripts are fixed strings, and variable data goes in over stdin as JSON, never interpolated.
Symlinks and junctions are refused. Data-folder ownership is checked, and anything inside OneDrive/Dropbox/Drive is detected so decrypted working copies never get synced.
Environment variables that influence paths (like the Nuitka onefile parent PID) are only honoured if they match the actual process layout.
Log output goes through a redaction filter for keys and tokens.

7. Detection layer

Ransomware canary decoys in Desktop/Documents/Pictures/Downloads, a startup-item watchdog with a baseline and allow-list, an audit log with its own verify command, and intruder photo/video capture after failed unlocks.

8. Testing

ATLOCK.exe --selftest runs against a throw-away data folder and registry key, so it never touches a real install. --fuzz N throws N random corruptions at the container parser.

Now the actual point: break it

I can't find my own blind spots, which is why I'm posting this here.

Download ATLOCK_v5.zip: https://github.com/Akhouri-Systems/ATLOCK/releases/download/v5.0.0/ATLOCK_v5.zip
Extract ATLOCK.exe. It's unsigned, so Windows SmartScreen will warn you. Click "More info → Run anyway", but do it in a VM or Windows Sandbox. You should treat any random exe from a stranger this way, including mine.
Use it, then try to break it. Recover a protected file without the password, bypass lockout, forge or roll back state, or get plaintext where there shouldn't be any.

Reward: ₹50 via UPI for a valid break, ₹60 for a major one. Send a reproducible write-up in the comments or DM me, and I'll judge what counts.

I'm not rich, so that's what I can afford. Because my parents didn't give me money 💵 and in my fampay account I've only 110rupees 😂 The real reward is that every break you find gets fixed in v6, and your name goes in the credits.

I'm Anmol. I'm 13 and I build under Akhouri Systems. Yes, really. Tear it apart.

DEV Community: Akhouri Anmol Kumar

APIC v2 Sneak Peek: A Free, Offline Image Editor, Converter & Compressor for Desktop

Description: Development Update #2 from Akhouri Systems: exclusive glimpses of APIC v2, a privacy-first desktop image editor with Smart Export, batch convert and compress, GPS metadata removal and more. Try APIC v1 while you wait.

🚀 APIC v2 Development Update #2: The First Real Glimpse

🧭 What is APIC?

👀 Glimpse #1: Smart Export, Where You See the Real Result Before You Save

🔐 Glimpse #2: The Privacy Inspector

✨ Glimpse #3: Auto Enhance That Isn't a Black Box

🧱 Glimpse #4: Fully Non-Destructive Editing

📦 Glimpse #5: Batch Studio

🎨 Glimpse #6: A Brand-New Workspace (This Week's Big Change)

🔧 Under the Hood: How We're Building It

🌍 Platforms: You Asked, We Listened

⏳ When Does APIC v2 Release?

🛠️ While You Wait: Try APIC v1 (and Break It!)

❓ FAQ

💬 Your Turn

Are You a Web Developer or a Browser Expert? 7 Tests I Failed Building a Photo Editor That Never Uploads Your Photos

Description: On-device AI, WASM threads, target-size compression, inpainting and 3D LUTs in a single HTML file. 7 real lessons from building APIC Web.

Test 1: Why did my AI step silently never finish on phones?

Test 2: Can you tell a slow download from a dead one?

Test 3: Can your app hit "under 200 KB" without guessing?

Test 4: Why did my transparent PNG turn black as a JPEG?

Test 5: Do you process the whole image, or only what changed?

Test 6: Can you export your whole colour grade as a .cube LUT?

Test 7: Why does your resized image look soft?

Bonus: How do you ship a Web Worker inside a single HTML file?

Try it yourself

Your score

What's Your Dream Job? Mine Is Founder & CEO of My Own Startup 🚀 (Yours Can Be Anything)

🎯 My Dream Job

🤔 Why Founder & CEO?

⚖️ The Honest Part (Because Dreams Deserve Reality Checks)

🎲 Plot Twist: It Doesn't Have to Be My Startup

🗳️ Quick Poll (Comment Edition)

💬 Your Turn! Drop Your Dream Job Below

🙌 Let's Make This Thread Awesome

APIC v2 Development Has Begun: A New Desktop Image Editor Is Coming

Description: "Akhouri Systems has started building APIC v2, a desktop image editing tool. Here's the roadmap, the release condition, and how you can shape it by breaking APIC v1."

🚀 APIC v2 Development Starts Today — 29 October 2026

What is APIC?

What will v2 have?

When will it release?

🛠️ Help shape v2: break APIC v1

Stay tuned

Are You a Python Developer or a Python Expert? 7 Tests I Failed Building 3 Desktop Apps

Test 1: Do you know that import order can be a security decision? (ATLOCK)

Test 2: Can your screen recorder avoid recording itself? (ASNIPP)

Test 3: Can your app decide what you meant, without asking? (APIC)

Test 4: Do you know the difference between "encrypted" and "encrypted correctly"? (ATLOCK)

Test 5: Can you make a Qt animation feel alive with 6 lines of math? (ASNIPP)

Test 6: Does your app look sharp on a 4K laptop with 150% scaling? (APIC)

Test 7: Can you explain why Python can't truly erase a password from memory? (ATLOCK)

Bonus: "Why does it work in VS Code and silently do nothing as a .exe?"

Try the code yourself

Your score

ASNIPP: The Dynamic Island Snipping Tool for Windows (A Free ShareX & Snipping Tool Alternative)

I Built a Dynamic Island Snipping Tool for Windows. Here's Why It Might Replace ShareX and the Snipping Tool for You

What Is a "Dynamic Island" Snipping Tool?

Feature Tour

📸 Screenshots in one keystroke

🎥 A screen recorder with real audio

✏️ Draw on your screen, even while recording

🖼️ A full editor, not just a crop box

🎞️ A video editor hiding inside

🎯 A color picker and pixel ruler

🗂️ Capture library

ASNIPP vs ShareX vs Windows Snipping Tool

Is ASNIPP Safe? Does It Phone Home?

Under the Hood (for the devs)

Get Started in 10 Seconds

FAQ

What Should I Build Next?

Does Encryption Really Matter? An Honest Answer for Windows Users

What encryption actually does

"I have nothing to hide"

"My Windows password protects my files"

"That's for hackers and governments"

Where encryption quietly fails

A sensible setup for a normal person

Test 6: Can you export your whole colour grade as a `.cube` LUT?

Bonus: "Why does it work in VS Code and silently do nothing as a `.exe`?"