Why WireGuard over OpenVPN

If you’ve set up OpenVPN before, you know the pain: certificate authorities, .ovpn config bundles, sluggish throughput. WireGuard is a different approach entirely — modern cryptography, a tiny codebase (easy to audit, hard to hide bugs in), and it’s fast enough that you’ll barely notice it’s running. It’s also baked into the Linux kernel since 5.6, so there’s no sketchy third-party kernel module to install.

Here’s the whole setup — one server, one client — in about 15 minutes.

Step 1: Install WireGuard on the server

1
2

sudo apt update
sudo apt install wireguard

Step 2: Generate keys for the server

1
2
3

cd /etc/wireguard
umask 077
wg genkey | tee server_private.key | wg pubkey > server_public.key

umask 077 matters — it makes sure the private key file isn’t readable by other users on the box.

Step 3: Generate keys for the client

Do this on the client machine (or just run it again on the server and copy the keys over):

1

wg genkey | tee client_private.key | wg pubkey > client_public.key

Step 4: Write the server config

1
2
3
4
5
6
7
8
9
10
11

# /etc/wireguard/wg0.conf
[Interface]
PrivateKey = <paste server_private.key>
Address = 10.8.0.1/24
ListenPort = 51820
PostUp = iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = <paste client_public.key>
AllowedIPs = 10.8.0.2/32

Replace eth0 with whatever your server’s actual internet-facing interface is — check with ip a if you’re not sure.

Step 5: Write the client config

1
2
3
4
5
6
7
8
9
10
11

# client.conf
[Interface]
PrivateKey = <paste client_private.key>
Address = 10.8.0.2/24
DNS = 1.1.1.1

[Peer]
PublicKey = <paste server_public.key>
Endpoint = your.server.ip:51820
AllowedIPs = 0.0.0.0/0
PersistentKeepalive = 25

Two settings worth understanding, not just copy-pasting:

• AllowedIPs = 0.0.0.0/0 routes all client traffic through the tunnel — full VPN mode. If you only want to reach your home network (not route your general internet traffic through it), narrow this to your LAN range, e.g. 192.168.1.0/24.
• PersistentKeepalive = 25 sends a keepalive packet every 25 seconds. Without it, NAT on your router or mobile carrier will silently drop the “connection” (WireGuard is connectionless/UDP) after a period of inactivity, and you won’t notice until you try to use it.

Step 6: Open the port and enable IP forwarding

On the server, allow IP forwarding so it can actually route traffic between the tunnel and the internet:

1
2

echo 'net.ipv4.ip_forward=1' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Then forward UDP port 51820 to your server in your router’s settings — same place you’d forward any other port.

Step 7: Bring it up

On the server:

1
2

sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0   # start on boot

On the client (Linux):

1

sudo wg-quick up ./client.conf

On iOS/Android/macOS/Windows, just import client.conf into the official WireGuard app — it reads the same format directly, no conversion needed.

Step 8: Verify it’s actually working

1

sudo wg show

You should see the peer listed with a recent “latest handshake” timestamp. If that timestamp never updates, the most common culprits are: the port isn’t actually forwarded, a firewall is blocking UDP 51820, or you copied a key wrong somewhere.

Then from the client, confirm your traffic is actually routing through:

1

curl ifconfig.me

That should now show your server’s public IP, not your actual location.

Adding a second client

Each new device is just another [Peer] block on the server and a new key pair:

1
2
3

[Peer]
PublicKey = <new client's public key>
AllowedIPs = 10.8.0.3/32

Restart the interface to pick up the change:

1

sudo wg-quick down wg0 && sudo wg-quick up wg0

That’s it — no certificate authority to manage, no revocation lists, no bloated config bundles. Just key pairs and IP ranges. This is genuinely the fastest “set up my own VPN” path there is right now.

Somewhere along the way, the terminal stopped being “the thing I use when something breaks” and became the thing I reach for first — even on tasks I used to open a whole app for. Here are five that quietly made specific GUI apps disappear from my workflow entirely.

1. ncdu replaced my disk usage analyzer

I used to open a graphical disk-space app, wait for it to scan, then click through a treemap to find what was eating my storage. ncdu (NCurses Disk Usage) does the same job, in the terminal, over SSH, on a headless server where a GUI was never an option anyway.

1
2

sudo apt install ncdu
ncdu /

Navigate with arrow keys, press d to delete something you find, and it updates live. It’s faster than any GUI equivalent I’ve used, mostly because there’s no window to render.

2. htop replaced my task manager

Every OS has some version of a graphical task manager. On Linux, htop beats most of them — color-coded CPU/memory bars per core, tree view of process relationships, and you can kill a process without ever leaving the keyboard.

1
2

sudo apt install htop
htop

Press F6 to sort by any column, F9 to kill a process, t to toggle tree view. If you SSH into a remote server, this is non-negotiable — there is no GUI task manager to fall back on anyway.

3. rsync replaced my file-sync GUI

I used to run a GUI sync tool to mirror folders between machines, complete with a progress bar and a “scanning files…” spinner that took longer than the actual transfer. rsync does it faster, resumes interrupted transfers automatically, and only copies what’s actually changed.

1

rsync -avh --progress /source/folder/ user@remote:/destination/folder/

-a preserves permissions and timestamps, -v is verbose, -h makes sizes human-readable, and --progress gives you the progress bar you actually wanted. Add --delete if you want the destination to exactly mirror the source (careful with that one).

4. tmux replaced juggling a dozen terminal windows

Before tmux, I had a taskbar full of separate terminal windows for “the server log,” “the build process,” “the editor,” “the monitoring dashboard.” tmux puts all of that in one SSH session, split into panes and windows that survive even if your connection drops.

1
2
3
4
5

tmux new -s work
# Ctrl+b % → split pane vertically
# Ctrl+b " → split pane horizontally
# Ctrl+b d → detach (keeps running)
tmux attach -t work   # reattach later, exactly where you left off

That last part is the real win: close your laptop, open it later, reattach, and everything’s still running exactly as you left it — including over a flaky connection where a GUI remote desktop would’ve just frozen.

5. ffmpeg replaced my simple video editor

I’m not cutting a feature film in the terminal, but for the 90% case — trim a clip, convert a format, strip audio, compress a video before uploading it somewhere — opening a full video editor is massive overkill. ffmpeg does all of it in one line.

1
2
3
4
5
6
7
8

# Trim from 00:01:30 for 20 seconds, no re-encode (fast, lossless)
ffmpeg -i input.mp4 -ss 00:01:30 -t 20 -c copy output.mp4

# Compress for upload
ffmpeg -i input.mp4 -vcodec libx264 -crf 28 output.mp4

# Strip audio entirely
ffmpeg -i input.mp4 -an output_noaudio.mp4

The learning curve is real — ffmpeg’s flag soup is legendarily unintuitive — but once you have your five go-to commands saved somewhere, you never touch a GUI editor for simple tasks again.

The pattern here

None of these are obscure power-user tools. They’re just better at the one job they do than the GUI equivalent, because they don’t have to render a window, they work identically over SSH on a headless box, and they’re scriptable the moment you need to repeat something. That’s usually the actual argument for the terminal — not “it looks cooler,” but “it does the same job with less overhead and it still works when there’s no display attached.”

Why bother auditing your own network

It’s easy to assume “it’s just my home Wi-Fi, who cares.” But a home network today usually has more exposed surface than most small offices did a decade ago — smart plugs, a NAS, a few Docker hosts, a kid’s tablet, a guest’s phone that was never removed from Wi-Fi. I decided to actually go through mine properly instead of assuming it was fine.

Here’s what I used, what I found, and what I fixed — so you can run the same pass on yours in an evening.

Step 1: Find every device actually on the network

Don’t trust your router’s “connected devices” page — it’s often incomplete or just wrong. I used arp-scan for a fast local sweep:

1

sudo arp-scan --localnet

And nmap for a more thorough host discovery pass:

1

sudo nmap -sn 192.168.1.0/24

What I found: two devices I didn’t recognize at first glance. One turned out to be a smart bulb I’d forgotten existed. The other was an old phone still connected from a visit months ago — not malicious, just sloppy hygiene. Still, if I didn’t recognize it, neither would I notice if something actually unwanted joined.

Fix: renamed every device in the router’s device list to something identifiable, and kicked the stale connection off.

Step 2: Port-scan your own devices

For each device that matters (NAS, servers, anything self-hosted), I ran a proper port scan from another machine on the same network:

1

nmap -sV -p- 192.168.1.50

-p- scans all 65535 ports, not just the common 1000 — slower, but it’s the only way to actually know what’s listening.

What I found: a management interface on my NAS that I’d set up once for a one-time task and never closed back down. Also a service I’d forgotten was still bound to 0.0.0.0 instead of 127.0.0.1, meaning it was reachable from any device on the LAN, not just the host itself.

Fix: closed the management interface, and rebound the forgotten service to localhost-only since nothing else on the network needed to talk to it.

Step 3: Check what’s actually exposed to the internet

Your router is your real perimeter. From outside your network (phone on mobile data works fine), check what’s actually reachable:

1

nmap -Pn your.public.ip -p 1-1000

Or just use an external tool like Shodan or canyouseeme.org to check specific ports without needing a second network.

What I found: a port-forward rule I’d set up for a game server over a year ago that I never removed. It wasn’t actively dangerous, but it was one more thing an attacker didn’t need to work for.

Fix: audited every port-forward rule in the router, removed anything not actively in use, and documented the ones that stayed with a reason why.

Step 4: Review Wi-Fi settings properly

A few things worth checking that people set once and never revisit:

• WPA3 if your devices support it, WPA2-AES at minimum — never WPA/TKIP or (god forbid) WEP
• WPS disabled. It’s a convenience feature with a long history of being trivially brute-forceable
• Guest network actually isolated from the main LAN, not just a separate SSID on the same subnet
• Router admin password changed from the default — sounds obvious, still worth double-checking
• Router firmware up to date — most people never check this after initial setup

What I found: WPS was still enabled. Had been since the router was first set up. No idea for how long.

Fix: disabled it, verified over a second scan that it was actually off (some routers lie about this in the UI).

Step 5: Look at what your devices are phoning home to

This one’s less common advice but worth it: run a quick DNS query log on your router or a Pi-hole if you have one, and look at what’s leaving your network. You’ll be surprised how much “smart” home gear talks to servers you’ve never heard of, constantly.

1
2

# if you're running Pi-hole
pihole -t

What I found: nothing alarming, but a genuinely useful list of exactly which devices talk to which third parties — which is good baseline knowledge to have before something does look wrong later.

The actual takeaway

None of what I found was a five-alarm fire. That’s kind of the point — most home network security isn’t about catching a sophisticated attacker, it’s about closing the dozen small gaps that accumulate from “I’ll fix that later” over years of normal use. An hour with nmap and arp-scan is enough to find most of them.

If you’ve never done this pass on your own network, do it this weekend. You’ll probably find at least one thing you forgot was even there.

Why Compose, not just docker run

If you’ve only ever run containers one at a time with docker run, you already know the pain: remembering which flags you used last time, manually creating networks, starting things in the right order after a reboot. Docker Compose fixes all of that with one YAML file that describes your entire stack — and one command to bring it all up or tear it all down.

For a homelab, that’s the difference between “I’ll fix the server when I get home” and “I’ll SSH in and run docker compose up -d from my phone.”

The stack we’re building

A dead-simple, real-world shape: a reverse proxy in front of an app, talking to a database. This is the backbone of a huge number of self-hosted services (Nextcloud, Ghost, Immich, you name it).

• nginx — reverse proxy, the only thing exposed to the internet
• app — your actual service
• postgres — the database, never exposed outside the Docker network

The docker-compose.yml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

version: "3.9"

services:
  proxy:
    image: nginx:1.25
    ports:
      - "443:443"
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/nginx/certs:ro
    depends_on:
      - app
    restart: unless-stopped

  app:
    image: yourapp:latest
    environment:
      DATABASE_URL: postgres://appuser:${DB_PASSWORD}@db:5432/appdb
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: appdb
    volumes:
      - db_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  db_data:

A few things worth calling out for beginners:

• Only proxy publishes ports. app and db don’t need ports: at all — Compose automatically puts every service on the same internal network, so app can reach db just by using the service name db as the hostname. That’s why the connection string above says @db:5432, not an IP address.
• depends_on controls start order, not readiness. Compose will start db before app, but it won’t wait for Postgres to actually finish initializing. For anything that matters, add a healthcheck (see below) or build in retry logic on the app side.
• Named volumes (db_data) survive docker compose down. If you want to wipe everything including data, you need docker compose down -v — that extra -v is the difference between “restart clean” and “delete my database.”
• ${DB_PASSWORD} pulls from a .env file sitting next to your docker-compose.yml. Never hardcode secrets directly in the YAML if you’re ever going to commit this to git.

Adding a healthcheck (the thing most tutorials skip)

1
2
3
4
5
6
7

db:
  image: postgres:16
  healthcheck:
    test: ["CMD-SHELL", "pg_isready -U appuser"]
    interval: 5s
    timeout: 5s
    retries: 5

Then change app’s dependency to actually wait for it:

1
2
3
4

app:
  depends_on:
    db:
      condition: service_healthy

Now app won’t even attempt to start until Postgres reports healthy — no more crash-loop on first boot after a reboot.

The commands you’ll actually use

1
2
3
4
5
6

docker compose up -d        # start everything, detached
docker compose logs -f app  # tail logs for one service
docker compose ps           # see what's running and its health status
docker compose restart app  # restart just one service
docker compose down         # stop and remove containers (keeps volumes)
docker compose pull && docker compose up -d   # update to latest images

Where to go from here

Once this clicks, the natural next steps are:

• Put Traefik or Caddy in front instead of raw nginx for automatic HTTPS certificates
• Split secrets into a proper .env file and add it to .gitignore
• Add a second Compose file (docker-compose.override.yml) for dev-vs-prod differences
• Look at Watchtower for automated image updates, if you trust upstream maintainers enough

Compose won’t replace Kubernetes for a real production fleet, but for a homelab running a dozen self-hosted services on one box, it’s honestly all you need.

The headline

On October 21, 2026, the PHP core team shipped an out-of-band security release for two critical vulnerabilities — CVE-2026-109618 and CVE-2026-109619 — now widely known by their project name, PHP2Shell. Both allow unauthenticated remote code execution, and PHP’s own advisory says every installation serving web requests is at risk: PHP-FPM, Apache mod_php, php-cgi, FrankenPHP, and LiteSpeed are all in scope.

That’s basically the entire PHP hosting ecosystem — WordPress, Laravel, Magento, Drupal, ThinkPHP, and every hand-rolled legacy app sitting on a shared host.

What’s actually broken

This isn’t a simple injection bug — it’s a use-after-free chain buried in PHP’s memory management, and it’s been there since PHP 5.4.

In plain terms:

1. The setup (mod_php): PHP can leave dangling pointers when an allocation blows past memory_limit, or a fatal error interrupts cleanup. On Apache’s mod_php, the worker process survives the crash and gets reused for the next request — but some old request’s memory (like session data) never got properly destroyed. A later request can end up reading memory that should have been freed.
2. The PHP-FPM twist: FPM usually kills the whole worker on a startup failure, so that trick shouldn’t work there. But researchers found a second path through PHP’s unserializer (BG(unserialize)). If an out-of-memory error hits after the request has already started — say, during session_start() or unserialize() — FPM’s worker survives, but it’s left holding a stale pointer into freed memory.
3. The reclaim: Attackers then send a crafted multipart file upload (abusing session.upload_progress) that runs before PHP’s normal request setup. This lets them overwrite that freed memory with their own fake data structures — forging a fake PHP object whose “destructor” is system().
4. The fire: When the session is cleaned up at the end of the request, PHP calls that fake destructor — and the attacker’s shell command runs. The worker crashes right after, but FPM just respawns it, and the attacker already has their output.

No login, no plugin, no uploaded .php shell required — just HTTP requests at a PHP app that uses sessions.

Who’s affected

If you’re still running PHP 7.x or 8.0/8.1 in production, this is the wake-up call to migrate — there is no fix coming for EOL branches.

What to do right now

1. Patch immediately. Upgrade to PHP 8.2.35 / 8.3.36 / 8.4.27 / 8.5.12 or later. This is the only complete fix.
2. If you can’t patch yet (temporary, partial mitigation only):
   • On PHP-FPM: set session.upload_progress.enabled = 0 and memory_limit = -1.
   • On mod_php: set memory_limit = -1.
   • Understand that removing memory_limit trades one risk (RCE) for another (memory exhaustion / DoS) — patch as soon as you can and don’t treat this as a fix.
3. If you’re on a managed platform (AWS, Azure App Service, etc.), check whether the platform already auto-patched — most major cloud PHP runtimes rolled out fixes within 24 hours of disclosure.
4. Watch your logs for unusually large multipart/session traffic hitting PHP endpoints — that’s the fingerprint of exploitation attempts in the wild.

It’s not just PHP2Shell — a rough month for PHP security

A few other PHP-ecosystem CVEs have landed recently and are worth knowing about if you’re running a PHP stack:

• CVE-2025-63888 / CVE-2025-63889 — Two vulnerabilities in ThinkPHP 5.0.24’s template engine: a remote code execution bug via the template file driver, and an arbitrary file-read bug via crafted template paths. If you’re still on ThinkPHP 5.0.x, it’s end-of-life and these won’t be the last.
• CVE-2025-63828 — An HTTP header injection vulnerability in the Backdrop CMS (PHP-based) password reset flow, allowing session hijacking via a manipulated Host header. No fixed version exists yet.

The pattern across all of these is the same: legacy PHP code paths, memory-handling edge cases, and unvalidated input in places developers assumed were “internal.” If there’s one takeaway, it’s this — patch cadence matters more for PHP than almost any other stack, because so much of the internet still runs on it.

Bottom line

PHP2Shell is a textbook example of how a decade-old memory bug can resurface as a pre-auth RCE once someone puts the right pieces together. If you run anything on PHP — and odds are you do, even indirectly — check your version today:

1

php -v

If it’s not 8.2.35+, 8.3.36+, 8.4.27+, or 8.5.12+, that’s your next task.

The Problem: Your Agent Remembers Everything, Except When It Matters

In my last post I walked through running OpenClaw on Hermes on my own hardware. It works well, but after weeks of daily usage, two fundamental pain points kept surfacing:

1. Context lived in chat logs I would never scroll back through. A critical architectural decision made during a 2:00 AM debugging session three weeks ago was effectively lost.
2. Agent memory was an opaque black box. Whatever the agent decided to remember, it silently stashed away. I had no easy way to inspect it, verify it, or say: “no, that assumption is wrong.”

So I built Hermes Brain: an Obsidian vault template that sits next to your agent and turns every session into plain, searchable markdown, with a human-in-the-loop review step before anything becomes permanent memory.

It is free, MIT-licensed, and lives here: github.com/mistrysiddh/hermes-brain-template.

Since its initial release, the project has grown through 40+ releases into a full-fledged agent intelligence system (currently v1.37.0), featuring 15+ multi-harness agent skills, offline semantic search, cognitive reflection cycles, a decision log, and automated vault curation.

How It Works: The 3-Stage Memory Pipeline

The foundation of Hermes Brain is a disciplined three-stage progression:

1
2
3

04-Archives/Daily/YYYY/MM/DD/*.md  →  04-Archives/Memory-Review/*.md  →  Hermes MEMORY.md / USER.md
      (raw session archive)              (staged candidate facts,            (durable, injected into
                                          human-reviewed)                     every turn, promoted by hand)

1. Archive. An automated background job dumps every Hermes session to markdown. Transcripts are deduplicated, scrubbed for secrets (API keys, IP addresses, tokens) on the way in, and indexed in manifest.jsonl.
2. Stage. Facts and learnings worth preserving are written as candidates into 04-Archives/Memory-Review/. Nothing auto-promotes to permanent memory without review.
3. Promote. You review candidates (via Obsidian Kanban boards, or through promote_memory.py --review) and approve the ones you want. Only then do they reach the agent’s durable system prompt memory.

Your agent gets a persistent memory, and you retain the editor’s pen.

What’s Inside the Vault

The vault implements the PARA method (Projects, Areas, Resources, Archives) augmented with a _System/ automation core:

It comes preconfigured with Dataview, Kanban, Local REST API, and Smart Connections plugins, two dark themes (Tokyo Night and Nemoclaw), and a unified Dashboard.md tracking active projects, token telemetry, archiver health, and skill analytics.

It also bundles an MCP Server (hermes_brain_mcp.py) that exposes tools like vault_search, read_note, and stage_memory_candidate directly to local and remote LLM agents.

Decisions, Principles & Axioms

Added in v1.24, this is a knowledge layer built for how agents actually reason, not just search:

• Decisions/: log hard-to-reverse choices with a mandatory Alternatives Rejected section. It is the most valuable part, because it stops your agent re-proposing an idea you already considered and rejected months ago.
• Principles/: standing rules distilled from repeated decisions (“we always do X”, not just “we chose X on this date”).
• Axioms.md: the few foundational beliefs everything else derives from. It ships empty on purpose, because these should be yours.

Notes link to each other (derived_from, evidenced_by), so an agent can trace why a rule exists.

Multi-Harness Agent Skills & GitHub Agents

Hermes Brain is no longer just a passive note repository. It ships with a suite of multi-harness agent skills (AGENTS.md) designed to run as standalone CLI tools or as GitHub Agents (.github/agents/ / @hermes-brain <skill>):

• 🔍 self-critique (self_critique.py): Runs comprehensive vault health audits — flagging broken wikilinks, missing YAML frontmatter, path inconsistencies, and secret leaks.
• 🛠️ auto-remediate (auto_remediate.py): Safely and automatically applies fixes for issues surfaced by self-critique.
• 🧬 knowledge-synthesis (knowledge_synthesis.py): Performs BASB and Zettelkasten knowledge consolidation — extracting atomic notes, progressive summaries, Maps of Content (MOCs), and bidirectional backlinks.
• 🌙 dream-cycle (dream_cycle.py): Autonomous cognitive reflection — connects disparate sessions, identifies knowledge drift, drafts ADRs, and prepares memory candidates.
• 📡 radar (radar.py): Standing surveillance on blogs, news feeds, and arXiv papers, producing curated daily/weekly intelligence digests.
• 📊 metrics (metrics.py): Generates timestamped snapshots of vault growth, link density, tag distribution, and stale content.
• 🎯 quiz (quiz.py): Generates active-recall questions directly from your notes to reinforce learned concepts.
• 🧠 converse-learn (converse_learn.py): Reviews sessions and extracts learnings into memory, lessons, skills, or project docs, confirmation-first.
• 🗂️ zknote (zknote.py): Zettelkasten workflow with fleeting and literature notes, MOC building, note splitting, and orphan and weak-link detection.
• 🧹 merge-duplicate (merge_duplicate.py): Finds near-duplicate notes (Jaccard similarity), flags divisive topics instead of auto-merging, and can atomize large notes by heading.
• 🧭 unstuck-decide (unstuck_decide.py): Structured antidotes for roadblocks, plus pros/cons, 2x2 matrix, and weighted-criteria decision modes.
• 📝 auto-changelog (auto_changelog.py): Builds a Keep-a-Changelog file from conventional commits.
• 👋 onboarding (onboarding.py): Conversational setup of your profile, integrations, and PARA structure check.
• ✍️ prompt-quality (prompt_quality.py): Scores prompts 0-100 on clarity, specificity, actionability, structure, and completeness, with improvement tips.
• 🔁 self-improvement (self_improvement_agent.py): Routes grunt work to small models and orchestration to large ones, with a self-evaluation loop.
• 🔬 pm-skills (pm_skills_examination.py) and sota-scan (sota_scan.py): Compare skill-pack repos, and benchmark this repo against comparators with a ranked gap list.
• 🤖 Specialized Subagents (subagents.py): Decomposed roles (researcher, graph-analyst, curator, ingestor, linker, reviewer) that execute focused vault tasks without overloading context.

Every skill defaults to --dry-run and only writes with --apply/--save, so you stay the approver here too.

Local Semantic Search & Intelligent Analytics

Unlike cloud-dependent memory tools, Hermes Brain emphasizes local privacy:

• Local Vector Search (semantic_search.py): Uses sentence-transformers/all-MiniLM-L6-v2 (a lightweight 22MB CPU model) to build an incremental semantic index over your sessions and notes. It runs entirely offline with zero cloud API costs, accessible via CLI or an embedded HTTP endpoint powering natural-language queries directly in Dashboard.md.
• Automated Topic Tagging (session_tagger.py): Extracts topics using lightweight pattern matching, creating global tag clouds and tracking 14-day topic trends.
• Predictive Skill Forecasting (skill_forecast.py): Analyzes vault activity logs alongside your installed skill index to suggest what skills, tools, or workflows your agent should acquire next.

Why Not Just Use a Vector-DB Memory Service?

If you want completely hands-off semantic recall, a hosted vector database works. If you want to see, verify, and govern what your AI knows in files you control forever, Hermes Brain is built for you.

Installing & Verifying in Under 2 Minutes

Pick whichever method fits your setup:

Option 1: One-Line Terminal Install (Linux, macOS, WSL)

1

curl -fsSL https://raw.githubusercontent.com/mistrysiddh/hermes-brain-template/main/_System/Scripts/Installers/install.sh | bash

(Windows PowerShell equivalent: irm https://raw.githubusercontent.com/mistrysiddh/hermes-brain-template/main/_System/Scripts/Installers/install.ps1 | iex)

Option 2: Clone & Local Setup

1
2
3

git clone https://github.com/mistrysiddh/hermes-brain-template.git my-second-brain
cd my-second-brain
./_System/Scripts/Installers/install.sh

Option 3: Instant 60-Second Verification (No Hermes Needed)

Verify the bundled machinery right after installation:

1
2
3
4
5
6

# 1. Self-test the bundled MCP server
python _System/Scripts/hermes_brain_mcp.py --test
# Output ends with: "All hermes-brain-mcp self-tests PASSED"

# 2. Check pending candidate memory facts (prints [] on fresh install)
python _System/Scripts/promote_memory.py --list

The installer also runs verify_install automatically, checking the folder structure, required plugins, MCP server, memory pipeline, and User-Profile.md integrity.

Grow Into It: Opt-in Feature Packs

_System/Scripts/features/ lets you adopt the template gradually: beginner (archiving and memory promotion, the default), analyst (semantic search, tagging, dashboards), poweruser (forecasting, audit, drift checks), and experimental.

Other Ways to Try

• One paste into Hermes (INSTALL_PROMPT.md): Copy the master prompt directly into your Hermes chat to install the vault and schedule the hourly cron job automatically.
• Scratch Vault (try.sh / try.ps1): Spins up a throwaway temporary vault so you can experiment without modifying your live environment.
• GitHub Codespaces: One-click zero-install browser environment using the GitHub Codespaces template badge.

Privacy & Operational Safety

• Structure Only: The repository contains no private chat history, API keys, or personal data. A GitHub Action workflow (personal-data-guard) actively blocks accidental secrets.
• Git-Ignored Personal Paths: Daily/, Memory-Review/, .smart-env/, and plugin data.json files are excluded by default.
• Safe Template Updates: Running update.sh / update.ps1 pulls the latest code, templates, and skills while strictly preserving your User-Profile.md and personal notes.
• Local Git Safety Net: session_git_snapshot.py auto-commits a local snapshot at session end (never pushes), and refuses to commit if it spots API keys or private keys. Wire it to on_session_end as a cheap undo button for bad multi-file agent edits.
• Template Drift Checker: template_drift.py compares your vault to the latest release by SHA256 and marks each file safe-to-update, customized, outdated, or missing.
• Process Concurrency Locking: The session archiver uses exclusive .hourly_archive.lock protection so background crons and on-demand archive_now.py runs never corrupt manifest.jsonl.

Do I Need Hermes or a Local LLM?

• No local LLM required: The core vault, archiving engine, memory pipeline, and multi-harness skills run fast on pure Python. Only the optional trend-digest scripts use Ollama or sentence-transformers.
• No Hermes required for the vault: The PARA architecture, templates, Dataview queries, and Kanban boards work as a standalone Obsidian second brain. Hermes or OpenClaw is only needed when you want automated transcript feeds.

Links & Community

• ⭐ GitHub Repository: github.com/mistrysiddh/hermes-brain-template
• 🌐 Interactive Showcase: mistrysiddh.github.io/hermes-brain-template
• 📺 Install Walkthrough: Watch on YouTube
• 💬 Discussions & Ideas: GitHub Discussions

Give your agent a memory you can actually inspect, govern, and trust.

Why I Stopped Renting My AI and Started Hosting It

Every “AI assistant” you use today — ChatGPT, Gemini, whatever bot is trending this month — lives on someone else’s server, under someone else’s terms of service, with your conversations sitting on someone else’s disk. For a lot of casual use, that’s fine. But if you actually want an assistant that remembers things across sessions, can act on your behalf (send messages, run automations, manage your projects), and doesn’t quietly change behavior after a policy update — you want it running on hardware you control.

That’s exactly why I set up OpenClaw running on Hermes on my own Linux box. No monthly “Pro” tier, no rate limits I don’t control, no black box. Just a system I configured, that I can inspect, extend, and fully own.

This post walks through what that setup actually looks like, why I chose this stack, and what you need if you want to build something similar.

What Is Hermes?

Hermes is the runtime — think of it as the engine that lets an AI agent actually do things instead of just replying with text in a chat window. It gives the assistant:

• Tools — browser control, terminal access, file read/write, web search, code execution
• Memory — persistent facts and context that carry across sessions, not wiped every time you close the tab
• Skills — reusable, documented procedures for recurring tasks (deploying a server, managing a Discord community, editing a video, whatever you do often)
• Integrations — Telegram, Discord, cron jobs, and other delivery channels so the assistant can reach you outside of a chat window

In short: Hermes turns a language model from “a thing you type questions into” into “an agent that lives on your infrastructure and does work.”

What Is OpenClaw?

OpenClaw is the framework/persona layer sitting on top of Hermes — it’s what gives the assistant a consistent identity, personality, and operating rules across every session, instead of starting from a blank slate every time you open a new chat. It’s the difference between talking to a stateless chatbot and working with something that actually remembers who you are and how you like things done.

The Actual Setup

Here’s the practical side — what running this actually takes:

Hardware: You don’t need a beast of a machine. My box runs on a modest 2-CPU, ~8GB RAM VPS. No GPU required, because the model inference itself happens via API calls to a hosted model (Claude, in my case) — the server just runs the agent, not the model weights. That’s an important distinction: self-hosting the agent is lightweight; self-hosting the model is a completely different (and much heavier) project.

Core stack:

• Linux server (any modern distro works)
• Hermes runtime installed and configured
• API key for your model of choice (Anthropic, OpenAI, or a local model if you want to go fully offline)
• .env file holding your bot tokens (Telegram, Discord) — never committed to git
• Cron jobs for scheduled tasks (briefings, monitoring, reports)

Integrations I run:

• Telegram bot — direct messages and notifications land straight in my phone via the Bot API (sendPhoto, sendMessage), no polling needed
• Discord — full server management (channels, roles, onboarding, AutoMod) via raw REST calls using a bot token, tied to my YouTube community server
• Skills system — instead of re-explaining how I want something done every single time, I write it once as a skill file and the assistant loads it automatically when relevant

What This Actually Buys You

1. Privacy — conversations, memory, and automations stay on infrastructure you control. No third party mining your chat history for training data.
2. Persistence — memory survives across sessions. It doesn’t forget your preferences, your projects, or your running context every time you start a new conversation.
3. Automation — cron-triggered briefings, monitoring, and notifications running independently of you being actively in a chat.
4. No lock-in — swap the underlying model provider without rebuilding your entire workflow. The agent layer stays yours.
5. Extensibility — every tool, skill, and integration is something you can read, edit, and fix yourself. When something breaks, you’re not waiting on a support ticket.

Is This For Everyone?

Honestly — no. If you just want quick answers to questions, a hosted chatbot is easier and requires zero setup. This approach makes sense if you:

• Automate things regularly (deployments, monitoring, content workflows)
• Care about where your data lives
• Like understanding and controlling your own tools instead of trusting a black box
• Already run Linux servers and are comfortable in a terminal

If that’s you, self-hosting your AI agent stack is one of the more satisfying things you can build right now — it’s the same shift we already made with self-hosted NAS systems, home automation, and Pi servers, just applied to AI.

What’s Next

I’ll be covering the deeper technical bits in follow-up posts and on the YouTube channel — setting up specific integrations, writing custom skills, and the security considerations that come with giving an AI agent terminal and browser access on your own machine (spoiler: sandboxing and permission boundaries matter a lot).

If you’re building something similar or have questions about the setup, drop them in the comments.

How to Protect Yourself from Hackers and Online Scams

Summary
Cybersecurity is about keeping your online world safe from threats like hackers and scammers. Think of it as locking the doors to your digital life. Whether it’s protecting personal data, avoiding fraud, or using technology responsibly, staying secure online is essential in today’s fast-paced digital age. In this guide, we’ll explore simple yet effective steps you can take to safeguard yourself and your loved ones from cyber threats.

The internet has made our lives easier in so many ways. We shop online, manage our bank accounts, connect with friends, and even work remotely. But unfortunately, hackers and scammers are constantly looking for ways to take advantage of us.

The good news? You don’t have to be a tech expert to protect yourself online. With a few simple habits, you can significantly reduce your risk of falling victim to cybercrimes. Let’s break it down!

1. Use Strong, Unique Passwords

Think of your password as the lock on your front door. A weak password is like leaving your door unlocked. Here’s how to make a strong one:

• Use at least 12 characters.
• Mix letters (uppercase and lowercase), numbers, and symbols.
• Don’t reuse passwords across different accounts.

👉 Tip: Use a password manager app (like LastPass or Dashlane) to remember them for you.

2. Double-Check Before You Click

Have you ever received an email or message asking you to click a link or download something? Scammers often use tricks like this to steal your information.

• If you don’t know the sender, don’t click!
• Check for oddities in the email, like misspellings or unusual requests.

👉 Tip: If an email claims to be from your bank or a company, visit their website directly instead of using the link in the email.

3. Keep Everything Updated

Your devices and apps often release updates to fix security issues. If you skip these updates, hackers might find ways to break in.

• Turn on automatic updates for your phone, computer, and apps.
• Update antivirus software regularly (it’s like a digital security guard).

👉 Tip: If you see a notification about updates, don’t delay—do it right away!

4. Watch What You Share Online

Social media is fun, but sharing too much can be risky. Hackers use personal details like your birthday, pet’s name, or school name to guess passwords or trick you.

• Avoid posting private information, like your address or travel plans.
• Be cautious about what you share in public profiles.

5. Use Two-Step Verification

This is like adding a second lock to your door. Even if someone steals your password, they can’t get in without a second step, like a code sent to your phone.

• Look for “Two-Factor Authentication” or “2FA” in your account settings.

👉 Tip: Use apps like Google Authenticator instead of relying on text messages for these codes.

6. Stay Alert to Scams

Scammers are smart, but you can outsmart them. Here’s what to watch for:

• Fake calls or texts: If someone claims to be from your bank or a company and asks for sensitive information, hang up and call the company directly.
• Too-good-to-be-true offers: If it feels too good to be true, it probably is.

7. Secure Your Wi-Fi at Home

Your Wi-Fi connects all your devices, so it’s important to keep it safe.

• Change the default password on your router to something only you know.
• Use a strong Wi-Fi password, not something easy like “password123.”

8. Check Your Bank Statements

Hackers sometimes make small charges on your credit card to test if it works before taking more.

• Review your statements every month.
• Set up alerts for unusual activity.

👉 Tip: If you see a charge you don’t recognize, report it to your bank immediately.

9. Back Up Your Data

Imagine losing all your photos, documents, or contacts—terrifying, right? Backing up your data keeps it safe.

• Use an external hard drive or a cloud service like Google Drive or iCloud.
• Back up important files regularly.

10. Stay Informed

Cybercriminals are always finding new tricks. By staying informed, you can stay ahead of them.

• Follow trusted websites or news sources about online safety.
• Share tips with your friends and family to help them stay safe too.

Final Thoughts

Online security doesn’t have to be complicated. Small steps like using strong passwords, keeping your software updated, and being cautious about what you click can go a long way.

If something feels suspicious, trust your instincts. It’s better to be safe than sorry. By staying alert and following these tips, you can enjoy the benefits of the digital world without falling victim to hackers and frauds.

💡 Remember: Staying safe online is a habit. Start today and protect your future!

Share this post to help others stay safe online too!

Donation

Safeguarding Your Digital World: A Comprehensive Guide to Cybersecurity

In our modern age, where digital technology reigns supreme, the need for cybersecurity has taken center stage. From individuals to corporations, the increasing frequency and sophistication of cyber threats make it crucial to bolster our digital defenses. This comprehensive guide aims to demystify the world of cybersecurity and provide you with practical steps to ensure your online safety.

1. Understanding Cybersecurity

At its core, cybersecurity involves a range of strategies and measures aimed at shielding digital systems, networks, and data from unauthorized access, malicious attacks, and potential damage. It’s a multi-layered approach that thwarts threats like hacking, phishing, malware, and ransomware.

2. Common Cyber Threats

Let’s familiarize ourselves with some prevalent cyber threats:

• Phishing: Deceptive attempts to acquire sensitive information.
• Malware: Destructive software that can compromise, disrupt, or gain unauthorized access.
• Ransomware: Encrypts data and demands payment for its release.
• Data Breaches: Unauthorized access to sensitive information.
• Social Engineering: Manipulating individuals into revealing confidential data.

3. Essential Cybersecurity Practices

Here are some fundamental practices for robust cybersecurity:

• Strong Passwords: Craft intricate passwords with a mix of characters, avoiding easily guessable information.
• Multi-Factor Authentication (MFA): Add an extra layer of security by requiring multiple verification steps.
• Regular Updates: Keep software and systems up to date to patch vulnerabilities.
• Firewalls and Antivirus: Install reliable firewalls and antivirus software to prevent breaches.
• Secure Wi-Fi: Use robust encryption, change router passwords, and avoid public Wi-Fi for sensitive tasks.
• Data Encryption: Safeguard sensitive data through encryption to prevent unauthorized access.
• Backup Data: Regularly back up crucial files to an external, secure location.

4. Cyber Hygiene for Individuals

Practice good “cyber hygiene” with these individual-oriented steps:

• Email Vigilance: Be cautious of unexpected emails, avoid clicking suspicious links, and verify sender identities.
• Social Media Awareness: Limit sharing personal information and adjust privacy settings.
• Safe Browsing: Verify URLs, stick to secure connections (HTTPS), and steer clear of untrusted websites.
• App Permissions: Review and restrict app permissions to only necessary functions.

5. Cybersecurity for Businesses

Businesses need specialized measures to protect their digital assets:

• Employee Training: Regularly educate staff about cybersecurity threats and best practices.
• Network Security: Implement firewalls, intrusion detection systems, and stringent access controls.
• Data Management: Safeguard sensitive data with encryption and access controls.
• Incident Response Plan: Develop a clear strategy for addressing cyber incidents to minimize damage.
• Vendor Security: Assess third-party vendor security practices before sharing data.

6. Staying Informed

Stay updated on evolving cybersecurity trends through reliable sources, industry news, and security blogs.

7. Seek Professional Help

For intricate cybersecurity needs, consider enlisting experts or consultants to assess, advise, and bolster your security measures.

In today’s interconnected world, cybersecurity is everyone’s responsibility. By adopting proactive measures, staying informed, and cultivating cautious digital habits, you can shield your digital presence and contribute to a safer online environment. Remember, the most powerful defense against cyber threats is knowledge and preparedness.

Donation

Overview

We will be install ROS on Raspberry PI 4 without Ubuntu. In this tutorial we we will be using docker insted of using ubuntu or any other software.

Requirments

• Laptop or Desktop
• Stable internet connection(Mobile or Router no matter which connection is it)
• Raspberry Pi with 4GB+ ram (mine is Raspberry Pi 4 B+ model with 8GB of ram)
• MicroSD card with a minimum of 32GB size
• Power supply (power bank or cell phone adaptor)
• MicroB to HDMI with monitor(optional) if you’re going to use a monitor then you will be needing of keyboard
• And most important thing a cup of coffee

Step 1 - Hardware setup

Ok first of all we need some software which will help us to flash memory card so that we can install os in the memory card to boot in pi.

Go to https://www.raspberrypi.com/software/ and download software according to your OS I’m using Zorin OS which is based on Ubuntu so I will be using the terminal. If you are using terminal use the following command

1

sudo apt install rpi-imager

as you can see in the below image I have already installed it on my device

Go ahead and open it up after opening it up plugin your 8GB or higher sd card on your laptop. as you can see in the image I have inserted 8GB of card

Now do the following steps as soon in the photo’s

Select Raspberry Pi OS(other)

Then select Raspberry Pi OS with desktop

Now select your disk but before writing your os we will configure it first so that we don’t have to connect any kind of ethernet cable or mini Wi-Fi. Press ALT + SHIFT + X to open secret setting

Note: set your hostname and remember it we will be needing it later

Click on Yes and let it complete it. After that, you will be granted this message so it means that it is been completed.

Step 2 - Booting UP

Remove your memory card from the computer and plug that it into pi and power it on, well as the pi is doing some process grab a cup of coffee and wait for a few minutes.

Open up your terminal and enter the following command

1
2

# as you remember I have told you to set your hostname in the software and remember it.
ssh pi@hostname.local

Replace your hostname with the hostname you have set while preparing the sd card. In my case, I have set my hostname with datacenter so my command will be like this

1

ssh pi@datacenter.local

as soon as you hit enter it will as you for a conformation like this

1
2
3
4

~ ➤ ssh pi@datacenter.local                                                   
The authenticity of host 'datacenter.local (192.168.32.200)' can't be established.
ECDSA key fingerprint is SHA256:VlnqrEfP5pLc62h2TQbN0Z4pEudRsmRQL4+LqDD6ZB8.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

answer it with yes after that it will as you for a password which we have set during the software installation. As you have given the password right then you will see that you have been login into your account successfully like I did.

Congratulation we have been login successfully into our pi take a break grab a cup of coffee and relax.

Step 3 - Software setup

As we successfully login into pi first we will update the repository as well as we will be upgrading it by the following command don’t worry if you haven’t used Linux in your life this will be your first experience as well as it will be really easy just follow my steps.

Update and Upgradation of packages

1
2
3

sudo apt update
sudo apt upgrade -y
sudo apt full-upgrade -y

The above command will update the repositories as well as it will be upgrading all the packages which are outdated so that we don’t get any kind of error while installing. It will take a few minutes after all the process is completed we will check once again if there is any software that is left to upgrade by the following command.

1

sudo apt update && sudo apt list --upgradable

The following command will check whether any package is upgradable or not, if its all upgrade then it will return it with this message

Package Installation

Now we will install some few pre-required software so that we will use it properly. Follow me oh and don’t forget your cup of coffee ;)

1
2
3

sudo apt update
sudo apt install nano wget git curl htop -y
sudo init 6 # this command will restart your Raspberry PI4

Step 4 - Getting docker

There is a script which will help us to easily install docker on our PI without any command just a single command and then run it. Right simple as it says lets give it a run.

Download the following scipt

1

curl -fsSL https://get.docker.com -o get-docker.sh

After downloading it script rut it with super user permission(root access)

1

sudo bash get-docker.sh

Grab your cup of coffee and wait till the installtion is over

Once Docker is installed, add your login user to the docker group with the following command:

1

sudo usermod -aG docker $(whoami)

For our safty we will reboot out PI for external changes

1

sudo init 6

After rebooting just check docker verion by following command:

1

docker version # if the following command wont work then add sudo in front of it

This is the following version which im running right now:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

docker version
Client: Docker Engine - Community
 Version:           20.10.19
 API version:       1.41
 Go version:        go1.18.7
 Git commit:        d85ef84
 Built:             Thu Oct 13 16:45:42 2022
 OS/Arch:           linux/arm64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.19
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.18.7
  Git commit:       c964641
  Built:            Thu Oct 13 16:44:07 2022
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.6.8
  GitCommit:        9cd3357b7fd7218e4aec3eae239db1f68a5a6ec6
 runc:
  Version:          1.1.4
  GitCommit:        v1.1.4-0-g5fd4c4d
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

Step 5 - Installing Docker composer

Docker Compose is a tool for automating Docker projects using a YAML file. With the help of thi file you can create many project from scratch as I did.

1

sudo apt install python3-pip -y

PIP is a tool which will help us to install docker composer. If it already install then we will move on to the next step

1

sudo pip3 install docker-compose

After installing docker composer we will check wheather it is installed properly or not

1
2
3
4
5

docker-compose version
docker-compose version 1.29.2, build unknown
docker-py version: <module 'docker.version' from '/usr/local/lib/python3.10/dist-packages/docker/version.py'>
CPython version: 3.10.7
OpenSSL version: OpenSSL 3.0.5 5 Jul 2022

Step 6 - Installation of ROS (semi-final step)

Before going further we will just give it a reboot so that we make sure that everything is working propely

1

sudo init 6

As we have rebooted our system we will now search for our docker repository by using docker search command

1
2
3
4

docker search siddhmistry
NAME                   DESCRIPTION              STARS     OFFICIAL   AUTOMATED
siddhmistry/mrfoxie                             0                    
siddhmistry/ros_rpi4   ROS for Raspberry PI 4   0  

We need to install second one which is second one siddhmistry/ros_rpi4 follow the following steps

1
2
3

xhost +
docker pull siddhmistry/ros_rpi4:armhf
docker container run -it --name ROS_RPI4 --net=host -e DISPLAY siddhmistry/ros_rpi4:armhf

Now it will take come time so have a coffee break

Step 7 - Final step

As by now you have noticed that a terminator has been popped up run the following command so that we can setup our ROS System

1
2
3

source /opt/ros/noetic/setup.bash
echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

As we have completed all the steps try to run roscore if this commands works then you have successfully installed it. Press Ctrl + C to exit roscore after that type exit to exit it. Now that we have done everything we just need to install just a small thing which is called Portainer which will help to run this container easily

Step 8 - Installing Portainer

As we know we have already install docker so we will start installing Portainer so just follow the steps

First, create the volume that Portainer Server will use to store its database:

1

docker volume create portainer_data

Then, download and install the Portainer Server container:

1

docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest

Portainer Server has now been installed. You can check to see whether the Portainer Server container has started by running docker ps:

1
2
3

docker ps
CONTAINER ID   IMAGE                          COMMAND                  CREATED       STATUS      PORTS                                                                                  NAMES             
de5b28eb2fa9   portainer/portainer-ee:latest  "/portainer"             2 weeks ago   Up 9 days   0.0.0.0:8000->8000/tcp, :::8000->8000/tcp, 0.0.0.0:9443->9443/tcp, :::9443->9443/tcp   portainer

Now that the installation is complete, you can log into your Portainer Server instance by opening a web browser and going to: portainer

1

https://localhost:9443

When you open the url you will be asked to steup admin username and password after login into the admin panel it looks like this

Here you will see a local enviroment click on it and this page will open it up:

At the left side panel you will able to see Containers option. When you open that page it will grant you with some containers.

You will see that there is a container name ROS_PI4 select it and press start anf baam it started working. Portainer is a tool where it will help you control your container and also to add more containers in it. I hope you loved it.

Overview

We will be seeing a fully functional NAS server on Raspberry Pi(all pi version) homemade with simple few lines of command and with one software require before we start we will be requiring a few things before we start.

Requirments

• Laptop or Desktop
• Stable internet connection(Mobile or Router no matter which connection is it)
• Raspberry Pi with 4GB+ ram (mine is Raspberry Pi 4 B+ model with 8GB of ram)
• MicroSD card with a minimum of 8GB size
• Power supply (power bank or cell phone adaptor)
• MicroB to HDMI with monitor(optional) if you’re going to use a monitor then you will be needing of keyboard
• And most important thing a cup of coffee

Step 1 Hardware setup

Ok first of all we need some software which will help us to flash memory card so that we can install os in the memory card to boot in pi.

Go to https://www.raspberrypi.com/software/ and download software according to your OS I’m using Zorin OS which is based on Ubuntu so I will be using the terminal. If you are using terminal use the following command

1

sudo apt install rpi-imager

as you can see in the below image I have already installed it on my device

Go ahead and open it up after opening it up plugin your 8GB or higher sd card on your laptop. as you can see in the image I have inserted 8GB of card

Now do the following steps as soon in the photo’s

Select Raspberry Pi OS(other)

Then select Raspberry Pi OS Lite (Legacy)

Now select your disk but before writing your os we will configure it first so that we don’t have to connect any kind of ethernet cable or mini Wi-Fi. Press ALT + SHIFT + X to open secret setting

Note: set your hostname and remember it we will be needing it later

Click on Yes and let it complete it. After that, you will be granted this message so it means that it is been completed.

Step 2

After that plug, it into pi and power it on, well as the pi is doing some process grab a cup of coffee and wait for a few minutes.

Open up your terminal and enter the following command

1
2

# as you remember I have told you to set your hostname in the software and remember it.
ssh pi@hostname.local

Replace your hostname with the hostname you have set while preparing the sd card. In my case, I have set my hostname with datacenter so my command will be like this

1

ssh pi@datacenter.local

as soon as you hit enter it will as you for a conformation like this

1
2
3
4

~ ➤ ssh pi@datacenter.local                                                   
The authenticity of host 'datacenter.local (192.168.32.200)' can't be established.
ECDSA key fingerprint is SHA256:VlnqrEfP5pLc62h2TQbN0Z4pEudRsmRQL4+LqDD6ZB8.
Are you sure you want to continue connecting (yes/no/[fingerprint])?

answer it with yes after that it will as you for a password which we have set during the software installation. As you have given the password right then you will see that you have been login into your account successfully like I did.

Congratulation we have been login successfully into our pi take a break grab a cup of coffee and relax.

Step 2 Software setup

As we successfully login into pi first we will update the repository as well as we will be upgrading it by the following command don’t worry if you haven’t used Linux in your life this will be your first experience as well as it will be really easy just follow my steps.

Update and Upgradation of packages

1
2
3

sudo apt update
sudo apt upgrade -y
sudo apt full-upgrade -y

The above command will update the repositories as well as it will be upgrading all the packages which are outdated so that we don’t get any kind of error while installing our NAS software. It will take a few minutes after all the process is completed we will check once again if there is any software that is left to upgrade by the following command.

1

sudo apt update && sudo apt list --upgradable

The following command will check whether any package is upgradable or not, if its all upgrade then it will return it with this message

Packages installation

Now we will be requirement few software for NAS to install without any error follow me

1

sudo apt install wget htop -y

These packages are preinstalled but in some cases, these packages are not been installed so we will be making sure that it’s installed.

Script installation

This script will not affect your network connection but if it did then I will leave a tutorial at the end of installation (Wi-Fi setup). Clear your terminal by using the clear command it will clear your terminal so that you can see it easily. Now past this script into the terminal so that installation start’s

1
2
3

wget https://github.com/OpenMediaVault-Plugin-Developers/installScript/raw/master/install
chmod +x install
sudo ./install -n

Sit back and relax until the process is been done till that time go ahead and give me a cup of coffee so that I can bring up various kinds of this topic so that you can enjoy it

Congratulation it’s been installed completed for our protection we will reboot our system with the following command sudo reboot.

Step 3 NAS setup on browser

As in Step 2 Software setup we have installed once again we will be login into ssh account to check the IP address of our Pi use the following command to check the IP address

1

hostname -I

After finding your IP address use that IP address and open it in the browser with https://your_ip_address and it will grant you this page

Now now don’t be frightened of the login page because you don’t know the password and username well of course I also don’t know. Just joking type the following and it will let you in

1
2

username: admin
password: openmediavault

Congratulation you have successfully login, now before doing anything we will go ahead and change the password you will grant with this screen

Changing admin panel password

Go to System >> General Settings >> Click on Web Administrator Password then enter your new password after doing that we will plug in any kind of hard drive or some sort of memory storing device

Storage setup

As we have inserted external storage head over to Storage >> Disk and there you will be able to see your storage mounted on pi in my case I have inserted 128GB of memory card for the testing purpose also I have a few files copied into it

Select the disk and then click on Wipe

![Disk Wipe]

As we have confirmed that our storage is been mounted on our pi now we will make a shared folder so that we can access it from any device.

Now select the quick option

File System setup

After wiping the data from the drive click on File System in the Storage section. Click on Add button and select Device and select the device and give it a label of your choice I will be giving it the name DataCenter, and make sure that you select EXT4 in File System.

After hitting Yes to add device take a cup of coffee and wait for it

Select your device and click on the mount option to mount your device. A pop-up has been visible on the top just hit on the Apply button to apply changes so that to make sure that what are we going to make changes will work properly. It will take a few minutes to complete the process.

Sharing Folder setup

Now we will head to Sharing Folder Setup to set up our sharing folder. Go to Access Rights Management > Shared Folders when you will go there you will find it empty because we haven’t set up any sharing folder go ahead and hit that Add button without any thoughts.

Fill in all the details according to your need and make sure to leave Permission as it is until and unless you know the purpose of it. I will be labeling it as DataCenter if you want to comment on that device then you can otherwise Save it, again you will see Apply button on the top right side of the screen as shown in the image below it will take a while to apply the changes.

We will permit it so that we can Read/Write files into it. Select your newly created folder and click Privileges and give Read/Write to both pi users. Hit save and apply.

Services Setup

Go to the Services section and select SMB/CIFS as soon as you select it you will be granted a screen with soo many scary options but don’t worry we will be using only 2 options only. So go ahead and click sharing in the SMB/CIFS section.

Go ahead click on the Add button select your shared folder which you have been created. Hit save and apply don’t change any other kind of options if your expert then only does it or else let it be as it is. Go back to the SMB/CIFS setting page and enable it. Hit save and apply. Take a cup of coffee and relax for a bit because we are coming to the most intrusting part which is accessing it from our devices.

Accessing our NAS

If you try to access it, it will as you for authentication so use your pi account and password which you used while setting up os if it fails then go to Access Rights Management > User, select pi user, and edit it after that add your new password and save it. go back to the folder and try to login back and you will be successfully logged in to NAS Folder

Wi-Fi Setup

If you’re going to use Wi-Fi then connect to a monitor and attach a keyboard then simply type the following command in the terminal to access the raspberry pi configuration setup

1
2

sudo raspi-config
# it will represent you with the screen bellow

Select System Options > Wireless LAN > Enter your Wi-Fi Name > Enter your Wi-Fi password

After completing all the above steps reboot your system with sudo reboot and bam done.

Microsoft Edge has taken over PDF viewer, and other default web tasks. Even when manually removing it will reinstall via windows updates.

Removing the Base Install

We first need to find the Edge install of the chromium edition in your Program Files.

Location:

1

C:\Program Files (x86)\Microsoft\Edge\Application\

The setup program is what we need to uninstall edge. Go to the location above and drill down from the number and Install folder

Example:

1

C:\Program Files (x86)\Microsoft\Edge\Application\92.0.902.62\Installer

Once you find your path you can now uninstall edge with the following command (Note: YOURS WILL BE DIFFERENT!)

1

C:\Program Files (x86)\Microsoft\Edge\Application\92.0.902.62\Installer\setup.exe --uninstall --system-level --verbose-logging --force-uninstall

Keep it from coming back… for now

You now need to add a registry entry. The following location Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\EdgeUpdate needs to be added with a DWORD called DoNotUpdateToEdgeWithChromium with a value of 1.

You can do this with a simply reg file. (stopedge.reg)

1
2
3
4

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\EdgeUpdate]
"DoNotUpdateToEdgeWithChromium"=dword:00000001

Create this file or download the file @ https://www.mistrysiddh.tk/files/stopedge.zip

Run this to prevent edge reinstallation. Note: Microsoft will kill this workaround in the future and force edge on you

Requirement

1. Android Phone
2. Data cable
3. Scrcpy - https://github.com/Genymobile/scrcpy
4. Guiscrcpy - https://github.com/srevinsaju/guiscrcpy

Enabling Usb debugging

First of all, you need to know the Android version of your phones. You can find it on your phone information section. Try to tap Settings > About Device > Software information (or System in some Android version) > Android version and then you can know which Android version your phone have on.

Now connect your phone with your desktop.

Guiscrcpy & Scrcpy installation

Goto Guiscrcpy release and scrcpy files and place it in one folder like this

Extract all the file of scrcpy*.zip into a folder after doing that open Guiscrcpy. It will ask you to locate scrcpy.exe no go into the extraced folder and select scrcpy.exe

!

After doing that connect your phone to your device and Start Scrcpy

Congratulations now you can cast you screen on your laptop or Desktop.

Watch Netflix Movie on larger screen with mobile plan (Top Secret)

Use this method to trick your friends. Enjoy

Overview

This is perfect for setting up your first website and learning not only administering a wordpress site, but learning Linux. You will need a Raspberry Pi, a couple hours, and a computer to download the image on. The Raspberry Pi (RPI) is a perfect device for learning these things.

Also check out the official projects site from RaspberryPi
Source: https://projects.raspberrypi.org/en/projects/lamp-web-server-with-wordpress

Downloading the RPI Imager

Download the Imager for your operating system. This supports all three OS’s (Windows, Mac, and Linux).

https://www.raspberrypi.org/downloads/

• Run and Install the Imager
• Select Raspberry Pi OS (other) -> Raspberry Pi OS Lite (32-bit)
  • Note: This is the one with NO Desktop Environment
• Insert the SD Card into your Computer
• Click Write

Install Dependencies

1
2

sudo apt-get install apache2 php mariadb-server php-mysql -y
sudo service apache2 restart

Install Wordpress

1
2
3
4
5
6
7

cd /var/www/html/
sudo rm *
sudo wget http://wordpress.org/latest.tar.gz
sudo tar xzf latest.tar.gz
sudo mv wordpress/* .
sudo rm -rf wordpress latest.tar.gz
sudo chown -R www-data: .

Setup WordPress Database

1

sudo mysql_secure_installation

• You will be asked Enter current password for root (enter for none): — press Enter.
• Type in Y and press Enter to Set root password?.
• Type in a password at the New password: prompt, and press Enter. Important: remember this root password, as you will need it later to set up WordPress.
• Type in Y to Remove anonymous users.
• Type in Y to Disallow root login remotely.
• Type in Y to Remove test database and access to it.
• Type in Y to Reload privilege tables now.

When complete, you will see the message All done! and Thanks for using MariaDB!.

Login to MySQL with sudo mysql -uroot -p and enter the password you set above.

You will see the terminal prompt change and you can enter the following:

1
2
3

create database wordpress;
GRANT ALL PRIVILEGES ON wordpress.* TO 'root'@'localhost' IDENTIFIED BY 'YOURPASSWORD';
FLUSH PRIVILEGES;

IMPORTANT: Exit SQL Prompt with Ctrl + D and change YOURPASSWORD above to your password!

Reboot with sudo reboot

Wordpress Configuration

Remote Access can be done with SSH from any system. Find your Raspberry Pi IP with ip a. This IP is only your Local IP and not accessible from the outside world.

Initial setup can be done from any computer in the same network as the RPI. Type your pi ip address from above into your browsers address bar.

Example: https://127.0.0.1

Remote Login after initial setup append /wp-admin to the address

Example: https://127.0.0.1/wp-admin

Recommended Server settings

Finally we need to make some quality of life improvements so you don’t have weird looking addresses. This is called “Friendly Permalinks”.

In the WP Admin Portal:

• Go to Setting, then Permalinks
• Select the Post name option and click Save Changes

From SSH or Terminal on the RPI you need to enter the following:

1
2

sudo a2enmod rewrite
sudo nano /etc/apache2/sites-available/000-default.conf

000-default.conf edits (Add this midway in the file)

1
2
3

<Directory "/var/www/html">
    AllowOverride All
</Directory>

Save the File by press Ctrl + O and Exit with Ctrl + X

Now restart Apache Web with sudo service apache2 restart

Requirement software

1. Latest version Windows 11. Download
2. Winrar. Download
3. Rufuse. Download
4. TPM fix. Download (if its prompt for password then enter 123)

Windows Insider Registration

The path for upgrading to 11 requires you to have an activated Windows 10 PC and be subscribed to the insider builds.

Insider builds can be registerd for use https://insider.windows.com/

System Modification

Windows 11 does checks for TPM and Secure boot before it allows the upgrade process to start. However, these can be bypassed.

Note: It is important to understand Microsoft can at ANY TIME enforce these rules or ignore these modifications which means you would NO LONGER recieve updates

Here is the registry edits that need to be made: (win11bypass.reg)

1
2
3
4
5

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\Setup\LabConfig]
"BypassTPMCheck"=dword:00000001
"BypassSecureBootCheck"=dword:00000001

Download Reg File here: https://www.mistrysiddh.com/files/win11bypass.reg

REBOOT AFTER MODIFICATIONS MADE

TPM & Secure Boot Fix

Copy Windows 11 and TPM fix in one folder

Extract both the ISO and zip in that folder after that open fix_TPM_error and copy both the files and past it in 21996.1.210529-1541.co_release_CLIENT_CONSUMER_x64FRE_en-us (1)/sources folder it will as you for replacing the file replace it.

Now go back 21996.1.210529-1541.co_release_CLIENT_CONSUMER_x64FRE_en-us (1) folder and run setup.exe select the options of your like.

Congratulation

Congratulation now you have successfully install Windows 11 on your system

What is Face Detection?

Face detection is AI-based computer technology that is used to extract and identify human faces from digital images. When integrated with biometric security systems (particularly, facial recognition ones), this kind of technology is what makes it possible to monitor and track people in real-time. In applications that use facial tracking, analysis, and recognition, face detection typically works as the first step and has a significant impact on how sequential operations within the app will perform.

Face detection helps with facial analysis by identifying the parts of a video or an image that should be focused on when determining gender, age, and emotions. Similarly, with facial recognition systems (which create “faceprint” maps of facial features), face detection data is included in the system’s algorithms. And why? Face detection helps determine which parts of the video or image are needed to produce a faceprint.

HOW DOES FACE DETECTION WORK?

Face detection technology uses machine learning and algorithms in order to extract human faces from larger images; such images typically contain plenty of non-face objects, such as buildings, landscapes, and various body parts.

Facial detection algorithms usually begin by seeking out human eyes, which are one of the easiest facial features to detect. Next, the algorithm might try to find the mouth, nose, eyebrows, and iris. After identifying these facial features, and the algorithm concludes that it has extracted a face, it then goes through additional tests to confirm that it is, indeed, a face.

To make algorithms as accurate as possible, they must be trained with huge data sets that contain hundreds of thousands of images. Some of these images contain faces, while others do not. The training procedures help the algorithm’s ability to decide whether an image contains faces, and where those facial regions are located.

Also, now would be a good time to give you definitions of the main types of algorithms – ML, AI, and Deep Learning.

• Machine Learning (ML): ML algorithms use statistics to find patterns in huge amounts of data. This data can include words, numbers, images, clicks, and more. ML is the process behind many modern services – voice assistants (Siri and Alexa), search engines (Google and Baidu), and recommendation systems (Spotify and Netflix);
• Artificial Intelligence (AI): If an ML solution is programmed to learn how to perform a task, rather than just simple performance, then it is AI. Systems that use AI demonstrate behaviors similar to human intelligence – for instance, problem solving, planning, learning, perception, manipulation, and reasoning;
• Deep Learning: This algorithm is a subset of machine learning, and it is what forms deep neural networks; essentially, machines are given a greater ability to find and amplify tiny patterns. Such networks have any layers of computational nodes that collaborate to sift through data and deliver predictions.

Now, as for the exact technologies used to develop face detection applications; these include:

• OpenCV;
• Matlab;
• Tensorflow;
• Neural Networks.

All of these follow almost the exact same procedure for face detection.

FACE DETECTION METHODS

Three researchers from the University of California, David Kriegman, Ming-Hsuan Yang, and Narendra Ahuja, published a classification of facial detection methods. There are four classifiable categories, of which face detection algorithms can belong to 2+ groups. Let’s take a look at each category.

Feature-Based Method

This method located faces by extracting structural features. First, an algorithm is trained as a classifier. Next, it is used to sort facial regions from non-facial regions. The general idea is to move past humans’ instinctive knowledge of faces. When feature-based approaches tackle photos with many faces, they have a 94% success rate.

Summary: Features such as a person’s nose or eyes are used to detect a face.

Knowledge-Based Method

A knowledge-based algorithm is dependent upon a set of rules, and it is built on human knowledge. For instance, “rules” might include that a face should have eyes, a nose, and a mouth in certain positions relative to each other. However, this kind of method comes with one huge challenge: it is very difficult to build an appropriate rules set. If the rules are too general, there may be many false positives – and, conversely, if the rules are too detailed, the system could generate many false negatives.

Summary: A face is determined based on whether it meets a set of rules made by a human.

Template Matching Method

With a template matching algorithm, parameterized or pre-defined templates are used to locate or detect faces – the system measures the correlation between the input photos and the templates. For instance, the template may show that a human face is divided into nose, mouth, eyes, and face contour regions. Also, a facial model could be comprised of just edges and use the edge detection method – implementation of this approach is easy, but it is insufficient for face detection.

Summary: Images are compared to standard face patterns that have been previously stored.

Appearance-Based Method

An appearance-based algorithm uses a set of training images to “learn” what a face should look like. In general, this method relies on machine learning and statistical analysis to determine relevant facial characteristics. An appearance-based approach is generally considered to be stronger than the previously mentioned methods.

Summary: Statistical analysis and machine learning are combined to find a face image’s characteristics.

FACE DETECTION TECHNIQUES

Some of the more specific facial detection techniques include:

1. Removing the background. Let’s say an image has a pre-defined, static background or a plain, single-color background – removing it can help determine the face’s boundaries;
2. With color images, the color of the skin can sometimes be used to find faces;
3. Motion can be used to detect faces. In a real-time video, a person’s face is nearly always in motion. However, a drawback of this technique is that a face could be confused with other moving objects.

When the aforementioned strategies are combined, they can create a comprehensive face detection approach.

WHAT ARE THE CHALLENGES IN FACE DETECTION?

Researchers Ashu Kumar, Amandeep Kaur, and Munish Kumar published a review of face detection techniques, which included a detailed explanation of the challenges that facial detection faces. To sum up their findings, the challenges in face detection include:

• Odd expressions. A human face might have an odd expression, making it difficult for facial detection algorithms to identify it as a face;
• Face occlusion. If a face is hidden by hair, a hat, a hand, glasses, or a scarf, it may result in a false negative;
• Illuminations. An image might not have uniform lighting effects; part of the image may be overexposed, while another part is very dark. Again, this can contribute to false negatives;
• Complex background. When lots of objects are present in an image, face detection’s accuracy is reduced;
• Too many faces. If there is a large number of human faces in an image, face detection software may have a hard time distinguishing between some of them;
• Low resolution. If an image’s resolution is poor, it is more difficult to detect faces;
• Skin color. If somebody’s skin color falls outside of the gradient that is recognized by the algorithm,
  their face might not be detected.

HOW DOES FACE DETECTION WORK WITH DEEP LEARNING?

As we mentioned earlier, deep learning is a subset of machine learning in which large neural networks process huge amounts of data and make complex predictions. So how does deep learning factor into face detection? Well, multiple deep learning methods have been developed specifically for facial detection.

One of the most popular deep learning approaches is the Multi-Task Cascaded Convolutional Neural Network – or, MTCNN. This approach is popular because it achieved cutting-edge results (for the time) on a variety of benchmark datasets – plus, it is able to use landmark detection to recognize the eyes, mouth, and other facial features.

MTCNN uses a cascade structure that contains three networks: P-net, R-Net, and O-Net. The image is first rescaled to different sizes (or an image period). P-Net proposes facial regions, R-Net filters the bounding boxes, and O-Net proposes facial landmarks.

WHY IS FACE DETECTION IMPORTANT TODAY?

Face detection is the initial step in face analysis, face tracking, and, most importantly, face recognition. The latter industry is growing by leaps and bounds, and is applied to device unlocking, banking, hospitality, law enforcement, building security, and more. Face detection is necessary for facial recognition algorithms to know which parts of an image must be used to generate faceprints.

FACE DETECTION VS. FACE RECOGNITION: WHAT’S THE DIFFERENCE?

Facial recognition is merely one application of face detection. The former is used for biometric verification and device unlocking, whereas the latter can also be applied to facial analysis and tracking. For a more comprehensive look at face recognition, check out our Types of Biometrics guide.

ADVANTAGES AND DISADVANTAGES OF FACE DETECTION SYSTEMS

While face detection systems can be powerful, they are by no means foolproof, as demonstrated by our list of challenges. Let’s take a look at the advantages and disadvantages that face detection systems can bring.

ADVANTAGES OF FACE DETECTION

1. Better security. Face detection augments surveillance tactics and forms the basis of the identification process of terrorists and criminals;
2. Easy to integrate. Most face detection solutions are compatible with security software;
3. Automated identification. Face detection lets facial identification be automated, thus increasing efficiency alongside a heightened rate of accuracy.

DISADVANTAGES OF FACE DETECTION

1. Huge storage requirements. Machine learning technology requires powerful data storage;
2. Detection can be vulnerable. We’ve outlined the way in which facial detection can be thrown off;
3. Potential privacy issues. There is disagreement on whether face detection is compatible with human privacy rights.

PROS AND CONS TABLE SUMMARY

HOW FACE DETECTION ALGORITHMS ARE USED

Before we wrap up this guide, we wanted to give some examples of how face detection algorithms are applied in the real world. Some applications include photography, lip reading, marketing, and more.

FACIAL MOTION CAPTURE

With applications such as Snapchat, people’s faces can be altered in real-time with fun filters. Facial detection makes this possible, as its algorithms tell the applications that there is a face that can be traced and changed.

FACIAL RECOGNITION

Facial recognition adds increased security to nearly every global industry. It seeks to identify a person and then authenticate their identity – but for a person’s faceprint to be analyzed via facial recognition, the facial area to be assessed is determined by face detection.

PHOTOGRAPHY

Facial recognition can be used to “tag” people’s faces in photos across social media platforms, and facial detection forms the foundation of this application. Furthermore, facial detection technology can be used alongside tracking to focus on a person’s face while the photo is being taken.

MARKETING

Facial surveillance can help stores determine customers that have visited a few times and offer them perks or discounts – thus fostering increased customer loyalty.

EMOTIONAL INFERENCE

Emotion recognition applications are still in the works; when they are fully developed, AI might be able to “read” nonverbal cues, gestures, body movements, and facial expressions to convey a person’s feelings.

LIP READING

The detection, modeling, and tracking of lips during videos can be used to generate automatic subtitles. Such an application can be found on YouTube, where some videos have the option to turn on subtitles, even if the creator has not provided any.

SUMMARY

To sum up the key points of this guide:

• Face detection is AI-based computer technology that is used to extract and identify human faces from
  digital images;
• Face detection algorithms can be feature-based, knowledge-based, template matching, appearance- based, or a combination of methods;
• Advantages of face detection include better security, easy integration, and automated identification;
• Disadvantages include huge storage requirements, vulnerable detection, and potential privacy issues.

Face detection is the foundation of a huge number of facial applications – we can see it in our day-to-day life. When we unlock our smartphone via face recognition, that would not be possible without face detection. The same goes for facial recognition surveillance systems, photo tagging, and Snapchat filters. There are many exciting applications in the works that we can thank face detection for!

Tutorial Time

Now we will see a small example of OpenCV and Python with its explanations, before we start we will need following software and if you are Linux base OS then you can skip installation process. Lets start.

Installation on Windows

Software we will be using

1. PyCharm Community version
2. Latest version of python
3. And most import is your support. Lets start.

1. PyCharm Community version

First open your favorite browser and paste this link in there https://www.jetbrains.com/pycharm/download/ after that click on download under Community section.

After downloading it just open the installer you shall be granted with this screen

Click on next and complete installation process.

2. Python

After completing installation of PyCharm now we will install Python, so same copy and past this link https://www.python.org/downloads/ in browser and download installer

Now open the installer and start the installation process and make sure that you check all the options in Optional Features like this

Now we are set for tutorial so open up your PyCharm.

Coding

First of all we will be opening PyCharm from start menu under JetBrains folder

Create a new project named it OpenCV.

After creating new project it will take few minutes to setup editor for us and after completing this will on your screen

Package Installation

Now clear everything in main.py and it should be empty after that we will be creating a text file called requirement.txt in your project folder using cmd for that you have to open cmdand navigate to you project folder like this

now type notepad.exe requirement.txt it will ask you for create a new file and click on yes after that paste bellow packages name there.

1
2
3
4

opencv-python
opencv-contrib-python
numpy
pillow

Save the file and close it now as we have saved the file we need to install all this packages by bellow command it will take a few minutes depending on your data transfer speed

1

pip install -r requirement.txt

I have already installed it so it will give me this output

Video detection

Close cmd and come back to your PyCharm, after we have installed all the required packages we will make a simple program for video capture so that we know that our video camera is working or not, but before we code in PyCharm we have to import all this packages we installed so follow me. First got to menu then File > Settings and you will see this window.

Open Project: OpenCV and in that select Python Interpreter in that add all this packages

Now we will be coding a small program on video detection.

1
2
3
4
5
6
7
8
9
10
11

import cv2 #importing opencv package
capture = cv2.VideoCapture(0) # we will create a variable name capture to capture webcam of our device which is "0" or else you can write ip address in '' of your webcam

while(True):
    ret, frame = capture.read() # to read data from video capture variable
    cv2.imshow("Video Feed",frame) # to show live video camera feed
    if cv2.waitKey(1) & 0xFF == ord('q'): # we have set waitKey at 0 means infinite or you can write any miliseconds and for ord('q') for quiting in live feed by pressing q on keyboard
        break

capture.release()
cv2.destroyAllWindows()

Now press shift + F10 from keyboard or go-to menu Run > Run ‘main’ to run the program you may be able to see a new window with the name Video Feed try it yourself and you will be able to see your face.

This is test image which I will be using it.

OpenCV Cascade

It means that our camera of our system is working properly now we need face detection cascades there are two ways of finding that files first is by downloading from here or by following commands open your cmd and type python or py after that type following commands

1
2

import cv2
print(cv2.__file__)

Go to the highlighted path and in there you will be able to see all the files and in that file there will be a folder called data will be there

Copy that folder and past it in your project and rename from data to cascade like this.

After doing we will be creating a new variable called face_cascade and in that variable we will use OpenCV, paste this code in your main.py file

1
2

import cv2 #add bellow this line
face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_alt.xml') 

Using Face Classifier

Now we will be converting our colored BGR color to Gray color so that our cascade can understand the image properly, mostly face detection works in gray scale so we will be converting our colored frame to gray scale. For that you have to create a new variable called gray under ret, frame = capture.read(). Remember OpenCV uses BGR method while for other color code it is RGB you must be familiar with RGB so you will understand BGR. Now we will add this line into our code

1
2

ret, frame = capture.read() # add bellow this line
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # to convert BGR image to grayscale image

and don’t worry if your not able to understand the code I will be giving you project like so that you can download it and run it on your own. We will now detect faces in webcam, photo frame or video. For that we will be using gray scale which we have converted from BGR ti GRAY so for that we need detectMultiScale function for scale factor and minimum neighbors detection.

1
2

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #add bellow this
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.5, minNeighbors=5) # you can play with the numbers as much as you want

now we will pe finding our face in frame by finding position and checking whether the face is present or not for that we will be using width, height, x direction, y direction of the video feed.

1
2
3

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.5, minNeighbors=5)  # add bellow this line
    for (x, y, w, h) in faces:
        print(x,y,w,h) # print coordinates of your face

This command will show you the coordinates of your face in the frame so that we can identify that someone is present here.

Now we will be drawing a square around our face so that we can clearly identify it for that we will be will be using gray scale image. Now we will make a region of interest or ROI using gray scale image to determine its width and height

1
2
3
4

for (x, y, w, h) in faces:
     print(x,y,w,h) # print bellow this line
     roi_gray = gray[y:y + h, x:x + h] # regoin of interest of gray scale image
     roi_color = frame[y:y + h, x:x + w] # regoin of interest of colored image

so now as we have found our region of interest we will check that whether it is working properly or not so we will capture our face by making a PNG fine

1
2
3

roi_color = frame[y:y + h, x:x + w] # add bellow this
  img_item = "my-image.png" # creating a variable name img_item
  cv2.imwrite(img_item, roi_color) # to create an image file where we can see our face only

What this above line will do is that it will create an PNG file with the name my-image.png in your project folder so that we can understand that which portion of our face is been captured.

After detecting our face and saving it in a PNG file what we will do is that we will create a border and track our live feed cam and see it more clearly

1
2
3
4
5
6

cv2.imwrite(img_item, roi_color) # add bellow this
color = (0,0,255) # BGR format you can choose whatever you want go to this site to choose color https://wamingo.net/rgbbgr/
   stroke = 2
   end_cord_x = x + w
   end_cord_y = y + h
   cv2.rectangle(frame,(x, y), (end_cord_x, end_cord_y), color, stroke)

Until now what we have done is that we have just detecting our face using Cascades but as we have successfully done it so now we will be creating recognizer to recognize who is that person is for that we will be creating an algorithm. So now we will be creating new python file train-faces.py so that we will be writing all the algorithm in it to train our facial recognition system. After creating train-faces.py file we will create a folder of name images where we will be adding all images in it to train our trainer. Open train-faces.py and type the following code:

1
2

import os # to detect which kind of operating system we are been using example: Windows, Linux, Debian, Mac, etc.
BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # to automatical find out the path of our project

What we have done is that we told the system to find the path of our project automatically and also to detect os also and after detecting our project folder we will be adding our images directory so that we will be able to find all images at one place.

1
2

BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # add bellow this
image_dir = os.path.join(BASE_DIR, "images") # this will add images at the end of our base dir example: C:\User\Admin\Desktop\facedetection\images\

As our system or file has detected the path we will check all the images which are present in it.

1
2
3
4
5
6

image_dir = os.path.join(BASE_DIR, "images") # add bellow this line
for root, dirs, files in os.walk(image_dir): # this will detect our image path
    for file in files: 
        if file.endswith("png") or file.endswith("jpg"): # this is use to check whether there are png file or jpg files
            path = os.path.join(root, file) # this will join our project director and images folder path
            print(path) # to check all the apth of images

Now what we will do is that we will be giving labels to our directories which are present in images folder

1
2
3

      path = os.path.join(root, file) # add bellow this line
label = os.path.basename(root) # to give the label of our image folder
  print(label, path) # add label in old print function

So when we will run the code now we will be able to see path as well as label. So now we will be creating empty list.

1
2
3

image_dir = os.path.join(BASE_DIR, "images") # add bellow this
y_labels = []
x_train = []

Training images using NumPy array also we will be using PIL python library to grab pill of image

1
2
3

import cv2 #add bellow this
import numpy as np
from PIL import Image

After importing Image from PIL library we will be converting image into gray

1
2

  print(label, path) # add bellow this
pil_image = Image.open(path).convert("L") # to convert colored image to gray scale

Now we will be using NumPy array to train our images

1
2
3

pil_image = Image.open(path).convert("L") # add bellow this line
image_array = np.array(pil_image, "uint8")
print(image_array) # to check images array

We will check ROI of images so that we can train our trainer for that we need to import cv2 into our train-faces.py using our Cascades

1
2
3
4
5

import cv2 
BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # to automatical find out the path of our project

image_dir = os.path.join(BASE_DIR, "images") # this will add images at the end of our base dir example: C:\User\Admin\Desktop\facedetection\images\
face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_alt2.xml') # add this line

After importing OpenCV and Cascades we will be detecting faces using detectMultiScale.

1
2
3
4
5

      print(image_array) # add bellow this
faces = face_cascade.detectMultiScale(image_array, scaleFactor=1.5, minNeighbors=5)
      for (x, y, w, h) in faces:
          roi = image_array[y:y + h, x:x + w]
          x_train.append(roi)

We will be giving labels so that it would be easy to understand it properly, also not that it would be easy to see who is the person in the video feed or photo frame for that we will be creating a variable.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_alt2.xml') # add bellow this line
current_id = 0 # creating an id starting with 0
label_ids = {} # to create and empty directory
# Now come down to this line 
        print(label, path) # ad bellow this
            if not label in label_ids: # it will check whether the labels are there or not
                label_ids[label] = current_id
                current_id += 1
            id_ = label_ids[label]
            print(label_ids) # to print label ids
# Now come down to this line 
x_train.append(roi) # add bellow this line
                y_labels.append(id_)
print(y_labels)
print(x_train)

What we have done is that we have created labels ids for each and every image we have so after doing that we will saving all thoes lables so that it would be easy for our program to recognize it for that we need pickle so I assume that you know who to import any library so import pickle. Now go to the bottom of you train-faces.py file and paste bellow code but before pasting this code make sure to add # infront of print function.

1
2

with open("labels.pickle", "wb") as f:
    pickle.dump(label_ids, f)

After this we will train our OpenCV recognizer for each an every images so that it can recognize it propely so for that we will create a variable call recognizer.

1
2

face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_alt2.xml') # add bellow this line
recognizer = cv2.face.LBPHFaceRecognizer_create() #creating our face recognizer

Successful creation of our recognizer we will be needing numpy array to save all those array in a single file and remember one thing the more numbers of photo will take more time to write it also it deppends on speed of your devices also.

1
2
3
4

with open("labels.pickle", "wb") as f:
    pickle.dump(label_ids, f) # add bellow this
recognizer.train(x_train, np.array(y_labels)) # using numpy array we will be training our recognizer
recognizer.save("trainer.yml") # and from above training we will be saving it in a single file called trainner.yml

As we have completed our train-faces.py we will run it and train our project so that we can recognize our faces, so now go to your cmd and type py tain-faces.py and wait until you get this message

1

Process finished with exit code 0

After you see this message it means that our trainer has been successfully trained so main.py is been left to update for final run. Now open your main.py file and past this line

1
2
3
4
5

face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_alt2.xml') # add bellow this
recognizer = cv2.face.LBPHFaceRecognizer_create() #creating our face recognizer
recongnizer.read("trainer.yml")
with open("labels.pickle", "rb") as f:
    og_labels = pickle.load(f)

What we did is imported trainer.yml so that we can read all the data we have been trained data. After that we will be import all the the tags and ids we have created.

1
2
3
4

roi_color = img[y:y + h, x:x + w] # add bellow this line
id_, conf = recognizer.predict(roi_gray)
  if conf>= 45:
    print(id_)

Loading Label Names from Pickle

Now we will labels from labels.pickle so that we can identify labels, so what we will do is fetch all the labels from that file.

1
2
3

recognizer.read("trainer.yml") # add bellow this

labels = {"person_name": 1} # display person name

What we did is we will display person name so to do that we are going to add this line to display it

1
2

og_labels = pickle.load(f) # add bellow this
labels = {v:k for k,v in labels.items()}

Now we will print ids

1
2

print(id_) # add bellow this
    

Put Text on your face

We will put text on our webcam face recognition so that we can identify who is that person is for that we will be using putText function.

1
2
3
4
5
6

if conf >= 45:
    print(id_)
    print(labels[id_]) # add bellow this
    font = cv2.FONT_HERSHEY_SIMPLEX
    name = labels[id_]
    color = (0,0,255) # BGR choose any color you like

We will resize little bit so that it reads perfectly in train-faces.py

1
2
3

         pil_image = Image.open(path).convert("L") # add bellow this
size = (500,500)
         final_image = pil_image.rezise(size, Image.ANTIALIAS)

After saving both the files run your main.py file and check the output of it.

Complete Code

requirement.txt

1
2
3
4

opencv-python
opencv-contrib-python
numpy
pillow

main.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import cv2 
import pickle
# url = '' # add your remote ip of webcam example 'http://192.168.0.1/video' or 'http://192.168.0.1' depending on your ip even you can use security camera ip also
face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_alt2.xml')


recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read("trainer.yml")
labels = {"person_name": 1}
with open("labels.pickle","rb") as f:
    og_labels = pickle.load(f)
    labels = {v:k for k,v in og_labels.items()}
cap = cv2.VideoCapture(0) # comment this if your using ip camera
# cap = cv2.VideoCapture(url) # uncomment this line to use remote camera url
cap.set(3,512)
cap.set(4,512)
cap.set(10,150)

while True:
    # Capture frame-by-frame
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.5, minNeighbors=5)
    for (x, y, w, h) in faces:
        # print(x,y,w,h)
        roi_gray = gray[y:y+h, x:x+w]
        roi_color = frame[y:y+h, x:x+w]
        id_, conf = recognizer.predict(roi_gray)
        if conf>=45: # and conf<=85:
            # print(id_)
            # print(labels[id_])
            font = cv2.FONT_HERSHEY_SIMPLEX
            name = labels[id_]
            color = (0,255,0)
            stroke = 2
            cv2.putText(frame, name, (x,y), font, 1, color, stroke, cv2.LINE_AA)

        img_item = "test.png"
        cv2.imwrite(img_item, roi_color)
        color = (0,255,0) # BGR
        stroke = 2
        end_cord_x = x + w
        end_cord_y = y + h
        cv2.rectangle(frame, (x, y), (end_cord_x, end_cord_y), color, stroke)

    # Display the resulting frame
    cv2.imshow('Frame',frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

train-faces.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import cv2
import os
from PIL import Image
import numpy as np
import pickle

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
image_dir = os.path.join(BASE_DIR, "images")

face_cascade = cv2.CascadeClassifier('cascades/haarcascade_frontalface_default.xml')
recognizer = cv2.face.LBPHFaceRecognizer_create()

current_id = 0
label_ids = {}
y_labels = []
x_train = []

for root, dirs, files in os.walk(image_dir):
    for file in files:
        if file.endswith("png") or file.endswith("jpg"):
            path = os.path.join(root, file)
            label = os.path.basename(root).replace(" ", " ") #.upper()
            # print(label,path)
            if not label in label_ids:
                label_ids[label] = current_id
                current_id += 1
            id_ = label_ids[label]
            # print(label_ids )
            # y_labels.append(label)
            # x_train.append(path)
            pil_image = Image.open(path).convert("L")
            size = (512,512)
            final_image = pil_image.resize(size, Image.ANTIALIAS)
            image_array = np.array(pil_image, "uint8")
            # print(image_array)
            faces = face_cascade.detectMultiScale(image_array, scaleFactor=1.5, minNeighbors=5)
            for (x,y,w,h) in faces:
                roi = image_array[y:y+h, x:x+w]
                x_train.append(roi)
                y_labels.append(id_)

# print(y_labels)
# print(x_train)

with open("labels.pickle","wb") as f:
    pickle.dump(label_ids, f)

recognizer.train(x_train, np.array(y_labels))
recognizer.save("trainer.yml")

Source Code

Here is the source code OpenCV Facial Recognition on GitHub if you have any issues then you can ask there.

In previous post we have seen how to install Windows Subsystem Linux in your windows 10, so in this we will see how to use GUI on your system without any kind of software or other utilities. The main purpose of using this is so that you can easily use both the windows and Linux apps together on single operating system, after you have installed this WSLG on your system it will look like this.

Let’s start the installation process.

Brief Introduction

WSLg is short for Windows Subsystem for Linux GUI and the purpose of the project is to enable support for running Linux GUI applications (X11 and Wayland) on Windows in a fully integrated desktop experience.

WSLg provides an integrated experience for developers, scientists or enthusiasts that prefer or need to run Windows on their PC but also need the ability to run tools or applications which works best, or exclusively, in a Linux environment. While users can accomplish this today using a multiple system setup, with individual PC dedicated to Windows and Linux, virtual machine hosting either Windows or Linux, or an XServer running on Windows and projected into WSL, WSLg provides a more integrated, user friendly and productive alternative.

WSLg strives to make Linux GUI applications feel native and natural to use on Windows. From integration into the Start Menu for launch to appearing in the task bar, alt-tab experience to enabling cut/paste across Windows and Linux applications, WSLg enables a seamless desktop experience and workflow leveraging Windows and Linux applications.

Installation

Pre-requirements

Before you begin installation of WSLG you have to check few thing on your system so that there is no error while installation. Here are the requirements:

• Windows 10 Insider Preview build 21362+ (required for now but in future it will be available for normal builds if you aren’t on this build then go to setup Windows Insider and get latest versions of Insider Preview build)
• Choose your GPU (if you have already install drivers then you can skip this steps)
  • AMD GPU driver for WSL
  • Intel GPU driver for WSL
  • NVIDIA GPU driver for WSL (I have NVIDIA GeForce on my device so I have already installed it)

Install instructions

I assume that you have installed WSL on your system but if you haven’t installed it yet then go to WSL2 Installation and install it. Moving further If you have an existing WSL installation without WSLg and want to update to the latest version of WSL which includes WSLg, run the command wsl --update from an elevated command prompt, and also download and install Linux GUI support on your system so that the software requirement to run WSLg will be installed automatically.

Please note that WSLg is only compatible with WSL 2 and will not work for WSL distribution configured to work in WSL 1 mode. Verify that your Linux distro is configured for running in WSL 2 mode, if not switch to WSL 2. While you can continue to run Linux distro in WSL 1 mode after installing WSLg if you so desired, a distro configured to run in WSL 1 mode will not be able to communicate with WSLg and will not be able to run GUI applications.

You can list your currently installed distro and the version of WSL they are configured for using the following command from an elevated command prompt.

1

wsl --list -v

If running in version 1 mode, switch to version 2. This can take a while.

1

wsl --set-version _distro_name_ 2

Restart WSL by running this command from an elevated command prompt, make sure to save any pending work first:

1

wsl --shutdown

Updating WSL + WSLg

To update to the latest version of WSL and WSLg released for preview, simply run wsl --update from an elevated command prompt or powershell.

You’ll need to restart WSL for the changes to take effect. You can restart WSL by running wsl --shutdown from an elevated command prompt. If WSL was currently running, it will shutdown, make sure to first save any in progress work! WSL will be automatically restarted the next time you launch a WSL application or terminal.

First Launch

If you have installed the Ubuntu Linux distro per these instructions, you’ll find an Ubuntu icon in your start menu, launch it. This will launch the WSL 2 VM, launch the Ubuntu WSL distro in that VM and give you a terminal to interact with it. Voila! You’re running Linux on Windows!

If you would like to explore additional Linux distributions built for WSL, you can use the wsl --list --online command from an elevated command prompt to enumerate the list of available distributions for your system. You can have multiple Linux distributions installed within WSL and they will happily coexist side-by-side, so don’t be scared to experiment and try things out. Now let’s install and try some apps

Install and run GUI apps

If you want to get started with some GUI apps, you can run the following commands from your Linux terminal to download and install some popular applications. If you are using a different distribution than Ubuntu, it may be using a different package manager.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

## Update all packages in your distro
sudo apt update

## Gedit
sudo apt install gedit -y

## GIMP
sudo apt install gimp -y

## Nautilus
sudo apt install nautilus -y

## VLC
sudo apt install vlc -y

## X11 apps
sudo apt install x11-apps -y

## Google Chrome
cd /tmp
sudo wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo dpkg -i google-chrome-stable_current_amd64.deb 
sudo apt install --fix-broken -y
sudo dpkg -i google-chrome-stable_current_amd64.deb

## Microsoft Teams
cd /tmp
sudo curl -L -o "./teams.deb" "https://teams.microsoft.com/downloads/desktopurl?env=production&plat=linux&arch=x64&download=true&linuxArchiveType=deb"
sudo apt install ./teams.deb -y

## Microsoft Edge Browser
sudo curl https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-dev/microsoft-edge-dev_91.0.852.0-1_amd64.deb -o /tmp/edge.deb
sudo apt install /tmp/edge.deb -y

Once these applications are installed, you’ll find them in your start menu under the distro name. For example Ubuntu -> Microsoft Edge. You can also launch these from your terminal window using the commands:

• xcalc, xclock, xeyes
• gimp
• gedit ~/.bashrc
• nautilus
• vlc
• google-chrome
• teams
• microsoft-edge

Congrats you are done and ready to use GUI apps!

What is WSL?

The Windows Subsystem for Linux lets developers(WSL) run a GNU/Linux environment – including most command-line tools, utilities, and applications – directly on Windows, unmodified, without the overhead of a traditional virtual machine or dual-boot setup.
You can:

• Choose your favorite GNU/Linux distributions from the Microsoft Store.
• Run common command-line tools such as grep, sed, awk, or other ELF-64 binaries.
• Run Bash shell scripts and GNU/Linux command-line applications including:
  • Tools: vim, emacs, tmux
  • Languages: NodeJS, Javascript, Python, Ruby, C/C++, C## & F##, Rust, Go, etc.
  • Services: SSHD, MySQL, Apache, Lighttpd, MongoDB, PostgreSQL.
• Install additional software using your own GNU/Linux distribution package manager.
• Invoke Windows applications using a Unix-like command-line shell.
• Invoke GNU/Linux applications on Windows.

What is WSL 2?

WSL 2 is a new version of the Windows Subsystem for Linux architecture that powers the Windows Subsystem for Linux to run ELF64 Linux binaries on Windows. Its primary goals are to increase file system performance, as well as adding full system call compatibility.

This new architecture changes how these Linux binaries interact with Windows and your computer’s hardware, but still provides the same user experience as in WSL 1 (the current widely available version).

Individual Linux distributions can be run with either the WSL 1 or WSL 2 architecture. Each distribution can be upgraded or downgraded at any time and you can run WSL 1 and WSL 2 distributions side by side. WSL 2 uses an entirely new architecture that benefits from running a real Linux kernel. Let’s see the comparison between WSL 1 and WSL 2

Comparing WSL 1 and WSL 2

The primary difference and reasons for updating the Windows Subsystem for Linux from WSL 1 to WSL 2 are to:

• increase file system performance,
• support full system call compatibility.
  WSL 2 uses the latest and greatest in virtualization technology to run a Linux kernel inside of a lightweight utility virtual machine (VM). However, WSL 2 is not a traditional VM experience.

Comparing features

Performance across OS file systems

We recommend against working across operating systems with your files, unless you have a specific reason for doing so. For the fastest performance speed, store your files in the WSL file system if you are working in a Linux command line (Ubuntu, OpenSUSE, etc). If you’re working in a Windows command line (PowerShell, Command Prompt), store your files in the Windows file system.

For example, when storing your WSL project files:

• Use the Linux file system root directory: \\wsl$\Ubuntu-18.04\home\<user name>\Project
• Not the Windows file system root directory: C:\Users\<user name>\Project

All currently running distributions (wsl -l) are accessible via network connection. To get there run a command [WIN+R] (keyboard shortcut) or type in File Explorer address bar \\wsl$ to find respective distribution names and access their root file systems.

You can also use windows commands inside WSL’s Linux Terminal. Try opening a Linux distribution (ie Ubuntu), be sure that you are in the Linux home directory by entering this command: cd ~. Then open your Linux file system in File Explorer by entering (don’t forget the period at the end): powershell.exe /c start .

WSL 2 is only available in Windows 10, Version 1903, Build 18362 or higher. Check your Windows version by selecting the Windows logo key + R, type winver, select OK. (Or enter the ver command in Windows Command Prompt). You may need to update to the latest Windows version. For builds lower than 18362, WSL is not supported at all.

Installation of WSL 2

There are two options available for installing Windows Subsystem for Linux (WSL):

• Simplified install (preview release): wsl --install

  The wsl --install simplified install command requires that you join the Windows Insiders Program and install a preview build of Windows 10 (OS build 20262 or higher), but eliminates the need to follow the manual install steps. All you need to do is open a command window with administrator privileges and run wsl --install, after a restart you will be ready to use WSL.

Manual Installation Steps

If you are not on a Windows Insiders build, the features required for WSL will need to be enabled manually following the steps below.

• Step 1 - Enable the Windows Subsystem for Linux

You must first enable the “Windows Subsystem for Linux” optional feature before installing any Linux distributions on Windows.

Open PowerShell as Administrator and run:

1

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

• Step 2 - Check requirements for running WSL 2

To update to WSL 2, you must be running Windows 10.

• For x64 systems: Version 1903 or higher, with Build 18362 or higher.
• For ARM64 systems: Version 2004 or higher, with Build 19041 or higher.
• Builds lower than 18362 do not support WSL 2. Use the Windows Update Assistant to update your version of Windows.

If you are running Windows 10 version 1903 or 1909, open “Settings” from your Windows menu, navigate to “Update & Security” and select “Check for Updates”. Your Build number must be 18362.1049+ or 18363.1049+, with the minor build # over .1049. Read more: WSL 2 Support is coming to Windows 10 Versions 1903 and 1909. See the troubleshooting instructions.

• Step 3 - Enable Virtual Machine feature

Before installing WSL 2, you must enable the Virtual Machine Platform optional feature. Your machine will require virtualization capabilities to use this feature.

Open PowerShell as Administrator and run:

1

dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

Restart your machine to complete the WSL install and update to WSL 2.

• Step 4 - Download the Linux kernel update package

Download the latest package:

• WSL2 Linux kernel update package for x64 machines

If you’re using an ARM64 machine, please download the ARM64 package instead. If you’re not sure what kind of machine you have, open Command Prompt or PowerShell and enter: systeminfo | find "System Type". Caveat: On non-English Windows versions, you might have to modify the search text, for example, in German it would be systeminfo | find "Systemtyp".

• Run the update package downloaded in the previous step. (Double-click to run - you will be prompted for elevated permissions, select ‘yes’ to approve this installation.)

• Step 5 - Set WSL 2 as your default version

Open PowerShell and run this command to set WSL 2 as the default version when installing a new Linux distribution:

1

wsl --set-default-version 2

• Step 6 - Install your Linux distribution of choice

1. manual installation

If you are on Windows 10 Insider Preview build 21362+ then just type the following commands in powershell

1
2

#this command will show you list of all distribution which is been supported by windows
wsl --list --online

as soon as paste the above command you will get this message there

1
2
3
4
5
6
7
8
9
10
11
12
13

PS C:\Users\SIDDH> wsl --list --online
The following is a list of valid distributions that can be installed.
Install using 'wsl --install -d <Distro>'.

NAME            FRIENDLY NAME
Ubuntu          Ubuntu
Debian          Debian GNU/Linux
kali-linux      Kali Linux Rolling
openSUSE-42     openSUSE Leap 42
SLES-12         SUSE Linux Enterprise Server v12
Ubuntu-16.04    Ubuntu 16.04 LTS
Ubuntu-18.04    Ubuntu 18.04 LTS
Ubuntu-20.04    Ubuntu 20.04 LTS

you can choose any of the distro you want to install in your system say for example if you want to install Ubuntu then just past the following command

1

wsl --install -d ubuntu

and it will start installing into your system after completion it will ask you for a username and password set those two parameters and you will be able to use Ubuntu in your system without dual-boot

2. Open the Microsoft Store and select your favorite Linux distribution.

The following links will open the Microsoft store page for each distribution:

• Ubuntu 18.04 LTS

• Ubuntu 20.04 LTS

• openSUSE Leap 15.1

• SUSE Linux Enterprise Server 12 SP5

• SUSE Linux Enterprise Server 15 SP1

• Kali Linux

• Debian GNU/Linux

• Fedora Remix for WSL

• Pengwin

• Pengwin Enterprise

• Alpine WSL

• Install Windows Terminal (optional)

Windows Terminal enables multiple tabs (quickly switch between multiple Linux command lines, Windows Command Prompt, PowerShell, Azure CLI, etc), create custom key bindings (shortcut keys for opening or closing tabs, copy+paste, etc.), use the search feature, and custom themes (color schemes, font styles and sizes, background image/blur/transparency).

Install Windows Terminal.

Now you can use linux as well as windows at a same time. In next post we will be seeing how to GUI app in WSL2.

Nanotechnology is science, engineering, and technology conducted at the nanoscale, which is about 1 to 100 nanometers. Nanoscience and nanotechnology are the study and application of extremely small things and can be used across all the other science fields, such as chemistry, biology, physics, materials science, and engineering. It is the leading technology in the world where all the material are been made on the nanoscale level, you must have not been noticed that Microcontroller which we are using in our circuits and much more applications are been made up to the nanoscale level which is called VLSI Very Large Scale Integration. Nanotechnology is also called nanotech.

Origins

^Wikipidia The concepts that seeded nanotechnology were first discussed in 1959 by renowned physicist Richard Feynman in his talk There's Plenty of Room at the Bottom, in which he described the possibility of synthesis via direct manipulation of atoms.

The term Nanotechnology was first used by Norio Taniguchi in 1974, though it was not widely known. Inspired by Feynman’s concepts, K. Eric Drexler used the term nanotechnology in his 1986 book Engines of Creation: The Comming Era of Nanotechnology which proposed the idea of a nanoscale “assembler” which would be able to build a copy of itself and the items of arbitrary complexity with atomic control. It’s also been said that nanotechnology will be able to perform AI level operation which will help to eradicate those diseases which humans can’t remove it, say for example AIDS, Radioactive materials from the body, also this CoronaVirus from current pandemic year.

Fundamental Concepts

Nanotechnology is the engineering of functional systems at the molecular scale. This covers both current work and concepts that are more advanced. In its original sense, nanotechnology refers to the projected ability to construct items from the bottom up, using techniques and tools being developed today to make complete, high performance products.

One nanometer (nm) is one billionth, or 10−9, of a meter. By comparison, typical carbon-carbon bond lengths, or the spacing between these atoms in a molecule, are in the range 0.12–0.15 nm, and a DNA double-helix has a diameter around 2 nm. On the other hand, the smallest cellular life-forms, the bacteria of the genus Mycoplasma, are around 200 nm in length. By convention, nanotechnology is taken as the scale range 1 to 100 nm following the definition used by the National Nanotechnology Initiative in the US. The lower limit is set by the size of atoms (hydrogen has the smallest atoms, which are approximately a quarter of a nm kinetic diameter) since nanotechnology must build its devices from atoms and molecules. The upper limit is more or less arbitrary but is around the size below which phenomena not observed in larger structures start to become apparent and can be made use of in the nano device.[26] These new phenomena make nanotechnology distinct from devices which are merely miniaturised versions of an equivalent macroscopic device; such devices are on a larger scale and come under the description of microtechnology.[27]

To put that scale in another context, the comparative size of a nanometer to a meter is the same as that of a marble to the size of the earth.[28] Or another way of putting it: a nanometer is the amount an average man’s beard grows in the time it takes him to raise the razor to his face.[28]

Two main approaches are used in nanotechnology. In the “bottom-up” approach, materials and devices are built from molecular components which assemble themselves chemically by principles of molecular recognition.[29] In the “top-down” approach, nano-objects are constructed from larger entities without atomic-level control.[30]

Areas of physics such as nanoelectronics, nanomechanics, nanophotonics and nanoionics have evolved during the last few decades to provide a basic scientific foundation of nanotechnology.

Current research

Nanomaterials

The nanomaterials field includes subfields which develop or study materials having unique properties arising from their nanoscale dimensions.

• Interface and colloid science has given rise to many materials which may be useful in nanotechnology, such as carbon nanotubes and other fullerenes, and various nanoparticles and nanorods. Nanomaterials with fast ion transport are related also to nanoionics and nanoelectronics.
• Nanoscale materials can also be used for bulk applications; most present commercial applications of nanotechnology are of this flavor.
• Progress has been made in using these materials for medical applications; see Nanomedicine.
• Nanoscale materials such as nanopillars are sometimes used in solar cells which combats the cost of traditional silicon solar cells
• Development of applications incorporating semiconductor nanoparticles to be used in the next generation of products, such as display technology, lighting, solar cells and biological imaging; see quantum dots.
• Recent application of nanomaterials include a range of biomedical applications, such as tissue engineering, drug delivery, antibacterials and biosensors.

Research and development

Because of the variety of potential applications (including industrial and military), governments have invested billions of dollars in nanotechnology research. Prior to 2012, the USA invested $3.7 billion using its National Nanotechnology Initiative, the European Union invested $1.2 billion, and Japan invested $750 million. Over sixty countries created nanotechnology research and development (R&D) programs between 2001 and 2004. In 2012, the US and EU each invested $2.1 billion on nanotechnology research, followed by Japan with $1.2 billion. Global investment reached $7.9 billion in 2012. Government funding was exceeded by corporate R&D spending on nanotechnology research, which was $10 billion in 2012. The largest corporate R&D spenders were from the US, Japan and Germany which accounted for a combined $7.1 billion.

Robotics

Robotics is the intersection of science, engineering and technology that produces machines, called robots, that substitute for (or replicate) human actions. As you have seen in the movie such as I robot, wall-e, Transformer etc. where robots are been there. As time passes technology also evolves not also that it gets smatter and smatter also.

What is a Robot?

A robot is the product of the robotics field, where programmable machines are built that can assist humans or mimic human actions. Robots were originally built to handle monotonous tasks (like building cars on an assembly line), but have since expanded well beyond their initial uses to perform tasks like fighting fires, cleaning homes and assisting with incredibly intricate surgeries. Each robot has a differing level of autonomy, ranging from human-controlled bots that carry out tasks that a human has full control over to fully-autonomous bots that perform tasks without any external influences.

Characteristics

1. Robots all consist of some sort of mechanical construction. The mechanical aspect of a robot helps it complete tasks in the environment for which it’s designed. For example, the Mars 2020 Rover’s wheels are individually motorized and made of titanium tubing that help it firmly grip the harsh terrain of the red planet.
2. Robots need electrical components that control and power the machinery. Essentially, an electric current (a battery, for example) is needed to power a large majority of robots.
3. Robots contain at least some level of computer programming. Without a set of code telling it what to do, a robot would just be another piece of simple machinery. Inserting a program into a robot gives it the ability to know when and how to carry out a task.

Robots all consist of some sort of mechanical construction. The mechanical aspect of a robot helps it complete tasks in the environment for which it’s designed. For example, the Mars 2020 Rover’s wheels are individually motorized and made of titanium tubing that help it firmly grip the harsh terrain of the red planet.
Robots need electrical components that control and power the machinery. Essentially, an electric current (a battery, for example) is needed to power a large majority of robots.
Robots contain at least some level of computer programming. Without a set of code telling it what to do, a robot would just be another piece of simple machinery. Inserting a program into a robot gives it the ability to know when and how to carry out a task.

Utilization of Robotics

According to the International Federation of Robotics, 1.3 million industrial robots will be in use by 2018. Robotics continues to emerge as a large and influential market.

The following five industries are utilizing this new technology to boost efficiency and convenience for both businesses and consumers.

1. Health Care

Advances in robotics have the potential to change a wide variety of health care practices, such as surgery, rehabilitation, therapy, patient companionship, and everyday activities. Robotic instruments used in health care are not designed to take over the duties of health care professionals, but rather to make their work easier.

The da Vinci Surgical System, for example, utilizes the hand movements of the operating surgeon to control tiny, precise instruments inside the patient’s body. This allows for minimally invasive procedures in surgeries such as cardiac, colorectal, gynecologic, head and neck, thoracic, and urologic.

For patients who have suffered strokes or spinal cord injuries, or who are paralyzed, robotic devices such as exoskeletons have the ability to assist and guide them during rehabilitation. In addition, robotic lifting machines can help nurses lift patients who are elderly or immobile. Companion and therapeutic robots such as Paro can also comfort patients with mental health issues with a system of sensors, microphones, and cameras.

2. Agriculture

To help increase productivity while lowering overall costs, the agriculture industry has been actively working to adopt different forms of robotic technology. Farmers have already been using tractors and harvesters that are self-guided by GPS. Recently, there has been a rise in the experimental use of autonomous systems that automate operations like pruning, thinning, mowing, spraying, and weed removal. Sensor technology is also being utilized to manage pests and diseases that affect crops.

3. Food Preparation

One of the more extravagant advancements in robot technology will soon be available in the kitchen. Automated and intelligent robots — such as those invented by Moley Robotics — will be able to prepare and cook hundreds of meals in a home kitchen. This robotic chef will be controlled via a smartphone, and once the controller chooses a recipe and arranges pre-packaged containers of cut and prepared ingredients, the robot will be able to cook the predetermined meal quickly and efficiently. Moley Robotics is also developing a consumer-friendly version of a robot kitchen, which will include a built-in smart dishwasher and refrigerator.

4. Manufacturing

Robotics are being used in many aspects of manufacturing to help increase productivity and efficiency while lowering production costs. Similar to the health care industry, many robots in manufacturing collaborate with workers to perform repetitive, monotonous, or intricate tasks under the worker’s guidance and control. With these machines, precision is valued more than speed, as is the ability to be reprogrammed for specific tasks of different sizes and complexities. Robotic manufacturing technology is also becoming safer to operate. Cameras, sensors, and automatic shut-off capabilities enable robots to sense and stay clear of humans in the workplace.

5. Military

In the military and public safety sectors, robotic technology is being applied in many areas. One highly visible area involves unmanned drones. These machines can be used for surveillance and support operations on the battlefield. Military drones flying over areas of war and conflict, in hostage situations, and for natural and manmade disasters are able to assess danger levels and provide soldiers and first responders with real-time information. Drones are revolutionizing disaster response since they can access hazardous areas with greater speed and precision without placing human responders in harm’s way.

Robotic devices are already establishing a wide presence in several commercial industries. As robotic technologies become more affordable, they will soon be available in various forms for consumers as well, with the ability to impact our lives in countless ways.

Pros && Cons

Pros

1. The first and the foremost advantage of having robots in workplaces is their cost. Robots are much cheaper than humans and their cost is now decreasing.

2. It’s a fact that we cannot compare human abilities with robots but robotic capabilities are now growing quickly. For example, if you run an essay writing service, you can use robots to perform every kind of research related to any subject.

3. Because robots are more active and don’t get tired like humans, the collaboration between humans and robots is reducing absenteeism. The pace of human cannot increase hence robots are helping humans.

4. Robots are more precise than humans; they don’t tremble or shake as human hands. Robots have smaller and versatile moving parts which help them in performing tasks with more accuracy than humans.

5. There is no doubt that robots are significantly stronger and faster than humans.

6. Robots come in any shape and size, depending upon the need of the task.

7. Robots can work anywhere in any environmental condition whether it is space, underwater, in extreme heat or wind etc. Robots can be used everywhere where human safety is a huge concern.

8. Robots are programmed by a human; they cannot say no to anything and can be used for any dangerous and unwanted work where humans may deny to offer their services. For example, many robotic probes have been sent into space but have never returned.

9. Robots in warfare are saving more lives and have now proven to be very successful.

10. Robots are now being used in the chemical industry and can, for example deal with chemical spills in a nuclear plant, which would otherwise pose a major health concern.

11. The best thing about robots is that they never get tired and can literally work on certain tasks 24 x 7. The human brain gets tired if it’s working continuously but robots never get tired of what they are programmed to do and they can work on certain tasks error free.

Cons

1. Where robots are increasing the efficiency in many businesses, they are also increasing the unemployment rate. Because of robots, human labour is no longer required in many factories and manufacturing plants.

2. Robots can certainly handle their prescribed tasks, but they typically cannot handle unexpected situations.

3. The ROI of your business may suffer if your operation relies on too many robots. They have higher expenses than humans, so at the end of the day you may not always achieve the desired ROI.

4. Robots may have AI but they are certainly not as intelligent as humans. They can never improve their jobs outside the pre-defined programming because they simply cannot think for themselves.

5. Robots installed in workplaces still require manual labour attached to them. Training those employees on how to work with the robots definitely has a cost attached to it.

6. Robots have no sense of emotions or conscience. They lack empathy and this is one major disadvantage of having an emotionless workplace.

7. Robots operate on the basis of information fed to them through a chip. If one thing goes wrong the entire company bears the loss.

Where a robot saves times, on the other hand it can also result in a lag. It is, after all, a machine so you cannot expect too much from them. If a robot malfunctions, you need extra time to fix it, which would require reprogramming.

If ultimately robots would do all the work, and the humans will just sit and monitor them, health hazards will increase rapidly. Obesity will be on top of the list.

So there are advantages, but there are disadvantages as well. It is the twenty first century and we cannot work without machines.

Humans are still considered far more efficient than robots when it comes to decision making powers, handling difficult situations, brainstorming, and generally bringing a sense of emotion and empathy into a workplace.