DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
TECH & AI
Use a flat-priced, auto-routing LLM API in Aider or Cline — one npx command
jackminion 0



Coding assistants like Aider, Cline, and Continue all speak the OpenAI wire protocol — point them at a base_url, give them an API key, done. That makes swapping in a different LLM backend trivial… if that backend uses Authorization: Bearer.

The flat-priced, auto-routing API I’d been using doesn’t. It’s distributed through RapidAPI, which authenticates with an X-RapidAPI-Key header instead of Bearer. So I couldn’t just drop it into Aider. The fix turned out to be ~120 lines, so I open-sourced it.

modelis-openai

A zero-dependency local proxy (MIT, Node 18+). It listens on 127.0.0.1, speaks plain OpenAI, rewrites the auth header, and forwards to the upstream gateway. Streaming (stream: true) is piped straight through, so token-by-token output works exactly as with the OpenAI API.

your tool ──OpenAI(Bearer)──▶ modelis-openai (localhost) ──X-RapidAPI-Key──▶ upstream ──▶ best model

Enter fullscreen mode

Exit fullscreen mode

Quickstart

npx modelis-openai

Enter fullscreen mode

Exit fullscreen mode

Then point any OpenAI-compatible tool at it:

Setting
Value

Base URL
http://127.0.0.1:8787/v1

API key
your RapidAPI key

Model
modelis-auto

Drop it into your tool

Aider

export OPENAI_API_BASE=http://127.0.0.1:8787/v1
export OPENAI_API_KEY=
aider –model openai/modelis-auto

Enter fullscreen mode

Exit fullscreen mode

Cline / Roo Code — API Provider OpenAI Compatible, Base URL http://127.0.0.1:8787/v1, Model ID modelis-auto.

Continue (~/.continue/config.yaml)

models:
– name: Modelis
provider: openai
model: modelis-auto
apiBase: http://127.0.0.1:8787/v1
apiKey:

Enter fullscreen mode

Exit fullscreen mode

Any OpenAI SDK

from openai import OpenAI
client = OpenAI(base_url=”http://127.0.0.1:8787/v1″, api_key=””)
print(client.chat.completions.create(
model=”modelis-auto”,
messages=({“role”: “user”, “content”: “Hello”}),
).choices(0).message.content)

Enter fullscreen mode

Exit fullscreen mode

How it works

Reads the key from Authorization: Bearer (or MODELIS_RAPIDAPI_KEY).
Rewrites the request model to modelis-auto (configurable).
Forwards to the RapidAPI gateway with X-RapidAPI-Key / X-RapidAPI-Host.
Relays the response — including SSE streams and rate-limit headers — unchanged.

It also answers GET /v1/models and GET /health so tools that probe on startup don’t choke.

Honest notes

It routes to a paid API (there’s a free tier to start). The point of the proxy is to remove the integration friction, not to give anything away.

Cursor isn’t supported — it sends requests from its own servers, so a localhost endpoint can’t be reached. This is for tools that call the API from your machine.

Links

If you try it in a tool I didn’t list, I’d love to hear how it goes.



Source link

TECH & AI
Plasmo vs CRXJS vs WXT: Which Chrome Extension Framework Should You Use in 2026?
jackminion 0



If you are starting a browser extension in 2026, you no longer hand-roll a manifest.json, wire up a Webpack config, and pray that hot reload works on content scripts. Three projects now own this space: Plasmo, CRXJS, and WXT.

They look similar from the README, but they make very different bets. One is a full opinionated framework. One is just a build plugin. One tries to be the “Nuxt of extensions.” Pick wrong and you will feel it six months in, usually when you try to ship to Firefox or upgrade a dependency.

This post breaks down all three by the things that actually matter day to day, then gives you a straight decision guide. No “it depends” cop-outs.

TL;DR comparison table

Dimension
WXT
Plasmo
CRXJS

What it is
Full framework
Full framework
Vite plugin

Bundler
Vite
Parcel (custom)
Vite

Frontend frameworks
React, Vue, Svelte, Solid, vanilla
React-first
Any (you wire it)

Cross-browser
Chrome, Firefox, Safari, Edge
Chrome, Firefox, Edge
Chrome / Edge (Chromium)

MV2 + MV3
Both, simultaneously
Both, per build
Pick one

File-based entrypoints
Yes
Yes
No (manual manifest)

Auto-imports
Yes
No
No

Built-in storage / messaging
Yes (+ i18n)
Yes
No

Content-script HMR
Good (UI)
React only
Best (state-preserving)

Publishing / zip
Zip + Firefox source + publish
Zip + publish + Itero TestBed
None

GitHub stars (mid-2026)
~9.5k
~12k
~3.5k

Maintenance
Active
Maintenance mode
Revived (v2.0, Jun 2025)

Best for
Most new projects
React teams, more tutorials
Experts who want control

Sources for these claims are linked at the bottom. Star counts and bundle numbers move, so treat them as a snapshot, not gospel.

The 30-second answer

Starting fresh and want the safe default? Use WXT.

All-in on React and want the biggest pile of existing tutorials? Plasmo still delivers, with caveats.

You are a power user who wants minimal magic and full control of your Vite config? CRXJS.

Now the why.

WXT: the modern default

WXT brings Nuxt-style conventions to extensions. You drop files into an entrypoints/ directory and WXT generates the manifest, registers content scripts, and handles routing for you.

// entrypoints/content.ts
export default defineContentScript({
matches: (‘*://*.github.com/*’),
main() {
console.log(‘Hello from a WXT content script’);
},
});

Enter fullscreen mode

Exit fullscreen mode

Storage is a type-safe, reactive wrapper over browser.storage:

import { storage } from ‘#imports’;

const theme = storage.defineItem’light’ | ‘dark’>(‘local:theme’, {
fallback: ‘dark’,
});

await theme.setValue(‘light’);

Enter fullscreen mode

Exit fullscreen mode

Why people pick it:

Vite under the hood. Near-instant dev server start, fast builds.

Framework-agnostic. React, Vue, Svelte, Solid, or vanilla, all first-class. Want to use Svelte to shave bundle size? Go ahead.

True cross-browser. One codebase builds for Chrome, Firefox, Safari, and Edge, and it papers over the chrome.* vs browser.* namespace mess and MV2/MV3 differences.

Best-in-class dev mode. It opens a browser with the extension already installed and gives you HMR for UI.

Publishing built in. It can produce per-browser zips and even the Firefox source archive reviewers ask for.

Healthy project. Around 9.5k stars and active maintenance as of mid-2026, with production users like Eye Dropper (1M+ users) and ChatGPT Writer (600k+).

Watch-outs: it is the newest of the three, so there are fewer Stack Overflow answers than Plasmo. The conventions are opinionated, which is the point, but you do have to learn them.

Choose WXT if you are starting a new project and want speed, cross-browser support, and a maintained foundation without locking yourself into one UI library.

Plasmo: the React-first framework with the most tutorials

Plasmo was the framework that made extension dev feel like Next.js. Create a popup.tsx, export a React component, done. It still has the largest content library and the slickest first-run experience for React developers.

// content.tsx
import type { PlasmoCSConfig } from “plasmo”

export const config: PlasmoCSConfig = {
matches: (“https://www.github.com/*”)
}

const Overlay = () => div>Injected by Plasmodiv>
export default Overlay

Enter fullscreen mode

Exit fullscreen mode

Storage and messaging ship as dedicated packages:

import { Storage } from “@plasmohq/storage”

const storage = new Storage()
await storage.set(“theme”, “dark”)

Enter fullscreen mode

Exit fullscreen mode

Strengths:

React DX is excellent. Content Script UI with automatic Shadow DOM isolation is genuinely nice.

Biggest learning resource pool. ~12k stars and years of blog posts, videos, and starter repos.

Itero TestBed. A commercial product from the same team for staging and beta distribution before you hit the store, which none of the others offer.

The elephant in the room: maintenance. Multiple sources (including WXT’s own comparison) describe Plasmo as “in maintenance mode with little to no maintainers.” It is still on an older major version of Parcel, and that lag has real consequences, for example it blocks TailwindCSS v4. The high star count is partly legacy momentum, not current velocity. The framework is also still labeled alpha.

Choose Plasmo if you are React-only, you value the depth of existing tutorials and the Itero workflow, and you can accept the risk that feature development has slowed.

CRXJS: not a framework, a superpower for your Vite config

CRXJS (@crxjs/vite-plugin) is the odd one out: it is a Vite plugin, not a framework. You keep full ownership of your vite.config.ts and your project structure. CRXJS just teaches Vite how to build an extension, generate the manifest, and do hot reload.

// vite.config.ts
import { defineConfig } from ‘vite’
import { crx } from ‘@crxjs/vite-plugin’
import manifest from ‘./manifest.json’

export default defineConfig({
plugins: (crx({ manifest })),
})

Enter fullscreen mode

Exit fullscreen mode

Its killer feature is content-script HMR that preserves page state. Edit a content script, see it update on the page without a full reload or losing your place. For UI-heavy content scripts, that feedback loop is the fastest of the three.

The trade-off is that you get no abstractions. No built-in storage wrapper, no messaging helper, no i18n. You bring your own libraries (or raw chrome.* APIs) for everything. Cross-browser is effectively Chromium-only (Chrome and Edge); Firefox support is not the strength here.

CRXJS also has history: it sat in beta for over three years before v2.0 shipped in June 2025. It was recently revived with new maintainers, which is encouraging, but it is the smallest project of the three (~3.5k stars).

Choose CRXJS if you are an experienced developer who wants minimal magic, total control over the build, and the best content-script HMR, and you are happy to assemble the rest of the stack yourself.

Head-to-head on what matters

Build speed and bundle size

WXT and CRXJS both ride Vite (native ESM in dev, esbuild pre-bundling), so dev server start is near-instant. Plasmo’s custom Parcel bundler is the slowest, and developers migrating off it consistently report faster builds afterward. On output size, one benchmark put a WXT build around 400 KB versus roughly 800 KB for the Plasmo equivalent, though a lot of that comes down to your UI library choice (Svelte vs React) rather than the framework alone.

Cross-browser

This is where WXT pulls clearly ahead: one codebase to Chrome, Firefox, Safari, and Edge, with MV2/MV3 handled for you. Plasmo covers Chrome, Firefox, and Edge. CRXJS is realistically Chromium-only. If Firefox or Safari is on your roadmap, that decision is basically made.

Built-in APIs

WXT and Plasmo both give you storage, messaging, and content-script UI out of the box; WXT adds i18n. CRXJS gives you nothing here by design. Less code to maintain vs more control, pick your philosophy.

Maintenance health

For a project you will maintain for years, this is arguably the most important column in the table. WXT is actively developed. CRXJS is freshly revived. Plasmo’s slowdown is the real risk, and a stalled bundler dependency tends to quietly block the modern tools you will want later.

A simple decision tree

Need Firefox or Safari? WXT.

React-only team that lives in tutorials and wants Itero TestBed, and you accept maintenance risk? Plasmo.

Senior dev who wants a bare Vite setup and the fastest content-script HMR? CRXJS.

Anything else, or you just want the boring safe choice? WXT.

Building is only half the job

Here is the part nobody puts in the framework README: the framework decides how fast you build. It does nothing for whether anyone finds and installs your extension.

The Chrome Web Store is a discovery black box. New extensions launch invisible, ranking is heavily influenced by early reviews and keyword placement in your title and description, and you get almost no analytics on where your install funnel leaks (impressions to listing to install to retention).

A few practical things that move the needle once your code is shipped, regardless of which framework you chose:

Get your first real reviews early. Ranking and social proof both stall without them, and fake reviews get your listing pulled.

Make the listing assets convert. Icon, screenshots, and the small promo tile do more for install rate than another feature.

Watch your category. Knowing what competing extensions rank for and what users complain about is cheaper than guessing.

This is the gap ExtensionBooster is built for. It is a growth platform for extension and app developers: a credit-based system for getting real, store-compliant reviews and installs (with rating protection so low-star reviews do not cost you credits), market and competitor analytics to track ratings/users in your category and mine common complaints, and showcase pages that double as SEO backlinks. It also ships free developer tools that are genuinely useful no matter your stack, an icon generator, a screenshot maker, and a promo-tile cropper for the Web Store listing.

Worth bookmarking the free tools before your first submission, since you will need those listing assets the day you ship.

FAQ

Is WXT better than Plasmo?For most new projects in 2026, yes, mainly because it is actively maintained, Vite-fast, and works across all browsers. Plasmo still wins on React-specific tutorial depth and its Itero TestBed.

Is CRXJS a framework?No. It is a Vite plugin that adds Chrome extension support to a Vite project. You keep full control of the config and provide your own storage/messaging/i18n.

Can I migrate from Plasmo to WXT?Yes, and it is a common move. Expect to rewrite entrypoint conventions and swap @plasmohq/storage for WXT’s storage API, but builds and dev startup get noticeably faster.

Which is best for a React extension?Both WXT and Plasmo handle React well. Plasmo is React-first with more examples; WXT gives you React plus a maintained, cross-browser foundation and the option to use a lighter UI library later.

Which has the best hot reload?CRXJS for content scripts (state-preserving). WXT for overall UI dev experience. Plasmo’s HMR is tuned for React and falls back to full reloads otherwise.

Bottom line

WXT is the default I would hand a new team in 2026.

Plasmo is still a strong React experience if you accept the maintenance risk and want the Itero workflow.

CRXJS is the connoisseur’s choice for control and content-script HMR.

Pick the build tool that fits your team, then put real energy into the part that frameworks ignore: getting discovered and installed.

Sources: WXT official comparison, WXT homepage, Plasmo docs, The 2025 State of Browser Extension Frameworks, and project GitHub repos.



Source link

TECH & AI
Learning Linux from Scratch: My First Week in DevOps
jackminion 0


Hello everyone! 👋

Welcome to Week 1 of my DevOps learning journey.

As a final-year BCA student specializing in Cloud Computing, I have decided to document my journey toward becoming a DevOps Engineer. This blog series will cover everything I learn, from Linux fundamentals to cloud computing, containers, CI/CD, Kubernetes, and monitoring tools.

Since Linux is the backbone of most DevOps environments, I decided to start my journey by learning Linux fundamentals and essential commands.

Why Linux Matters in DevOps

Most servers in cloud environments run Linux. Whether you’re working with AWS EC2 instances, Docker containers, Kubernetes clusters, or CI/CD pipelines, Linux knowledge is essential.

As a DevOps Engineer, you’ll frequently:

Manage Linux servers
Deploy applications
Troubleshoot issues
Monitor system performance
Automate tasks using shell scripts

That’s why Linux is often considered the first skill every DevOps engineer should master.

What I Learned This Week

Understanding the Linux File System

One of the first things I learned was how Linux organizes files and directories.

Some important directories include:

/ – Root directory

/home – User home directories

/etc – Configuration files

/var – Logs and variable data

/tmp – Temporary files

/usr – User programs and utilities

Understanding the file system structure helps navigate servers more effectively.

Basic Navigation Commands

I practiced several commands used daily by Linux administrators.

Check Current Directory

pwd

Enter fullscreen mode

Exit fullscreen mode

List Files and Directories

ls
ls -l
ls -la

Enter fullscreen mode

Exit fullscreen mode

Change Directory

cd /home

Enter fullscreen mode

Exit fullscreen mode

Create Directory

mkdir project

Enter fullscreen mode

Exit fullscreen mode

Remove Directory

rmdir project

Enter fullscreen mode

Exit fullscreen mode

File Management Commands

Working with files is a common task in Linux.

Create a File

touch file.txt

Enter fullscreen mode

Exit fullscreen mode

Copy Files

cp file.txt backup.txt

Enter fullscreen mode

Exit fullscreen mode

Move Files

mv file.txt documents/

Enter fullscreen mode

Exit fullscreen mode

Delete Files

rm file.txt

Enter fullscreen mode

Exit fullscreen mode

View File Content

cat file.txt

Enter fullscreen mode

Exit fullscreen mode

Viewing System Information

I also learned how to check system details.

Check CPU Information

lscpu

Enter fullscreen mode

Exit fullscreen mode

Check Memory Usage

free -h

Enter fullscreen mode

Exit fullscreen mode

Check Disk Usage

df -h

Enter fullscreen mode

Exit fullscreen mode

Check Running Processes

ps -ef

Enter fullscreen mode

Exit fullscreen mode

Monitor Processes in Real Time

top

Enter fullscreen mode

Exit fullscreen mode

Understanding Permissions

Linux uses permissions to control access to files and directories.

I learned about:

Read (r)
Write (w)
Execute (x)

Viewing permissions:

ls -l

Enter fullscreen mode

Exit fullscreen mode

Changing permissions:

chmod 755 script.sh

Enter fullscreen mode

Exit fullscreen mode

Changing ownership:

chown user:user file.txt

Enter fullscreen mode

Exit fullscreen mode

Permissions are critical for maintaining system security.

Service Management

One interesting topic was managing services using systemctl.

Check Service Status

systemctl status nginx

Enter fullscreen mode

Exit fullscreen mode

Start a Service

systemctl start nginx

Enter fullscreen mode

Exit fullscreen mode

Stop a Service

systemctl stop nginx

Enter fullscreen mode

Exit fullscreen mode

Restart a Service

systemctl restart nginx

Enter fullscreen mode

Exit fullscreen mode

This is especially useful when managing web servers and applications.

Viewing Logs

Logs help identify issues and troubleshoot systems.

tail -f /var/log/messages

Enter fullscreen mode

Exit fullscreen mode

journalctl -xe

Enter fullscreen mode

Exit fullscreen mode

Understanding logs is one of the most important skills for troubleshooting production systems.

My First Bash Script

I wrote a simple script to check whether Nginx is running.

#!/bin/bash

if systemctl is-active –quiet nginx
then
echo “Nginx is running”
else
echo “Nginx is not running”
fi

Enter fullscreen mode

Exit fullscreen mode

This helped me understand:

if-else conditions
shell scripting basics
automation concepts

It was my first step toward infrastructure automation.

Challenges I Faced

During my learning, I encountered a few challenges:

Understanding Linux permissions
Navigating directories quickly
Reading system logs
Writing Bash scripts correctly

After practicing commands repeatedly and experimenting on AWS EC2 instances, these concepts became much clearer.

Key Takeaways

This week taught me that Linux is much more than just a command-line operating system.

I learned:

✅ Linux file system structure

✅ Essential Linux commands

✅ File and directory management

✅ System monitoring basics

✅ Service management

✅ Log analysis

✅ Bash scripting fundamentals

Most importantly, I realized that strong Linux fundamentals make learning DevOps tools much easier.

What’s Next?

In Week 2, I plan to learn:

Advanced Linux Commands
User and Group Management
Networking Basics
SSH and Remote Access
Package Management
More Bash Scripting

Final Thoughts

Every DevOps Engineer starts somewhere, and Linux is the perfect place to begin.

This week gave me a solid foundation and increased my confidence in working with servers and cloud environments. I’m excited to continue learning and sharing my progress through this blog series.

If you’re also starting your DevOps journey, feel free to connect and share your experiences.

See you in Week 2! 🚀



Source link